Jtdylktuy

If we have a list of binary numbers from the set $[0,1]$

And the first row of our list is 0.0

To get the second row we will copy and paste the list above and add 1/2 to row 2 and our list will have two rows like so.

$0.0$

$0.1$

To get rows 3 & 4 we will copy and paste the list above and add 1/4 to rows 3 & 4 like so.

$0.00$

$0.10$

$0.01$

$0.11$

To get rows 5 to 8 we will copy and paste the list above and add 1/8 to rows 5 to 8 like so.

$0.000$

$0.100$

$0.010$

$0.110$

$0.001$

$0.101$

$0.011$

$0.111$

This is a simple pattern, we copy, paste and increment the bottom copy of our list.

My question is this, if we reverse the procedure, will we get the same list?

By "reverse the procedure" I mean we copy, paste and increment the top copy of our list.

So where our list used to have a $0$ it will now have a $1$ and vice versa.

The reason that this is a problem for me is that given any finite expression of this list, it makes no difference what order we increment the the lists, bottom or top. It just puts the elements of the list in a different order but all the elements are the same. But, when the list is infinite the number $0.111 dots = 1.0$ will not be an element in the first list, but it will be an element in the reverse list.

So our procedure is commutative when the list is finite but not when it is infinite. Is this true?

Edit: My method of constructing the List makes it look like there is a
infinite cascade of lists. $L_1 subset L_2 subset L_3 subset dots$

But there should be only one list. You can see it easily if you have a
spreadsheet app where,

Cell A1 is 0

Cell B1 is =A1+1 then fill right

Cell A2 is =A1+1 then fill down

Cell B2 is =INT(MOD(($A2−1),(2^B$1))÷(2^(B$1−1)))

then fill right and down

To get the inverse list use for B2 above

=MOD(INT(MOD(($A2−1),(2^B$1))÷(2^(B$1−1)))+1,2)

If you get it right you will have the top left corner of an eternal
object kind of like this.

$0,1,2,3,4,5,6 dots$

$1,0,0,0,0,0,0 dots$

$2,1,0,0,0,0,0 dots$

$3,0,1,0,0,0,0 dots$

$4,1,1,0,0,0,0 dots$

$5,0,0,1,0,0,0 dots$

$6,1,0,1,0,0,0 dots$

$ dots$

If you don't want the spreadsheet version, here is the formula version. The binary digit in column x and row y is given by this formula A

$$ b_{x,y} = lfloor{frac{(y-1)pmod {2^x}}{2^{x-1}}} rfloor : x in mathbb N land y in mathbb N$$

And the reverse version is formula B

$$ {b_{x,y} = lfloor{frac{(y-1)pmod {2^x}}{2^{x-1}}} rfloor +1}pmod{2} : x in mathbb N land y in mathbb N$$

We restate the problem more rigorously. Since when you say 'equal', you seems to ignore their order, we can better formulate this by using 'sets', which are collection of objects with no specific order.

Suppose the set $L_0$ contains the empty string $e$, we build a family of sets $L_n$ by the equation $$L_{n+1}={overline{s0} :sin L_{n-1}}cup{overline{s1} :sin L_{n-1}},$$ where $overline{s1}$ means the string $s$ concatenated with $1$. Also, $$L'_{n+1}={overline{s1} :sin L'_{n-1}}cup{overline{s0} :sin L'_{n-1}}.$$

It should be noted that there will never be a string of infinite length in your lists. Because in this case, we only defined $L_n$ with $ninmathbb N$. Since the union operation is commutative, the two methods produce the same result when confined to finite cases, as you have seen.

However, can we somehow define objects like $L_infty$? In a way, yes. This has to be defined as some sort of 'limit' of the construction above. This is exactly what 'limit' (in fact, inverse limits) means in category theory. First, we define a 'projection' function $pi$ from $L_{n+1}$ to $L_n$, simply by cutting off the last digit. Then the inverse limit defined by $pi$ is $$lim_leftarrow L_n,$$ which is the set of infinite binary decimals such as $0.000dots$ and $0.010110011100011110000dots$, etc. It is easily verified that, since $L_n=L'_n$ for all finite $n$, the two inverse limits are also the same.