Root 0, 2-ary:

[0] 0
/ \
/ \
/ \
/ \
/ \
[1] 1 2
/ \ / \
/ \ / \
[2] 3 4 5 6
/ \ / \ / \ / \
[3] 7 8 9 10 11 12 13 14
.................................

It goes on forever. There is no end. There are an infinite number of
levels, however, no leafs in sight... ;^)

Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
never reach infinity, even though the tree is infinite in and of itself...

starting at root, 9 = LRL, and 10 = LRR

;^)

Want to get to the children of a node? Say 5...

left = 2*5+1 = 11
right = 2*5+2 = 12

Say, 2...

left = 2*2+1 = 5
right = 2*2+2 = 6

Perhaps 1...

left = 2*1+1 = 3
right = 2*1+2 = 4

Oh shit how about zero:

left = 2*0+1 = 1
right = 2*0+2 = 2

Three:

left = 2*3+1 = 7
right = 2*3+2 = 8

On and on... On and on....

;^)

On 12/31/2021 10:56 PM, Chris M. Thomasson wrote:
> Root 0, 2-ary:
>
>
> [0]            0
>               / \
>              /   \
>             /     \
>            /       \
>           /         \
> [1]      1           2
>         / \         / \
>        /   \       /   \
> [2]   3     4     5     6
>      / \   / \   / \   / \
> [3] 7   8 9  10 11 12 13  14
> ................................
>
> It goes on forever. There is no end. There are an infinite number of
> levels, however, no leafs in sight... ;^)
[...]
> On and on... On and on....

https://youtu.be/soIewreZjls

LOL!!!!!

>
> ;^)

On 12/31/2021 10:56 PM, Chris M. Thomasson wrote:
> Root 0, 2-ary:
>
>
> [0]            0
>               / \
>              /   \
>             /     \
>            /       \
>           /         \
> [1]      1           2
>         / \         / \
>        /   \       /   \
> [2]   3     4     5     6
>      / \   / \   / \   / \
> [3] 7   8 9  10 11 12 13  14
> ................................

[...]

Hey now, a level is finite, yet there are an infinite amount of them,
and a level can hold an infinite amount of elements... So, humm:

[0] = { 0 }
[1] = { 1, 2 }
[2] = { 3, 4, 5, 6 }
[3] = { 7, 8, 9, 10, 11, 12, 13, 14 }
....

;^)

On 1/1/2022 12:03 AM, Chris M. Thomasson wrote:
> On 12/31/2021 10:56 PM, Chris M. Thomasson wrote:
>> Root 0, 2-ary:
>>
>>
>> [0]            0
>>                / \
>>               /   \
>>              /     \
>>             /       \
>>            /         \
>> [1]      1           2
>>          / \         / \
>>         /   \       /   \
>> [2]   3     4     5     6
>>       / \   / \   / \   / \
>> [3] 7   8 9  10 11 12 13  14
>> ................................

[4] 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

lol!

>
> [...]
>
> Hey now, a level is finite, yet there are an infinite amount of them,
> and a level can hold an infinite amount of elements... So, humm:
>
> [0] = { 0 }
> [1] = { 1, 2 }
> [2] = { 3, 4, 5, 6 }
> [3] = { 7, 8, 9, 10, 11, 12, 13, 14 }
> ...
>
> ;^)
>

Want to extend things, in a sense?

The children of 7 are:

left = 2*7+1 = 15 (LLLL from root?)
right = 2*7+2 = 16

Oh my, WM! They do go on forever:

14:

left = 2*14+1 = 29
right = 2*14+2 = 30

;^)

Oh... How about 13?

left = 2*13+1 = 27
right = 2*13+2 = 28

27, 28, 29, 30, ... Notice the pattern?

;^)

On Saturday, January 1, 2022 at 12:03:26 AM UTC-8, Chris M. Thomasson wrote:
> On 12/31/2021 10:56 PM, Chris M. Thomasson wrote:
> > Root 0, 2-ary:
> >
> >
> > [0] 0
> > / \
> > / \
> > / \
> > / \
> > / \
> > [1] 1 2
> > / \ / \
> > / \ / \
> > [2] 3 4 5 6
> > / \ / \ / \ / \
> > [3] 7 8 9 10 11 12 13 14
> > ................................
> [...]
>
> Hey now, a level is finite, yet there are an infinite amount of them,
> and a level can hold an infinite amount of elements...

Ahhh. CAN hold. But never actually DOES hold 'an infinite amount of elements'

On the other hand, as you note, there are actually 'an infinite amount of' rows.

Thus demonstrating the difference between potential and actual infinite (and, also, demonstrating the falsity of that dichotomy so often promulgated in these discussions). Other examples of the same phenomenon include the difference between polynomials and power series and that between the algebraic and analytic notions of basis of a vector space.

One might also find interesting (possible) traversals of infinite trees and the 'application' of these 'actual infinite' mathematical objects since 'Some finite trees are too large to represent explicitly, such as the game tree for chess or go, and so it is useful to analyze them as if they were infinite.'

https://en.wikipedia.org/wiki/Tree_traversal#Infinite_trees

https://thoughtfulsoftware.wordpress.com/2013/10/19/infinite-data-structures/

https://thoughtfulsoftware.wordpress.com/2013/10/26/traversal-of-infinite-complete-binary-trees/

On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
> Root 0, 2-ary:
>
>
> [0] 0
> / \
> / \
> / \
> / \
> / \
> [1] 1 2
> / \ / \
> / \ / \
> [2] 3 4 5 6
> / \ / \ / \ / \
> [3] 7 8 9 10 11 12 13 14
> ................................
>
> It goes on forever. There is no end. There are an infinite number of
> levels, however, no leafs in sight... ;^)
>
> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> never reach infinity, even though the tree is infinite in and of itself...
>
> starting at root, 9 = LRL, and 10 = LRR
>
> ;^)
>
>
>
> Want to get to the children of a node? Say 5...
>
> left = 2*5+1 = 11
> right = 2*5+2 = 12
>
> Say, 2...
>
> left = 2*2+1 = 5
> right = 2*2+2 = 6
>
> Perhaps 1...
>
> left = 2*1+1 = 3
> right = 2*1+2 = 4
>
> Oh shit how about zero:
>
> left = 2*0+1 = 1
> right = 2*0+2 = 2
>
>
>
>
> Three:
>
> left = 2*3+1 = 7
> right = 2*3+2 = 8
>
> On and on... On and on....
>
> ;^)

Hmm, so you've organized the tree by layers, then leaves,
figuring to always know what binary section of the "row" of leaves,
makes for depth and breadth first traversal. As a data structure,
there's much to be said for implementing whatever accessors
result best-case linear and random access with the expectations
of algorithms that terminate and algorithms that exhaust.

The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
leaves, binary, meaning 2-ary at each node its children, rooted tree",
here is for usually the unbounded. [Which is finite.]

If you've defined some arithmetic that computes offsets, that's great.

In the case for 2's it might be "that's defined ideally for a bitmap with
an exception bitmap", just for example, that admits a default natural
organization for data structures, that with no other knowledge of the
distributions of the inputs but the expected access terminate or exhaust,
in terms of resources or the concrete what result the continuation,
it runs out the exhaust or parallelizes (makes serial) results.

The arithmetic on the integer units works up to word size, with the
idea that "our container is this, its arithmetic of bounds fits in the
word size, so, countings all result computing an offset iterator for
traversal of a tree, in what is constant and also instruction-level time,
what iterates".

About this is this fact about "how can it be, there are about as many rationals
as irrationals, because they're both dense". Starting at the top of
the infinite balanced binary tree, the root, each of the leaves, is an
entire copy of the tree. Anyways, so starting with the root making a
rational number, if it's a rational then it eventually repeats how it
terminates as it exhausts, writing out its next digit. Arriving at that
in chance would be small. But, arriving that at chance results the
infinitely many copies of the same terminus. So, thus it's is as likely
that a number is as rational or irrational, a random one, according
to their properties in density and also "though irrationals are
combinatorially more varied, rationals as regular have many more copies".

On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
> > Root 0, 2-ary:
> >
> >
> > [0] 0
> > / \
> > / \
> > / \
> > / \
> > / \
> > [1] 1 2
> > / \ / \
> > / \ / \
> > [2] 3 4 5 6
> > / \ / \ / \ / \
> > [3] 7 8 9 10 11 12 13 14
> > ................................
> >
> > It goes on forever. There is no end. There are an infinite number of
> > levels, however, no leafs in sight... ;^)
> >
> > Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> > root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> > number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> > never reach infinity, even though the tree is infinite in and of itself...
> >
> > starting at root, 9 = LRL, and 10 = LRR
> >
> > ;^)
> >
> >
> >
> > Want to get to the children of a node? Say 5...
> >
> > left = 2*5+1 = 11
> > right = 2*5+2 = 12
> >
> > Say, 2...
> >
> > left = 2*2+1 = 5
> > right = 2*2+2 = 6
> >
> > Perhaps 1...
> >
> > left = 2*1+1 = 3
> > right = 2*1+2 = 4
> >
> > Oh shit how about zero:
> >
> > left = 2*0+1 = 1
> > right = 2*0+2 = 2
> >
> >
> >
> >
> > Three:
> >
> > left = 2*3+1 = 7
> > right = 2*3+2 = 8
> >
> > On and on... On and on....
> >
> > ;^)
> Hmm, so you've organized the tree by layers, then leaves,
> figuring to always know what binary section of the "row" of leaves,
> makes for depth and breadth first traversal. As a data structure,
> there's much to be said for implementing whatever accessors
> result best-case linear and random access with the expectations
> of algorithms that terminate and algorithms that exhaust.
>
> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
> leaves, binary, meaning 2-ary at each node its children, rooted tree",
> here is for usually the unbounded. [Which is finite.]
>
> If you've defined some arithmetic that computes offsets, that's great.
>
> In the case for 2's it might be "that's defined ideally for a bitmap with
> an exception bitmap", just for example, that admits a default natural
> organization for data structures, that with no other knowledge of the
> distributions of the inputs but the expected access terminate or exhaust,
> in terms of resources or the concrete what result the continuation,
> it runs out the exhaust or parallelizes (makes serial) results.
>
> The arithmetic on the integer units works up to word size, with the
> idea that "our container is this, its arithmetic of bounds fits in the
> word size, so, countings all result computing an offset iterator for
> traversal of a tree, in what is constant and also instruction-level time,
> what iterates".
>
> About this is this fact about "how can it be, there are about as many rationals
> as irrationals, because they're both dense". Starting at the top of
> the infinite balanced binary tree, the root, each of the leaves, is an
> entire copy of the tree. Anyways, so starting with the root making a
> rational number, if it's a rational then it eventually repeats how it
> terminates as it exhausts, writing out its next digit. Arriving at that
> in chance would be small. But, arriving that at chance results the
> infinitely many copies of the same terminus. So, thus it's is as likely
> that a number is as rational or irrational, a random one, according
> to their properties in density and also "though irrationals are
> combinatorially more varied, rationals as regular have many more copies".

