Back in high school, I sometimes wondered what all the big deal about ZFC and the Axiom of Choice was, but I never really understood what I read in the corresponding Wikipedia page. In this post, I’ll try to explain what axiomatic set theory is trying to do in a way accessible to those with just a high school background.

**1. Motivation **

What we’re going to try to lay out something like a “machine code” for math: a way of making math completely rigorous, to the point where it can be verified by a machine. This would make sure that our foundation on which we do our high-level theorem proving is sound. As we’ll see in just a moment, this is actually a lot harder to do than it sounds — there are some traps if we try to play too loosely with our definitions.

First of all, since this is a set theory post, the first thing we need to do is define exactly what a set is. Well, we know what a set is, right? It’s just a *collection of objects*, and two sets are the same if they have the same objects. For example, we have our empty set that contains no objects. We can have a set that , or maybe the set of natural numbers . (For the purposes of set theory, is usually considered a natural number.) Sets can even contain other sets, like . Fine and dandy, right?

The trouble is that this definition actually isn’t good enough, and here’s why. If we just say “a set is any collection of objects”, then we can consider a really big set , the set of all sets. So far no problem, right? has the oddity that it has to contain itself , but oh well, no big deal. In fact, for this section, let’s even give a name to these sets — we’ll call a set *extraordinary* if it happens to contain itself, and *ordinary* otherwise. (Note that this isn’t actually a math term, it’s just for my convenience.)

Now here comes the problem, called **Russell’s Paradox** (link here). If I can look at the set of all sets , I can also probably look at the set of all ordinary sets, which I’ll call . Here’s the question: is ordinary?

- Well, if is ordinary, then . Hence is extraordinary by definition, which is impossible.
- Now suppose is extraordinary. Then is not ordinary, so that implies . But that contradicts the assumption that is extraordinary!

So that’s all a contradiction! Just by considering the set of all ordinary sets, we’ve run into a trap.

Now if you’re not a set theorist, you could probably just brush this off, saying “oh well, I guess you can’t look at certain sets”. But if you’re a set theorist, this worries you, because you realize it means that you can’t just define a set as “a collection of objects”, because then everything would blow up. Something more is necessary.

**2. The Language of Set Theory **

