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.

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.

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.

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.

from dataclasses import dataclass
@dataclass
class InfinityComparison:
natural_numbers: list
real_numbers: list
@classmethod
def from_lists(cls, natural_numbers, real_numbers):
return cls(natural_numbers, real_numbers)
@staticmethod
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.")
else:
print("The set of natural numbers is as large as the set of real numbers.")