There are no final elements in the infinite tree: but, it's expected, that,
at each layer, half the leaves are 1's and half the leaves are 0's.

This then makes for Cantor space 2^w, that, about the sequences in
Cantor space, there results the statistical and probabilistic that half
the sequences have equal 0-1 densities.

This then widens for the old "Factorial/Exponential Identity, Infinity".

Ross A. Finlayson wrote:

> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
> leaves, binary, meaning 2-ary at each node its children, rooted tree",
> here is for usually the unbounded. [Which is finite.]

This would be funny if we didn’t know the gravity of those people
collapsing https://www.bitchute.com/video/cL48U41JJLga/

On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
> > On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
> > > Root 0, 2-ary:
> > >
> > >
> > > [0] 0
> > > / \
> > > / \
> > > / \
> > > / \
> > > / \
> > > [1] 1 2
> > > / \ / \
> > > / \ / \
> > > [2] 3 4 5 6
> > > / \ / \ / \ / \
> > > [3] 7 8 9 10 11 12 13 14
> > > ................................
> > >
> > > It goes on forever. There is no end. There are an infinite number of
> > > levels, however, no leafs in sight... ;^)
> > >
> > > Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> > > root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> > > number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> > > never reach infinity, even though the tree is infinite in and of itself...
> > >
> > > starting at root, 9 = LRL, and 10 = LRR
> > >
> > > ;^)
> > >
> > >
> > >
> > > Want to get to the children of a node? Say 5...
> > >
> > > left = 2*5+1 = 11
> > > right = 2*5+2 = 12
> > >
> > > Say, 2...
> > >
> > > left = 2*2+1 = 5
> > > right = 2*2+2 = 6
> > >
> > > Perhaps 1...
> > >
> > > left = 2*1+1 = 3
> > > right = 2*1+2 = 4
> > >
> > > Oh shit how about zero:
> > >
> > > left = 2*0+1 = 1
> > > right = 2*0+2 = 2
> > >
> > >
> > >
> > >
> > > Three:
> > >
> > > left = 2*3+1 = 7
> > > right = 2*3+2 = 8
> > >
> > > On and on... On and on....
> > >
> > > ;^)
> > Hmm, so you've organized the tree by layers, then leaves,
> > figuring to always know what binary section of the "row" of leaves,
> > makes for depth and breadth first traversal. As a data structure,
> > there's much to be said for implementing whatever accessors
> > result best-case linear and random access with the expectations
> > of algorithms that terminate and algorithms that exhaust.
> >
> > The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
> > leaves, binary, meaning 2-ary at each node its children, rooted tree",
> > here is for usually the unbounded. [Which is finite.]
> >
> > If you've defined some arithmetic that computes offsets, that's great.
> >
> > In the case for 2's it might be "that's defined ideally for a bitmap with
> > an exception bitmap", just for example, that admits a default natural
> > organization for data structures, that with no other knowledge of the
> > distributions of the inputs but the expected access terminate or exhaust,
> > in terms of resources or the concrete what result the continuation,
> > it runs out the exhaust or parallelizes (makes serial) results.
> >
> > The arithmetic on the integer units works up to word size, with the
> > idea that "our container is this, its arithmetic of bounds fits in the
> > word size, so, countings all result computing an offset iterator for
> > traversal of a tree, in what is constant and also instruction-level time,
> > what iterates".
> >
> > About this is this fact about "how can it be, there are about as many rationals
> > as irrationals, because they're both dense". Starting at the top of
> > the infinite balanced binary tree, the root, each of the leaves, is an
> > entire copy of the tree. Anyways, so starting with the root making a
> > rational number, if it's a rational then it eventually repeats how it
> > terminates as it exhausts, writing out its next digit. Arriving at that
> > in chance would be small. But, arriving that at chance results the
> > infinitely many copies of the same terminus. So, thus it's is as likely
> > that a number is as rational or irrational, a random one, according
> > to their properties in density and also "though irrationals are
> > combinatorially more varied, rationals as regular have many more copies".
> There are no final elements in the infinite tree: but, it's expected, that,
> at each layer, half the leaves are 1's and half the leaves are 0's.
>
> This then makes for Cantor space 2^w, that, about the sequences in
> Cantor space, there results the statistical and probabilistic that half
> the sequences have equal 0-1 densities.
>
> This then widens for the old "Factorial/Exponential Identity, Infinity".

"lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"

"lim 2^2n / e^n = sqrt(pi)"

On 1/2/2022 12:23 PM, Ross A. Finlayson wrote:
> On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
>> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
>>> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
>>>> Root 0, 2-ary:
>>>>
>>>>
>>>> [0] 0
>>>> / \
>>>> / \
>>>> / \
>>>> / \
>>>> / \
>>>> [1] 1 2
>>>> / \ / \
>>>> / \ / \
>>>> [2] 3 4 5 6
>>>> / \ / \ / \ / \
>>>> [3] 7 8 9 10 11 12 13 14
>>>> ................................
>>>>
>>>> It goes on forever. There is no end. There are an infinite number of
>>>> levels, however, no leafs in sight... ;^)
>>>>
>>>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
>>>> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
>>>> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
>>>> never reach infinity, even though the tree is infinite in and of itself...
>>>>
>>>> starting at root, 9 = LRL, and 10 = LRR
>>>>
>>>> ;^)
>>>>
>>>>
>>>>
>>>> Want to get to the children of a node? Say 5...
>>>>
>>>> left = 2*5+1 = 11
>>>> right = 2*5+2 = 12
>>>>
>>>> Say, 2...
>>>>
>>>> left = 2*2+1 = 5
>>>> right = 2*2+2 = 6
>>>>
>>>> Perhaps 1...
>>>>
>>>> left = 2*1+1 = 3
>>>> right = 2*1+2 = 4
>>>>
>>>> Oh shit how about zero:
>>>>
>>>> left = 2*0+1 = 1
>>>> right = 2*0+2 = 2
>>>>
>>>>
>>>>
>>>>
>>>> Three:
>>>>
>>>> left = 2*3+1 = 7
>>>> right = 2*3+2 = 8
>>>>
>>>> On and on... On and on....
>>>>
>>>> ;^)
>>> Hmm, so you've organized the tree by layers, then leaves,
>>> figuring to always know what binary section of the "row" of leaves,
>>> makes for depth and breadth first traversal. As a data structure,
>>> there's much to be said for implementing whatever accessors
>>> result best-case linear and random access with the expectations
>>> of algorithms that terminate and algorithms that exhaust.
>>>
>>> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
>>> leaves, binary, meaning 2-ary at each node its children, rooted tree",
>>> here is for usually the unbounded. [Which is finite.]
>>>
>>> If you've defined some arithmetic that computes offsets, that's great.
>>>
>>> In the case for 2's it might be "that's defined ideally for a bitmap with
>>> an exception bitmap", just for example, that admits a default natural
>>> organization for data structures, that with no other knowledge of the
>>> distributions of the inputs but the expected access terminate or exhaust,
>>> in terms of resources or the concrete what result the continuation,
>>> it runs out the exhaust or parallelizes (makes serial) results.
>>>
>>> The arithmetic on the integer units works up to word size, with the
>>> idea that "our container is this, its arithmetic of bounds fits in the
>>> word size, so, countings all result computing an offset iterator for
>>> traversal of a tree, in what is constant and also instruction-level time,
>>> what iterates".
>>>
>>> About this is this fact about "how can it be, there are about as many rationals
>>> as irrationals, because they're both dense". Starting at the top of
>>> the infinite balanced binary tree, the root, each of the leaves, is an
>>> entire copy of the tree. Anyways, so starting with the root making a
>>> rational number, if it's a rational then it eventually repeats how it
>>> terminates as it exhausts, writing out its next digit. Arriving at that
>>> in chance would be small. But, arriving that at chance results the
>>> infinitely many copies of the same terminus. So, thus it's is as likely
>>> that a number is as rational or irrational, a random one, according
>>> to their properties in density and also "though irrationals are
>>> combinatorially more varied, rationals as regular have many more copies".
>> There are no final elements in the infinite tree: but, it's expected, that,
>> at each layer, half the leaves are 1's and half the leaves are 0's.
>>
>> This then makes for Cantor space 2^w, that, about the sequences in
>> Cantor space, there results the statistical and probabilistic that half
>> the sequences have equal 0-1 densities.
>>
>> This then widens for the old "Factorial/Exponential Identity, Infinity".
>
> "lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"
>
> "lim 2^2n / e^n = sqrt(pi)"
>

Both those are malformed. Try again.

do you mean ?

the limit as n goes from 1 to oo of ((sqrt(n * pi/2) * n! ) / (((n/2)!^2) * 2^n)) = 1

