Am 30.06.2024 um 23:38 schrieb Chris M. Thomasson:

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...

r[0] = .01
r[i+1] = r[i] / 10 + 1 / 10^(2*i+2)

Taken to infinity, it would be: .(0)(1) or something? How to properly
write it:

lim_(i->oo) r[i] = 0. (zero)

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am 01.07.2024 um 00:06 schrieb Moebius:

Am 30.06.2024 um 23:38 schrieb Chris M. Thomasson:

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...

r[0] = .01
r[i+1] = r[i] / 10 + 1 / 10^(2*i+2)

Taken to infinity, it would be: .(0)(1) or something? How to properly
write it:

lim_(i->oo) r[i] = 0. (zero)

Hint:

Let

s[0] = .0111111...
s[1] = .0011111...
s[2] = .0001111...
:

Then

An e IN: r[i] < s[i].

Hence:

lim_(i->oo) r[i] <= lim_(i->oo) s[i].

But cleary

lim_(i->oo) s[i] = 0 .

(After all, s[i+1] = s[i] / 10.)

Hence: lim_(i->oo) r[i] <= lim_(i->oo) s[i] = 0.

On the other hand:

Ai e IN: 0 < r[i].

Hence 0 <= lim_(i->oo) r[i].

So we finally get:

0 <= lim_(i->oo) r[i] <= 0 ,

and hence lim_(i->oo) r[i] = 0. qed

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 30/06/2024 22:38, Chris M. Thomasson wrote:

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...

Now, think of a possible formula. Something like this shit:

;^) lol.

r[0] = .01
r[1] = .01 * 10^(-1) + .1 * 10^(-3) = .0011
r[2] = .0011 * 10^(-1) + .1 * 10^(-5) = .000111
r[3] = .000111 * 10^(-1) + .1 * 10^(-7) = .00001111
r[4] = .00001111 * 10^(-1) + .1 * 10^(-9) = .0000011111
r[5] = .0000011111 * 10^(-1) + .1 * 10^(-11) = .000000111111
...

Taken to infinity,

.. to Infinity And Beyond !! :)

it would be: .(0)(1) or something? How to properly write it:

.0...1...

?

I'd go for .(0)(1) specifying a point '.' then w (first infinite ordinal) '0's then w '1's.

If you settle for .0...1... you will have to clarify how .022332...23550... should be interpreted.

A harder question is what the above actually means, beyond just a way of describing (well-ordered)
infinite strings.

E.g. you didn't put quotes around anything, making it look like you were describing regular real
numbers, but regular real numbers have decimal notation with digits (after the decimal point) just
at positions 1,2,...n,... with n < w. So a "string" like .(0)(1) does not represent a real number.
And "taken to infinity" /as a sequence of real numbers/ your sequence obviously converges to the
real number 0.

More generally you might search for a notation to represent "strings" of digits indexed by any
ordinal, rather than just the simple ordinals w and 2*w in your example. As a starter, what might
the following designate:

.((1)(2))
.((12))
and what might be an example of a string with w^w digits?

..or why stick to ordinals? Be brave! To Infinity and Beyond !!

Regards,
Mike.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am 30.06.2024 um 23:38 schrieb Chris M. Thomasson:

.0...1...

Not sensible if "..." means "infinitely many digits".

Hint there is no natural number (i.e. index) after ALL natural numbers
(i.e. indexes).

We may have .0... but no .0...<whatever>.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 6/30/24 8:36 PM, Barry Schwarz wrote:

On 30/06/2024 22:38, Chris M. Thomasson wrote:

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...

Now, think of a possible formula.

If you start numbering at 1 instead of 0, then

r[n] = int(10^n / 9) / 10^(2n)

where int denotes the integer portion of the value.

And you can get rid of the 'int' function by using:


r[n] = ((((10^n)-1)/9) / 10^(2n)


or

r[n] = ((10^n)-1)/(9*(10^(2n)))

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 30/06/2024 22:38, Chris M. Thomasson wrote:

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...

Now, think of a possible formula.

If you start numbering at 1 instead of 0, then

r[n] = int(10^n / 9) / 10^(2n)

where int denotes the integer portion of the value.

--
Remove del for email

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Le 30/06/2024 à 23:38, "Chris M. Thomasson" a écrit :

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...

Now, think of a possible formula. Something like this shit:

;^) lol.

