Proving Some Infinities to be Larger Than Other Infinities

In mathematics there is a way to prove that some infinities are larger than others. It can be proven with Cantor’s diagonal argument. Basically what is done is you have an infinite long list of numbers that have an infinite amount of digits, this is a way to prove there are more Real numbers than Natural numbers.

1 - 0.12345…
2 - 0.26389…
3 - 0.11111…
4 - 0.57192…
5 - 0.86019…

On a smaller scale this can be done, so first you grab the first digit of the first item in the list and you add 1 to it, if it is a 9 make it an 8. You then go to the second digit of the second item, and so on and so forth.

1 - 0.[1]2345…
2 - 0.2[6]389…
3 - 0.11[1]11…
4 - 0.571[9]2…
5 - 0.8601[9]…

And your new number you will find to not be on list, even at extreme scales this still works. It should even work for infinity, since Cantor’s diagonal argument basically every digit makes it so it can’t be that string of numbers, meaning some infinities are then larger than others.

Based off of this in quest to prove this theory correct at smaller scales I made a program in Python to do so. First you input a length this will result in the list and digit length, this program doesn’t use numbers rather a string of A’s and B’s. It then checks to see if it is in any other sequences, if it is (which it shouldn’t) it would return True. Otherwise if it can’t find it, it will return False.

Larger Infinities

I hope you enjoyed this showcase. If you have any questions I would be happy to answer them.


On some youtuber’s video, they said that if someone is named ABABBBABABAB… (similar to your case) then they will be a larger infinity. But why can’t you convert their name from base 2 to base 10 then use numbers?

Can you elaborate on this further on what you exactly mean. There would be nothing stopping you from using any base to preform this experiment as this rule is universal for anything.

anothing thing: 0.2342342343 → reversed 3432432432.

from dataclasses import dataclass

class InfinityComparison:
    natural_numbers: list
    real_numbers: list

    def from_lists(cls, natural_numbers, real_numbers):
        return cls(natural_numbers, real_numbers)

    def is_real_numbers_larger(natural_numbers, real_numbers):
        def cantor_diagonal_argument(numbers):
            diagonal_number = ""
            for i in range(len(numbers)):
                digit = int(numbers[i] * 10) % 10
                diagonal_number += str((digit + 1) % 10)
            diagonal_real = int(diagonal_number) / 10**len(diagonal_number)
            return diagonal_real

        diagonal_real = cantor_diagonal_argument(natural_numbers)

        return diagonal_real not in real_numbers

    def compare_infinities(self):
        result = self.is_real_numbers_larger(self.natural_numbers, self.real_numbers)
        return result

natural_numbers = [1, 2, 3, 4, 5] 
real_numbers = [0.12345, 0.67890, 0.11111, 0.98765, 0.54321]  

comparison = InfinityComparison.from_lists(natural_numbers, real_numbers)
is_real_larger = comparison.compare_infinities()

if is_real_larger:
    print("The set of real numbers is larger than the set of natural numbers.")
    print("The set of natural numbers is as large as the set of real numbers.")

Pretty much a Python replication of this.