On Sunday, January 2, 2022 at 11:20:18 AM UTC-8, Serg io wrote:
> On 1/2/2022 12:23 PM, Ross A. Finlayson wrote:
> > On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
> >> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
> >>> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
> >>>> Root 0, 2-ary:
> >>>>
> >>>>
> >>>> [0] 0
> >>>> / \
> >>>> / \
> >>>> / \
> >>>> / \
> >>>> / \
> >>>> [1] 1 2
> >>>> / \ / \
> >>>> / \ / \
> >>>> [2] 3 4 5 6
> >>>> / \ / \ / \ / \
> >>>> [3] 7 8 9 10 11 12 13 14
> >>>> ................................
> >>>>
> >>>> It goes on forever. There is no end. There are an infinite number of
> >>>> levels, however, no leafs in sight... ;^)
> >>>>
> >>>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> >>>> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> >>>> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> >>>> never reach infinity, even though the tree is infinite in and of itself...
> >>>>
> >>>> starting at root, 9 = LRL, and 10 = LRR
> >>>>
> >>>> ;^)
> >>>>
> >>>>
> >>>>
> >>>> Want to get to the children of a node? Say 5...
> >>>>
> >>>> left = 2*5+1 = 11
> >>>> right = 2*5+2 = 12
> >>>>
> >>>> Say, 2...
> >>>>
> >>>> left = 2*2+1 = 5
> >>>> right = 2*2+2 = 6
> >>>>
> >>>> Perhaps 1...
> >>>>
> >>>> left = 2*1+1 = 3
> >>>> right = 2*1+2 = 4
> >>>>
> >>>> Oh shit how about zero:
> >>>>
> >>>> left = 2*0+1 = 1
> >>>> right = 2*0+2 = 2
> >>>>
> >>>>
> >>>>
> >>>>
> >>>> Three:
> >>>>
> >>>> left = 2*3+1 = 7
> >>>> right = 2*3+2 = 8
> >>>>
> >>>> On and on... On and on....
> >>>>
> >>>> ;^)
> >>> Hmm, so you've organized the tree by layers, then leaves,
> >>> figuring to always know what binary section of the "row" of leaves,
> >>> makes for depth and breadth first traversal. As a data structure,
> >>> there's much to be said for implementing whatever accessors
> >>> result best-case linear and random access with the expectations
> >>> of algorithms that terminate and algorithms that exhaust.
> >>>
> >>> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
> >>> leaves, binary, meaning 2-ary at each node its children, rooted tree",
> >>> here is for usually the unbounded. [Which is finite.]
> >>>
> >>> If you've defined some arithmetic that computes offsets, that's great.
> >>>
> >>> In the case for 2's it might be "that's defined ideally for a bitmap with
> >>> an exception bitmap", just for example, that admits a default natural
> >>> organization for data structures, that with no other knowledge of the
> >>> distributions of the inputs but the expected access terminate or exhaust,
> >>> in terms of resources or the concrete what result the continuation,
> >>> it runs out the exhaust or parallelizes (makes serial) results.
> >>>
> >>> The arithmetic on the integer units works up to word size, with the
> >>> idea that "our container is this, its arithmetic of bounds fits in the
> >>> word size, so, countings all result computing an offset iterator for
> >>> traversal of a tree, in what is constant and also instruction-level time,
> >>> what iterates".
> >>>
> >>> About this is this fact about "how can it be, there are about as many rationals
> >>> as irrationals, because they're both dense". Starting at the top of
> >>> the infinite balanced binary tree, the root, each of the leaves, is an
> >>> entire copy of the tree. Anyways, so starting with the root making a
> >>> rational number, if it's a rational then it eventually repeats how it
> >>> terminates as it exhausts, writing out its next digit. Arriving at that
> >>> in chance would be small. But, arriving that at chance results the
> >>> infinitely many copies of the same terminus. So, thus it's is as likely
> >>> that a number is as rational or irrational, a random one, according
> >>> to their properties in density and also "though irrationals are
> >>> combinatorially more varied, rationals as regular have many more copies".
> >> There are no final elements in the infinite tree: but, it's expected, that,
> >> at each layer, half the leaves are 1's and half the leaves are 0's.
> >>
> >> This then makes for Cantor space 2^w, that, about the sequences in
> >> Cantor space, there results the statistical and probabilistic that half
> >> the sequences have equal 0-1 densities.
> >>
> >> This then widens for the old "Factorial/Exponential Identity, Infinity".
> >
> > "lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"
> >
> > "lim 2^2n / e^n = sqrt(pi)"
> >
> Both those are malformed. Try again.
>
> do you mean ?
>
> the limit as n goes from 1 to oo of ((sqrt(n * pi/2) * n! ) / (((n/2)!^2) * 2^n)) = 1

The limit's all in the one term if that's what you mean.

On 1/2/2022 1:27 PM, Ross A. Finlayson wrote:
> On Sunday, January 2, 2022 at 11:20:18 AM UTC-8, Serg io wrote:
>> On 1/2/2022 12:23 PM, Ross A. Finlayson wrote:
>>> On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
>>>> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
>>>>> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
>>>>>> Root 0, 2-ary:
>>>>>>
>>>>>>
>>>>>> [0] 0
>>>>>> / \
>>>>>> / \
>>>>>> / \
>>>>>> / \
>>>>>> / \
>>>>>> [1] 1 2
>>>>>> / \ / \
>>>>>> / \ / \
>>>>>> [2] 3 4 5 6
>>>>>> / \ / \ / \ / \
>>>>>> [3] 7 8 9 10 11 12 13 14
>>>>>> ................................
>>>>>>
>>>>>> It goes on forever. There is no end. There are an infinite number of
>>>>>> levels, however, no leafs in sight... ;^)
>>>>>>
>>>>>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
>>>>>> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
>>>>>> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
>>>>>> never reach infinity, even though the tree is infinite in and of itself...
>>>>>>
>>>>>> starting at root, 9 = LRL, and 10 = LRR
>>>>>>
>>>>>> ;^)
>>>>>>
>>>>>>
>>>>>>
>>>>>> Want to get to the children of a node? Say 5...
>>>>>>
>>>>>> left = 2*5+1 = 11
>>>>>> right = 2*5+2 = 12
>>>>>>
>>>>>> Say, 2...
>>>>>>
>>>>>> left = 2*2+1 = 5
>>>>>> right = 2*2+2 = 6
>>>>>>
>>>>>> Perhaps 1...
>>>>>>
>>>>>> left = 2*1+1 = 3
>>>>>> right = 2*1+2 = 4
>>>>>>
>>>>>> Oh shit how about zero:
>>>>>>
>>>>>> left = 2*0+1 = 1
>>>>>> right = 2*0+2 = 2
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> Three:
>>>>>>
>>>>>> left = 2*3+1 = 7
>>>>>> right = 2*3+2 = 8
>>>>>>
>>>>>> On and on... On and on....
>>>>>>
>>>>>> ;^)
>>>>> Hmm, so you've organized the tree by layers, then leaves,
>>>>> figuring to always know what binary section of the "row" of leaves,
>>>>> makes for depth and breadth first traversal. As a data structure,
>>>>> there's much to be said for implementing whatever accessors
>>>>> result best-case linear and random access with the expectations
>>>>> of algorithms that terminate and algorithms that exhaust.
>>>>>
>>>>> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
>>>>> leaves, binary, meaning 2-ary at each node its children, rooted tree",
>>>>> here is for usually the unbounded. [Which is finite.]
>>>>>
>>>>> If you've defined some arithmetic that computes offsets, that's great.
>>>>>
>>>>> In the case for 2's it might be "that's defined ideally for a bitmap with
>>>>> an exception bitmap", just for example, that admits a default natural
>>>>> organization for data structures, that with no other knowledge of the
>>>>> distributions of the inputs but the expected access terminate or exhaust,
>>>>> in terms of resources or the concrete what result the continuation,
>>>>> it runs out the exhaust or parallelizes (makes serial) results.
>>>>>
>>>>> The arithmetic on the integer units works up to word size, with the
>>>>> idea that "our container is this, its arithmetic of bounds fits in the
>>>>> word size, so, countings all result computing an offset iterator for
>>>>> traversal of a tree, in what is constant and also instruction-level time,
>>>>> what iterates".
>>>>>
>>>>> About this is this fact about "how can it be, there are about as many rationals
>>>>> as irrationals, because they're both dense". Starting at the top of
>>>>> the infinite balanced binary tree, the root, each of the leaves, is an
>>>>> entire copy of the tree. Anyways, so starting with the root making a
>>>>> rational number, if it's a rational then it eventually repeats how it
>>>>> terminates as it exhausts, writing out its next digit. Arriving at that
>>>>> in chance would be small. But, arriving that at chance results the
>>>>> infinitely many copies of the same terminus. So, thus it's is as likely
>>>>> that a number is as rational or irrational, a random one, according
>>>>> to their properties in density and also "though irrationals are
>>>>> combinatorially more varied, rationals as regular have many more copies".
>>>> There are no final elements in the infinite tree: but, it's expected, that,
>>>> at each layer, half the leaves are 1's and half the leaves are 0's.
>>>>
>>>> This then makes for Cantor space 2^w, that, about the sequences in
>>>> Cantor space, there results the statistical and probabilistic that half
>>>> the sequences have equal 0-1 densities.
>>>>
>>>> This then widens for the old "Factorial/Exponential Identity, Infinity".
>>>
>>> "lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"
>>>
>>> "lim 2^2n / e^n = sqrt(pi)"
>>>
>> Both those are malformed. Try again.
>>
>> do you mean ?
>>
>> the limit as n goes from 1 to oo of ((sqrt(n * pi/2) * n! ) / (((n/2)!^2) * 2^n)) = 1
>
> The limit's all in the one term if that's what you mean.

well then it wrong, Ill let you find the real answer...

https://www.desmos.com/calculator

