How to describe the difference: Take a digit string of countable infinite 0's and construct a collection of all such strings where we allow a 1 at any position with finitely preceding digits, or allow a 1 at any digit position.
e.g.:
finite choice: [(0|1) -> lim_inf] ++ [0 -> inf]
infinite choice: [(0|1) -> lim_inf] ++ [(0|1) -> inf]
such that i can also choose to write:
finite choice: [(0|1) -> lim_inf]
infinite choice: [(0|1) -> inf]
The collection of finite choice bitstrings is countable infinite, whereas the collection of infinite choice bitstrings is uncountable infinite.
The amount of choice / "(0|1)" digit positions is finite in the first collection, the amount of choice digit positions is countable infinite in the second collection.
I do not approve of the above notation, as it is unclear about how lim_inf and inf differ.
I thought also about writing this difference as "there exists some position in [(0|1) -> inf], which has infinite preceding digits - whereas [(0|1) -> lim_inf] does not", but this is not necessarily true. Consider for example the natural numbers, which are countable infinite, yet no number has infinite preceding (other) numbers.
References are also welcome.
P.S. ++ is the list concatenation operator, A -> B stands for A repeating B times, where A is allowed to create "branches".
e.g.:
[0 -> 5] = [00000]
[(0|1) -> 2]++[1 -> inf] =
{[01]++[111..], [11]++[111..], [00]++[111...], [10]++[111..]}
yet :
[0->inf] = [000..]
[0->lim_inf] = [000..]
[(0|1)->inf] =/= [(0|1)->lim_inf]
Thus inf and lim_inf should be of different sizes.