r[0] = .01
r[1] = .01 * 10^(-1) + .1 * 10^(-3) = .0011
r[2] = .0011 * 10^(-1) + .1 * 10^(-5) = .000111
r[3] = .000111 * 10^(-1) + .1 * 10^(-7) = .00001111
r[4] = .00001111 * 10^(-1) + .1 * 10^(-9) = .0000011111
r[5] = .0000011111 * 10^(-1) + .1 * 10^(-11) = .000000111111
...

Taken to infinity, it would be: .(0)(1) or something? How to properly
write it:

.0...1...

?

In the sequence

01
0011
000111
00001111
...

little by little every index is covered by zero. The limit is an infinite sequence of zeros 000..., if we start to enumerate from the left-hand side
as is usual in European literature and in the notation of digits behind
the decimal point. Starting from the right-hand side, as is usual in
Arabic literature and in denoting the digits of integers, the limit is an infinite sequence of ones 111... . When indexing the digits alternatingly
like

..., -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, ...

then the limit of the sequence has infinitely many zeros at the left-hand
side and infinitely many ones at the right-hand side. What may happen when writing from top to bottom? https://www.hs-augsburg.de/~mueckenh/Transfinity/Transfinity/pdf p. 225

Regards, WM

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am 01.07.2024 um 18:45 schrieb Chris M. Thomasson:

On 6/30/2024 3:44 PM, Mike Terry wrote:

[...] you didn't put quotes around anything, making it look like you
were describing regular real numbers, but regular real numbers have
decimal notation with digits (after the decimal point) just at
positions 1,2,...n,... with n < w.  So a "string" like .(0)(1) does
not represent a real number. And "taken to infinity" /as a sequence of
real numbers/ your sequence obviously converges to the real number 0.

Well, humm... Each iterate of .(0)(1) is a real number as in:

Well, ".(0)(1)" is an undefined expression in the present context. It
doesn't mean anything sensible (especially no real number).

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
...

Each one is a real number, and <etc.>

And r[n] "tends to" 0 (=0.000...) as n "tends to infinity".

In other words, r[n] --> .(0) for n --> oo.

Again, r[n] DOES NOT tend to something that is denoted by ".(0)(1)" (see
Mike comment above). Only in Mückenland (i.e. crankland) 0.999... can
also be written as "0.999...999".

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am 01.07.2024 um 19:54 schrieb Chris M. Thomasson:

On 7/1/2024 10:12 AM, Moebius wrote:

I was just thinking that each iterate of the .(0)(1) is a real number...

Ok, you really make me laugh, sorry.

The point is that you are using an _undefined_ expression here.

It's like claiming [in the context of the real numbers] that 1/x tends
to 1/0 as x tends to 0, or something like that.

I other words, there IS NO "iterate of the .(0)(1)" as there is no
(referent of) ".(0)(1)". At least not in my book. :-P

You already wrote down what you meant:

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
...

Why not use the expression ".0...01...1" as a general "term" für your
r's? Ok, we do not see that the number of "0"s is always identical with
the numbers of "1" here.

Maybe a little diagram might be helpful:

. 0 ... 0 1 ... 1
------- -------
n-times n-times

Starting with the index 1 we might (alternatively) state:

s[1] = .01
s[2] = .0011
r[3] = .000111
s[4] = .00001111
...

Then we'd have:

s[n] = . 0 ... 0 1 ... 1
------- -------
n-times n-times

(for n = 1, 2, 3, ...).

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Am 01.07.2024 um 19:56 schrieb Chris M. Thomasson:

Only in Mückenland (i.e. crankland) 0.999... can also be written as "0.999...999".

That would be .(9) = .(9)(9) = 1

Right?

Hmmm... you really should ask Mückenheim here.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 01/07/2024 17:45, Chris M. Thomasson wrote:

On 6/30/2024 3:44 PM, Mike Terry wrote:

On 30/06/2024 22:38, Chris M. Thomasson wrote:

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...

Now, think of a possible formula. Something like this shit:

;^) lol.

r[0] = .01
r[1] = .01 * 10^(-1) + .1 * 10^(-3) = .0011
r[2] = .0011 * 10^(-1) + .1 * 10^(-5) = .000111
r[3] = .000111 * 10^(-1) + .1 * 10^(-7) = .00001111
r[4] = .00001111 * 10^(-1) + .1 * 10^(-9) = .0000011111
r[5] = .0000011111 * 10^(-1) + .1 * 10^(-11) = .000000111111
...

Taken to infinity,

.. to Infinity And Beyond !!  :)

it would be: .(0)(1) or something? How to properly write it:

.0...1...

?

I'd go for .(0)(1)  specifying a point '.' then w (first infinite ordinal) '0's then w '1's.

I agree. .(0)(1) the first part is an infinity of zeros and the last part is an infinity of ones.

If you settle for .0...1... you will have to clarify how .022332...23550... should be interpreted.

Yeah. It's more confusing that just .(0)(1)

A harder question is what the above actually means, beyond just a way of describing (well-ordered)
infinite strings.

This might be missing your main point, but when zooming into some of my work, or even adjusting a
parameter that alters the field, there are some big time differences between say:

.000111

and

.00001111

The differences show up in the final render result.

Not quite sure if that even relevant or not...

Humm.... Just thinking out loud here. Sorry! ;^o

E.g. you didn't put quotes around anything, making it look like you were describing regular real
numbers, but regular real numbers have decimal notation with digits (after the decimal point) just
at positions 1,2,...n,... with n < w.  So a "string" like .(0)(1) does not represent a real
number. And "taken to infinity" /as a sequence of real numbers/ your sequence obviously converges
to the real number 0.

Well, humm... Each iterate of .(0)(1) is a real number as in:

r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
...

Each one is a real number, and each index is an unsigned integer? Fair enough? Mapping is fun. :^)

Sure - we have a properly defined mapping from N to R, aka a "sequence of real numbers". That
sequence "taken to infinity" converges to 0. Lol, here I assigned my own interpretation of "taken
to infinity", deciding it to mean "what is the limit of the sequence?". Hmmm, now we need to
interpret what I meant by the "limit" of the sequence - but mathematicians already understand what
that means. But if they didn't, we'd have to give it some definition otherwise we'd still be in the
dark...

The interpretation I decided on was natural for a mathematician given a sequence of real numbers.
You would maybe like to come up with some other interpretation of "taken to infinity", which better
recognises the pattern apparent in the base-10 representation of the real numbers. That's a
reasonable goal, but it becomes your job to explain your alternative interpretation so we can be on
the same page. I suppose my point is that it is easier to Say Words than it is to come up with a
coherent and useful mathematical system. Just Saying Words is playing around, and that can be fun
and may ultimately lead to new mathematics so who would want to discourage that?

But some people [WM comes to mind] put too much stock in Words, believing that because they've
framed a sentence using Words they must have said something with a definite meaning! Your phrase
"taken To infinity" is rather like that - what does it actually mean? In contrast, "the /limit/ of
the sequence of real numbers", has a well understood meaning, but probably not the one you were
aiming for.


Mike.

More generally you might search for a notation to represent "strings" of digits indexed by any
ordinal, rather than just the simple ordinals w and 2*w in your example.  As a starter, what might
the following designate:

Hummm... For some reason this is making me think of L-Systems.

  .((1)(2))

0 . 111111111... 22222222... 111111111... 22222222... 111111111... 22222222...
111111111... 22222222... 111111111... 22222222... 111111111... 22222222...
...

  .((12))

0 . 12121212... 12121212... 12121212... 12121212... 12121212... 12121212... 12121212...
12121212... 12121212... 12121212... 12121212... 12121212... 12121212... 12121212...
...

[hey, they're just infinite "strings", no suggestion by me of any other meaning...]

and what might be an example of a string with w^w digits?

..or why stick to ordinals?  Be brave!  To Infinity and Beyond !!

Thanks for your input Mike!  Thanks.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)