On Sunday, January 2, 2022 at 11:53:34 AM UTC-8, Serg io wrote:
> On 1/2/2022 1:27 PM, Ross A. Finlayson wrote:
> > On Sunday, January 2, 2022 at 11:20:18 AM UTC-8, Serg io wrote:
> >> On 1/2/2022 12:23 PM, Ross A. Finlayson wrote:
> >>> On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
> >>>> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
> >>>>> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
> >>>>>> Root 0, 2-ary:
> >>>>>>
> >>>>>>
> >>>>>> [0] 0
> >>>>>> / \
> >>>>>> / \
> >>>>>> / \
> >>>>>> / \
> >>>>>> / \
> >>>>>> [1] 1 2
> >>>>>> / \ / \
> >>>>>> / \ / \
> >>>>>> [2] 3 4 5 6
> >>>>>> / \ / \ / \ / \
> >>>>>> [3] 7 8 9 10 11 12 13 14
> >>>>>> ................................
> >>>>>>
> >>>>>> It goes on forever. There is no end. There are an infinite number of
> >>>>>> levels, however, no leafs in sight... ;^)
> >>>>>>
> >>>>>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> >>>>>> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> >>>>>> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> >>>>>> never reach infinity, even though the tree is infinite in and of itself...
> >>>>>>
> >>>>>> starting at root, 9 = LRL, and 10 = LRR
> >>>>>>
> >>>>>> ;^)
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>> Want to get to the children of a node? Say 5...
> >>>>>>
> >>>>>> left = 2*5+1 = 11
> >>>>>> right = 2*5+2 = 12
> >>>>>>
> >>>>>> Say, 2...
> >>>>>>
> >>>>>> left = 2*2+1 = 5
> >>>>>> right = 2*2+2 = 6
> >>>>>>
> >>>>>> Perhaps 1...
> >>>>>>
> >>>>>> left = 2*1+1 = 3
> >>>>>> right = 2*1+2 = 4
> >>>>>>
> >>>>>> Oh shit how about zero:
> >>>>>>
> >>>>>> left = 2*0+1 = 1
> >>>>>> right = 2*0+2 = 2
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>>
> >>>>>> Three:
> >>>>>>
> >>>>>> left = 2*3+1 = 7
> >>>>>> right = 2*3+2 = 8
> >>>>>>
> >>>>>> On and on... On and on....
> >>>>>>
> >>>>>> ;^)
> >>>>> Hmm, so you've organized the tree by layers, then leaves,
> >>>>> figuring to always know what binary section of the "row" of leaves,
> >>>>> makes for depth and breadth first traversal. As a data structure,
> >>>>> there's much to be said for implementing whatever accessors
> >>>>> result best-case linear and random access with the expectations
> >>>>> of algorithms that terminate and algorithms that exhaust.
> >>>>>
> >>>>> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
> >>>>> leaves, binary, meaning 2-ary at each node its children, rooted tree",
> >>>>> here is for usually the unbounded. [Which is finite.]
> >>>>>
> >>>>> If you've defined some arithmetic that computes offsets, that's great.
> >>>>>
> >>>>> In the case for 2's it might be "that's defined ideally for a bitmap with
> >>>>> an exception bitmap", just for example, that admits a default natural
> >>>>> organization for data structures, that with no other knowledge of the
> >>>>> distributions of the inputs but the expected access terminate or exhaust,
> >>>>> in terms of resources or the concrete what result the continuation,
> >>>>> it runs out the exhaust or parallelizes (makes serial) results.
> >>>>>
> >>>>> The arithmetic on the integer units works up to word size, with the
> >>>>> idea that "our container is this, its arithmetic of bounds fits in the
> >>>>> word size, so, countings all result computing an offset iterator for
> >>>>> traversal of a tree, in what is constant and also instruction-level time,
> >>>>> what iterates".
> >>>>>
> >>>>> About this is this fact about "how can it be, there are about as many rationals
> >>>>> as irrationals, because they're both dense". Starting at the top of
> >>>>> the infinite balanced binary tree, the root, each of the leaves, is an
> >>>>> entire copy of the tree. Anyways, so starting with the root making a
> >>>>> rational number, if it's a rational then it eventually repeats how it
> >>>>> terminates as it exhausts, writing out its next digit. Arriving at that
> >>>>> in chance would be small. But, arriving that at chance results the
> >>>>> infinitely many copies of the same terminus. So, thus it's is as likely
> >>>>> that a number is as rational or irrational, a random one, according
> >>>>> to their properties in density and also "though irrationals are
> >>>>> combinatorially more varied, rationals as regular have many more copies".
> >>>> There are no final elements in the infinite tree: but, it's expected, that,
> >>>> at each layer, half the leaves are 1's and half the leaves are 0's.
> >>>>
> >>>> This then makes for Cantor space 2^w, that, about the sequences in
> >>>> Cantor space, there results the statistical and probabilistic that half
> >>>> the sequences have equal 0-1 densities.
> >>>>
> >>>> This then widens for the old "Factorial/Exponential Identity, Infinity".
> >>>
> >>> "lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"
> >>>
> >>> "lim 2^2n / e^n = sqrt(pi)"
> >>>
> >> Both those are malformed. Try again.
> >>
> >> do you mean ?
> >>
> >> the limit as n goes from 1 to oo of ((sqrt(n * pi/2) * n! ) / (((n/2)!^2) * 2^n)) = 1
> >
> > The limit's all in the one term if that's what you mean.
> well then it wrong, Ill let you find the real answer...
>
>
> https://www.desmos.com/calculator

Cantor space, or 2^w, is the language of all the infinite
binary sequences, it is their words or names also values.

Some have all the infinite binary sequences start with
..000... and end with .111.... I.e. the natural order is automatically
associated with any linear order, partial order, total order,
well order, .... (It is the linear and total order.)

Then it rules length assignment with Cantorian line-drawing.

Then what are the orders are exercises in words.

The idea of "let's make this multivariate input univariate
where the input results it's conveniently under operator
arithmetic, though it would require what forms all make
so that in the calculator, roots" - is for the effective employment
of limit in terms.

So, the point is that from the properties of Cantor space as a
space instead of as what results some exhaustion in words,
or besides the usual ones like iterating integers or fractions
usually about moduli where values result. Here when I say
values it means "values as of a model of machine arithmetic".

Here though that also includes the infinite machine arithmetic.
The point is that value representation in machine arithmetic is
bounded.

Modern silicon computers effectively offer quite reasonable large
bounds over what are usual high precision analog and digital computers.

I.e. it's outrageous the millions and millions of times the resources
what result over computing machinery, what would define "an effective
algorithm, in terms" in terms of after 20 or 40 years of silicon doubling,
it would still be an effective algorithm in 20 or 40 halvings, what would
result power extension series as usual linear estimators so computable,
representing large numbers with respect to many numbers.

