wrt 333...34, for Sergio...

[Chris M. Thomasson]

I got a direct solution, Sergio. This direct solution does not need a
successor.

i[n] = floor((1/3) * 10^(n+2) + 1)

Here is a snippet of a little program I wrote:
_____________________________________
// sci.math experiment
{
std::cout << "sci.math experiment\n" << std::endl;

// recursive solution
{
std::cout << "recursive solution" << std::endl;

unsigned long result = 34;
unsigned long n = 5;

for (unsigned long i = 0; i < n; ++i)
{
std::cout << "i[" << i << "] = " << result << "\n";

result = result + 3 * std::pow(10, i + 2);
}
}

// Direct solution
{
std::cout << "\ndirect solution" << std::endl;

unsigned long n = 5;

for (unsigned long i = 0; i < n; ++i)
{
unsigned long result = std::floor((1. / 3.) * std::pow(10,
i + 2) + 1);
std::cout << "i[" << i << "] = " << result << "\n";
}
}

}
_____________________________________


Here is the output:
_____________________________________
sci.math experiment

recursive solution
i[0] = 34
i[1] = 334
i[2] = 3334
i[3] = 33334
i[4] = 333334

direct solution
i[0] = 34
i[1] = 334
i[2] = 3334
i[3] = 33334
i[4] = 333334
_____________________________________

[Chris M. Thomasson]

On 9/20/2022 2:01 PM, Chris M. Thomasson wrote:
> I got a direct solution, Sergio. This direct solution does not need a
> successor.
>
> i[n] = floor((1/3) * 10^(n+2) + 1)

[...]

I does not depend on a predecessor or a successor, its direct.

So any result can be reached directly just by providing an index.

[Sergi o]

That look great!
I knew their should be a direct solution.
I think there is a general direct solution for both arithimetic and geometric, Im rusty, I would have to dig out a book to find it.

[Chris M. Thomasson]

Check this shit out, why does the anti equal one wrt using negative
indexes greater than 1. Not sure about index 0 and 1 they go into
positive i[0] = 34 and i[1] = 4, then everything goes into ones.

floor((1. / 3.) * 10^(-0 + 2)) + 1) = 1 // False
floor((1. / 3.) * 10^(-1 + 2)) + 1) = 1 // False

floor((1. / 3.) * 10^(-2 + 2)) + 1) = 1 // True
floor((1. / 3.) * 10^(-6 + 2)) + 1) = 1 // True
floor((1. / 3.) * 10^(-7 + 2)) + 1) = 1 // True

Here is some output from my program:
______________________________
// Direct solution, ones?

{
std::cout << "\ndirect solution" << std::endl;

long n = 8;

for (long i = 0; i < n; ++i)
{
long result = std::floor((1. / 3.) * std::pow(10, -i + 2) + 1);

std::cout << "i[" << i << "] = " << result << "\n";
}
}
______________________________

The output:
______________________________

direct solution
i[0] = 34

i[1] = 4
i[2] = 1
i[3] = 1
i[4] = 1
i[5] = 1
i[6] = 1
i[7] = 1
______________________________


Using all negatives is a fun contrast to the results using all positives.

[He, who travels time to time]

Hey. Would You like to talk a little bit ?

Call >>>>>>>>>>>>> 3 7 2 [[[[[[[country]]]]]]]]]]]] and then 56330687

[Timothy Golden]

As computer programmers I think we have a very different mindset than the traditional formal mathematician.
As to whose logic wins: clearly the computer as a logical machine has to be correct. Ambiguities are not to be taken lightly.
For those of us who use a compiled language the integrity of the compiler as a tool; and hopefully one without bugs; is paramount.
To claim the same of the mathematicians is to pose them as a class of individuals who have been schooled under one or another curricular habit, almost like we treat Pascal or C, or C++ versus C#, and this latter I'll have to confess I know very little about. Their compilers were humans who simply said: "Good Enough." and that was that. Print it and go on to the next piece. Whether in letters of in journals I suppose it didn't really matter. The vector only just came onto the horizon like a hundred fifty years ago or less. The sign of the real value is barely even appreciated. We are at a stage of mathematics where the accumulation of past works demands not so much an appetite to shove them down your throat, but instead caution and care as to what one accepts.

That ambiguities have existed in mathematics is as simply exposed as explaining how every number system is modulo-10. This right here is an early moment of defiance that Peano would rather not admit, so he scurries away for a successor function and says to hell with those damn digits. Meanwhile all who use Peano's axioms are using those digits, or at least are not denying the possibility of the usage of such digits. So then to claim to be working purely from the Peano axioms on a value n=34 is an invalid claim. there is quite a bit more that needs to be done in order to develop the mechanism of number.

The usage of induction in order to develop the concept of the natural number is as simple as providing the text:
1, 2, 3, ...
yet you see at nine we run out of glyphs, and if you think these little glyphs have nothing to do with the problem then you are swamped. Obviously the trick lays in the ellipsis, and that the ellipsis is inductive in nature. for us as computer programmers the code you see above is a no-go. It will never halt. Yet the mathematician accepts such a code and has become habituated into it. The usage of the ellipsis can take many subtle variations, yet so long as the pattern is well enough formed that a consensus on the next value and the next value is agreeable then no dissent will be felt. Except of course here on usenet we see the endless quagmire of discussions on infinity. In the past I would pare them away as silliness. Anyway, back on variations the work you are doing is actually of an even simpler form of induction, in that no complexity of operation is even introduced. You see, the counting algorithm that is the successor function has to do something, and that something is encoded in that line up there. Well: is it really encoded in that line? Anyway, our form is simpler. We simply want a repeating digit:
333...34
and in this way we arguably have simplified the meaning of the ellipsis. This sort of informational modification could subtly achieve what? Well, I suppose we could argue that this is a different form of induction. A simpler form of induction. It is so infantile in its nature as to be cast aside by the mathematician who pleads their superiority by the complexity of thought that they can achieve. Meanwhile programmers know that good code is simple code, and that the complexity arises when those simple pieces fit together to yield something interesting. Code that works well works this way, anyways. There is plenty of spaghetti out there too. It happens that the decimal form yields repeating digits rather regularly, so to plead irrelevance here can quickly be refuted. Simply divide a couple of arbitrary values and you'll be on about what product you need to get the one over the other, and its going to involve repeating digits generally. Most will digress into discussions of rational values here but there are other ways.

[Sergi o]

On 9/21/2022 9:53 AM, Timothy Golden wrote:
> On Tuesday, September 20, 2022 at 5:04:22 PM UTC-4, Chris M. Thomasson wrote:
>> On 9/20/2022 2:01 PM, Chris M. Thomasson wrote:
>>> I got a direct solution, Sergio. This direct solution does not need a
>>> successor.
>>>
>>> i[n] = floor((1/3) * 10^(n+2) + 1)
>> [...]
>>
>> I does not depend on a predecessor or a successor, its direct.
>>
>> So any result can be reached directly just by providing an index.
>
> As computer programmers I think we have a very different mindset than the traditional formal mathematician.

NSS

> As to whose logic wins: clearly the computer as a logical machine has to be correct.

Wrong, it just a dumb box.

> For those of us who use a compiled language the integrity of the compiler as a tool; and hopefully one without bugs; is paramount.

Compilers ?

> To claim the same of the mathematicians is to pose them as a class of individuals who have been schooled under one or another curricular

curricular?


> habit,

habit,?


post drifts way off and far out .....

[mitchr...@gmail.com]

Why does .333 repeating have a remainder of 4?

[Chris M. Thomasson]

On 9/21/2022 12:17 PM, mitchr...@gmail.com wrote:
>
>
> Why does .333 repeating have a remainder of 4?

I just tried to get a representation of it (333...34) as a direct
formula depending on an index, only. When I say direct, it does not
depend on any predecessor and/or successor.

[Timothy Golden]

Yeah, and this is fine. We don't generally require that you count to one hundred in order to use the value one hundred. As to whether this cuts Peano out completely I suppose so. We just don't work that way. When presented with the digits we were taught to crunch them and get the right answer.
These do that just fine. Well, it does become an inductive job when it comes to computing the product for these long values; at least so far that is the method that I've been using. I suppose some algorithm could be built up as well. I did find one problem out at six repeating digits that I took out to a pretty crazy length still with no repeat. It could have more than 400,000 digits as I recall in the string. The treachery of long repeats is already apparent in the product of simpler values.

I think that informationally because of the repetition within these values the ability to compress them via such notation can take place within a machine as well. In other words, while these do appear as infinitely long natural numbers the representation that we are using is not infinitely long, and as a result the computational possibilities are very good. Possibly some more rules can be found. This ground is found by leaving the rational numbers behind. Oddly, for those who like the rational and irrational values this work could be pretty stimulating.

In all this theory remember one thing: Peano doesn't do digits.

[Chris M. Thomasson]

On 9/20/2022 2:40 PM, Sergi o wrote:

> On 9/20/2022 4:04 PM, Chris M. Thomasson wrote:
>> On 9/20/2022 2:01 PM, Chris M. Thomasson wrote:
>>> I got a direct solution, Sergio. This direct solution does not need a
>>> successor.
>>>
>>> i[n] = floor((1/3) * 10^(n+2) + 1)
>> [...]
>>
>> I does not depend on a predecessor or a successor, its direct.
>>
>> So any result can be reached directly just by providing an index.
>>
>>
>>
> That look great!

Thank you. :^)

> I knew their should be a direct solution.

Yup. You got me thinking on it.

> I think there is a general direct solution for both arithimetic and
> geometric, Im rusty, I would have to dig out a book to find it.

Nice. :^)

[Chris M. Thomasson]

On 9/21/2022 7:53 AM, Timothy Golden wrote:
> On Tuesday, September 20, 2022 at 5:04:22 PM UTC-4, Chris M. Thomasson wrote:
>> On 9/20/2022 2:01 PM, Chris M. Thomasson wrote:
>>> I got a direct solution, Sergio. This direct solution does not need a
>>> successor.
>>>
>>> i[n] = floor((1/3) * 10^(n+2) + 1)
>> [...]
>>
>> I does not depend on a predecessor or a successor, its direct.
>>
>> So any result can be reached directly just by providing an index.
>
> As computer programmers I think we have a very different mindset than the traditional formal mathematician.

Perhaps. Humm... I think so.

> As to whose logic wins: clearly the computer as a logical
> machine has to be correct. Ambiguities are not to be taken lightly.
> For those of us who use a compiled language the integrity of
> the compiler as a tool; and hopefully one without bugs; is paramount.
> To claim the same of the mathematicians is to pose them as a
> class of individuals who have been schooled under one or another
> curricular habit, almost like we treat Pascal or C, or C++ versus C#,

> and this latter I'll have to confess I know very little about. [...]

Love C and C++. Special place in my heart for C. I have used C# several
times as a benchmark for its garbage collector vs manual memory
management in C. I know a lot about writing synchronization algorithms
in C using POSIX, memory barriers and atomic RMW. Good thing that C and
C++ have fairly low level access to them.

Wrt to a GC, well, JavaScript is fun.

[Chris M. Thomasson]

I should point out that "modern" C and C++ have C11, C++11 have access
to membars and atomics

[Ross A. Finlayson]

What is fence?

[Ibes Confortola]

Ross A. Finlayson wrote:

>> > Love C and C++. Special place in my heart for C. I have used C#
>> > several times as a benchmark for its garbage collector vs manual
>> > memory management in C. I know a lot about writing synchronization
>> > algorithms in C using POSIX, memory barriers and atomic RMW. Good
>> > thing that C and C++ have fairly low level access to them.
>> I should point out that "modern" C and C++ have C11, C++11 have access
>> to membars and atomics
>> >
>> > Wrt to a GC, well, JavaScript is fun.
>> >
> What is fence?

an atomic instruction a semaphore is using, to protect a region from
changing its data.

[Timothy Golden]

OK, but now to the mathematics.
If we sit here and nod our heads while mathematicians claim that the continuum is found by dividing one integer by another integer and landing with a float then the game is given away. Computers work naturally with halves and halves of halves in terms of division. How interesting that division devolves into rotation of digits down at a simple level when we remain within our modulo system.

I, state your modulo, do hearby swear that all my values that I ever commit to memory or paper shall be, state your modulo, especially when I do not state their modulo.

And of course this boiler plate filled out reads:
I, modulo-10, do hearby swear that all my values that I ever commit to memory or paper shall be modulo-10 especially when I do not state their modulo.

And yet the halves and the tenths are just passing values to those who are rationally behaved.
To get there fast you'd have stayed in one or the other but instead the works plod along as if to say that twelfths are finer than elevenths. Along this way you might meet the sixteenths, but don't look back. To remain rational never look back, for that way lays modulo 10. Do not state your name and never utter even the very concept of the modulo value. Let that be a lesson to those who are interested in getting to larger values; or smaller values, as the case may be.

Even the humble addition can be said to have issues: I didn't realize it until bumped into a Digi-Key video recently coding an FPGA to add or count within a phase locked loop system. The humble adder has to perform a carry operation, and this then introduces a subtle delay since while the bits of each value to add could have been presented in parallel, the cascading effect of the carry operation has to be accrues over every bit of the add. This means that the challenge of adding 64 bit values does actually rise over the 32 bit case. These are subtle effects that have to be put before the hardware engineer and failure is not an option. Another form of compiler level integrity exists here, and the addition of in particular a value which must carry all the way up the chain of digits must be accounted for. One plus one equals zero... carry one. One plus one plus one equals one carry one. That causally the first (lsb) can affect the largest bit (msb) and that it must logically pass through all the other bits; thus the value 111...11 and the value 000...01

Carry Lookahead saves the day? https://www.ece.lsu.edu/ee3755/2013f/cla.pdf
https://en.wikipedia.org/wiki/Carry-lookahead_adder
So does ripple exist in our operations?
Or is it the mathematician who is pure, and the hardware has it wrong?
Can mathematics devoid of timing concerns then implement an f(t)?

I'm sorry I've gone off the deep end here. Even I do not wish to face such complications. Yet they are the complications of the modulo value.
As to who obeys closure; even a switch has bounce. I had to look up the RMW acronym. I've dealt a bit. semaphore lockups are problematic.
The idea that we are going to eventually provide a compiler that will not allow buggy code to exist is not on the forefront.

[Ross A. Finlayson]

Or, allow it to change its data according to access and store.

Fence

Write-only RAM, Read-Write RAM, ....

I think fences are offsets, also in the usual instruction
I think it's offset not the allocator. [Consume to the fence.]

There's fence and boundaries and barriers, I suppose.

My organizations are very simple and for example API is fence.

The mode, in terms of fence, is also for real fence in mode.

How about a "very simple General Purpose Unit abstraction"?

I studied the Itanium and x86, Sparc, RTL, general purpose,
multiprocessing, ....

Then there's "MiX" or something, way too complicated.

Though, it also has a tape abstraction, ....

When fence is boundary, ..., barrier.

Usually computing the bounds for the allocator,
in terms of "move the fence once" or allocate,
aligned allocation and access can be incredibly performant,
over usual step fault.


"The usual step fault of the general purpose."

[Ross A. Finlayson]

The general branch predictor, reflects branch is fault.

[Ibes Confortola]

Ross A. Finlayson wrote:

>> > What is fence?
>> an atomic instruction a semaphore is using, to protect a region from
>> changing its data.
>
> Or, allow it to change its data according to access and store.
> Fence Write-only RAM, Read-Write RAM, ....

not sure, too advanced for me. Actually today you never read from RAM in a
semaphore situation. No time for it.