We need a way to refer to sets other than “collection of objects”. So here’s what we’re going to do. We’ll start by defining a formal *language of set theory*, a way of writing logical statements. First of all we can throw in our usual logical operators, like `‘, for all; , exists; , equals; and , our “if then ”. Let’s also add in , which means “and”, and , which means “or”, as well as , which means “not”. Now we can write down logical statements.

Since we’re doing set theory, there’s one more operator we’ll add in: the inclusion . And that’s all we’re going to use (for now).

So how do we express something like “the set ”? The trick is that we’re not going to actually “construct” any sets, but rather refer to them indirectly, like so:

“There exists an such that is in if and only if either is in or is in ”. We don’t have to refer to sets as objects in and of themselves anymore — we now have a way to “create” our sets, by writing formulas for exactly what they contain. This is something a machine can parse.

Well, what are going to do with things like and , which are not sets? Here’s the answer: we’re going to make **everything** into a set. Natural numbers will be sets. Ordered pairs will be sets. Functions will be sets. In later posts, I’ll tell you exactly how we manage to do something like encode as a set. For now, all you need to know is that that sets don’t just hold objects; they hold other sets.

So now it makes sense to talk about whether something is a set or not: means “ is a set”, while means “ is not a set”. In other words, we’ve rephrased the problem of deciding whether something is a set to whether it exists, which makes it easier to deal with in our formal language. That means that our axiom system had better find some way to let us show a lot of things exist, without letting us prove the following formula:

For if we prove this formula, then we have our “bad” set from Bertrand’s paradox that caused us to go down the rabbit hole in the first place.

**3. The Axioms of ZF **

What the axioms of ZF is do is tell a computer exactly what it’s allowed to do. Since the axioms want to be perfectly crystal clear, they’re all written in formal symbols. Humans don’t actually think in these formal symbols, unless they’re set theorists and have also gone insane. But the point of these symbols is that there is absolutely no confusion what is true and isn’t true.

It’s worth noting that there are several versions of ZF, but they’re all equivalent to one another. Also, we’ll start representing sets with lowercase letters below.

First, we agreed before that two sets are the same if they share the same elements. We’d like to encode that in an axiom: if and only if for every , . (And now you’re starting to see how convenient it is that everything’s a set!)

This leads us to the first axiom of ZF, called Extensionality.

Axiom 1 (Extensionality).

This is machine code for “if and have the property that , then ”. Now our computer can recognize that two sets are equal if they share exactly the same elements. Great.

Unfortunately, our computer still doesn’t know that there even exist any sets. We have to tell it that. So what’s the first thing we tell it? There exists the empty set.

Axiom 2 (Empty Set Exists).

Now you notice that I have rather than the that we’re all used to. That’s going to get tiring very soon, so we’ll make our first “shortcut”: whenever we write , we really mean . This makes it easier for us humans to read the formula, but we’re happy because in principle, we could just expand this shortcut and give the computer something to read.

Now our computer knows the empty set is a set. But does our computer know that there’s only one? In fact, yes! If we have two sets and , and both of them have no elements, then our computer can prove by using Extensionality now. So in fact, there’s only one empty set. Now we’ll take another shortcut and give this set a name, “”.

The next three axioms provide us with some various ways of building more sets.

Axiom 3 (Pairing)Given two elements and , there exists a set containing only those two elements. In machine code,

Note that and do not have to be different! What that means is that our machine can now build a set by taking . Pairing gives a set such that if and only if . In our human mind, what we’re thinking is “we’ve built the set !” No need for the computer to know that, though.

We can the apply Pairing again to build some more sets, like , or . Can you see how? And now if I use pairing on *those* two sets, I get . Yipee!

At this point I’m going to cheat and use for some examples as natural “objects”, since all those braces are getting hard to read. All you need to know at this point is that these guys are secretly sets too, and you’ll have to wait until next time for me to tell you what their elements are.

So Pairing tells you that if I have my hands on , and I have my hands on , then I can get my hands on the set . Cool. Now suppose I told you: and . Or rather, the computer told you

and

Now you want to construct the set . You might try pairing, but that just gives you the set . It turns out we’re actually super clumsy: our axioms so far don’t even let us get our hands on and , even though we have a set that contains them!

Maybe this is actually not that surprising. If I write down the formula

but I know there are no unicorns, then I shouldn’t expect to actually be able to prove that exists. However, I’d really like to ignore that and get the set . The axiom that lets us do that is called Union.

Axiom 4 (Union)Given a set , we can create , the union of the elements of . For example, if , then is a set. Formally,

By repeatedly using Pairing and Union, we can take any finite collection of elements and gather them into one set.

Finally, we’ll also give our computer a way to build a power set. Recall that the **power set** of a set , which I write , consists of all its subsets. For example, in human world, we had .

Axiom 5 (Power Set)We can construct . Formally,

where is short for .

**4. Closing **

That lays down the first five axioms of ZF.

Though I don’t have the space to show you how to encode the integers here, I’ll give you an idea for some ways we can hack together “encodings” of things as et. For example, what if we want an ordered pair ? I claim we can encode this as

Indeed, you can check that if and only if and , which is what we wanted. You can see that this is indeed a set by some applications of Pairing.

Extending this, if we have a relation , we can encode it as

A function is a special type of relation such that if and , then . In other words, we represent functions by their “graphs” of ordered pairs .

In the next post, I’ll explain some of the more involved axioms, and I’ll also finally tell you what the elements of and are. Specifically, I’ll be constructing the ordinal numbers.

*Thanks to Peter Koellner, Harvard, for his class Math 145a, which taught me this material. My notes for this course can be downloaded from my math website.*

There’s an error in Axiom 4, I think. The final ‘z’ should actually be an ‘a’.

LikeLike

Yep, thanks!

LikeLike

I like the comparison to computers/machine code you used :)

LikeLike

[…] For a quick read on ZFC, I recommend Evan Chen’s blog post. […]

LikeLike