On 1/2/2022 1:55 PM, Ross A. Finlayson wrote:
> On Sunday, January 2, 2022 at 11:53:34 AM UTC-8, Serg io wrote:
>> On 1/2/2022 1:27 PM, Ross A. Finlayson wrote:
>>> On Sunday, January 2, 2022 at 11:20:18 AM UTC-8, Serg io wrote:
>>>> On 1/2/2022 12:23 PM, Ross A. Finlayson wrote:
>>>>> On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
>>>>>> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
>>>>>>> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
>>>>>>>> Root 0, 2-ary:
>>>>>>>>
>>>>>>>>
>>>>>>>> [0] 0
>>>>>>>> / \
>>>>>>>> / \
>>>>>>>> / \
>>>>>>>> / \
>>>>>>>> / \
>>>>>>>> [1] 1 2
>>>>>>>> / \ / \
>>>>>>>> / \ / \
>>>>>>>> [2] 3 4 5 6
>>>>>>>> / \ / \ / \ / \
>>>>>>>> [3] 7 8 9 10 11 12 13 14
>>>>>>>> ................................
>>>>>>>>
>>>>>>>> It goes on forever. There is no end. There are an infinite number of
>>>>>>>> levels, however, no leafs in sight... ;^)
>>>>>>>>
>>>>>>>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
>>>>>>>> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
>>>>>>>> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
>>>>>>>> never reach infinity, even though the tree is infinite in and of itself...
>>>>>>>>
>>>>>>>> starting at root, 9 = LRL, and 10 = LRR
>>>>>>>>
>>>>>>>> ;^)
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Want to get to the children of a node? Say 5...
>>>>>>>>
>>>>>>>> left = 2*5+1 = 11
>>>>>>>> right = 2*5+2 = 12
>>>>>>>>
>>>>>>>> Say, 2...
>>>>>>>>
>>>>>>>> left = 2*2+1 = 5
>>>>>>>> right = 2*2+2 = 6
>>>>>>>>
>>>>>>>> Perhaps 1...
>>>>>>>>
>>>>>>>> left = 2*1+1 = 3
>>>>>>>> right = 2*1+2 = 4
>>>>>>>>
>>>>>>>> Oh shit how about zero:
>>>>>>>>
>>>>>>>> left = 2*0+1 = 1
>>>>>>>> right = 2*0+2 = 2
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Three:
>>>>>>>>
>>>>>>>> left = 2*3+1 = 7
>>>>>>>> right = 2*3+2 = 8
>>>>>>>>
>>>>>>>> On and on... On and on....
>>>>>>>>
>>>>>>>> ;^)
>>>>>>> Hmm, so you've organized the tree by layers, then leaves,
>>>>>>> figuring to always know what binary section of the "row" of leaves,
>>>>>>> makes for depth and breadth first traversal. As a data structure,
>>>>>>> there's much to be said for implementing whatever accessors
>>>>>>> result best-case linear and random access with the expectations
>>>>>>> of algorithms that terminate and algorithms that exhaust.
>>>>>>>
>>>>>>> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
>>>>>>> leaves, binary, meaning 2-ary at each node its children, rooted tree",
>>>>>>> here is for usually the unbounded. [Which is finite.]
>>>>>>>
>>>>>>> If you've defined some arithmetic that computes offsets, that's great.
>>>>>>>
>>>>>>> In the case for 2's it might be "that's defined ideally for a bitmap with
>>>>>>> an exception bitmap", just for example, that admits a default natural
>>>>>>> organization for data structures, that with no other knowledge of the
>>>>>>> distributions of the inputs but the expected access terminate or exhaust,
>>>>>>> in terms of resources or the concrete what result the continuation,
>>>>>>> it runs out the exhaust or parallelizes (makes serial) results.
>>>>>>>
>>>>>>> The arithmetic on the integer units works up to word size, with the
>>>>>>> idea that "our container is this, its arithmetic of bounds fits in the
>>>>>>> word size, so, countings all result computing an offset iterator for
>>>>>>> traversal of a tree, in what is constant and also instruction-level time,
>>>>>>> what iterates".
>>>>>>>
>>>>>>> About this is this fact about "how can it be, there are about as many rationals
>>>>>>> as irrationals, because they're both dense". Starting at the top of
>>>>>>> the infinite balanced binary tree, the root, each of the leaves, is an
>>>>>>> entire copy of the tree. Anyways, so starting with the root making a
>>>>>>> rational number, if it's a rational then it eventually repeats how it
>>>>>>> terminates as it exhausts, writing out its next digit. Arriving at that
>>>>>>> in chance would be small. But, arriving that at chance results the
>>>>>>> infinitely many copies of the same terminus. So, thus it's is as likely
>>>>>>> that a number is as rational or irrational, a random one, according
>>>>>>> to their properties in density and also "though irrationals are
>>>>>>> combinatorially more varied, rationals as regular have many more copies".
>>>>>> There are no final elements in the infinite tree: but, it's expected, that,
>>>>>> at each layer, half the leaves are 1's and half the leaves are 0's.
>>>>>>
>>>>>> This then makes for Cantor space 2^w, that, about the sequences in
>>>>>> Cantor space, there results the statistical and probabilistic that half
>>>>>> the sequences have equal 0-1 densities.
>>>>>>
>>>>>> This then widens for the old "Factorial/Exponential Identity, Infinity".
>>>>>
>>>>> "lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"
>>>>>
>>>>> "lim 2^2n / e^n = sqrt(pi)"
>>>>>
>>>> Both those are malformed. Try again.
>>>>
>>>> do you mean ?
>>>>
>>>> the limit as n goes from 1 to oo of ((sqrt(n * pi/2) * n! ) / (((n/2)!^2) * 2^n)) = 1
>>>
>>> The limit's all in the one term if that's what you mean.
>> well then it wrong, Ill let you find the real answer...
>>
>>
>> https://www.desmos.com/calculator
>
>
> Cantor space, or 2^w, is the language of all the infinite
> binary sequences, it is their words or names also values.
>
> Some have all the infinite binary sequences start with
> .000... and end with .111.... I.e. the natural order is automatically
> associated with any linear order, partial order, total order,
> well order, .... (It is the linear and total order.)
>
> Then it rules length assignment with Cantorian line-drawing.
>
> Then what are the orders are exercises in words.
>
> The idea of "let's make this multivariate input univariate
> where the input results it's conveniently under operator
> arithmetic, though it would require what forms all make
> so that in the calculator, roots" - is for the effective employment
> of limit in terms.
>
>
> So, the point is that from the properties of Cantor space as a
> space instead of as what results some exhaustion in words,
> or besides the usual ones like iterating integers or fractions
> usually about moduli where values result. Here when I say
> values it means "values as of a model of machine arithmetic".
>
> Here though that also includes the infinite machine arithmetic.
> The point is that value representation in machine arithmetic is
> bounded.
>
> Modern silicon computers effectively offer quite reasonable large
> bounds over what are usual high precision analog and digital computers.
>
> I.e. it's outrageous the millions and millions of times the resources
> what result over computing machinery, what would define "an effective
> algorithm, in terms" in terms of after 20 or 40 years of silicon doubling,
> it would still be an effective algorithm in 20 or 40 halvings, what would
> result power extension series as usual linear estimators so computable,
> representing large numbers with respect to many numbers.
>
> If there's one other fact it's that the integral of the equivalency function,
> f(n) = n/d, n->d, d->oo, that though it looks like 1/2 stretched out, it's
> actually twice that or 1 instead, that if an inductive set had a limit ordinal
> transfinite induction condition establishing transfinite induction, that
> it made a case for infinity as the _last_ number in an exhaustion of
> whatever models the inductive set or integers, it looks like a right triangle
> of half the unit square, then, in the actual case in the infinite, each of
> the point-width intervals doubles for having two sides instead of one side,
> making that Int f = 1.
>
>
>
>

On Sunday, January 2, 2022 at 12:01:38 PM UTC-8, Serg io wrote:
> On 1/2/2022 1:55 PM, Ross A. Finlayson wrote:
> > On Sunday, January 2, 2022 at 11:53:34 AM UTC-8, Serg io wrote:
> >> On 1/2/2022 1:27 PM, Ross A. Finlayson wrote:
> >>> On Sunday, January 2, 2022 at 11:20:18 AM UTC-8, Serg io wrote:
> >>>> On 1/2/2022 12:23 PM, Ross A. Finlayson wrote:
> >>>>> On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
> >>>>>> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
> >>>>>>> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
> >>>>>>>> Root 0, 2-ary:
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> [0] 0
> >>>>>>>> / \
> >>>>>>>> / \
> >>>>>>>> / \
> >>>>>>>> / \
> >>>>>>>> / \
> >>>>>>>> [1] 1 2
> >>>>>>>> / \ / \
> >>>>>>>> / \ / \
> >>>>>>>> [2] 3 4 5 6
> >>>>>>>> / \ / \ / \ / \
> >>>>>>>> [3] 7 8 9 10 11 12 13 14
> >>>>>>>> ................................
> >>>>>>>>
> >>>>>>>> It goes on forever. There is no end. There are an infinite number of
> >>>>>>>> levels, however, no leafs in sight... ;^)
> >>>>>>>>
> >>>>>>>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> >>>>>>>> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> >>>>>>>> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> >>>>>>>> never reach infinity, even though the tree is infinite in and of itself...
> >>>>>>>>
> >>>>>>>> starting at root, 9 = LRL, and 10 = LRR
> >>>>>>>>
> >>>>>>>> ;^)
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> Want to get to the children of a node? Say 5...
> >>>>>>>>
> >>>>>>>> left = 2*5+1 = 11
> >>>>>>>> right = 2*5+2 = 12
> >>>>>>>>
> >>>>>>>> Say, 2...
> >>>>>>>>
> >>>>>>>> left = 2*2+1 = 5
> >>>>>>>> right = 2*2+2 = 6
> >>>>>>>>
> >>>>>>>> Perhaps 1...
> >>>>>>>>
> >>>>>>>> left = 2*1+1 = 3
> >>>>>>>> right = 2*1+2 = 4
> >>>>>>>>
> >>>>>>>> Oh shit how about zero:
> >>>>>>>>
> >>>>>>>> left = 2*0+1 = 1
> >>>>>>>> right = 2*0+2 = 2
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> Three:
> >>>>>>>>
> >>>>>>>> left = 2*3+1 = 7
> >>>>>>>> right = 2*3+2 = 8
> >>>>>>>>
> >>>>>>>> On and on... On and on....
> >>>>>>>>
> >>>>>>>> ;^)
> >>>>>>> Hmm, so you've organized the tree by layers, then leaves,
> >>>>>>> figuring to always know what binary section of the "row" of leaves,
> >>>>>>> makes for depth and breadth first traversal. As a data structure,
> >>>>>>> there's much to be said for implementing whatever accessors
> >>>>>>> result best-case linear and random access with the expectations
> >>>>>>> of algorithms that terminate and algorithms that exhaust.
> >>>>>>>
> >>>>>>> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
> >>>>>>> leaves, binary, meaning 2-ary at each node its children, rooted tree",
> >>>>>>> here is for usually the unbounded. [Which is finite.]
> >>>>>>>
> >>>>>>> If you've defined some arithmetic that computes offsets, that's great.
> >>>>>>>
> >>>>>>> In the case for 2's it might be "that's defined ideally for a bitmap with
> >>>>>>> an exception bitmap", just for example, that admits a default natural
> >>>>>>> organization for data structures, that with no other knowledge of the
> >>>>>>> distributions of the inputs but the expected access terminate or exhaust,
> >>>>>>> in terms of resources or the concrete what result the continuation,
> >>>>>>> it runs out the exhaust or parallelizes (makes serial) results.
> >>>>>>>
> >>>>>>> The arithmetic on the integer units works up to word size, with the
> >>>>>>> idea that "our container is this, its arithmetic of bounds fits in the
> >>>>>>> word size, so, countings all result computing an offset iterator for
> >>>>>>> traversal of a tree, in what is constant and also instruction-level time,
> >>>>>>> what iterates".
> >>>>>>>
> >>>>>>> About this is this fact about "how can it be, there are about as many rationals
> >>>>>>> as irrationals, because they're both dense". Starting at the top of
> >>>>>>> the infinite balanced binary tree, the root, each of the leaves, is an
> >>>>>>> entire copy of the tree. Anyways, so starting with the root making a
> >>>>>>> rational number, if it's a rational then it eventually repeats how it
> >>>>>>> terminates as it exhausts, writing out its next digit. Arriving at that
> >>>>>>> in chance would be small. But, arriving that at chance results the
> >>>>>>> infinitely many copies of the same terminus. So, thus it's is as likely
> >>>>>>> that a number is as rational or irrational, a random one, according
> >>>>>>> to their properties in density and also "though irrationals are
> >>>>>>> combinatorially more varied, rationals as regular have many more copies".
> >>>>>> There are no final elements in the infinite tree: but, it's expected, that,
> >>>>>> at each layer, half the leaves are 1's and half the leaves are 0's.
> >>>>>>
> >>>>>> This then makes for Cantor space 2^w, that, about the sequences in
> >>>>>> Cantor space, there results the statistical and probabilistic that half
> >>>>>> the sequences have equal 0-1 densities.
> >>>>>>
> >>>>>> This then widens for the old "Factorial/Exponential Identity, Infinity".
> >>>>>
> >>>>> "lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"
> >>>>>
> >>>>> "lim 2^2n / e^n = sqrt(pi)"
> >>>>>
> >>>> Both those are malformed. Try again.
> >>>>
> >>>> do you mean ?
> >>>>
> >>>> the limit as n goes from 1 to oo of ((sqrt(n * pi/2) * n! ) / (((n/2)!^2) * 2^n)) = 1
> >>>
> >>> The limit's all in the one term if that's what you mean.
> >> well then it wrong, Ill let you find the real answer...
> >>
> >>
> >> https://www.desmos.com/calculator
> >
> >
> > Cantor space, or 2^w, is the language of all the infinite
> > binary sequences, it is their words or names also values.
> >
> > Some have all the infinite binary sequences start with
> > .000... and end with .111.... I.e. the natural order is automatically
> > associated with any linear order, partial order, total order,
> > well order, .... (It is the linear and total order.)
> >
> > Then it rules length assignment with Cantorian line-drawing.
> >
> > Then what are the orders are exercises in words.
> >
> > The idea of "let's make this multivariate input univariate
> > where the input results it's conveniently under operator
> > arithmetic, though it would require what forms all make
> > so that in the calculator, roots" - is for the effective employment
> > of limit in terms.
> >
> >
> > So, the point is that from the properties of Cantor space as a
> > space instead of as what results some exhaustion in words,
> > or besides the usual ones like iterating integers or fractions
> > usually about moduli where values result. Here when I say
> > values it means "values as of a model of machine arithmetic".
> >
> > Here though that also includes the infinite machine arithmetic.
> > The point is that value representation in machine arithmetic is
> > bounded.
> >
> > Modern silicon computers effectively offer quite reasonable large
> > bounds over what are usual high precision analog and digital computers.
> >
> > I.e. it's outrageous the millions and millions of times the resources
> > what result over computing machinery, what would define "an effective
> > algorithm, in terms" in terms of after 20 or 40 years of silicon doubling,
> > it would still be an effective algorithm in 20 or 40 halvings, what would
> > result power extension series as usual linear estimators so computable,
> > representing large numbers with respect to many numbers.
> >
> > If there's one other fact it's that the integral of the equivalency function,
> > f(n) = n/d, n->d, d->oo, that though it looks like 1/2 stretched out, it's
> > actually twice that or 1 instead, that if an inductive set had a limit ordinal
> > transfinite induction condition establishing transfinite induction, that
> > it made a case for infinity as the _last_ number in an exhaustion of
> > whatever models the inductive set or integers, it looks like a right triangle
> > of half the unit square, then, in the actual case in the infinite, each of
> > the point-width intervals doubles for having two sides instead of one side,
> > making that Int f = 1.
> >
> >
> >
> >
> yea, but there are downsides to that

