hot to write out this summation:

[Chris M. Thomasson]

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...

?

[Moebius]

Post by 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)

Post by Chris M. Thomasson
Taken to infinity, it would be: .(0)(1) or something? How to properly

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

[Moebius]

Post by Chris M. Thomasson

Post by 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)

Post by Chris M. Thomasson
Taken to infinity, it would be: .(0)(1) or something? How to properly

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

[Moebius]

Post by 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>.

[Mike Terry]

Post by Chris M. Thomasson
r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...
;^) 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 !! :)

Post by Chris M. Thomasson
.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.

[Barry Schwarz]

Post by Chris M. Thomasson
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.

[Richard Damon]

Post by Barry Schwarz

Post by Chris M. Thomasson
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)))

[Chris M. Thomasson]

Post by Chris M. Thomasson
r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...
;^) 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 !!  :)

Post by Chris M. Thomasson
.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. :^)

More generally you might search for a notation to represent "strings" of
digits indexed by any ordinal, rather than just the simple ordinals w

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

 .((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 !!

Thanks for your input Mike! Thanks.

[Moebius]

Post by Chris M. Thomasson

[...] 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, ".(0)(1)" is an undefined expression in the present context. It
doesn't mean anything sensible (especially no real number).

Post by Chris M. Thomasson
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".

[Chris M. Thomasson]

Post by Moebius

Post by Chris M. Thomasson

[...] 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, ".(0)(1)" is an undefined expression in the present context. It
doesn't mean anything sensible (especially no real number).

Post by Chris M. Thomasson
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".

I do not want to be akin to a crank! Yikes!

I was just thinking that each iterate of the .(0)(1) is a real number...
Is that a bad way to ponder on such things?

[Chris M. Thomasson]

Post by Chris M. Thomasson

Post by Moebius

Post by Chris M. Thomasson

[...] 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, ".(0)(1)" is an undefined expression in the present context. It
doesn't mean anything sensible (especially no real number).

Post by Chris M. Thomasson
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".

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

Right?

Post by Chris M. Thomasson
I do not want to be akin to a crank! Yikes!
I was just thinking that each iterate of the .(0)(1) is a real number...
Is that a bad way to ponder on such things?

[Moebius]

Post by 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.

[FromTheRafters]

Post by Chris M. Thomasson

Post by Moebius

Post by Chris M. Thomasson

[...] 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, ".(0)(1)" is an undefined expression in the present context. It
doesn't mean anything sensible (especially no real number).

Post by Chris M. Thomasson
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".

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

If it implies a last post radix digit, it makes no sense to use such
notation in this context.

[Moebius]

Post by Chris M. Thomasson
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, ...).

[Mike Terry]

Post by Chris M. Thomasson
r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...
;^) 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 !!  :)

Post by Chris M. Thomasson
.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
.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.

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

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.

[WM]

Post by Chris M. Thomasson
r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...
;^) 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
.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

[Chris M. Thomasson]

Post by WM

Post by Chris M. Thomasson
r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...
;^) 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
.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

I see how the iterates get closer and closer, or converge on zero. for sure.

[Chris M. Thomasson]

Post by Chris M. Thomasson

Post by WM

Post by Chris M. Thomasson
r[0] = .01
r[1] = .0011
r[2] = .000111
r[3] = .00001111
r[4] = .0000011111
...
;^) 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
.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

I see how the iterates get closer and closer, or converge on zero. for sure.

The fun part is that in, say, fractals, 0 the limit is vastly different
than its iterates wrt this summation wrt render results. Fractals are fun!

.01
.0011
.000111

All create different fractals, for infinity and beyond! ;^) lol.

Check out this fractal of mine. Give it a go:

https://paulbourke.org/fractals/cubicjulia

Can you render it?