[Ross A. Finlayson]

Also there's where the generation of pemutations can
be parallelized, and where parameters result constant
time, ..., the "adaptive" has that "every data distribution
defines a perfect implementation", while though "each does not".

That the general purpose for unbounded categories or values
has that a general purpose for bounded categories, admits a
machine that works up in space bounds, what defines access
in terms of access and store and that linear contiguous access
results constant rate over the access of values, in category.

The adaptive containers in the small for organization of categories,
is much different than besides usual Big O, always including that
besides "Big O is only time", that "Big O in space is either co-linear
with Big O in time, or, not", and why compression includes general
purpose compression, and, automatically adapting objects to closed
categories in value including their behavior.

The SIMD single-instruction multiple-data, and for example single/multiple
producer/consumer, in cooperation or multithreading, it's usual vectors and queues.

Then, event-driven transfers, are all most usual in the runtime, also IPC,
inter-process communication. (That processes that share state are one process.)

Most I read is dirt simple property adaptation, at some point it was arrive at
that computer science was the art of naming variables, and they weren't
named data or x, that it pretty quickly ran out in simple names.

That though ends running in a stack all "stack segment deep", usually
"this process is an IPC wait".

Or, you know, variously plodding or screaming.

Making dictionaries, ..., adaptive containers, ..., shouldn't that all be
normalizable? "Natural language parts of speech are simple".

Really it should be "making AI is really too easy".

Here for machines of a general purpose unit, then there's the theory
that the special purpose unit runs it to eternity in an instant.

Then, there's whether the cost of building them is worth it.
(To teach the programmer the world of its function according
to that the runtime might be adaptive, anyways.) Here that
it's not is a usual sand-castle, still though that it makes sense
deep in the stack, that locals are together process and state
and simply their own small and direct stacks.

It's said the "stack machine' is a usual model of computation,
register stack machine.

(And that connected state is also locals, ..., under the definition
of that only atomic state is locals.)

Undisturbed is often in effect atomic, ....


Your vector I/O and your preemptive multithreading and your
spinlock or wait, in your mutex or IO port, and using RAM
of whatever burst buffer cache vector I/O grinds off least
context most I/O, don't mock me your "don't even use RAM"
when you just de-nice'd yourself your SSL termination.

[Ross A. Finlayson]

... it's a memory fence.

[Sergi o]

On 9/21/2022 2:17 PM, mitchr...@gmail.com wrote:
>
>
> Why does .333 repeating have a remainder of 4?

.333... = 1/3

1/3 remainder 4 = 13/3

are you using Base(13/3) ?

[Sergi o]

my first course was MIX an easier version of ASSY language, but below C, we had to write a linking loader, was about 1200 lines.
You have one bit wrong and you're hosed. Mine almost worked. primitive stuff, but highly necessary

[Sergi o]

no, you and your friends are still nodding your heads.

>Computers work naturally with halves and halves of halves in terms of division.

no, it is just binary shifts (L or R) and adds

>How interesting that division devolves into rotation of digits down at a simple level when we remain within our modulo system.

no. Its shifts and adds.

>
> I, state your modulo, do hearby swear that all my values that I ever commit to memory or paper shall be, state your modulo, especially when I do not state their modulo.

I think you live in a modulo. Module(pi) ?

>
> And of course this boiler plate filled out reads:
> I, modulo-10, do hearby swear that all my values that I ever commit to memory or paper shall be modulo-10 especially when I do not state their modulo.
>
> And yet the halves and the tenths are just passing values to those who are rationally behaved.
> To get there fast you'd have stayed in one or the other but instead the works plod along as if to say that twelfths are finer than elevenths. Along this way you might meet the sixteenths, but don't look back. To remain rational never look back, for that way lays modulo 10. Do not state your name and never utter even the very concept of the modulo value. Let that be a lesson to those who are interested in getting to larger values; or smaller values, as the case may be.
>
> Even the humble addition can be said to have issues: I didn't realize it until bumped into a Digi-Key video recently coding an FPGA to add or count within a phase locked loop system. The humble adder has to perform a carry operation, and this then introduces a subtle delay since while the bits of each value to add could have been presented in parallel, the cascading effect of the carry operation has to be accrues over every bit of the add. This means that the challenge of adding 64 bit values does actually rise over the 32 bit case. These are subtle effects that have to be put before the hardware engineer and failure is not an option. Another form of compiler level integrity exists here, and the addition of in particular a value which must carry all the way up the chain of digits must be accounted for. One plus one equals zero... carry one. One plus one plus one equals one carry one. That causally the first (lsb) can affect the largest bit (msb) and that it must logically pass through all the other bits; thus the value 111...11 and the value 000...01

Good! you looked it up. tedious low level stuff that is required of all computer functions.

[Ibes Confortola]

Ross A. Finlayson wrote:

> The SIMD single-instruction multiple-data, and for example
> single/multiple producer/consumer, in cooperation or multithreading,
> it's usual vectors and queues.

ohh yeah, I remember now, I need to recap. You are great.

[Jim Burns]

On 9/24/2022 11:42 AM, Timothy Golden wrote:

> If we sit here and nod our heads
> while mathematicians claim that
> the continuum is found by dividing one integer
> by another integer and landing with a float
> then the game is given away.

That's not the continuum.
Floats are not real numbers, whatever you call them.
Floats are not points in the continuum.

The _continuum_ is what is needed in order for
a _continuous_ function to behave how we intend
it to behave, given what we mean by "continuous".

A _continuous_ function is:
if you give me a bound on variation in output,
I can give you some bound on variation in input
that will keep the output within your bound.
OR
_Continuous_ functions don't jump.
Where a function jumps,
where it's discontinuous,
a bound on output less than the jump cannot be
obeyed by any non-zero variation in input.

A continuous function is continuous at
every point: no jumps anywhere.

However,
some notions of "every point" do not have
enough points. Not having jumps _at those points_
is not enough.