Ross A. Finlayson wrote:

>> > side, making that Int f = 1.
>> >
>> yea, but there are downsides to that
>
> These are "identities that Finlayson found that look like Stirling
> identities".

nonsense. Without the communism and WW2 won by the communists, you
wouldn't even have been born, but the capitalism would genocide you.

see Keynes, the father of liberalism. An eugenicist. So thank the
communism that you guys are well and alive.

https://en.wikipedia.org/wiki/John_Maynard_Keynes#Political_life

Keynes was a proponent of eugenics.[193] He served as director of the
British Eugenics Society from 1937 to 1944. As late as 1946, shortly
before his death, Keynes declared eugenics to be "the most important,
significant and, I would add, genuine branch of sociology which
exists."[194]

On Sunday, January 2, 2022 at 11:55:44 AM UTC-8, Ross A. Finlayson wrote:
> On Sunday, January 2, 2022 at 11:53:34 AM UTC-8, Serg io wrote:
> > On 1/2/2022 1:27 PM, Ross A. Finlayson wrote:
> > > On Sunday, January 2, 2022 at 11:20:18 AM UTC-8, Serg io wrote:
> > >> On 1/2/2022 12:23 PM, Ross A. Finlayson wrote:
> > >>> On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
> > >>>> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
> > >>>>> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
> > >>>>>> Root 0, 2-ary:
> > >>>>>>
> > >>>>>>
> > >>>>>> [0] 0
> > >>>>>> / \
> > >>>>>> / \
> > >>>>>> / \
> > >>>>>> / \
> > >>>>>> / \
> > >>>>>> [1] 1 2
> > >>>>>> / \ / \
> > >>>>>> / \ / \
> > >>>>>> [2] 3 4 5 6
> > >>>>>> / \ / \ / \ / \
> > >>>>>> [3] 7 8 9 10 11 12 13 14
> > >>>>>> ................................
> > >>>>>>
> > >>>>>> It goes on forever. There is no end. There are an infinite number of
> > >>>>>> levels, however, no leafs in sight... ;^)
> > >>>>>>
> > >>>>>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> > >>>>>> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> > >>>>>> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> > >>>>>> never reach infinity, even though the tree is infinite in and of itself...
> > >>>>>>
> > >>>>>> starting at root, 9 = LRL, and 10 = LRR
> > >>>>>>
> > >>>>>> ;^)
> > >>>>>>
> > >>>>>>
> > >>>>>>
> > >>>>>> Want to get to the children of a node? Say 5...
> > >>>>>>
> > >>>>>> left = 2*5+1 = 11
> > >>>>>> right = 2*5+2 = 12
> > >>>>>>
> > >>>>>> Say, 2...
> > >>>>>>
> > >>>>>> left = 2*2+1 = 5
> > >>>>>> right = 2*2+2 = 6
> > >>>>>>
> > >>>>>> Perhaps 1...
> > >>>>>>
> > >>>>>> left = 2*1+1 = 3
> > >>>>>> right = 2*1+2 = 4
> > >>>>>>
> > >>>>>> Oh shit how about zero:
> > >>>>>>
> > >>>>>> left = 2*0+1 = 1
> > >>>>>> right = 2*0+2 = 2
> > >>>>>>
> > >>>>>>
> > >>>>>>
> > >>>>>>
> > >>>>>> Three:
> > >>>>>>
> > >>>>>> left = 2*3+1 = 7
> > >>>>>> right = 2*3+2 = 8
> > >>>>>>
> > >>>>>> On and on... On and on....
> > >>>>>>
> > >>>>>> ;^)
> > >>>>> Hmm, so you've organized the tree by layers, then leaves,
> > >>>>> figuring to always know what binary section of the "row" of leaves,
> > >>>>> makes for depth and breadth first traversal. As a data structure,
> > >>>>> there's much to be said for implementing whatever accessors
> > >>>>> result best-case linear and random access with the expectations
> > >>>>> of algorithms that terminate and algorithms that exhaust.
> > >>>>>
> > >>>>> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
> > >>>>> leaves, binary, meaning 2-ary at each node its children, rooted tree",
> > >>>>> here is for usually the unbounded. [Which is finite.]
> > >>>>>
> > >>>>> If you've defined some arithmetic that computes offsets, that's great.
> > >>>>>
> > >>>>> In the case for 2's it might be "that's defined ideally for a bitmap with
> > >>>>> an exception bitmap", just for example, that admits a default natural
> > >>>>> organization for data structures, that with no other knowledge of the
> > >>>>> distributions of the inputs but the expected access terminate or exhaust,
> > >>>>> in terms of resources or the concrete what result the continuation,
> > >>>>> it runs out the exhaust or parallelizes (makes serial) results.
> > >>>>>
> > >>>>> The arithmetic on the integer units works up to word size, with the
> > >>>>> idea that "our container is this, its arithmetic of bounds fits in the
> > >>>>> word size, so, countings all result computing an offset iterator for
> > >>>>> traversal of a tree, in what is constant and also instruction-level time,
> > >>>>> what iterates".
> > >>>>>
> > >>>>> About this is this fact about "how can it be, there are about as many rationals
> > >>>>> as irrationals, because they're both dense". Starting at the top of
> > >>>>> the infinite balanced binary tree, the root, each of the leaves, is an
> > >>>>> entire copy of the tree. Anyways, so starting with the root making a
> > >>>>> rational number, if it's a rational then it eventually repeats how it
> > >>>>> terminates as it exhausts, writing out its next digit. Arriving at that
> > >>>>> in chance would be small. But, arriving that at chance results the
> > >>>>> infinitely many copies of the same terminus. So, thus it's is as likely
> > >>>>> that a number is as rational or irrational, a random one, according
> > >>>>> to their properties in density and also "though irrationals are
> > >>>>> combinatorially more varied, rationals as regular have many more copies".
> > >>>> There are no final elements in the infinite tree: but, it's expected, that,
> > >>>> at each layer, half the leaves are 1's and half the leaves are 0's.
> > >>>>
> > >>>> This then makes for Cantor space 2^w, that, about the sequences in
> > >>>> Cantor space, there results the statistical and probabilistic that half
> > >>>> the sequences have equal 0-1 densities.
> > >>>>
> > >>>> This then widens for the old "Factorial/Exponential Identity, Infinity".
> > >>>
> > >>> "lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"
> > >>>
> > >>> "lim 2^2n / e^n = sqrt(pi)"
> > >>>
> > >> Both those are malformed. Try again.
> > >>
> > >> do you mean ?
> > >>
> > >> the limit as n goes from 1 to oo of ((sqrt(n * pi/2) * n! ) / (((n/2)!^2) * 2^n)) = 1
> > >
> > > The limit's all in the one term if that's what you mean.
> > well then it wrong, Ill let you find the real answer...
> >
> >
> > https://www.desmos.com/calculator
> Cantor space, or 2^w, is the language of all the infinite
> binary sequences, it is their words or names also values.
>
> Some have all the infinite binary sequences start with
> .000... and end with .111.... I.e. the natural order is automatically
> associated with any linear order, partial order, total order,
> well order, .... (It is the linear and total order.)
>
> Then it rules length assignment with Cantorian line-drawing.
>
> Then what are the orders are exercises in words.
>
> The idea of "let's make this multivariate input univariate
> where the input results it's conveniently under operator
> arithmetic, though it would require what forms all make
> so that in the calculator, roots" - is for the effective employment
> of limit in terms.
>
>
> So, the point is that from the properties of Cantor space as a
> space instead of as what results some exhaustion in words,
> or besides the usual ones like iterating integers or fractions
> usually about moduli where values result. Here when I say
> values it means "values as of a model of machine arithmetic".
>
> Here though that also includes the infinite machine arithmetic.
> The point is that value representation in machine arithmetic is
> bounded.
>
> Modern silicon computers effectively offer quite reasonable large
> bounds over what are usual high precision analog and digital computers.
>
> I.e. it's outrageous the millions and millions of times the resources
> what result over computing machinery, what would define "an effective
> algorithm, in terms" in terms of after 20 or 40 years of silicon doubling,
> it would still be an effective algorithm in 20 or 40 halvings, what would
> result power extension series as usual linear estimators so computable,
> representing large numbers with respect to many numbers.
>
> If there's one other fact it's that the integral of the equivalency function,
> f(n) = n/d, n->d, d->oo, that though it looks like 1/2 stretched out, it's
> actually twice that or 1 instead, that if an inductive set had a limit ordinal
> transfinite induction condition establishing transfinite induction, that
> it made a case for infinity as the _last_ number in an exhaustion of
> whatever models the inductive set or integers, it looks like a right triangle
> of half the unit square, then, in the actual case in the infinite, each of
> the point-width intervals doubles for having two sides instead of one side,
> making that Int f = 1.

