Dichotomy paradox reverse engineering

netzweltler

We know we can biject the segments of size 0.5, 0.25, 0.125, … to the segments of size 0.25, 0.125, 0.0625, …, furthermore we can biject these segments to the segments of size 0.125, 0.0625, 0.03125, …, and there is no end to it. So, we can use index #1 for segment 0.5. We can as well use index #1 for segment 0.25 or segment 0.125 and so on, since we know there are always infinitely many more segments following. If we create the task:

t = 0: move pen from 0 to 0.5 (taking 1/2 second), naming it segment #1
t = 0.5: move pen from 0.5 to 0.75 (taking 1/4 second), naming it segment #1
t = 0.75: move pen from 0.75 to 0.875 (taking 1/8 second), naming it segment #1
t = 0.875: move pen from 0.875 to 0.9375 (taking 1/16 second), naming it segment #1
…

At which step should we stop using #1 as the segment's index in order to have enough segments of non-zero size left to assign the rest of the natural numbers?

HallsofIvy

I know what a "bijection" is and can guess that to "biject" one set of objects to another means that you have a mapping from one set to another that is a bijection.
(I also thought that you might mean "bisect" since each segment has half the length of the one assigned to it, but I think you really do mean "biject".)

Your question is "At which step should we stop using #1 as the segment's index in order to have enough segments of non-zero size left to assign the rest of the natural numbers?"
There is no such step. You will always have an infinite (countable) number of segments that you can assign to the natural numbers.

netzweltler

We don't use "biject"? Oops! Sorry.

If we don't stop using #1 all segments in [0, 1) will be named #1 at t = 1, right? What about all the other segments (#2, #3, ...) at t = 1? I mean it like this:

t = 0: move pen from 0 to 0.5, naming it segment #1, [0.5, 0.75] is #2, [0.75, 0.875] is #3, ...
t = 0.5: move pen from 0.5 to 0.75, naming it segment #1, [0.75, 0.875] is #2, [0.875, 0.9375] is #3, ...
t = 0.75: move pen from 0.75 to 0.875, naming it segment #1, [0.875, 0.9375] is #2, [0.9375, 0.96875] is #3, ...

and so on.

netzweltler

I think I can understand the concept of limits, but I am not that sure about it. If I try to apply the concept of limits to the task
I guess the (most) correct assumption is, that all segments in [0, 1) are named #1 in the limit case. But what happens to the other segments which are always present at the finite steps. There is always a segment #2. The size of the segment named #2 is converging towards 0. Is there a segment #2 present in the limit case? Is it's size 0 in the limit case? If so, does it mean it is no longer an element of the set of segments in [0, 1]?

chiro

One thing you should be aware of, is that a limit talks about what something approaches but it does not mean that it ever gets there.

Your limit for the interval if you evaluate it like lim x->0 x will be zero, but the actual value never becomes zero: it only approaches zero.

You can have other conditions that enforce that something not only approaches but actually ends up at the value corresponding to the limit, but this is different.

netzweltler

Which mathematical model are you talking about?

The task is to design a process that enables us to draw a line from point 0 to point 1 in 1 second in infinitely many steps. The pen is not allowed to change direction. Point 1 is the last point covered by the line. There is no last step in this process.

Any suggestions how to accomplish that (i.e. which steps have to be defined)?

chiro

I'm talking about a limit.

That's what limits are: they refer to things that tend towards something but don't get there in a finite sense (but they get there in an infinite sense).

This is the whole premise of calculus and modern mathematical analysis.

netzweltler

That's the sense that I mean - the infinite sense - when I am asking for the limit case of this task:

chiro

Probably something like lim n-> infinity (1 - 1/2^n) = lim n-> (2^n - 1)/2^n for start of each interval and then add 1/2^(n+1) for each step (I think).

netzweltler

If we allow only finitely many copies of a line segment s in [0, 1], where the size of s is an element of (0, 0.5], how can we allow infinitely many line segments { [0, 0.5], [0.5, 0.75], [0.75, 0.875], ... } in [0, 1], where the size of each line segment is an element of (0, 0.5]? We wouldn't allow an infinite number of copies of any element of { [0, 0.5], [0.5, 0.75], [0.75, 0.875], ... } in [0, 1], right?