For example,
we might declare the rationals to be _all the points_
The function f,
f(x) =
{ 0 x*x < 2
{ 1 2 < x*x

is continuous at all the (rational) points.
And yet it jumps!

There needs to be a point sqrt(2)
for f(x) to be continuous at.

More generally,
for any partition of the continuum into
_all one side_ and _all the other side_
there needs to be a point between sides at
which continuous functions can be continuous.

Anywhere there are sides without a point-between
there can be a jump in a (by definition)
"continuous" function.

That's why floats are not reals.
Floats don't do the job we want done.
Reals do that job.

----
Requiring a point between sides
is Dedekind completeness.

Requiring that,
if
f(x) is continuous at each point of
closed interval [a,b]
then
f(x) has each value between f(a) and f(b)

is the Intermediate Value Theorem.

[Ross A. Finlayson]

There's usually a small floating point constant defined,
according to single or double precision floating point,
its name is epsilon and two floating points differing less epsilon
aren't distinguishable or ordered.

Which otherwise they all are, ....



"Gaplessness", will do, right? Completeness?

The intermediate value theorem is then used right away
to arrive at the fundamental theorems of calculus, usually.


Of course, floating point and fixed point and extended precision
are only finite precision, it's totally agreeable, while at the same time,
any symbolic calculator is free to deal in algebra, then about
perfect algebraic and transcendental constants and their neighborhoods.

The, "interval arithmetic", basically can hold up, "significant values".


You describe a revered and accepted formalization of real analysis.

There are others, ..., or rather, there's line reals, and first.

Basically a continuous space of numbers fills our discrete space of words.

[Chris M. Thomasson]

They are meant to define a memory visibility order in a multi-threaded
program. Now, there are two kinds of fences, compiler and one for
memory. In C/C++ a compiler fence would be atomic_signal_fence, and a
memory barrier would be an atomic_thread_fence. The compiler fences are
meant to prevent a compiler from making optimizations that can break a
single threaded program that has to deal with signals. The memory fences
are meant to order memory visibility. A memory fence implies a compiler
fence, but no the other way around.

[Chris M. Thomasson]

Oh cool. You programmed for the SPARC as well? Remember the good ol'
MEMBAR instruction? Iirc, an acquire barrier is:

membar #LoadStore | #LoadLoad

and a release is:

membar #LoadStore | #StoreStore

works perfectly for a mutex. Now, remember that deadly performance
destroying #StoreLoad? IT had to be used for more exotic algorithms that
depended on a store followed by a load to a different address. Think of
the SMR, or hazard pointer, algorithm if you will.

Remember back on SPARC where is is a no-no to put a membar instruction
in a branch delay slot?

Good times. Actually, I won a contest called CoolThreads by Sun. My
project was called vZOOM. I won a SunFire T2000 server!

Programming for the SPARC in RMO mode was always fun. ;^)

[Chris M. Thomasson]

On 9/24/2022 9:31 AM, Ross A. Finlayson wrote:
> On Saturday, September 24, 2022 at 9:20:19 AM UTC-7, Ibes Confortola wrote:
>> Ross A. Finlayson wrote:
>>
>>>>> What is fence?
>>>> an atomic instruction a semaphore is using, to protect a region from
>>>> changing its data.
>>>
>>> Or, allow it to change its data according to access and store.
>>> Fence Write-only RAM, Read-Write RAM, ....
>> not sure, too advanced for me. Actually today you never read from RAM in a
>> semaphore situation. No time for it.
>
>
> Also there's where the generation of pemutations can
> be parallelized, and where parameters result constant
> time, ..., the "adaptive" has that "every data distribution
> defines a perfect implementation", while though "each does not".

[...]

Have you ever developed adaptive mutexs? They can be useful by trying to
avoid a trip to the kernel to wait. Call that a slow-path. The trick to
creating scalable sync is to cleverly avoid a slow-path when you can.

Btw, have you ever worked with RCU?

[Chris M. Thomasson]

[...]

Remember that odd instruction for Itanium, iirc, cmp8xchg16? Had to be a
special way to avoid the ABA problem in some lock-free algorithms.

[Jim Burns]

On 9/25/2022 2:43 PM, Ross A. Finlayson wrote:
> On Sunday, September 25, 2022
> at 10:33:09 AM UTC-7, Jim Burns wrote:

>> The _continuum_ is what is needed in order for
>> a _continuous_ function to behave how we intend
>> it to behave, given what we mean by "continuous".

>> A continuous function is continuous at
>> every point: no jumps anywhere.
>>
>> However,
>> some notions of "every point" do not have
>> enough points. Not having jumps _at those points_
>> is not enough.
>>
>> For example,
>> we might declare the rationals to be _all the points_
>> The function f,
>> f(x) =
>> { 0 x*x < 2
>> { 1 2 < x*x
>>
>> is continuous at all the (rational) points.
>> And yet it jumps!
>>
>> There needs to be a point sqrt(2)
>> for f(x) to be continuous at.

> There's usually a small floating point constant
> defined, according to single or double precision
> floating point, its name is epsilon and
> two floating points differing less epsilon aren't
> distinguishable or ordered.

And that would not be the continuum,
That's not even the rationals.

The continuum fills a certain role:
Enough points in order that "continuous"
functions can't jump.

We would not discuss whether triangles
"really" have three sides, would we?
That's what we're doing.

> "Gaplessness", will do, right? Completeness?

There are two kinds of gaps to consider.

Interval-gaps, where two distinct points
have no points between them.
Your floating-point constant epsilon
has interval-gaps.
Rationals eliminate interval-gaps.

One-point-gaps, where points on one side and
the other are closer than any non-zero distance,
but there is no point-between.
The rationals have one-point-gaps, like sqrt(2).
The reals eliminate one-point-gaps.

Yes, eliminating one-point gaps is
Dedekind completeness.

> The intermediate value theorem is then
> used right away to arrive at the
> fundamental theorems of calculus, usually.

Agreed.
IVT provides the means to prove a value exists,
from very general conditions.

We want to prove a derivative _exists_
an integral _exists_
IVT is useful here.

> You describe a revered and accepted
> formalization of real analysis.
> There are others, ..., or rather,
> there's line reals, and first.
> Basically a continuous space of numbers
> fills our discrete space of words.

If there aren't enough points for
a point between each split,
then what you describe does not fill the role
which we intend to have filled.
"Continuous" functions might have jumps.

If there are enough points for
a point between each split,
then what you describe are
the Good Old-Fashioned Real Numbers.

Consider two versions ℝ₁ and ℝ₂

Map
0₁ ⟷ 0₂
1₁ ⟷ 1₂
if n₁ ⟷ n₂ then n₁+1₁ ⟷ n₂+1₂
If p₁ ⟷ q₂ and q₁ ⟷ q₂ then (p/q)₁ ⟷ (p/q)₂
For 𝐴₁ ⊆ ℚ₁ and 𝐴₂ ⊆ ℚ₂
if 𝐴₁ ⟷ 𝐴₂ then lub 𝐴₁ ⟷ lub 𝐴₂

Thus
for x₁ ∈ ℝ₁ and x₂ ∈ ℝ₂
x₁ ⟷ x₂

[Ross A. Finlayson]

I mostly tried to understand that Sparc is ring registers and
about how fault works, while, x86, is, after eax and so on,
the, Itanium, was designed in some superscalar many more registers,
also it had its thread context notion basically designing in the
Itanium chip, what would've resulted its server class.

So, otherwise besides "mostly I just studied the instruction
manuals and read all the program developer documentation",
just to understand what computing architecture is and along
the lines of 286 through later Intel chips and commodity chips,
that I theoretically understand how computers work and know
enough to write my own routine, basically from "PC".

Mostly from PC, I was just looking at writing UEFI modules and
using Secure Boot to make an executive or operating system,
in terms of that a really simple real-time system or even a clunky
software stack, could run a program like a web browser, while
having all throughout the entire usual software stack, ..., what
comprises a CPU and a disk controller and the bus and GPIO and
the USB controller and the video output and the network and
"programming the PC" and "building PC systems".

I like the idea of basically programming an emulator on the
PC though that it emulates a PC.

Let's start with all computer machinery as real simple, for where
"user mode and kernel mode are about same, ...",
or something like "write Orange Book like Sun Sparc or NT",
for making the world of virtual adapters a very "open" book.

You're talking resources, concurrency, a usual distributed
locking might be opportunistic or in a protocol itself of
consistent concurrency and the "eventually consistent", besides,
whereas according to resources synchronized, the CPU is free to melt.

I wish I was a demo coder but I'm only a specs collector.

Anyways though "writing an OS" can be at least pretty simple.

Write an OS, ..., write a controller boss, write an executive, make a
memory manager, reflect on BeOS and why it was the coolest thing
along with Amiga, implement the protocol stacks and their layers,
implement a disk and I/O access routine, employ the controller bus
and GPIO, manage USB and AT code the wifi chipsets, make for the
display controller a frame buffer or drive it, computers these days
are _way_ more complicated than they need to be.

So, Sparc fundamentally to me is ring registers, unique that way,
while Power and x86, ..., the 68000 and 86 are so different, ...,
the Itanium was or is about carrier class, then really it's the bus
and controller DMA, GPIO, ..., vector I/O, DMA, ..., DMA.


The DMA is "Direct Memory Access", really though USB chipset
usually has all sorts devices in its world just like PC, exact same.


(My approach these days for protocol is cooperative multithreading
the "re-routine".) I live in a world of runtimes.




What's an RCU? Yeah, maybe.

I've programmed variable bit-length coding and so on before if that makes sense.

Mostly I implemented some machines in word operations for linear speedup
the alignment for consuming bit-streams, low-level.

Certainly though I depend on usual flow of control and
context and state and according to that non-blocking I/O's
employment of DMA is very critical to its performance as
an example of what isn't just linear speedup but traction, at all.

My current synchronization primitive, is the slique, it's a queue,
that allows, reading into the mark and then atomic swap on that,
so that when it's determined a message can be consumed, ,
it's not a linear operation except to consume the queue.
This is for vector I/O with DMA pretty much the idea from
the "Meta: a usenet for just sci.math", ..., thread.

"Murphy's world of distributed business routines".

Anyways let's talk about how easy it is to write an OS for a PC for an example.

[Ross A. Finlayson]

comp exchange remembers!

Makes me think of muldiv. Ah, ..., muldiv.

You know the dining philosophers was a thing about ring buffers,
wow then besides Sparc, for example x86 is so great in some of string
rep branch, ffs or find first set, population count, still the 68000 had
a very strong affinity, what's called a Motorola DSP.

I knew much strong coders than me, Ataris, ..., 8, 16-bit.

I knew code, though, and there was poke. (Which sets a value in the frame buffer.)

Then all this "world of ARM" and "meh".

Yeah I think computers can be really simple for people to employ.

[Chris M. Thomasson]

Nice! Have you ever explored the Cell processor, iirc ps3 had them. The
inherent distributed nature of its programming. I think it had a PPC or
two for its main work.

>
> What's an RCU? Yeah, maybe.

RCU is Read-Copy Update. It's a highly scalable method for thread
synchronization in read-mostly workloads. Here is a talk on it:

https://youtu.be/Gi3EjaIq_gE

[...]

[Chris M. Thomasson]

On 9/25/2022 2:32 PM, Ross A. Finlayson wrote:
> On Sunday, September 25, 2022 at 1:59:31 PM UTC-7, Chris M. Thomasson wrote:
>> On 9/24/2022 9:31 AM, Ross A. Finlayson wrote:
>>> On Saturday, September 24, 2022 at 9:20:19 AM UTC-7, Ibes Confortola wrote:
>>>> Ross A. Finlayson wrote:

[...]

> What's an RCU? Yeah, maybe.

[...]

https://youtu.be/qcD2Zj9GgI4

https://patents.google.com/patent/US5442758

[Timothy Golden]

There are continuous functions that your analysis cannot touch, such as the three body problem.
The computer will have no trouble crunching out a five body problem.
Other problems that analysis cannot solve but the computer simply goes piecemeal and works out the integral just as Newton's method describes.

https://math.stackexchange.com/questions/2603031/unsolved-elementary-integrals

In that real numbers are an idea and that these concepts fill or cover the ground about them: the rational value as the division of two integers is a compromised birth of the continuum. Did you expect to multiply a real by an integer and get an integer back? That would be the reverse operation, but you see the product is the fundamental operation; not division. And so the very usage of division is suspect.

[Ross A. Finlayson]

The "update" problem is one of those really critical things you mention.

This is where "update is epochal", for a small event, besides for example,
a transaction, in terms of that when update completes, the resources exist again.
(The resources to complete the transaction.)

Combining operations on the state of what is a context, say, read, copy, update, ...,
that can be "epochal" in what otherwise is "three serial operations", that "serializing
the context", makes one, giving amazing speedup and dropping down blocking in
resources, to allow that constant-rate type flow results, "scaling the resources".

Here for example with "time-series and universal identifiers", in a world of "no drops,
no dupes", the contents of data, we have the serial and we have the parallel and
protocols and atomicity in critical sections and "eventual consistency", according
to protocol in resources "drives lifecycle events in interactive and mechanical work-flows".



Then, for making a simple user mode, here what we're talking about ".333, 4", at
least we're all clear here that it's not ".333, 44". I.e., it is _all 3's_, at most only one 4.

Now that in the geometric and those roots, then also we can talk about what it
meangs when it starts going ".333 ... 444..." that that's _not_ the result of division
that fraction and ratio, but, it is very like division at least having all 3's in the front,
while different from division "according the geometric series this is how it is rounding".

I.e., when that drops to "half 3's, and, half 4's, its expected in a few operations that
it will round over to .444...".

Now it's a machine.

[Ross A. Finlayson]

Well yeah that's "agreeable" though when you have
least upper bound there as a property, the model provides it.

Here the lines real's inclusive property is courtesy construction, ....
("Least upper bound property", another gaplessness, "inside the
open and closed".)

So, reducing your R_1 and R_2 to copies of the unit interval, ....

[Sergi o]

write an OS using FORTH...

[Ross A. Finlayson]

Isn't forth like modula?

If forth's like modula, modula's about the greatest.


About "update", the key here seems "invalidation", basically that invalidation is
free to cascade what drives conditional update. (For example that it drives
unconditional update.)

Or, it's a key simple approach what makes in a framework a default well-defined
event model, that happens to include abstractly Murphy's law or the failed connection
or dropped item, in events, while at the same time that concretely, those drops are
only abstract, and the memory-machine is in--place. (It's high-performance.)

Still the bottleneck is maintaining a unique ID for the ID item, the key, then,
maintaining the forward-safe, self-healing, well-defined forward state machine,
distributed model of distributed operation. (Or, I serialize asynchronous I/O this way.)
Then the critical section can be truncated after dailies or bad rows / latelies.


Here there's no .333, 2, at all, though the idea of what happens when the thirds are a dial
and bending the handle of the dial toward .444 or .222 just results a bend in the handle,
where the dial is parallel to one third, .333... while the handle is parallel to 4/9, .444, ...,
then that after the dial moves the dial is parallel also. (A flex.)

Which, according to a readout of an atomic clock lattice, is a number.

[Ross A. Finlayson]

No, modula is not from forth.

[Sergi o]

no, but its dead like modula, forth is RPN stack machine , great for small fast controllers, but troubleshooting is extremely hard

https://en.wikipedia.org/wiki/Forth_(programming_language)

[Jim Burns]

On 9/26/2022 8:52 AM, Timothy Golden wrote:
> On Sunday, September 25, 2022

> at 5:29:06 PM UTC-4, Jim Burns wrote:

>> If there aren't enough points for
>> a point between each split,
>> then what you describe does not fill the role
>> which we intend to have filled.
>> "Continuous" functions might have jumps.
>>
>> If there are enough points for
>> a point between each split,
>> then what you describe are
>> the Good Old-Fashioned Real Numbers.

> There are continuous functions that your analysis
> cannot touch, such as the three body problem.
>
> The computer will have no trouble crunching out
> a five body problem.
> Other problems that analysis cannot solve
> but the computer simply goes piecemeal and
> works out the integral
> just as Newton's method describes.

By "cannot touch", you seem to mean
"don't know how to compute".

Yes.
That's a feature, not a bug.

The paradigm we're using is
|
| Finite you finitely make a finite claim
| which is true of each one of certain things,
| infinitely-many certain things.

We describe a _function_ in a broad sense,
making claims which are true of each thing
we consider a _function_ (of infinitely-many).

And then, we proceed from there, to further
claims, carefully, so that our claims _remain_
true of each thing we consider of function.

This paradigm gives us the ability to refer to
and reason about functions which we don't know
how to compute.

Sometimes, we learn how to compute them.
That will always start by describing them.


When we use a computer to crunch the numbers
for something like a five-body problem,
_how we know what to crunch_ is a result of
describing functions in that broad sense.

That particular number-crunching answers
a question. The question is rooted in our notion
of continuum:
enough points that no jumps are allowed.

[Jim Burns]

On 9/26/2022 11:45 AM, Ross A. Finlayson wrote:
> On Sunday, September 25, 2022

> at 2:29:06 PM UTC-7, Jim Burns wrote:

>> If there aren't enough points for
>> a point between each split,
>> then what you describe does not fill the role
>> which we intend to have filled.
>> "Continuous" functions might have jumps.
>>
>> If there are enough points for
>> a point between each split,
>> then what you describe are
>> the Good Old-Fashioned Real Numbers.

>> For 𝐴₁ ⊆ ℚ₁ and 𝐴₂ ⊆ ℚ₂
>> if 𝐴₁ ⟷ 𝐴₂ then lub 𝐴₁ ⟷ lub 𝐴₂

> Well yeah that's "agreeable"
> though when you have least upper bound
> there as a property, the model provides it.

"A point between each split" is equivalent to
the least upper bound property.

Suppose you have a bounded non-empty set 𝐴 of
points in the continuum.

A split 𝑈,𝐷 exists such that, on one side, all
the bounds of 𝐴 are, and, on the other, all the
other points of the continuum are.

Each split has a point-between.
For the split 𝑈,𝐷, the point-between is lub 𝐴


The least upper bound property,
Dedekind completeness,
a-point-between-each-split,
..

One more way to describe the reason that
we pay more attention to the real numbers
than to some arbitrary theory is that,
if, two _continuous_ curves cross,
then they intersect at one or more points.

Not everything is like that.
Not everything is what we mean by "continuum".

[Ross A. Finlayson]

What you figure is the gainer, here what you provide here is for something
like a smooth integument, described under cuts and completeness and also
"what is maintained in splits, or cuts", splits are usually in the middle while
cuts are on the ends, of the integrable regions.


Two lines cross on a plane, while, they converge on whatever surface they are on.

Lines that touch either cross, and touch once, or converge, and touch forever,
or at the point of tangency, contact.

Parallel lines in perspective to infinity all converge to a point at infinity.

Here the point is these two segments make a translation-invariance,
the integer part is free of the non-integer part in the ordered field,
which essentially has no integer part, as the usual set that models it
in equivalence classes of values, which for example are written in usual conventions.

After courtesy properties of the real numbers "after upholding least-upper-bound property".


Angle-preserving is pretty much box-preserving. (Integrable integument.)
So, for example triangle inequality is one of the next properties there.

Triangle inequality is really great and about a key feature in what all
results most usual linear terms in the physics derivations from school.

[Timothy Golden]

And doesn't this bring into question the validity of the split or cut?
These are unremarkable on the discrete version, whereas issues of an open or closed point on one side of a cut or another arise within the real segment. Graphically a closed circle and an open circle must be presented for a cut at 2.000...
You had to have put the 2.000... on one side of the cut or the other in order for the surgery to reassemble perfectly.
Actually I do see options here, but I don't mean to digress. In the integer form you just 'cut' somewhere between 2 and 3 and there is no slop nor open nor closed point to worry about.

This graphically is problematic in that we just put the integers on the real line. It looks valid from traditional analysis, but in that a discrete system should remain discrete, and maybe the cut should remain at two in this way rather than getting that little lift I gave it, well, it seems to me again that the options to allow the two to go to both sides is fine. So long as the reverse operation recovers the original then all is well, isn't it? the whole segmented notion here is actually not so applicable to the construction of number itself. At least not when the modulo system is engaged. Leaving out the modulo mechanics within this analysis is the worst failing of this analysis.

Engaging the modulo mechanics we see that digits form our numbers. We see that we can freely construct numbers. We see that man has already constructed
0.333...
and so to construct
333...33
is not so far off, and then neither is
333...34
so far off again.

This freedom to construct has not been falsified by these analyses. That these numbers are natural with the exception of the successor problem is fine. That the Peano axioms are not necessarily consistent with this representation is not a stopper. The consistency of these values as inductive by nature is obvious.

[Jim Burns]

On 9/27/2022 9:42 AM, Timothy Golden wrote:

> We see that we can freely construct numbers.
> We see that man has already constructed
> 0.333...
> and so to construct
> 333...33
> is not so far off, and then neither is
> 333...34
> so far off again.
>
> This freedom to construct has not been falsified
> by these analyses.

There exists a great deal of freedom to construct.

Also, a great deal of freedom to describe.
So much freedom that we can describe things
which cannot exist.

Yay, freedom, but that isn't a particularly useful
thing to do. The point of constructions is to
prove that what's been described exists.

( We start with an agreement that certain other
( things exist, such as sets of some description.
( I am not aware of any other kind of construction.

The description is prior to the construction.
The description provides the reason for the construction.

I wouldn't be at all shocked if we could construct
some model of 333...34 and its ilk in ZFC.
But are they natural numbers?

That is entirely a question of what a natural number
and its ilk are. A question of description.

> That these numbers are natural with the exception
> of the successor problem is fine.
> That the Peano axioms are not necessarily consistent
> with this representation is not a stopper.

I see you addressing the question of what a
natural number is. Thank you.

However,
I think that what we mean by "natural number"
should be consistent with the Peano axioms.
That would make it a stopper.

> The consistency of these values as inductive
> by nature is obvious.

No, I don't think so.
It's not clear to me what 333...34 is intended
to represent. I've suggested that it comes
after each of
4
34
334
3334
..

and you responded in a way that took the
correctness of my suggestion for granted.
So, I'll assume that's what you mean.

_That_ -- the thing after each of _those_ --
represented by 333...34, is not a natural number.

It is a common metaphor to say that induction
_reaches_ infinitely-many natural numbers.
It is a misleading metaphor.
It suggest that some kind of infinite procedure
of reaching is performed when we use induction.
No infinite actions are performed.

It is less picturesque, but also less misleading
to say that induction _is true of_ infinitely-many
natural numbers.

But what is a natural number?
How I would say it is that a natural number is
something which can be counted to.

You have emphasized successors and predecessors,
and they are certainly needed, but the ability to
be counted to depends upon the territory
between a candidate-natural and 0

I imagine some sort of map like
4
34
334
3334
..
----------------------------
..
(Here Be Sea Monsters. Arrr!)
..
333...34

If 333...34 can be counted to,
wherever that map is split, there needs to be
a step from one side to the other.
Or else, you can't get there from here.

333...34 fails that test of being a natural number
because,
whatever Sea Monsters be after the line,
no step crosses the line.

No step crosses the line
because
each step which starts on the near side
ends on the near side.

The presence or absence of Sea Monsters
doesn't enter the discussion.
It follows from the nature of 4, 34, 334, ...

That is why I say 333...34 is not a natural number.

[Timothy Golden]

I don't understand this usage of 'split'.
If you go ahead and demonstrate the conflict that would be fine.
It's obviously an infinite value, so denying its inductive nature isn't going to fly.
A natural number can be regarded as a series of digits.
Clearly this is an infinite series. Do you deny other infinite series?
Or just this one?

What we have is a new interpretation of infinity here.
It is unusual to be able to name multiple instances of infinity that do have successors.
333...33 + 1 = 333...34
Obviously we cannot count to infinity. I am not going to be able to deny that.
Still, with the numerous concerns around large values these do inform the user very well.
In some regards WM is correct on his interpretations. In other regards though he is wrong.
I can say this based on these infinite values and their computable behaviors.
Whatever 'the line' is these numbers have definitely crossed it.
They will only ever work via induction but it is a very simple form of induction.
The fact that such a simplistic form exists: the ones who wrote 1/3=0.3333... have helped enable me to develop this value.
Claims that the real number has an infinite trail of digits helps enable these values.
Reinterpreting the decimal point in terms of a secondary form of unity exposes that the number without any decimal point is a natural value.
Taking this approach on interpretations of unity exposes that the rational value as well may be done via this secondary unity reasoning. This then eliminates the need of worry about closure and the usage of division, for when six become one then one becomes one sixth. That this feature is only little different from our modulo usage of number is enlightening and exposes a breach that no clear-minded thinker will care to look back from. This attack, and I say that from the stance of game theory, is strong and will stand freely. The results expose that the real number is little more than a rescaled natural number. The conflicts of operator theory have evaporated. For instance claims that the square root of two is a number are falsified directly by recognizing that the expression contains an operator and so is not a pure value. This sort of contamination has been lived with and inbred into the mathematics curriculum. Likewise the value one sixth is not a pure value; it is two values and an operator, and so the 'rational value' is a barrier to clear thought. That it is followed by an 'irrational value' merely is icing on the cake that is now on your face.

[Chris M. Thomasson]

Fwiw, here is some of my i686 asm code from a while back:

https://web.archive.org/web/20060214112539/http://appcore.home.comcast.net/appcore/src/cpu/i686/ac_i686_masm_asm.html

2005? Wow, how times goes by.

[Chris M. Thomasson]

333...34 can be described as:

i[n] = floor((1/3) * 10^(n+2) + 1)

If not, why not?

[Timothy Golden]

That is some serious name mangling going on.
All to make sure other code doesn't step on your code?
Very strange.
I guess it'll link universally though, eh?
Just doesn't seem right though, honestly.
I do know though that C++ mangles things too.
Sorry I didn't really try to study the code.

Seems clear to me that this new representation is infinite. And that they are natural values.
That the digit has such power over traditional natural analysis: indeed it does.
The poor traditionalist has to creep along successor after successor. They finally make it to ten, and we're on up at
33333333334
or some such. This situation does not grow any better in time either. Some say that you'll never get there, and that is for sure with Peano at the helm.

[Timothy Golden]

This is a lie in these last two lines.
It doesn't follow at all. every instance in that sequence is natural valued. By induction we get that the ultimate value is natural.
Let's actually implement it within the sequence now:
4, 34, 334, ..., 333...34
That we can terminate this sequence is only possibly due to the embedded ellipsis, which you seem fond of ignoring. In that the ellipsis itself is inductive in nature: this point is not getting any attention in the discussion. Clearly the value is inductive. We will only ever work out its square inductively. Otherwise we will not be able to halt the operation.

The truth is that using digital analysis we've gone much farther than you can get with your incremental theory based on successors.
Best of all the usage of the ellipses here is of a simpler form: we merely remain constant with regard to its meaning. This is the least complicated usage of the ellipsis possible.

We can as well ponder the issue of a number whose digits are well defined and ask whether that number has two sides. Natural numbers are two-sided. They have a head and they have a tail. Now if we ask about infinity we know that we cannot pin down the quantity of digits for that will by definition be a finite value. Clearly this is the alternative, and it has a well defined head and a well defined tail. In this regard these numbers are natural valued, and by this detail their successors, sums, and even products can be computed.

The proper defeat of this construction is the defeat of the ellipsis as invalid on the grounds that the line does not halt. This is a direct ambiguity because by inserting the ellipses rather than carrying on indefinitely the line has halted. This is the logical contradiction of the usage of the ellipsis. If we consider whether the mathematician could have gone on forever at the line with the ellipsis in it he could not ever have gotten to the next line, and since the next line exists he couldn't have gone on forever at the ellipsis.

I believe this last paragraph is close enough to traditional logic to grab somebody who reads it. That mathematics can scarcely dodge the usage of the ellipsis is problematic. That all works must halt, for if they do not then there can be no result, and the purpose of the work is to get a result. The only way out is to engage induction at every ellipsis, which is merely to say that the next step is obvious; there are no surprises ahead; do not carry on here forever because you will never return. Trust that all is well here. If something were broken it should be evident already. When something breaks it will be remedied. This latter is the more practical stance. For instance on paper using an eighth of an inch for your numerals an 8and1/2 inch sheet will support 68 numeral glyphs on one line. Clearly to exceed this limitation some ad-hoc notation will implement a continuation of a number to the next line or some such contrivance which could lead to confusion, but would only have to be dealt with upon reaching that limit. We cannot freely insert characters into a modulo-ten value for it would no longer be a modulo-ten value. In this regard we can state that shrugging off these matters as 'just notation' is a fraud of inductive nature, whose purveyor would say: "I can see that it will all work out". By the time all conventions are exposed; all notation carefully defined, there will still be a need for an ad-hoc solution, as when for example the arbitrary precision sage mathematics application runs out of room on a 2TB flash 32GB RAM system. The obnoxious nature of this situation is no different than the original usage of the ellipsis. Sage is only arbitrary precision up to the capacity of the system that holds it.

The usage of the ellipsis marks a stage of mathematics and the works which can be done without it ought to be carried out and investigated. For instance a natural numerical limit can be stated on modulo-ten values in that the polynomial representation which depicts the value ought not to use a value greater than ten, for that would then require the usage of a polynomial to describe that value. so the value 999999999 is arguably the largest 'polynomial natural' value that can be described within base-ten . This still does not alleviate the usage of 10 within the interpretation as:
9 x 10 ^ 9 + 9 x 10 ^ 8 ... + 9 x 10^0
Possibly this finite limit is of interest down in the lower forms, where 3(base-ten) is the largest value in base-two:
1 x 10^1 + 1 x 10 ^ 0
which is 3base-ten and now in this progression base-three yields:
2 x 10 ^ 2 + 2 x 10 ^ 1 + 2 x 10 ^ 0
which is 26 base-ten. In ordinary terms these are n^n-1 natural limits. It's a strange concept, but if there is some cause for natural finite limits, these here do fit a requirement at least. Nicely the modulo-one system tops out at zero, thus establishing a denial of fundamental mathematics within these finite limits. Hah! I've disproven them already... unless there is some other way to base two and so forth. Now the gears of the numbers would have to come under investigation. Sure enough the first usage of a new glyph to pass beyond base-one was a unital interpretation.
These figures aren't bad in that early string theory did want 26 dimensions, and three dimensions is our ordinary sense.
That's pushing awfully far, but as a finite theory the math will hold up. On the path to mixed modulo processing, maybe?

[Ross A. Finlayson]

The split or cut is where the point's line can bend, ....

The point of gaplessness of points is then it's a line, or curve.

(Or a neighborhood.)

It's all matters of perspective here two distant points,
and their relation other points which preserve perspective,
through quarter-angles.

Really I'm looking at the .334 and .332 as about a rotation,
that fundamentally, rotation is an increment on the "outside",
of the number. These day's i is the quarter-angle, simply that
powers of i are periodic and have two half-periods.

This is that ranging through non-integral powers of i,
that it starts on the outside and rounds that way, while
instead, the inner part is about the roots of unity,
separating the roots of unity from the powers of i.

Which together share all "complex analysis".

[Sergi o]

"split" is the result of "chop"
you chop then it splits

[Ross A. Finlayson]

33334 00001 <- ends down rounding, "would still carry"
33333 00000
33333 00000
33333 00000
33333 00000
rounds down

33334 00001 <- starts ending down , eg acceleration halves, ...
33344 00010
33444 00100
34444 01000
44444 10000
rounds up


The "333...34" is a notation.

Because the ellipsis means "un-ending", the notation usually demands
the ellipsis is only at the end after the radix.

The ellipsis of course is also written overbar, parentheses then ellipsis,
the overbar/parenthesized term is a repeated term, where otherwise
the ellipsis always means "repeating the terminus, the term".

Now, in any result that arrives at .333..., it's same as "thirds".
"Thirds" have no finite representations in bases co-prime to 3.
The result in a long division according to representation will always
have produced a .333 and always be carrying long divisiion on the last
.4.

It's then with subtracting those thirds, which according to deduction
are .333..., it results last "subtracting .333... then .333... then that
when it's only finite or there's still carry, the last "third" is .334.

Anyways the notation is a result of the repeating terminus, so,
real numbers with repeating terminus' (or, termini I suppose)
are perfectly well defined as happening to also be the rational
numbers' representation, where the real numbers have dual
representations, of .1000... and .0(b-1)....

Then, having "a value after the end", basically must reflect that
proportion is either defined the beginning or some "middle",
which would be some extension to the convention of the usual
notation.

I.e., "from the beginning, there's no way I can read off the elements
of these sequence and distinguish it some different 'end', there must
simply be something extra these quantities, then that whether it's
geometric or shares a parameter, or not, if not then it's totally irrelevant
and is so then it's germane, what could define enduring consistent notation,
in terms of what it defines and how it's defined". Of course there is a general
sense where there is none, so, that's because repeating really does mean un-ending.

Any sense of a new middle the ending has "there's an infinity at the end".
Then either "I made a projection into a finite space" or 'the middle goes
out to infinity and now there's two ends, and I made a projection into a
finite space", in terms of the total definition of the notation of real values after the radix.


Then for example if .333... X is a notation, having "X-1" for decreasing and "X+1" for
increasing, is for a measure of instantaneous rate of change, that the usual notation
means "constant". In that sense the notation simply implies value over time.

For the real value of the numbers these notations represent, is for real-valued variables.

[Ross A. Finlayson]

You can have roots of unity without having the imaginary, just
happening to meet at the circle - and that there's a writing of
one in powers of the other.

Mostly though of course they're introduced together and even
as the same thing.

[Ross A. Finlayson]

Yeah, up above the firmware and for after power-on self-test, and, about
"gotta support ACPI" or "this hack is a brick", basically there's definitely
for a modular kernel mode, or out of protected mode, for after boot, for
a manifest and a very simple assortment of hardware, that implementing
TCP/IP and DNS, and UDP, and ping and SNMP and "protocols", or a working subset of same,
is simple, then for some pretty minimal tools or "looks like POSIX", pretty much has
that for a pretty simple organization, makes PC operating systems 1000s
times faster and less-bloated.

Not to mention "secure on purpose".

"Sure, USB works, but only keyboard and mouse."

"There's a simple frame buffer adapter, multi-resolution according the output adapter or
rendering target."

"No, ..., netboot is optional."

'Simple as dirt."


"All systems based on the IBM-PC and PC/AT have the DMA hardware located at the same I/O ports."
-- https://docs.freebsd.org/doc/3.3-RELEASE/usr/share/doc/handbook/dma.html

"The single largest entity held in [Kernel Virtual Memory] is the filesystem buffer cache. "
-- https://docs.freebsd.org/doc/3.3-RELEASE/usr/share/doc/handbook/internals-vm.html

"Plenty stupid." "No automatic features."


Combined with a very simple network affinity system, providing services, more
or less makes an entirely "open-book / closed-peep" type "unhackable property".

"No maintenance required."

[Chris M. Thomasson]

On 9/28/2022 10:15 AM, Ross A. Finlayson wrote:
> On Monday, September 26, 2022 at 10:11:39 AM UTC-7, Sergi o wrote:
>> On 9/26/2022 11:06 AM, Ross A. Finlayson wrote:
>>> On Monday, September 26, 2022 at 8:57:21 AM UTC-7, Sergi o wrote:
>>>> On 9/25/2022 4:32 PM, Ross A. Finlayson wrote:
>>>>> On Sunday, September 25, 2022 at 1:59:31 PM UTC-7, Chris M. Thomasson wrote:
>>>>>> On 9/24/2022 9:31 AM, Ross A. Finlayson wrote:
>>>>>>> On Saturday, September 24, 2022 at 9:20:19 AM UTC-7, Ibes Confortola wrote:
>>>>>>>> Ross A. Finlayson wrote:

[...]

You might be interested in the following thread, wrt "trying" to get
some random number with a multi-threaded race condition:

https://groups.google.com/g/comp.lang.c++/c/7u_rLgQe86k/m/fYU9SnuAFQAJ

;^)

[Jim Burns]

On 9/28/2022 8:57 AM, Timothy Golden wrote:
> On Tuesday, September 27, 2022
> at 2:51:30 PM UTC-4, Timothy Golden wrote:
>> On Tuesday, September 27, 2022
>> at 1:56:45 PM UTC-4, Jim Burns wrote:

>>> 333...34 fails that test of being a natural number
>>> because,
>>> whatever Sea Monsters be after the line,
>>> no step crosses the line.
>>>
>>> No step crosses the line
>>> because
>>> each step which starts on the near side
>>> ends on the near side.
>>>
>>> The presence or absence of Sea Monsters
>>> doesn't enter the discussion.
>>> It follows from the nature of 4, 34, 334, ...
>>>
>>> That is why I say 333...34 is not a natural number.
>
> This is a lie in these last two lines.
>
> It doesn't follow at all.
> every instance in that sequence
> is natural valued.

What does it look like to be an instance in
that sequence?

i[0] = 4
i[i+1] = 10*i[i] - 6
AND
you _can_ get there from here.

What does it looks like to be able to
get there (i[n]) from here {4)?

For each _split_
there is a way across that split
a last-before j and a first-after k
for which we require k = 10*j - 6

( A _split_ is two subsets BEFORE and AFTER,
( both non-empty, together containing
( each instance from 4 to i[n],
( and each of BEFORE ≺ each of AFTER

That's what it looks like to be able to
get there (i[n]) from here (4).

> By induction we get that
> the ultimate value is natural.

No,
by induction we get that
each instance is a natural.

Being a natural follows from
being able to get there (AKA induction).

| Assume otherwise.
| Assume i[n] is NOT a natural.
| i[n] ∉ ℕ
|
| This split BEFOREₙ AFTERₙ exists
| BEFOREₙ = { j | ∀j' =< j : j' ∈ ℕ }
| AFTERₙ = { k | ∃k' =< k : k' ∉ ℕ }
|
| By assumption, we _can_ get there from here.
| Last-before jₙ in BEFOREₙ
| and first-after kₙ in AFTERₙ exist.
|
| From the definitions of BEFOREₙ and AFTERₙ
| ∀j ∈ BEFOREₙ : j ∈ ℕ
|
| kₙ is first in AFTERₙ
| ∀j < kₙ : j ∈ BEFOREₙ
| ∀j < kₙ : j ∈ ℕ
| ~∃j < kₙ : j ∉ ℕ
|
| kₙ ∈ AFTERₙ
| kₙ ∉ ℕ or ∃j < kₙ : j ∉ ℕ
| But ~∃j < kₙ : j ∉ ℕ
| kₙ ∉ ℕ
|
| jₙ ∈ BEFOREₙ
| jₙ ∈ ℕ
|
| jₙ ∈ ℕ kₙ ∉ ℕ and
| kₙ immediately follows jₙ in the sequence.
|
| However,
| kₙ immediately follows jₙ in the sequence.
| kₙ = 10*jₙ - 6
| if jₙ ∈ ℕ then kₙ ∈ ℕ
| Contradiction.

Therefore
i[n] IS a natural.

> By induction we get that
> the ultimate value is natural.

No,
we get that
each instance i[n] is followed by i[n+1]
Each instance i[n] is not the ultimate value.

We get that
no ultimate value exists.

> Let's actually implement it
> within the sequence now:
> 4, 34, 334, ..., 333...34

If
you can't get there (333...34) from here (4)
then
there (333...34) is not within the sequence.

There (333...34) is after all of 3,34,334,3334,...
Getting there requires a step j to 10*j-6
from not after all 3,34,334,3334,...
to all after all 3,34,334,3334,...

There is no such step.
You can't get there from here.
333...34 is not in the sequence.

> That we can terminate this sequence

You are mistaken about what is needed
to be in the sequence:
You _can_ get there from here.

Something not-in the sequence can be
after all of the sequence, but it is
still not-in the sequence.

> That we can terminate this sequence
> is only possibly due to the embedded ellipsis,
> which you seem fond of ignoring.

I don't always ignore your '...'
Repeating myself is boring.

Again, you are mistaken about what '...' means.

> In that the ellipsis itself is inductive in nature:

The ellipsis replaces detailed description
where that description is already obvious
and would only clutter the page, chalkboard,
or window.

It is the description which the ellipsis
replaces which is or is not inductive.
All the ellipsis says is "You know what I mean".

> this point is not getting any attention in
> the discussion.

Once you've been told you're reading '...'
incorrectly, there's not much left to say
-- at least, until you read it correctly.

> Clearly the value is inductive.

You can't get there from here.
It is not inductive.

[Chris M. Thomasson]

My labels in the asm code are highly verbose to be sort of self
documenting, in a sense. And, I use a namespace to separate my code from
somebody else's code. The namespace prefix can be removed for a release
build.

[Jim Burns]

On 9/28/2022 11:27 AM, Ross A. Finlayson wrote:

> The split or cut is where the point's line
> can bend, ....

This is not in the same spacetime continuum
as true.

> The point of gaplessness of points is
> then it's a line, or curve.

No,
the point of gaplessness is that
a function continuous _at every point_
will not have jumps.

Gaplessness makes sure that "every point"
includes enough points in order for
it to be true that there are no jumps.

[Jim Burns]

On 9/28/2022 11:54 AM, Ross A. Finlayson wrote:

> The "333...34" is a notation.
>
> Because the ellipsis means "un-ending",

The ellipsis does not mean unending.
What it means depends upon context.

We could use it here:
0 1 2 ... 10^(10^(10^(10)))-1 10^(10^(10^(10)))

Not endless. We use it instead of filling
multiple physical universes with 0's.

Here, it means "You know what I mean".
I hope you do. Isn't it obvious?

Elsewhere, it also means "You know what I mean"
but what you'll know is something else there.

Often enough, it means something that is
unending, because of where it's used.

> the notation usually demands the ellipsis is
> only at the end after the radix.

If the digits continue in some obvious way,
putting the ellipsis there would say
"You know how this continues".
_Really_ don't do that, though, if your reader
wouldn't know how.

----
How to say '...' without saying '...'

Inductive(𝐴) <->
0 ∈ 𝐴 ∧ ∀x ∈ 𝐴 : x+1 ∈ 𝐴

Inductive(ℕ)

∀𝐵 ⊊ ℕ : ~Inductive(𝐵)

That is what
ℕ = {0,1,2,3,4,...}
means.

The advantage of '...' is that it reduces clutter.

The advantage of not '...' is that these claims are
the seeds from which to grow more claims about ℕ
'...' not so much.

[Ross A. Finlayson]

Yeah, that was unusually loose, without connecting it directly
to the definition of continuous functions for any curves but
straight lines.

Then it looks just like smooth analysis, ....

[Ross A. Finlayson]

Sure, the usual notation for repeating is overbar,
or ellipsis, in this context it's mostly used for
extrapolation about the ends or the middle.

Writing in parentheses the repeating part then "dot dot dot"
is a usual notation for repeating terminus, when for example
the typesetting doesn't include overbar.

Then of course, R^bar, then I would talk about the various models
of R as sets, like R^bar, R^dots, ..., that I enjoyed defining.

Here then we're talking about the radix, "end radix",
and some, "middle radix". This is about the same modular
kernel for radices, usual most significant and this "middle least significant".



This is then directly for a usual both centralization and uniformization.


I studied at least about a year the probability theory - about a university
school year, so am much interested in that any non-standard numbers,
here as we're talking "Archimedean and non-Archimedean, though of course
maintaining linearity", would make via counting arguments for continuous cases,
analog results in probability theory.


At least these days something like "natural/unit equivalency function" is a function,
limit of functions, generalized distribution, not-a-real-function standardly modeled
by real functions, only/unique special not-a-real-function modeled by real-functions, ....

Something like unit impulse function had to wait some hundred more years.
Though, ..., it was carefully built up what results beiong formalized same way.
(It's a function.) (It's a function, in real-valued variables.)

Of course, then these functions in function theory, in set theory, are just as so:
modeled by real functions, according independent variables the parameter.

So, the unit impulse and unit step functions, are continuous, when it once wasx
that even only a vertical line was "not a continuous function". but, otherwise
was included "what is drawn without lifting the pencil", graph of a continuous function.
(Or curve.)


Then of course the natural/unit function is the special function from naturals to [0,1] in order
that is constant monotone strictly increasing. (Which results properties of the values under laws.)

[Ross A. Finlayson]

Nobody cares anything about unit impulse except its width is vanishing,
its height is a spike, and, its integral = 1.

Then there are any what sort functions build it, ....

There are certainly limits of standard functions which are also about the
most standard functions, ..., in fact that's a usual definition in continuous:
these are just, "extra" standard the "non" standard, part. (Not, "not" standard.)

[Ross A. Finlayson]

What now, ....

https://en.wikipedia.org/wiki/Atom_(measure_theory)

Define.

"Iota-values"

[Ross A. Finlayson]

I'll suppose they'll want sigma algebras for each all that, ....

Which I wrote.

[Chris M. Thomasson]

On 9/24/2022 9:57 AM, Sergi o wrote:
> On 9/21/2022 2:17 PM, mitchr...@gmail.com wrote:
>>
>>
>> Why does .333 repeating have a remainder of 4?
>
> .333... = 1/3
>
> 1/3 remainder 4 = 13/3
>
> are you using Base(13/3) ?

For some reason, I don't really think that Mitch knows much about what a
direct solution vs a recursive solution actually means.

[Ross A. Finlayson]

No, I think that is just a number coincidence, what is the
benefit of number coincidences is that a modular approach,
computes, past, the number coincidence, then rounds for
sufficiency, to where the small factors and powers in numbers
and abundant numbers, have cranked out their products in
parallel what is recursive. (While it's recursive, in a linear
system with constant evaluation bounds.)

I think of AP and AP kind of like mitch and Mitch, where for
example Mitch wrote all matters of Boolean satisfaction,
and AP is a giant geometer with 700 volumes, like Shelah.

[Ross A. Finlayson]

"First damn Wiki link I ever saw to "Stack Exchange"!"

"I'll suppose they'll want sigma algebras for each all that, ....

Which I wrote."

"Stack Exchange"



Heh, "first damn Wiki link I ever saw to Stack Exchange, ...".




I think "the method of least squares" is plenty simple.

You know it does kind of look good up here from Sierpinski's shoulder.



Yeah, I'd like their bibliography if you're going to link to them.


Or I can give them one.



This way I can add

"The modern ordering and elementary function from integers
countable to real unit [0,1] was rebuilt after running out foundations,
the tremendous modern iota-values and related theory".

Right here after:

https://en.wikipedia.org/wiki/Atom_(measure_theory)#Discrete_measures



Also, "if every atom is equivalent to a singleton, mu is discrete iff it is atomic".
There's: also, that "mu is discrete iff it is atomic and finite". (In iota-values.)

So, this way I have already wrote my next Wiki section, that I wrote, also.

[Ross A. Finlayson]

I'd say "Stack Overflow" is primarily advertisement-driven and not suitable for Wiki references.


Ha ha then this: "Dirac's atomic class, ...", same old "topology is empty' - same
"rationals/irrationals pair-wise".

Sure, I hung that on my door.



"Exists m, exists >> m".

Now my reputation points are gold, too.

Infinity negative gold.

Even my blog is great.

Read my questions.

[Chris M. Thomasson]

Interesting. Mitch said 13/3. Well, it most definitely can be exploited
in multiple ways:

13/3 = 4.33333333333333...

4 + 1/3 = 13/3 ?

Except, its backwards wrt 333...34, wrt:

34
334
3334
..


Humm... Interesting. Wrt 13/3 - 1 is = 3.333..., so we can scoot over
the endless three's, so to speak... Just like my direct solution does
for 333...34. Add one, to the the ending 4. Fair enough?

[Chris M. Thomasson]

On 9/28/2022 10:13 PM, Chris M. Thomasson wrote:
> On 9/28/2022 9:32 PM, Ross A. Finlayson wrote:
>> On Wednesday, September 28, 2022 at 9:28:37 PM UTC-7, Chris M.
>> Thomasson wrote:
>>> On 9/24/2022 9:57 AM, Sergi o wrote:
>>>> On 9/21/2022 2:17 PM, mitchr...@gmail.com wrote:

[...]

> Humm... Interesting. Wrt 13/3 - 1 is = 3.333..., so we can scoot over
> the endless three's, so to speak... Just like my direct solution does
> for 333...34. Add one, to the the ending 4. Fair enough?

Ouch. I mean add one to the ending three to make the four, in 333...34.

The floor operations basically strips off the infinite threes as in
floor(1/3) = 0

[Ross A. Finlayson]

Oh you mean storage?

[Chris M. Thomasson]

No. I mean getting rid of the string of infinite 3's (think base 10
representation), 1/3 = .3333333....

Fine.

floor(1/3) = 0
floor(.3333333...) = 0

However, floor(123456789.1011121314) = 123456789

To get 333...34 in a direct function, well, exploiting 1/3 sure seems to
work! ;^)

[Ross A. Finlayson]

Subtracting 1/3 twice?

Figuring out how many bits in the floating point,
here the idea is to, ..., "subtract 1/3 twice, get
.333...333... somewhere 3444...", that the "somewhere"
was where the floating point unit, would extend.
I.e., it might be fair, "the subtracted 1/3 twice
each extended all the way down .333..., leaving .3444...,
only wherever the floating point unit is beyond precision".

I figure it would be close or same to any other usual calculations,
also "for all the bits in the FPU value what result its bits is
its representation".

I.e. the Floating Point Unit is much bigger than Fixed Point,
the register width usually enough 32/64 doubles and 80 bit intel floats.
Then though keeping the guarantees of fixed point, for floating point,
I mostly look at floating point for how to implement fixed point arithmetic,
and mostly I use the vector registers and about having that the MMX is
used for shifting and so on instead of multimedia along ... multiplying transforms.

Then, though again the floating point unit is bigger, it doesn't have to
do integer arithmetic, I'd like to think that the floating point units, are
given to statistics, for where words are small in small alphabets, in words,
while floating point values are "80 bits".

Which is good to have defined as "10 8 bits".

Also I forget that it's a real number in [0, infinity) not just [0,1],
where "infinity" excuse me is, "Not A Number", "NaN", Not-a-number.

I guess the 754 and 854 kind of define this, IEEE floats,
with platforms "do or don't", IEEE float.




Now I've also written a scritto and if you'll excuse me I'll write it here.

You know, with a C runtime, and socket, and, ..., a C runtime, all sorts C then C++ code compile, ....

Then, some, event machine, is that let's say that there is JavaScript runtime, and, there is
"static JavaScript runtime", in terms of, say, "C runtime, ...".

This is enough library most tools make a POSIX.

"Why old POSIX?" Yeah, "why old POSIX", ....

Tooling down POSIX, basically is for reflecting the derivation of POSIX,
in the line terminal and the setting. Then, there is for making in tooling,
what are the environment and configuration, what makes terminal,
results a terminal.

The console and the terminal, here for kernel mode user land,
reflects a usual enough runtime quite unremarkable.

Then though it results for the framework and platform, for basically giving off
the hardware access, what results that resources are actually well-defined again,
putting nice conventions all over what results "cooperative multithreading under
constant bounds with immediate suspend is nice", what would result under routine
that for example it's usually organized in for example "an overall adaptive resource",
all sorts what running emulation makes run inspecting code under running it, in
terms of binary objects then running them.

So, a terminal, then for a shell, would be usually enough for the filesystem,
what results "as a computer, it looks like a shell, ...". The framebuffer is usually
considered a single area, in what is for example full frame console emulation,
that must provide a shell console and terminal, then with a usual user's minimal
semantics, simplest tools laying around, and homes.

Here the console emulation itself is often where the framebuffer, under console-only,
writes console to the framebuffer, for example where otherwise "what is the framebuffer"
is a "virtual framebuffer" if it's made virtual, there's no patent reasons not to drive output
directly to RAM besides the view adapter.

So, this operating system should be along the lines of "the system has 4GB of RAM and
1GB Quad CPU and an entire Terabyte of disk", then to run "the system has 32 bit address
virtual RAM according to the runtime", 1 Megabyte of Disk, and Zero RAM.


Then for driving full HD and especially for split-screen HD, or 30/60 refresh, it's usually
to be expected that the drivers are in a DMA convention must be. There's also the disk
controller, far be it for me to queue the spool to the disk controller anyways, "putting
all the I/O through the disk controller".

(What results a disk controller.)

Here that's the idea, the I/O, to work the I/O, in terms of: basically cooperating with
the disk controller network I/O, and, the fact that disk "read-often" or "read-random",
makes "memory-mapped files" for the C runtime, disk controller cache and virtual memory.

So, the I/O, is broken down into protocols, the Internet protocols these days about
result to "compression", and, "encryption", and catalog, what result block coders
that all computer nework I/O code executes in their block coding, with "TLS session"
and "Deflate/Gzip un-encumbered compression", or data format.

Then protocols vary for example their routine all transfer, for making:

JPEG protocols <- there are them
"Internet protocols", ..., data transfer in data formats

This way there is for making organization, "here are your videos", "here is your code",
"this is your shell", ....

I'd love to think I could make a computer, that I could program by tapping at the shell.

Probably best start with "disk controller and DMA".

[FromTheRafters]

Ross A. Finlayson has brought this to us :

It still allows for cusps and corners.

[Timothy Golden]

It is correct that there is no step to infinity.
However this sequence was selected by you, and agreeable to me.
It was selected because the pattern, repetitious as it is, does lead up to the ultimate value that is under scrutiny.
In this way the sequence is not critical to the value, but it helps cover the ground.
Allow me to state again:
4 is natural. 34 is natural. 334 is natural. 3334 is natural.
Therefor 333...34 is natural
You can stop whenever you like and the value will be natural.
Therefor there is no logic present which prohibits 333...34 from being natural, which you were claiming is a logical conclusion.
I can understand that you don't like 333...34, but here we are trying to analyze it cleanly.
Your construction in i and i[i] is flawed so I won't touch it for the sake of simplicity.

Once again you've managed to dodge the usage of the ellipsis and its own conflicted meaning. There to me lays the crux for rejection, but it is a crux that you have crossed already into I think. It is this fact that you willingly go there on other familiar occasions, but this subtle variation has not been tried yet. Clearly it is outside of the stuff in the books. Well it could easily be in somebody's writings but they are obscure.

>
> There is no such step.
> You can't get there from here.
> 333...34 is not in the sequence.
> > That we can terminate this sequence
> You are mistaken about what is needed
> to be in the sequence:
> You _can_ get there from here.
>
> Something not-in the sequence can be
> after all of the sequence, but it is
> still not-in the sequence.
> > That we can terminate this sequence
> > is only possibly due to the embedded ellipsis,
> > which you seem fond of ignoring.
> I don't always ignore your '...'
> Repeating myself is boring.
>
> Again, you are mistaken about what '...' means.
> > In that the ellipsis itself is inductive in nature:
> The ellipsis replaces detailed description
> where that description is already obvious
> and would only clutter the page, chalkboard,
> or window.

No Jim. You have completely dodged the halting problem of the ellipses.
The fact that we could go on forever could have been left out of all of analysis, since it should be clear in the analyst's mind that there is no need to stop the analysis at three instances. Therefor no usage of the ellipsis would be necessary under your own rendition. The truth is that the ellipsis implies something that the human cannot achieve. Neither can the computer. That you are struggling with this issue on the flattest instance of such usage, yet one which grows so much more quickly than your usual usages, exposes a weakness in your frame of thought. I know better than to punch your buttons, but as we carry on here your own refusal to address the iterative nature of the ellipsis as if it is not even present cannot go well.

I think in such a flat case as this the amount of analysis required to grant induction is only slight. There really is nothing clever to do here. In this regard we have not only simplified induction, but we've gotten away with a constant instance of infinity capable of computation as well. We owe it all to the modulo form or our number system; something refused by traditional natural analysis which can only creep along. The fact that you cannot disclose any analysis on this side of the fence is troubling. I have come over to your side in agreement with some of your own points. Indeed, I am not taking a charlatan approach here. The sequestering of these forms to a branch of mathematics is entirely appropriate. As to what else sits on that branch... here there may be quite some discussion. In this case the ellipsis discloses that there is more information and that the details are not covered yet.

>
> It is the description which the ellipsis
> replaces which is or is not inductive.
> All the ellipsis says is "You know what I mean".
> > this point is not getting any attention in
> > the discussion.
> Once you've been told you're reading '...'
> incorrectly, there's not much left to say
> -- at least, until you read it correctly.
> > Clearly the value is inductive.
> You can't get there from here.
> It is not inductive.

Well, now, this is becoming infantile.
I will say again that if I am misusing the terminology 'induction' then whatever careful definition denies me likely will expose the correct term, and when it does under its dissection we will still be staring down the ellipsis and grinding the juncture of the two for a neat whirring sound. A child could say that we will never get there, and they'd be right. That is the nature of infinity. Back on Peano the same mixing effect can be seen, as if the successor function is something new and different. I honestly never meant to delve into natural analysis at all. I pushed on the magnitude of the polysign rudiment sx and all this other stuff falls out. I suppose I am nearing a curriculum now, yet it seems awfully thin. Ahh, but shouldn't it be that way when decent mathematics is found? The quantity of correctives that I can lay out now is substantial. That ambiguities do exist in mathematics places this subject in a very different realm than I was told about it. How fascinating that philosophy could find space here. Physics too. I feel quite secure that this is valid math mainly because of its computability. At first it is unclear, but by practicing with these values their inductive form proves itself to be consistent.

The best features of the new analysis is back on the decimal value and its own natural valued forbearance. Back here the juncture of the reals and the naturals was felt just by implementing a secondary form of unity. Whether you count large values in tens or twelves, as was done for some things back in the day, and maybe donuts still come out this way, structural analysis suggests that the implementation of such units is all that rational analysis actually needs, and this then takes us to an even more general application of unity beyond the decimal point. Yet as radix concerns become a part of the awareness of these digital forms then it simply these radix forms with the decimal point in tow which allow for such representations as:
1/3 = 0.1
and the digital power can commence here too so that ninths are not such a foreign thing to the thirds. Yet for the rational analysis they lay off by six steps, whereas here they are but one step away. When the natural analyst threw away his digits he gave up quite a lot. Taking them back what we see is that where he landed us by the time he gets to the continuum is contaminated. Not only are the real values lacking in correspondence to reality; they make claims that are not possible to implement. The form that comes from the natural valued interpretation augmented by the decimal position (unital position) yields values that every engineer and physicist is comfortable with already. For this reason this attack on mathematics will stand the test of time. How long will mathematics withstand the attack? Given what politician's are willing to do these days it could be quite some time.

[Ross A. Finlayson]

Hey, thanks Tim. Thanks for writing that.

"Indeed, I am not taking a charlatan approach."

It's kind of like in fixed point, whether to use 2-bits for thirds,
i.e. 0, 1, 2, when instead that 4 triplets fit in 12, bits, binary digits.

Just because then powers of 2 arithmetic in binary "is about
as efficient as it is for 4", makes for a formal reason why
that binary is special then that base 3, 4, 5, ..., closures
in the fixed point by extended precision, is where the fractions
are all finite precision, each in their co-prime buckets, it's a data
structure with finite representations for each prime or integer
base representation.

Then arithmetic and so on is in spaces of those, ..., fixed-fractions.

This is for such data structures and for example "multisets in large primes",
that very, very large prime numbers, fit in extended precision bounds, then
that adding items is multiplying and testing items is test division and removing
items is division. Counting the items is repeated division, for example
"exponential counting", of composites which powers of the primes what in
the prime multriset take counts of the elements.

For example, a multiset is 1, then that there is a catalog of items each
given a prime number, with the more common elements a usual Huffman coding.
Then, for example, one of the elements is 2, so adding n-many is multiplying the
multiset by 2^n. Testing for a 2 then happens to be checking the last bit and
counting the last bits sets, but for any prime generally it's multiplication and division.

This is an example sort "primary catalog" of a data structure happens to fit under
algorithm, especially when there's a strong mode, then whether there's a large tail
is to bitmaps, an integer (ordinal, index).


I.e. "building these sorts data structures into arithmetic runtime", works out its collected instructions.

"Intrinsics", ..., "extrinsics".

[Ross A. Finlayson]

https://blogs.synopsys.com/expressyourself/2013/07/29/what-is-dma-and-what-good-is-it-to-me/


Hmm..., it says "PCI Express is the new DMA, also it's DMA".

"A PCI Bus has no DMA controller", ....

"Most PCIe devices are DMA masters", .... "the main memory is always a slave".

Ohh...,

So, the PCIe devices are fed data in memory, off the PCIe message bus would-be.

"A basic PCIe link includes two, low voltage, differentially driven signal pairs,
a transmit pair and a receive pair, ...".

"... Mapped legacy signals into Message Bus ...".

"PCI, DP, USB, and SATA, ..."

Hmm, there is IDE and there is SCSI, there is Serial ATA, and, there is for figuring
out the steady-stage memory logic and "classical disk controller", in terms of
what a "classical disk-controller for example with access control" vis-a-vis
"a very large bank of flash RAM called the disk", here is in terms of whatever
it actually is, however its communicated and under whatever conditions it does.

"Down to the TLP: How PCI express devices talk"


Heh, PCI Configuration and Enumeration.

"a chunk in the I/O and the address space"

"not a bus"

Vendor/Product IDs


"An acknowledge-retransmit mechanism makes sure no TLPs are lost on the way."

http://xillybus.com/tutorials/pci-express-tlp-pcie-primer-tutorial-guide-1


"The TLP's size limits are set at the peripheral's configuration stage, ...".

Then, it seems what is for activation and booting and resource management,
here about basically there is firmware enumeration and "PC system", then
there is resource lock and for editions the data - what is to result a basic,
moduling, menuing, overall system configuration and naming, as what it will
result that all the resources of the system will be plain as day and user-controlled.

http://xillybus.com/tutorials/iommu-swiotlb-linux



Seems like

0 yeah it's boot
up <- this is actually farmed for no access, accesses invalidate it
<- bus master space
<- boot space again, also side-cars the bus master space
<- end of 16MB main RAM

Something like Windows has virtual address randomization,
something like Windows 7. Here it's not so much the point
as physical address validation.

Then the instant memory should be constantly scanning always
with basically each core validating, ..., what also would effect maintenance.

"all read-only, ..., the mapping under the main RAM"

bus-master zone / I/O segments

"When a peripheral is performing Bus Mastering, it is important that the peripheral transmit data to or from memory constantly while it holds the system bus. If the peripheral cannot do this, it must release the bus frequently so that the system can perform refresh operations on main memory. " -- https://docs.freebsd.org/doc/3.3-RELEASE/usr/share/doc/handbook/dma.html

https://git.kernel.org/pub/scm/linux/kernel/git/agk/linux-dm.git/tree/include/linux/i2c.h

[Chris M. Thomasson]

[...]

:^)

I am just using the floor function to zap all the .333's into oblivion.
Quick and easy. Another way, without floor could be, say to get 333...34
directly, using subtraction like you suggested:

(1/3 * 100) - (1/3) + 1 = 34
(1/3 * 1000) - (1/3) + 1 = 334
(1/3 * 10000) - (1/3) + 1 = 3334

on and on. There is no need to depend on a predecessor and/or successor.
It's direct. Therefore:

i[n] = (1/3 * 10^(n + 2)) - (1/3) + 1
_________________________

i[5] = (1/3 * 10^(5 + 2)) - (1/3) + 1 = 3333334

i[6] = (1/3 * 10^(6 + 2)) - (1/3) + 1 = 33333334

i[7] = (1/3 * 10^(7 + 2)) - (1/3) + 1 = 333333334
_________________________

I like the floor version, but subtracting works as well. Thanks.

i[0] = (1/3 * 10^(0 + 2)) - (1/3) + 1 = 34

;^D

[Chris M. Thomasson]

((1/3 * 10^(0 + 2)) - (1/3) + 1) = (floor((1/3) * 10^(0+2) + 1)) = TRUE

;^)

[Ross A. Finlayson]

Quarter-angles?

It's like there's orthogonality, and there's quarter-angles.

The quarter angle is the quadrant's angle.

(Rotation is the angle.)

[Ross A. Finlayson]

"The geometry where all angles are right", ....

There's the isosceles triangle opposite an angle,
"what is the angle". The right angle formed on
the circle, is pi/4 radians times two, intersecting
the circle according to the radius of the circle,
what is the opening of the compass, that it happens
that the inscribed squares' side length, is the
opening of the compass, that the square's root two
is the diameter.

[Jim Burns]

On 9/29/2022 9:48 AM, Timothy Golden wrote:
> On Wednesday, September 28, 2022
> at 5:04:13 PM UTC-4, Jim Burns wrote:

>> There (333...34) is after all of 3,34,334,3334,...
>> Getting there requires a step j to 10*j-6
>> from not after all 3,34,334,3334,...
>> to all after all 3,34,334,3334,...
>
> It is correct that
> there is no step to infinity.

I'm saying something a little different.

There is no step out of finity.

That follows from the description of finity,
not from the description of infinity,
so it is very hard to avoid with some
(hypothetical) clever adjustment of infinity.
_Finity_ is unchanged.

> However this sequence was selected by you,
> and agreeable to me.

I selected it and asked
"Is that what you (TG) mean by 333...34?"
Please don't forget that I'm discussing
4,34,334,3334,... in order to understand
what you're trying to tell us.

> It was selected because the pattern,
> repetitious as it is,
> does lead up to the ultimate value
> that is under scrutiny.

No,
I remember why I (JB) selected it.
I selected it because I thought you (TG)
might be using 333...34 to refer to
the thing after all of 4,34,334,3334,...

Do you see the difference?
The difference is the point I want to make.

There is no ultimate value of 4,34,334,3334,...

The sense in which 4,34,334,... leads to 4,
leads to 34, leads to 334, leads to 3334,
_that_ sense does not apply to anything
after all of 4,34,334,3334,...
_that_ sense does not apply to an ultimate value.

In other words,
you can't get there from here.

> In this way the sequence is not critical
> to the value, but it helps cover the ground.
>
> Allow me to state again:
> 4 is natural.
> 34 is natural.
> 334 is natural.
> 3334 is natural.
> Therefor 333...34 is natural
> You can stop whenever you like
> and the value will be natural.

I see these _different_ possibilities for
what you (TG) mean by 333...34
(1)
333...34 is first after all of 4,34,334,...

(2)
333...34 is the set {4,34,334,3334,...}

(3)
333...34 is any of the set {4,34,334,3334,...}

My best guess is (1).
Please tell me if you mean something else.

> Therefor there is no logic present which
> prohibits 333...34 from being natural,
> which you were claiming is a logical conclusion.

My conclusion applies to (1)
Are we talking about (1)?

This is not how induction works.
| 4 is natural.
| ...

| Therefor 333...34 is natural
| You can stop whenever you like
| and the value will be natural.

Yes,
you can keep going, 4, 34, 333333334,
and each will be a natural number.
But the question is: is 333...34 one of them?
Keeping-going does not address that question.

>>> Clearly the value is inductive.
>>
>> You can't get there from here.
>> It is not inductive.
>
> Well, now, this is becoming infantile.

I don't want to offend.
I'm trying to find common ground upon which
you and I can communicate.
For that purpose, "infantile" is a feature,
not a bug.

It would be nice if we could have used '...' and
"inductive" to communicate. It looks as though
that is not going to happen.

----
Consider a few examples of recursive
-- I'm going to call them "definitions"
even though that's problematic --
a few examples of recursive definitions.

(Si = i+1 the successor of i)

Adding i:
j + 0 = j
j + Si = S(j + i)

Multiplying by i:
j*0 = 0
j*Si = (j*i) + j

Raising to the power of i:
j^0 = 1
j^Si = (j^i)*j

Factorial of i
0! = 1
(Si)! = (i+1)*(i!)

We want a definition to tell us what
a term means which we don't know
using terms which we know.

But see what we have here with these definitions.
'+' is on both sides.
'*' is on both sides.
'^' is on both sides.
'!' is on both sides.

These definitions can't be telling us what
'+' ('*' '^' '!') means which we don't know
using the same '+' ('*' '^' '!') which we know.
We can't be having our cake and eating it too.

However,
we can give better descriptions of '+'
('*' '^' '!') which do not have that problem.

The key assumption is that

you _can_ get there from here.

For a particular sum j+k, we assume that
a finite sequence ⟨j+0 j+1 ⋯ j+k⟩ exists.
Each split has a last-before j+i and
a first-after j+(i+1).
The 0ₜₕ value is j.
The kₜₕ value, whatever that value is,
is the defined sum.

Addition defined, without using '+' or '⋯' :

j+k = m ⟺
∃𝑺,
∀i < k, ∀mᵢ : (⟨mᵢ i⟩ ∈ 𝑺 ⟺ ⟨Smᵢ Si⟩ ∈ 𝑺)
∧ ⟨j 0⟩ ∈ 𝑺 ∧ ⟨m k⟩ ∈ 𝑺

𝑺 is the finite sequence of increments from j
to m, indexed by i.
If 𝑺 exists, j+k = m. If not, then not.


And similarly for defining '*' '^' '!'
without '*' '^' '!' or '⋯'

"You _can_ get there from here" is
an irreplaceable concept for important parts
of computing, even if it spends most of its
time buried. But being buried is the fate of
most foundations.

[Timothy Golden]

I understand that these inductive values that I am working with are new. Their product is found by induction. So at least here there is something fancy to do with induction, but it does boil down to pattern matching; again the 'infantile' system, but simplicity has to be a part of this feat.
x = 333...34
xx = 111...1555...56
Clearly I did not compute an infinity of digits here. This is the inductive result of considering the product on those predecessors that you have fixated upon. In the arbitrary precision math application sage I can write:
sage: x = 333333333333333333333333333333334
sage: x*x
111111111111111111111111111111111555555555555555555555555555555556
and further I can alter the quantity of threes in the expression and witness no change in the result other than the length of the string of digits.
Certainly this procedure is inductive. The addition of more three digits will not alter the pattern in the string.

We know that the number of digits in a square can take twice as many digits as its predecessor and that is exactly what we witness here. The form of infinity of the square of the infinite value 333...34 does indeed hold up. Granting a digital aleph one for the initial value we have achieved aleph two here computationally. Of course even my usage of 'aleph' will require some naming or care that will distinguish it. What is nice though is that we need it within this theory.

There is no need to require the predecessors in order to consider the value 333...34. At least it is not at all a detailed choice as you've marked up three options on. That is all a diversion. We happen to be lucky on this value as its square holds a simplistic form. Not so for 222...2:
sage: x=2222222222222222222222222222222222222
sage: x*x
4938271604938271604938271604938271603950617283950617283950617283950617284
Of course the resolution has been found and it will entail implementing some aleph marks in order to disambiguate the quantity of digits versus the length of the repetition. There is even a squirrely bit in the middle that will dance around, but thanks to induction we can break through all of this. After all our pure form is ultimately infinite in nature and so the pattern will come clean. One thing is for certain: each set of ellipses indicates an aleph is present. The quantity of digits in the repetition then has not actually blown up even though the complexity has risen.

We have to admit that it is only thanks to the repetitious qualities of these values that we can even make these claims. No doubt any reader who comes along would like to flip one of those 2's above to another digit. Well, this can technically be done at the head or at the tail of the value, and the pattern detection can grow cumbersome, but the thing that makes these values work is the ellipsis which implies repetition. You could try to work the square on a value such as x=123123123...123 however determining the result is likely best done by the computer. I do not have the theory that states how many digits would be in the repetition. Possibly that has been done in some other number theoretic system. Possibly it will one day be done on this theory. The point that I am making is that we do rely upon repetition in order that we achieve infinity. We have given up the complete freedom of digit n and instead we can state clearly every digit n simply. In effect this is a position of compromise, yet the result is new. Almost. There is one prior usage that is too well known:
1/3 =0.333...
and along with it comes rather a lot of repeating decimals. So you see we are not terribly far from existing numbers. The structured approach allows us to pull the decimal point from this value and regard it as a natural 333...3 and upon doing so we see that the decimal point encoded was taking an infinite position. In this regard the original expression might be said to be ambiguous. So such usages of the ellipsis go, and of course this detail of structural integrity is brought to us only in the last half century. Prior to this compiler integrity was a matter of the nod of the head. Yes, some heads were quite serious, and many were quite particular about their presentations. Here we have a new such presentation that leans more on modern technology and less of the scratch of the head approach.

The representation that is in use here is new. Nobody seems to have bothered putting a tail on the digital sequence before; perhaps on the ellipsis before? Here again it is thanks to the simplistic repetitive nature that this can be done. That we can modify the tail and do computations helps expose that this method works just fine. Thus the value 333...33 and its successor 333...34 are commensurate.

Under this approach I think the most fruitful broad analysis is that there are many forms of infinity. Particularly when we are forced to address the digits of an infinite natural value to deny that a first digit exists would be foolhardy. This is the units position and without it no next digit could even be constructed. Positionally the digits have meaning above and beyond the glyph which lays in that position. For infinite values to claim that there is an upper most digit is foolhardy as well. Yet numbers do indeed have a head and a tail, and all these qualities are present in this form.

I think a proper falsification of this form will land with a clean contradiction. Arguments like 'you can't get there from here' are not going to cut it. We got there already. It's done. Nicely enough it is done via instantiation. Of course the habituated mathematician feels a bit squirrely about them. As to whose interpretations on infinity hold up and how they compare: this is probably the ground to cover next within this topic.

I'll try to remain open to a contradiction arising, but I don't see such a falsification within your logic, Jim. I am grateful for your attention to this topic.
Especially your own rejection of discussing the relation between ellipses and induction, and as well the halting problem; these details I believe do matter greatly. I could write some peppery language about the Catholic mathematician who goes into the confessional booth looking for absolution. He says to the priest: "Father, I suspect I may have committed a sin." The priest, glaring down at the man through the screen, knowing he is in darkness and will not be detected, says "Ah, well then, out with it!". He has put up with decades of the mathematicians attempts to rectify his arithmetical problems and saw no need to play it any other way this day. "Well," said the mathematician, "All my work that I have ever done has been on numbers that are modulo 10, father, and I mean one zero, father. Do you see what I mean?" The priest had his eyes closed for the last part and really had no idea what the mathematician was on about. "Bless you my son," said the priest, "if your numbers did not work then we wouldn't have numbers, would we?" "No, father." said the mathematician, "This problem lays at the base of all numbers, father. It is as if the eight after the seven were infinite and implies an impenetrable wall to the seven days of the week, yet we have no such value after nine." A glimmer of hope showed up on the priest's face, realizing that this Sunday was somehow affecting the mathematician's brain."As a holy man you show up here every seventh day, yet as a mathematician you don't give a damn about the seven do you? It's a good thing we didn't put in the fix at six, sir, I'll see you next week." The mathematician smirked as he walked out of the confessional, feeling lifted.

[Sergi o]

you are using base10, try using another base, you will get different results which may blow your conclusions outta the water. So you would have to make
sure your conclusions work in another numbering system, like base3 or base222222222

> Of course the resolution has been found and it will entail implementing some aleph marks in order to disambiguate the quantity of digits versus the length of the repetition. There is even a squirrely bit in the middle that will dance around, but thanks to induction we can break through all of this. After all our pure form is ultimately infinite in nature and so the pattern will come clean. One thing is for certain: each set of ellipses indicates an aleph is present. The quantity of digits in the repetition then has not actually blown up even though the complexity has risen.
>
> We have to admit that it is only thanks to the repetitious qualities of these values that we can even make these claims. No doubt any reader who comes along would like to flip one of those 2's above to another digit. Well, this can technically be done at the head or at the tail of the value, and the pattern detection can grow cumbersome, but the thing that makes these values work is the ellipsis which implies repetition. You could try to work the square on a value such as x=123123123...123 however determining the result is likely best done by the computer. I do not have the theory that states how many digits would be in the repetition. Possibly that has been done in some other number theoretic system. Possibly it will one day be done on this theory. The point that I am making is that we do rely upon repetition in order that we achieve infinity. We have given up the complete freedom of digit n and instead we can state clearly every digit n simply. In effect this is a position of compromise, yet the result is new. Almost. There is one prior usage that is too well known:
> 1/3 =0.333...
> and along with it comes rather a lot of repeating decimals. So you see we are not terribly far from existing numbers. The structured approach allows us to pull the decimal point from this value and regard it as a natural 333...3 and upon doing so we see that the decimal point encoded was taking an infinite position. In this regard the original expression might be said to be ambiguous. So such usages of the ellipsis go, and of course this detail of structural integrity is brought to us only in the last half century. Prior to this compiler integrity was a matter of the nod of the head. Yes, some heads were quite serious, and many were quite particular about their presentations. Here we have a new such presentation that leans more on modern technology and less of the scratch of the head approach.
>
> The representation that is in use here is new. Nobody seems to have bothered putting a tail on the digital sequence before; perhaps on the ellipsis before? Here again it is thanks to the simplistic repetitive nature that this can be done. That we can modify the tail and do computations helps expose that this method works just fine. Thus the value 333...33 and its successor 333...34 are commensurate.

333...33 is unclear as is 333...34, therefore cannot be shown to be next to each other. Add some more digits or words. As they stand they are
magnitudes apart.

[Jim Burns]

On 10/1/2022 9:11 AM, Timothy Golden wrote:

> I understand that these inductive values that I am
> working with are new. Their product is found
> by induction. So at least here there is something
> fancy to do with induction, but it does boil down
> to pattern matching; again the 'infantile' system,
> but simplicity has to be a part of this feat.
> x = 333...34
> xx = 111...1555...56
>
> Clearly I did not compute an infinity of digits here.
> This is the inductive result of considering the
> product on those predecessors that you have fixated
> upon. In the arbitrary precision math application sage
> I can write:
> sage: x = 333333333333333333333333333333334
> sage: x*x
> 111111111111111111111111111111111555555555555555555555555555555556
> and further I can alter the quantity of threes
> in the expression and witness no change in the result
> other than the length of the string of digits.
>
> Certainly this procedure is inductive.
> The addition of more three digits will not alter
> the pattern in the string.

I see these _different_ possibilities for
what you (TG) mean by 333...34
(1)
333...34 is first after all of 4,34,334,...

(2)
333...34 is the set {4,34,334,3334,...}

(3)
333...34 is any of the set {4,34,334,3334,...}

(4)
333...34 is something that hasn't occurred to me.


For (1), "You _can_ get there from here"
is embedded in the meaning of 333...34
For each of 4,34,334,... you _can_
For anything after each of 4,34,334,...
you _can't_
By "from here", I mean "from 0"

For (2), a set of numbers is not a number.
I consider (2) least likely to be what you mean.

For (3), "any of" treats the number of 3's
as a _variable_ There is at least one other
poster who misunderstands what a _variable_ is.

If I say x is in {1,2,3},
perhaps x=1 or x=2 or x=3
But x _doesn't change_ despite "variable"

"x is in {1,2,3}" _incompletely identifies_ x
With more information, perhaps two of its
currently-possible values could be ruled out.
Perhaps not.

Using a variable x in a claim allows us to
finitely state a claim that is true of
infinitely-many. It is the incomplete
identification which allows us to do that.

If (3) is what you mean, you need better
notation. It looks to me as though,
if we insert '333' in '333...34'
we get '333...34'. It looks impossible to
discuss inserting '333' if we can't
distinguish '333...34'-before from
'333...34'-after.

> There is no need to require the predecessors
> in order to consider the value 333...34.

Then, not option (1)?

The kind of induction I've been discussion
assumes we are discussing things for which
"You _can_ get there from here" is true.
|
| If
| P(0) ∧ ∀j, P(j) ⟹ P(j+1)
| then
| ∀k, P(k)

There is also transfinite induction, for _ordinals_
This assumes we are discussing things for which
"If any exist, a first exists" is true.
|
| If
| ∀j, (∀i<j, P(i)) ⟹ P(j)
| then
| ∀k, P(k)

Transfinite induction also considers predecessors,
meaning ordinals that come before (<)
Not all ordinals have immediate predecessors.

Transfinite induction might also be something
other than what you (TG) are talking about.
But it deals very well with infinities.

[Jim Burns]

On 9/29/2022 1:13 AM, Chris M. Thomasson wrote:

> Interesting. Mitch said 13/3.
> Well, it most definitely can be exploited
> in multiple ways:
>
> 13/3 = 4.33333333333333...
>
> 4 + 1/3 = 13/3 ?
>
> Except, its backwards wrt 333...34, wrt:
>
> 34
> 334
> 3334

> ...

You remind me of a nice article Fred Jeffries
told sci.logic about, ca. 4 years ago.

Joel David Hamkins gives a non-standard order for
the natural numbers, the _final-digit order_
In that non-standard order, with the open sets
which it implies, addition and multiplication
are continuous.

And that is interesting but
the reason I mention it is that I think
we can fill in the single-point gaps in the
naturals -- when in the final-digit order --
with _non-standard_ naturals which look
something like 333...34 and its ilk.

I'm thinking of something along the lines
of the Dedekind construction of the real
numbers.

I think it's unlikely that this is what
Timothy Golden is talking about, but
it looks like fun (for geeky values
of "fun").


http://jdh.hamkins.org/topological-models-of-arithmetic/
https://arxiv.org/abs/1808.01270

Newsgroups: sci.logic
Subject: Topological models of (nonstandard) arithmetic
Date: Mon, 6 Aug 2018 11:56:58 -0700 (PDT)
From: FredJeffries <fredje...@gmail.com>
Message-ID: <36516443-e30c-4fc3...@googlegroups.com>

[Timothy Golden]

The predecessor to 333...34 is 333...33.
I've explained what I understand of this construction many times over here.
I don't have to select one of your four options which are not my language at all.
I do think that the sequence you've fixated on is good, but it is not the source of this value.
My thinking is actually quite a bit broader, and to express it once again is not a problem.
The rational number relies upon division. Not only this but it relies upon a type of division that lacks closure.
Beyond embedding an operator and two values and trying to make it seem like a singular value the level of conflict that the rational value has raised could have been alleviated. Witness that the meaning of the decimal point in a value can be taken as marking the unitary position of what is otherwise a natural number. Witness that extending this thinking further, should we consider the value six as unity in a secondary system, then as we count by ones in the primary system it follows that this same count will be as sixths in the secondary system. In this regard all of our numerical forms, and I can happily forgo the irrational numbers as they again do the embedded operator thing, which I just got rid of via this secondary unital concept, are in fact natural valued upon removing the secondary details. Those secondary details are augmentations to the natural value. The decimal point, for instance can be simply pulled from any value. It's position could be recorded so that it can be put back later, let's say. Now this argument conveniently lands us at the predecessor of 333...34, for in the lore of old mathematics still used in this day we have
1/3 = 0.333...
and so my own usage of repeating digits is not so unfamiliar is it? Ahh... but these digits disappear to fleetingly small values that we need not worry about, right? These threes of this one third expression are different from the threes of that extremely large value, right? Under the decimal interpretation just given we can pull the decimal point. We witness that its position relative to unity is infinite, and so under the new system this old value may be argued as poorly constructed, for structurally there is no ability to code that representation. Well, this argument overlooks the ellipses entirely, and so the ambiguities somewhat finger point at each other; often this is the case. Regardless, pulling the decimal point and now regarding
333...
as a natural value what harm is there in admitting that
333... = 333...33 ?
Indeed we can now express the successor; our chosen instance of debate; but how nice it is to actually have such a thing in hand.

Filling out a bit more ground here, to what degree are numbers two-sided? Do they have a head and a tail? Can they go prancing about slinking around looking for a treat to eat? That sounds more like a variable. Here these are statues; fixed in position and without a doubt fully defined. Every digit is so well expressed that you'd have to be a moron not to see it. Yet I suppose there are a few who do witness this very refusal. Well, to them I would say that taking the freedom to construct when subtle changes are made at the base of mathematics that such results are possible.

Clearly the freedom with which mathematicians use the ellipsis in their notation allows for this usage. Clearly the existing work that we will find in many a text exposing the repeating digits of one third will act as precedent. There is a strangeness about it all; yes. As to why it was not done before: I think this is the most apt that can alleviate the strangeness. Obviously these points are uncomfortable to discuss, for entering the ground this way we've just trashed the rational value. Yes, we did recover it along the way without any need for division. Did I mention that division is not even a fundamental operator? It is a reverse operator. Without a product that yields the divisor no such value is even guaranteed to exist. And even then there are exceptions. This is what your real value is built upon? No; it cannot be so. It quite literally cannot be so. Habituation and repetition amongst the human race explains too much, I'm afraid. I suppose it doesn't hurt that these old laws are enforced under threat of failure. Not only that but for the first twenty years or so of your life... some of which you are even expected to pay for... and quite a bit, too.

I do believe that the option to reject the usage of ellipses is a valid choice. As to what is left of mathematics upon doing so becomes a large problem.
The ambiguities of the ellipsis and its usage have been laid out. The halting problem ensues. The exact contradiction is well exposed and so to touch upon such ambiguity will be dodged every step of the way by those wishing to uphold the status quo.

Permitting the usage of the ellipses; legitimating them on this one episode of 333...34 we find some further strange ground. I had gone to the trouble of explaining the product of such values and its inductive nature earlier. The need of an aleph mark sometimes makes itself known. Going back to about here: https://groups.google.com/g/sci.math/c/tHL3zLZ97v0/m/RROBL-skAQAJ I do see those aleph marks coming into being.

What is really strange about this is that we can confuse those aleph marks with the decimal point and land in a sense of continuum that some who are so obsessed with natural valued infinity feel in their gut. Once again this can be taken as a unital interpretation but this time taking the aleph one form of infinity as unital. For this sort the notion that the tail of their values goes on and on to some infinite precision form gives them comfort. I don't feel this comfort myself. I see the form, but claiming that this has the ring of truth about it is too much.

As I recall, Jim, you have not bothered to address the usage of such values as 0.333...
Would you say that the far end of the number is ill-defined?
Or can we admit that the tail of this value goes like
0.333...33 ?

Of course this is just the first step.
Next I'll have you pulling away that decimal point.
Increment the value.
Now we've got our creature feature.

>
> The kind of induction I've been discussion
> assumes we are discussing things for which
> "You _can_ get there from here" is true.
> |
> | If
> | P(0) ∧ ∀j, P(j) ⟹ P(j+1)
> | then
> | ∀k, P(k)
>
> There is also transfinite induction, for _ordinals_
> This assumes we are discussing things for which
> "If any exist, a first exists" is true.
> |
> | If
> | ∀j, (∀i<j, P(i)) ⟹ P(j)
> | then
> | ∀k, P(k)
>
> Transfinite induction also considers predecessors,
> meaning ordinals that come before (<)
> Not all ordinals have immediate predecessors.
>
> Transfinite induction might also be something
> other than what you (TG) are talking about.
> But it deals very well with infinities.

The method that the construction is using is pertaining to the digits.
As you progress through ordinary natural analysis by incrementing by one
The digits are escaping you. On your tenth step you made it to around n=10.
on our tenth step we made it to n=33333333334. And it only gets worse from there.
We can see how back when the value was 0.333... it felt more tenable.
If anybody is going to make it to infinity first; clearly digital analysis is the winner!
How much does it win by? Hmmm... it's still a long way to get there.
Yet look at how much farther we got thanks to digital analysis.
We now have infinities that can increment.
This one claim alone is outstanding.
To claim that they can add and multiply is over the top.

[Jim Burns]

On 10/2/2022 8:47 AM, Timothy Golden wrote:

> The predecessor to 333...34 is 333...33.

Having a predecessor is not enough
to make 333..34 inductive
==meaning==
Even if we know
| P(0) ∧ ∀j, P(j) ⟹ P(j+1)
we don't know
| P(333..34)

When we do know a claim of that form,
for example, the way we would know
P(10^(10^(10^(10^(10))))+1)

how we know is NOT because somebody declared
10^(10^(10^(10^(10))))+1 is inductive.
Our knowledge follows from what
10^(10^(10^(10^(10))))+1 means,
an important part of which being:
you _can_ get there from here (from 0)

> I don't have to select one of your four options
> which are not my language at all.

You're absolutely right.
You don't have to tell anyone
what you're talking about.

So, are you happy with how that's
working out for you?

> As I recall, Jim, you have not bothered to
> address the usage of such values as 0.333...
> Would you say that the far end of the number
> is ill-defined?

The far end of 0.333... does not exist.
It is a square circle,
a description that is not true of anything.

> Or can we admit that the tail of this value goes like
> 0.333...33 ?

Each digit of 0.333... is at a place
for which you can get there from here.
For each split of the decimal-string 0.333...
there is a last-before and a first-after.

Did I remember to mention that it's not clear
what you mean by '333...33'? I think I did.

I'm guessing that the '33' at the end of
0.333...33 is different from the others,
so you _can't_ get there from here.

There are plenty of things like that
but they aren't natural numbers.

> We now have infinities that can increment.

https://en.wikipedia.org/wiki/Ordinal_arithmetic
https://en.wikipedia.org/wiki/Cardinal_number#Cardinal_arithmetic

You're welcome.

[Timothy Golden]

I am sorry that you are so sour to what could be called a new branch of mathematics. That this interpretation rings clean and through is a part of the largess of the theory. To fully appreciate this claim we have to admit that the natural value as continuous would require an infinite absurdum such as this one. To cast the real value as gray I believe is the mature way; it is to remain finite as you preach to do. You are on that branch of denial of the ellipses. As to what else you must cast aside as a purist in this form: I think this has yet to be filled out, yet as we see you dodge the halting problem of the ellipsis, and by this I do think I mean every ellipsis: here I cannot comment so much as you can.

I can't help that some of your own bitterness is due to the long slow crawl that the natural value as preached by Peano and his sort; a method which ignores the modulo quality of number completely: Then to see how quickly computations can refine such values as gears whirring along; the clickety-clack almost gone, but for a strange harmonic as the digits drive downward in precision... or was it upward? There is no question that the natural interpretation thanks especially to the new decimal point interpretation is upward unconditionally and naturally, too. The idea that you might be pleased by this realization awaits you.

I really truly do appreciate the energy that you expend here. Exasperated as you may feel. Perhaps I grant myself too much room, but if I don't who else will? So many ideas get pinched for they are unconsequential. That these interpreti (plural, actually) are consequential and form a simplification of standing mathematics is a thing of beauty; again awaiting reception.

[Jim Burns]

On 10/2/2022 7:08 PM, Timothy Golden wrote:

> I can't help that some of your own bitterness
> is due to

> yet as we see you dodge the halting problem of
> the ellipsis,

The ellipsis does not have a halting problem.
The ellipsis replaces description that is
too well-known to need repeating.

For example,
|
| ℕ = {0,1,2,3,...}

stands for
|
| Inductive(ℕ) ∧
| ~∃𝐵 ⫋ ℕ : Inductive(𝐵)
|
| Inductive(𝐵) <->
| 0 ∈ 𝐵 ∧ ∀k ∈ 𝐵 : k+1 ∈ 𝐵

The set ℕ of natural numbers does not halt.

I suppose that is considered a problem by
people who do not want the natural numbers
to be the natural numbers.

But now, we've left mathematics and
entered psychology. I am less interested in
why you do not want the natural numbers
to be the natural numbers.

[Fritz Feldhase]

On Monday, October 3, 2022 at 1:55:43 AM UTC+2, Jim Burns wrote:
> On 10/2/2022 7:08 PM, Timothy Golden wrote: <nonsense>

>
> The ellipsis does not have a halting problem.
> The ellipsis replaces description that is
> too well-known to need repeating.

Indeed!

> For example,
>
> | ℕ = {0, 1, 2, 3, ...}

>
> stands for
>
> | Inductive(ℕ) ∧
> | ~∃𝐵 ⫋ ℕ : Inductive(𝐵)

[ with

> | Inductive(𝐵) :<->
> | 0 ∈ 𝐵 ∧ ∀k ∈ 𝐵 : k+1 ∈ 𝐵 ]

and

∀k ∈ ℕ : k+1 =/= 0 ∧
∀k,k' ∈ ℕ : k+1 = k'+1 -> k = k'

[ as well as

1 = 0+1
2 = 1+1
3 = 2+1 ].

(After all, IN = {0, 1} with 0 =/= 1, 0+1 = 1 and 1+1 = 0, 0 = 2 and 1 = 3 would also allow to write ℕ = {0, 1, 2, 3, ...}. Moreover in this case Inductive(ℕ) ∧ ~∃𝐵 ⫋ ℕ : Inductive(𝐵) would hold too.)

From this "description" of IN (not taking into account 1 = 0+1, 2 = 1+1, 3 = 2+1) we can prove that there's a bijection from IN onto IN \ {0} (and hence from IN onto a proper subset of IN), which allows to conclude that IN is an "infinite" set (due to Dedekind).

[Chris M. Thomasson]

Love the fractal tree:

http://jdh.hamkins.org/wp-content/uploads/Final-digits-order-2.jpg

;^)

Thanks for the link Jim. :^)

[Timothy Golden]

On Sunday, October 2, 2022 at 7:55:43 PM UTC-4, Jim Burns wrote:
> On 10/2/2022 7:08 PM, Timothy Golden wrote:
>
> > I can't help that some of your own bitterness
> > is due to
> > yet as we see you dodge the halting problem of
> > the ellipsis,
> The ellipsis does not have a halting problem.
> The ellipsis replaces description that is
> too well-known to need repeating.

Well, why not just insert it this once since it is so boring?

>
> For example,
> |
> | ℕ = {0,1,2,3,...}

Right here in this line above, eh?
As you correctly point out we are dealing in a problem of human psychology.
The falsification of your statement both precedes you and succeeds you.
As it stares you in the face; your direct transgression as denial; what is one to do?

"The ellipsis replaces description that is too well-known to need repeating."
"The ellipsis does not have a halting problem."

I believe what we witness here is a psychological effect that I will call 'the untouchable'.
It is as if to say that as a status quo mathematician you may touch, but all else, you keep your hands off.
This is a faith position for you, I suppose. No doubt it is an entrained position as well.
To confront such details is to challenge not so much you as a person, but the schooling that you have absorbed.
The notion that we might start from scratch and do it all again from naught: will it come out the same?

And by the way, if I give a large value like x=33333333333334, are you really going to review its successors to prove that this one is natural?
This is the proof, isn't it? If so then I can determine with first order logic that this is unproven to be a natural number, or rather it will prove to not be a natural number due to the probability of human error or failing within the span of the review. Especially under a mathematical court, let's say, where more than two individuals are involved. The argument may sound silly, but by Peano you literally have to count up to this value in order to verify its natural qualities. Digital analysis, and by this I mean pertaining to the digits and their mechanistic qualities, does not require this sort of toil. Indeed we get there quite fast simply by reviewing the digits in the 'string'. Fourteen of them. Of course an assumption that this is a modulo ten value.

The concern of working large numbers has been a theme here on usenet's sci.math ever since I started spending time here. Already at a large finite value we've put Peano out of business. Literally in your tongue: you can't get there from here. Oh, and the ellipsis has no interaction with this detail, right? Yet onward toward infinity is where most feel compelled to go. That the digital analysis gets us there the fastest: it's an inconvenient fact that old Peano just didn't want to touch. Really, who am I to poke fun at the old man. Given this value that I've presented you, he might still be working on it to this day. Thus we do not even have to require the halting problem in its fullest form. Simply put a large enough value halts the system for a long enough time that the 'system' is dysfunctional. Absurdity ensues. Now, taking these issues seriously: the value x=33333333333334 is natural, and we won't be needing to compute it as a successor for we can witness that this is not humanly possible. We will have to rely upon some other mechanism of logic to account for it. Oddly enough, this same or similar sort of logic will allow us to work x=333...34, but for the ellipsis and their meaning, which I'm afraid have really gotten put out of whack if your rendition holds up.

Claims of an inductive N and a non-inductive N are a fraud I suspect. N were already inductive. In the paragraphs above we see that instantiation confronts the language of abstraction. As well, the slow demise of the incremental progression in the face of digital analysis exposes a weakness of natural analysis. That the discussion is one of philosophy as much as it is of mathematics is feasible. Bringing physics into the fold as well since numbers are of interest to all of these professions, and here the tenets of the natural value are coming under scrutiny. I had no idea that this was possible.

>
> stands for
> |
> | Inductive(ℕ) ∧
> | ~∃𝐵 ⫋ ℕ : Inductive(𝐵)
> |
> | Inductive(𝐵) <->
> | 0 ∈ 𝐵 ∧ ∀k ∈ 𝐵 : k+1 ∈ 𝐵
>
> The set ℕ of natural numbers does not halt.
>
> I suppose that is considered a problem by
> people who do not want the natural numbers
> to be the natural numbers.
>
> But now, we've left mathematics and
> entered psychology. I am less interested in
> why you do not want the natural numbers
> to be the natural numbers.

Well, I am starting to wonder myself. If the ellipsis requires the grand dodge that you've laid out then the whole deal is crikey.
That ambiguity can be exposed in the basis of mathematics is ultimately a criterion of openness perhaps.
At least though you've come around to even discussing those little dots.

[Ross A. Finlayson]

Sometimes it's written "{... infinitely-many ...}".

It's written to indicate "Really, infinitely many. No really.".

[Ross A. Finlayson]

Usually in set theory the entire set of an infinite sequence of numbers is
infinite, while of course it's just usually that each initial segment is finite.

I.e. constructivists have to work their way up, it's easier.

This then just makes little machines of mathematics in numerical resources,
but there are intuitionists' machines that provide constructive results
that achieve limits, and result for deconstructions for constructivism.

I.e. the intuitionists can make a much "stronger" theory with results over
deductive analysis, look at for example the success of set theory that
it's intuitive that sets are well-founded and even well-ordered.

There's just for example another, ..., stronger theory, weak in its alternatives,
each strong, thus strong.

In numbers, ....

[Ross A. Finlayson]

GeneraL Processing Unit: PC

PC operation

power and the PC
peripherals and the PC

display
input

power
board
bus
chip <- central processing unit

bus chip port

board bus chip port


operation:

1) power
2) "firmware" (BIOS, OpenFirmware, EFI, ...)


The "OEM"
each integrator is an "OEM", ....
Original Equipment Manufacturer


The entry point to the system passing control from the executive out of firmware, here the point is that the difference between
an executive and an operating system is the modularity, where here the point is for example "build a system with modules for
a given configuration, that's flexible under USB insertion order, then write that to boot media, or boot from media". The point
is to boot from media what with respect to bootloaders in their organization firmware or "loading images", there results
"small, modular media", printing out the modular drivers for the configuration from a configuration--reading boot adapter,
that builds an image.

The "operating system" is the protected memory, the executive is just "real-time scheduler".

Here there is "enumerating the bus", also the chip and so on for its family, so getting the families all of the bus.

The device families, then are most usual in organization, USB is the great spec for peripheral I/O and for example
it's a ubiquitous device family, they make various demands of servicing their power, configuration, operation, and I/O.

power <- device power / device no power
configuration <- what is
operation <- what is operations fundamentally device, protocols, ....
<- any protocol becomes a modular service routine / serial protocols
<- data formats, native

I/O
resources <- space, and also maintenance times in space
priority <- "hard", "soft", "opportunistic to wait" (long operation) "opportunistic to go" (short operation)
wait for resources


resources and plan

processes

"the" kernel process
"The:" CPU processes (cores)

RAM
DISK <- disk is a device, on the bus, bus controller, ..., expected "consistent"
"consistent" disk system
"read later" disk system <- consistency problems

POSIX and filesystem guarantees

mount and tools about filesystem
raw filesystem and what look like, ..., EXT, FAT, NTFS
"a slightly beefier structure of an inode" <-> massive array of inodes
POSIX and encrypting filesystems


"a shell"

basically for exploration, is to make a filesystem, that really looks like the firmware also,
that it follows any discovery the firmware results metadata, ..., that the resulting metadata
is to be used to best drive the devices, then also to be able to simply use the firmware "devices", ...

"Assembler" <- the point of the emulator is to run the image, its in the image format of probably the CPU, chips


/bin <- must write tools, simple/dumb
/sbin <- nothing, or tools make sense

/lib <- most mean C compiler or C runtime

/dev/
/proc/

"/dev/bus/usb/001/001"
^- here the point is to get the USB spec, and made drivers for all such USB devices
^- this should capture th same peripherals' configuration for serial, parallel, ... ports, ... ports in protocol



bin and tools

here it must be the image tools, that basically is for making executable images, what result, then in a library system,
that toward a modular system in shared objects and usual compilation, tools into compilers and assemblers,
is for making a compiler and an assembler, with the languages and translations, and targets.

compiler: c
assembler: a

language and C

language and subroutine
language and instruction lists

instruction lists and addressing

Here the key is for resources and addressing, here for giving various memory models, figuring to make it that
resources then will be quotad so memory models make for basically that a function carries into lexical scope,
what to make of allocation in routine.

Then, the kernel's process as a schedule, is where it is to maintain its state mostly in the L1 cache of the CPU,
that the cores share, to make an atomic boundary over that, out to "consistent RAM", to "disk-consistent RAM".





processes and commands



"trying to look like /dev and /proc filesystem from linux <-> less, about same"



CPU and cores

core[0] <- one of the units is usually the entry, somehow privileged

"MCUs"



Figuring there's one compiler for all the languages, and, one assembler for all the targets,
is getting into the idea of writing a program that is a bit-accurate, toward a clock-accurate,
simulation of a PC, ..., then that there are all these schematics sitting around of driver implementations,
to write a good "SMP/AMP operating system", and about for example "real-time, the bus, and
consoles out to log a hard shell", it's definitely nice to get back into POSIX and study, find it's all same.