On Sunday, January 2, 2022 at 3:38:57 PM UTC-8, Ross A. Finlayson wrote:
> On Sunday, January 2, 2022 at 11:55:44 AM UTC-8, Ross A. Finlayson wrote:
> > On Sunday, January 2, 2022 at 11:53:34 AM UTC-8, Serg io wrote:
> > > On 1/2/2022 1:27 PM, Ross A. Finlayson wrote:
> > > > On Sunday, January 2, 2022 at 11:20:18 AM UTC-8, Serg io wrote:
> > > >> On 1/2/2022 12:23 PM, Ross A. Finlayson wrote:
> > > >>> On Sunday, January 2, 2022 at 9:54:08 AM UTC-8, Ross A. Finlayson wrote:
> > > >>>> On Sunday, January 2, 2022 at 9:29:35 AM UTC-8, Ross A. Finlayson wrote:
> > > >>>>> On Friday, December 31, 2021 at 10:56:33 PM UTC-8, Chris M. Thomasson wrote:
> > > >>>>>> Root 0, 2-ary:
> > > >>>>>>
> > > >>>>>>
> > > >>>>>> [0] 0
> > > >>>>>> / \
> > > >>>>>> / \
> > > >>>>>> / \
> > > >>>>>> / \
> > > >>>>>> / \
> > > >>>>>> [1] 1 2
> > > >>>>>> / \ / \
> > > >>>>>> / \ / \
> > > >>>>>> [2] 3 4 5 6
> > > >>>>>> / \ / \ / \ / \
> > > >>>>>> [3] 7 8 9 10 11 12 13 14
> > > >>>>>> ................................
> > > >>>>>>
> > > >>>>>> It goes on forever. There is no end. There are an infinite number of
> > > >>>>>> levels, however, no leafs in sight... ;^)
> > > >>>>>>
> > > >>>>>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> > > >>>>>> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> > > >>>>>> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> > > >>>>>> never reach infinity, even though the tree is infinite in and of itself...
> > > >>>>>>
> > > >>>>>> starting at root, 9 = LRL, and 10 = LRR
> > > >>>>>>
> > > >>>>>> ;^)
> > > >>>>>>
> > > >>>>>>
> > > >>>>>>
> > > >>>>>> Want to get to the children of a node? Say 5...
> > > >>>>>>
> > > >>>>>> left = 2*5+1 = 11
> > > >>>>>> right = 2*5+2 = 12
> > > >>>>>>
> > > >>>>>> Say, 2...
> > > >>>>>>
> > > >>>>>> left = 2*2+1 = 5
> > > >>>>>> right = 2*2+2 = 6
> > > >>>>>>
> > > >>>>>> Perhaps 1...
> > > >>>>>>
> > > >>>>>> left = 2*1+1 = 3
> > > >>>>>> right = 2*1+2 = 4
> > > >>>>>>
> > > >>>>>> Oh shit how about zero:
> > > >>>>>>
> > > >>>>>> left = 2*0+1 = 1
> > > >>>>>> right = 2*0+2 = 2
> > > >>>>>>
> > > >>>>>>
> > > >>>>>>
> > > >>>>>>
> > > >>>>>> Three:
> > > >>>>>>
> > > >>>>>> left = 2*3+1 = 7
> > > >>>>>> right = 2*3+2 = 8
> > > >>>>>>
> > > >>>>>> On and on... On and on....
> > > >>>>>>
> > > >>>>>> ;^)
> > > >>>>> Hmm, so you've organized the tree by layers, then leaves,
> > > >>>>> figuring to always know what binary section of the "row" of leaves,
> > > >>>>> makes for depth and breadth first traversal. As a data structure,
> > > >>>>> there's much to be said for implementing whatever accessors
> > > >>>>> result best-case linear and random access with the expectations
> > > >>>>> of algorithms that terminate and algorithms that exhaust.
> > > >>>>>
> > > >>>>> The, "infinite, ..., balanced, meaning 'symmetrical' each ordering of
> > > >>>>> leaves, binary, meaning 2-ary at each node its children, rooted tree",
> > > >>>>> here is for usually the unbounded. [Which is finite.]
> > > >>>>>
> > > >>>>> If you've defined some arithmetic that computes offsets, that's great.
> > > >>>>>
> > > >>>>> In the case for 2's it might be "that's defined ideally for a bitmap with
> > > >>>>> an exception bitmap", just for example, that admits a default natural
> > > >>>>> organization for data structures, that with no other knowledge of the
> > > >>>>> distributions of the inputs but the expected access terminate or exhaust,
> > > >>>>> in terms of resources or the concrete what result the continuation,
> > > >>>>> it runs out the exhaust or parallelizes (makes serial) results.
> > > >>>>>
> > > >>>>> The arithmetic on the integer units works up to word size, with the
> > > >>>>> idea that "our container is this, its arithmetic of bounds fits in the
> > > >>>>> word size, so, countings all result computing an offset iterator for
> > > >>>>> traversal of a tree, in what is constant and also instruction-level time,
> > > >>>>> what iterates".
> > > >>>>>
> > > >>>>> About this is this fact about "how can it be, there are about as many rationals
> > > >>>>> as irrationals, because they're both dense". Starting at the top of
> > > >>>>> the infinite balanced binary tree, the root, each of the leaves, is an
> > > >>>>> entire copy of the tree. Anyways, so starting with the root making a
> > > >>>>> rational number, if it's a rational then it eventually repeats how it
> > > >>>>> terminates as it exhausts, writing out its next digit. Arriving at that
> > > >>>>> in chance would be small. But, arriving that at chance results the
> > > >>>>> infinitely many copies of the same terminus. So, thus it's is as likely
> > > >>>>> that a number is as rational or irrational, a random one, according
> > > >>>>> to their properties in density and also "though irrationals are
> > > >>>>> combinatorially more varied, rationals as regular have many more copies".
> > > >>>> There are no final elements in the infinite tree: but, it's expected, that,
> > > >>>> at each layer, half the leaves are 1's and half the leaves are 0's.
> > > >>>>
> > > >>>> This then makes for Cantor space 2^w, that, about the sequences in
> > > >>>> Cantor space, there results the statistical and probabilistic that half
> > > >>>> the sequences have equal 0-1 densities.
> > > >>>>
> > > >>>> This then widens for the old "Factorial/Exponential Identity, Infinity".
> > > >>>
> > > >>> "lim n->oo (sqrt(n pi/2) n! ) / ( (n/2)!^2 2^n) = 1"
> > > >>>
> > > >>> "lim 2^2n / e^n = sqrt(pi)"
> > > >>>
> > > >> Both those are malformed. Try again.
> > > >>
> > > >> do you mean ?
> > > >>
> > > >> the limit as n goes from 1 to oo of ((sqrt(n * pi/2) * n! ) / (((n/2)!^2) * 2^n)) = 1
> > > >
> > > > The limit's all in the one term if that's what you mean.
> > > well then it wrong, Ill let you find the real answer...
> > >
> > >
> > > https://www.desmos.com/calculator
> > Cantor space, or 2^w, is the language of all the infinite
> > binary sequences, it is their words or names also values.
> >
> > Some have all the infinite binary sequences start with
> > .000... and end with .111.... I.e. the natural order is automatically
> > associated with any linear order, partial order, total order,
> > well order, .... (It is the linear and total order.)
> >
> > Then it rules length assignment with Cantorian line-drawing.
> >
> > Then what are the orders are exercises in words.
> >
> > The idea of "let's make this multivariate input univariate
> > where the input results it's conveniently under operator
> > arithmetic, though it would require what forms all make
> > so that in the calculator, roots" - is for the effective employment
> > of limit in terms.
> >
> >
> > So, the point is that from the properties of Cantor space as a
> > space instead of as what results some exhaustion in words,
> > or besides the usual ones like iterating integers or fractions
> > usually about moduli where values result. Here when I say
> > values it means "values as of a model of machine arithmetic".
> >
> > Here though that also includes the infinite machine arithmetic.
> > The point is that value representation in machine arithmetic is
> > bounded.
> >
> > Modern silicon computers effectively offer quite reasonable large
> > bounds over what are usual high precision analog and digital computers.
> >
> > I.e. it's outrageous the millions and millions of times the resources
> > what result over computing machinery, what would define "an effective
> > algorithm, in terms" in terms of after 20 or 40 years of silicon doubling,
> > it would still be an effective algorithm in 20 or 40 halvings, what would
> > result power extension series as usual linear estimators so computable,
> > representing large numbers with respect to many numbers.
> >
> > If there's one other fact it's that the integral of the equivalency function,
> > f(n) = n/d, n->d, d->oo, that though it looks like 1/2 stretched out, it's
> > actually twice that or 1 instead, that if an inductive set had a limit ordinal
> > transfinite induction condition establishing transfinite induction, that
> > it made a case for infinity as the _last_ number in an exhaustion of
> > whatever models the inductive set or integers, it looks like a right triangle
> > of half the unit square, then, in the actual case in the infinite, each of
> > the point-width intervals doubles for having two sides instead of one side,
> > making that Int f = 1.
> https://www.journals.uchicago.edu/doi/full/10.1093/bjps/axw013
>
> "Non-Archimedean probability functions allow us to combine regularity with perfect additivity."

