Non-Computability Of Ordinals: Proof Without Diagonalization

Hey everyone! Today, we're diving into a fascinating question in computability theory: Can we compute the set of ordinals, denoted as ${\mathcal{O}}$? This is a pretty deep topic, but we're going to break it down and explore a proof that doesn't rely on the classic diagonalization trick. So, buckle up and let's get started!

Understanding the Basics: Ordinals, Well-Orderings, and Computability

Before we jump into the proof, let's make sure we're all on the same page with the key concepts. First off, what are ordinals? Simply put, ordinals are numbers that extend beyond the natural numbers (0, 1, 2, ...) to include infinite numbers. They represent the order type of well-ordered sets. A well-ordered set is a set where every non-empty subset has a least element. Think of it like a line where you can always find the smallest element, no matter how far down you go.

Computability, on the other hand, deals with what can be calculated by an algorithm. A set is considered computable if there's an algorithm that can tell you whether a given element belongs to that set or not. So, the big question here is: Can we write an algorithm that can determine whether a given object is an ordinal?

Now, why is this question interesting? Well, the set of ordinals, ${\mathcal{O}}$, is incredibly vast and complex. It includes all the natural numbers, the first infinite ordinal (${\omega}$), and a whole lot more! If we could compute ${\mathcal{O}}$, it would mean we have a way to systematically identify and work with all these ordinals, which would be a major breakthrough in our understanding of infinity and computation.

The Challenge of Computing Ordinals

Computing ordinals is tricky because they extend into infinity. Unlike natural numbers, which have a clear successor function (just add 1), ordinals have different kinds of successors. After all the natural numbers, we have ${\omega}$, and after that, ${\omega + 1}$, ${\omega + 2}$, and so on. Then comes ${\omega \cdot 2}$, ${\omega^2}$, and the ordinals just keep getting bigger and bigger! This complexity makes it hard to imagine a single algorithm that can handle all of them.

The classic way to prove that something is not computable is through a technique called diagonalization, famously used by Gödel and Turing. Diagonalization involves constructing a counterexample that contradicts the assumption that the set is computable. However, we're going to try a different approach here, one that directly tackles the properties of well-orderings and computability.

The Proof: A Journey Through Well-Orderings and Non-Computability

Okay, let's dive into the proof! We're going to assume, for the sake of argument, that ${\mathcal{O}}$ is computable. This means we have an algorithm that can tell us whether a given structure is a well-ordering. Our goal is to show that this assumption leads to a contradiction, which will then prove that ${\mathcal{O}}$ cannot be computable.

So, let's assume the set of ordinal notations ${\mathcal{O}}$ is computable. What does this mean? It implies there exists an algorithm, let's call it A, that can take any structure as input and tell us if it represents an ordinal. In other words, A can check if the structure is a well-ordered set.

Building a Computable Well-Ordering

Now, here's the key idea: If we can compute the set of ordinal notations, we should be able to build well-orderings algorithmically. Think about it – if we can identify ordinals, we can start constructing ordered sets that correspond to those ordinals.

Let's consider the set of natural numbers, ${\mathbb{N}}$. We know this is a well-ordered set. If ${\mathcal{O}}$ is computable, we can effectively list out all the ordinal notations corresponding to the natural numbers. We can then use these notations to build well-orderings of type ${0, 1, 2, 3, ...}$.

But here's where things get interesting. Since ${\mathcal{O}}$ includes infinite ordinals like ${\omega}$, our algorithm A should also be able to identify notations for these ordinals. This means we should be able to construct a well-ordering of type ${\omega}$, which is the order type of the natural numbers themselves.

The Liar's Paradox of Well-Orderings

Now, let’s ramp up the complexity. Remember, for a set to be well-ordered, every non-empty subset has a least element. This is a crucial property. If we can compute well-orderings, we should be able to check this property algorithmically.

Here's the twist: Suppose we try to construct a