On 12/31/2021 10:56 PM, Chris M. Thomasson wrote:
> Root 0, 2-ary:
>
>
> [0]            0
>               / \
>              /   \
>             /     \
>            /       \
>           /         \
> [1]      1           2
>         / \         / \
>        /   \       /   \
> [2]   3     4     5     6
>      / \   / \   / \   / \
> [3] 7   8 9  10 11 12 13  14
> ................................
>
> It goes on forever. There is no end. There are an infinite number of
> levels, however, no leafs in sight... ;^)
>
> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at the
> root, go (R, L, R) RLR... a finite path to 12. Want to get to a big
> number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You can
> never reach infinity, even though the tree is infinite in and of itself...
>
> starting at root, 9 = LRL, and 10 = LRR
>
> ;^)
>
>
>
> Want to get to the children of a node? Say 5...
>
> left = 2*5+1 = 11
> right  = 2*5+2 = 12
>
> Say, 2...
>
> left = 2*2+1 = 5
> right = 2*2+2 = 6
[...]

Funny... Humm.... Lets try to get the parent of say, 11 and 12:

parent = ceil(11 / 2 - 1) = 5
parent = ceil(12 / 2 - 1) = 5

Humm... How about, 6 and 5

parent = ceil(6 / 2 - 1) = 2
parent = ceil(5 / 2 - 1) = 2

How about 1 and 2:

parent = ceil(1 / 2 - 1) = 0
parent = ceil(2 / 2 - 1) = 0

Working! What happens with zero:

parent = ceil(0 / 2 - 1) = -1

Humm! Does this going into another realm?

;^)

The parent of 9, or 10:

parent = ceil(9 / 2 - 1) = 4
parent = ceil(10 / 2 - 1) = 4

How about 7, or 8?

parent = ceil(7 / 2 - 1) = 3
parent = ceil(8 / 2 - 1) = 3

Humm... Seems to work out okay for now.

On 1/2/2022 9:26 PM, Chris M. Thomasson wrote:
> On 12/31/2021 10:56 PM, Chris M. Thomasson wrote:
>> Root 0, 2-ary:
>>
>>
>> [0]            0
>>                / \
>>               /   \
>>              /     \
>>             /       \
>>            /         \
>> [1]      1           2
>>          / \         / \
>>         /   \       /   \
>> [2]   3     4     5     6
>>       / \   / \   / \   / \
>> [3] 7   8 9  10 11 12 13  14
>> ................................
>>
>> It goes on forever. There is no end. There are an infinite number of
>> levels, however, no leafs in sight... ;^)
>>
>> Want to get to the number 12, we go: (0, 2, 5, 12), or, starting at
>> the root, go (R, L, R) RLR... a finite path to 12. Want to get to a
>> big number, go all rights... (0, 2, 6, 14, ...). Notice a pattern? You
>> can never reach infinity, even though the tree is infinite in and of
>> itself...
>>
>> starting at root, 9 = LRL, and 10 = LRR
>>
>> ;^)
>>
>>
>>
>> Want to get to the children of a node? Say 5...
>>
>> left = 2*5+1 = 11
>> right  = 2*5+2 = 12
>>
>> Say, 2...
>>
>> left = 2*2+1 = 5
>> right = 2*2+2 = 6
> [...]
>
> Funny... Humm.... Lets try to get the parent of say, 11 and 12:
>
> parent = ceil(11 / 2 - 1) = 5
> parent = ceil(12 / 2 - 1) = 5
>
> Humm... How about, 6 and 5
>
>
> parent = ceil(6 / 2 - 1) = 2
> parent = ceil(5 / 2 - 1) = 2
>
> How about 1 and 2:
>
> parent = ceil(1 / 2 - 1) = 0
> parent = ceil(2 / 2 - 1) = 0
>
> Working! What happens with zero:
>
> parent = ceil(0 / 2 - 1) = -1
>
> Humm! Does this going into another realm?
>
> ;^)
>
> The parent of 9, or 10:
>
> parent = ceil(9 / 2 - 1) = 4
> parent = ceil(10 / 2 - 1) = 4
>
> How about 7, or 8?
>
> parent = ceil(7 / 2 - 1) = 3
> parent = ceil(8 / 2 - 1) = 3
>
>
> Humm... Seems to work out okay for now.

Humm... Let's try to abstract it:

The children of 5 are 11 and 12, lets check:

child_left = 2*5+1 = 11
child_right = 2*5+2 = 12

The parent of 11 and 12 are 5, lets check:

parent = ceil(11 / 2 - 1) = 5
parent = ceil(12 / 2 - 1) = 5

Therefore,

ceil((2*5+1) / 2 - 1) = 5
ceil((2*5+2) / 2 - 1) = 5

Humm...

left = ary * node_value + 1
right = ary * node_value + 2

and:

parent = ceil(left / ary - 1)
parent = ceil(right / ary - 1)

?

Humm...

On 1/2/2022 9:35 PM, Chris M. Thomasson wrote:
> On 1/2/2022 9:26 PM, Chris M. Thomasson wrote:
>> On 12/31/2021 10:56 PM, Chris M. Thomasson wrote:
>>> Root 0, 2-ary:
>>>
>>>
>>> [0]            0
>>>                / \
>>>               /   \
>>>              /     \
>>>             /       \
>>>            /         \
>>> [1]      1           2
>>>          / \         / \
>>>         /   \       /   \
>>> [2]   3     4     5     6
>>>       / \   / \   / \   / \
>>> [3] 7   8 9  10 11 12 13  14
>>> ................................
>>>
>>> It goes on forever. There is no end. There are an infinite number of
>>> levels, however, no leafs in sight... ;^)
[...]
>> How about 1 and 2:
>>
>> parent = ceil(1 / 2 - 1) = 0
>> parent = ceil(2 / 2 - 1) = 0
>>
>> Working! What happens with zero:
>>
>> parent = ceil(0 / 2 - 1) = -1
>>
>> Humm! Does this going into another realm?
>>
>> ;^)
>>
>> The parent of 9, or 10:
>>
>> parent = ceil(9 / 2 - 1) = 4
>> parent = ceil(10 / 2 - 1) = 4
>>
>> How about 7, or 8?
>>
>> parent = ceil(7 / 2 - 1) = 3
>> parent = ceil(8 / 2 - 1) = 3
>>
>>
>> Humm... Seems to work out okay for now.
>
> Humm... Let's try to abstract it:
>
> The children of 5 are 11 and 12, lets check:
>
> child_left  = 2*5+1 = 11
> child_right = 2*5+2 = 12
>
> The parent of 11 and 12 are 5, lets check:
>
> parent = ceil(11 / 2 - 1) = 5
> parent = ceil(12 / 2 - 1) = 5
>
> Therefore,
>
> ceil((2*5+1) / 2 - 1) = 5
> ceil((2*5+2) / 2 - 1) = 5
>
>
> Humm...
>
> left = ary * node_value + 1
> right = ary * node_value + 2
>
> and:
>
> parent = ceil(left / ary - 1)
> parent = ceil(right / ary - 1)
[...]

What about 3-ary? God damn ASCII art! Anyway:

[0] 0
/|\
/ | \
/ | \
/ | \
/ | \
/ | \
/ | \
[1] 1 2 3
/|\ /|\ /|\
/ | \ / | \ / | \
[2] 4 5 6 7 8 9 10 11 12
...............................................

Lets see here... This is 3-ary, therefore, the three children of, say 2
are: 7, 8, 9... Humm:

3-ary, children, for 2 are:

child_left = 3*2+1 = 7
child_middle = 3*2+2 = 8
child_right = 3*2+3 = 9

Humm... They Work!

Lets try getting the parent of say, 11, which should be 3:

ceil(11 / 3 - 1) = 3

okay, how about 10:

ceil(10 / 3 - 1) = 3

And, perhaps 12:

ceil(12 / 3 - 1) = 3

Humm... Afaict, this seems to work with a highly experimental fractal
encryption of mine called RIFC that stores data in the roots of
fractals. Humm... Interesting to me. Should world in integer land,
instead of floating heck!

Fwiw:

https://github.com/ChrisMThomasson/fractal_cipher/blob/master/RIFC/cpp/ct_rifc_sample.cpp

On 1/3/2022 12:10 AM, Chris M. Thomasson wrote:
> On 1/2/2022 9:35 PM, Chris M. Thomasson wrote:
>> On 1/2/2022 9:26 PM, Chris M. Thomasson wrote:
>>> On 12/31/2021 10:56 PM, Chris M. Thomasson wrote:
>>>> Root 0, 2-ary:
[...]
> What about 3-ary? God damn ASCII art! Anyway:
>
>
>
>
> [0]                 0
>                   /|\
>                  / | \
>                 /  |  \
>                /   |   \
>               /    |    \
>              /     |     \
>             /      |      \
> [1]        1       2       3
>           /|\     /|\     /|\
>          / | \   / | \   / | \
> [2]     4  5  6 7  8  9 10 11 12
> ..............................................

The infinite levels are a bit different now in 3-ary:

[0] = { 0 }
[1] = { 1, 2, 3 }
[2] = { 4, 5, 6, 7, 8, 9, 10, 11, 12 }
....

The three children of 4 should be, 13, 14, 15:

child_left = 3*4 + 1 = 13
child_middle = 3*4 + 2 = 14
child_right = 3*4 + 3 = 15

The three children of 12 should be, 37, 38, 39:

child_left = 3*12 + 1 = 37
child_middle = 3*12 + 2 = 38
child_right = 3*12 + 3 = 39

We have a new level [13...39]