Category Archives: Good Math

Set Theory – some basic definitions

So, what’s set theory really about?

We’ll start off, for intuition’s sake, by talking a little bit about what’s now called naive set theory, before moving into the formality of axiomatic set theory. Most of this post might be a bit boring for a lot of you, but it’s worth
being a bit on the pedantic side to make sure that we’re starting from a clear basis.

A set is a collection of things. What it means to be a member of a set S is
that there’s some predicate PS – that is, some way of describing things via logic – which is true only for members of S. To be a tad more formal, that means that for any possible object x, PS(x) is true if and only if
x is a member of S. In general, I’ll just write S for both the set and the predicate that defines the set, unless there’s some reason that that would be confusing and/or ambiguous. (Another way of saying that is that a set S is a collection of things that all share
some property, which is the defining property of the set. When you work through
the formality of what a property means, that’s just another way of saying that there’s a
predicate.)

Continue reading

Fun With Set Theory: Cantor's Diagonalization

While I’ve been writing about the Surreal numbers lately, it reminded me of some of the fun of Set theory. As a result, I’ve been going back to look at some old books. Since I’ve been enjoying it, I thought you folks would as well.

Set theory, along with its cousin, first order predicate logic, is pretty much the
foundation of nearly all modern math. You can construct math from a lot of
different foundations, but axiomatic set theory is currently pretty much the dominant approach. (Although Topoi seem to be making some headway…)

There’s a reason for that. Set theory starts with some of the simplest ideas, and extends in a reasonably straightforward way to encompass the most astonishingly complicated one. It’s truly remarkable in that – none of the competitors to set theory
as a foundation can approach the intuitive simplicity of set theory.

So I’m going to write a bit about set theory as I explore my old books. And I thought that a good place to start was Cantor’s diagonalization. Cantor is the inventor of set theory, and the diagonalization is an example of one of the first major results that Cantor published. It’s also a good excuse for talking a little bit about where set theory came from, which is not what most people expect. Set theory was originally created as a tool for talking about the relative sizes of different infinities.

Continue reading

Process Declarations in Pica

Sorry for the slow pace of things around here lately; life interferes sometimes. I’ve mentioned my fathers illness before; things took a drastic change for the worse a week ago, which made things more than a little bit crazy. Of course, life wouldn’t be life in things happened one at a time; so naturally, my asthma picked now to act up as well, so I’ve been coughing my lungs out. It’s been a fun week, really.

Anyway, I’ve been wanting to look a bit more at Pica. I’ve been thinking about how a named process definition looks, and what it does. The type part of a definition is relatively straightforward: a process is defined by a set of externally visible channels; each channel is defined by a type. In a named definition, there are two types of channels to think about. One is a set of channels supplied to the process when it’s created; the other is a set of channels created by the process, but which are ‘exported’: that is, made visible to other processes. The type of a process is a tuple of all of the channels which the process exports the outside world.

Continue reading

A Pathological Way to Paint: Gammaplex

Today’s a mighty cool example of bizzare language design, called GammaPlex In terms of language
design, it’s nothing particularly special: it’s yet another stack language
with a befunge-like graphical syntax. What’s unusual about GammaPlex is that it’s strongly focused on graphics. It’s got built in support for ascii graphics, OpenGL, and mouse input.

Continue reading

My Number

Don’t you dare use the number 271277229129081016424883074559900780951 under any circumstances. It’s mine, mine I tell you, and if you use it, or copy it, I can have you arrested and sent to do hard time in prison. And it doesn’t matter whether you use it in decimal, like I used above, or it’s hexidecimal form, “CC16180895F94705F667F1BB6DB20997”, or any other way of encoding it. It’s my number, and you’re not allowed to use it. In fact, I don’t think I want to allow you to look at it – so I’m going to sue all of you for having read this post!

Continue reading

Basics: Sets and Classes

This is something that came up in some of the comments on the recent “nimbers” post, and I thought it was worth promoting to the front, and getting up under an easy-to-find title in the “basics” series.

In a lot of discussions in all different areas of math, you encounter talk about sets and classes, and you’ll find people worried about whether they’re talking about sets or classes. What’s the difference? I mentioned this once before, but it’s buried in a discussion of the concept of “meta”, which is why I thought it was worth moving it to its own top-level post: if you don’t know the difference, you’re not going to look in the body of a discussion about the concept of going meta to find the explanation!

I’ll start with just the definitions, and then I’ll dive into the discussion of why we make the distinction.

  • A class is any collection of things which have some common property that defines them: the class of logical statements, the class of numbers.
  • A set is a class which is a member of a class.
  • A proper class is a class which is not a set.

Continue reading

Even More Stack Pathology

I thought that it would be fun to stick with the “stack-based” theme of last week’s pathological post, but this time, to pick an utterly pointlessly twisted stack based language, but one that would be appreciated by the mascot of one of my fellow ScienceBlogs. Orac, this one’s for you! 🙂 Our target these week is the language “Enema”.

Continue reading

The Strangeness of Nimber Addition

So, today we’re going to play a bit more with nimbers – in particular, we’re
going to take the basic nimbers and operations over nimbers that we defined last time, and
take a look at their formal properties. This can lead to some simpler definitions, and
it can make clear some of the stranger properties that nimbers have.

Continue reading

Moving on: π-calculus and common programming idioms

Before diving off into real content, the name of my little π-calculus monstrosity has been chosen. As several people recommended in the comments, I’m going to go with Pica.

So, today, we’re going to take the dive, and start looking at some interesting semantics of the language. The goal of this is still to work on Pica’s type system: I want to work towards a first draft of what a process type will look like. But to figure out what a process type should look like, we need to think about how process abstractions will be defined and used in Pica, what control structures are going to look like. So that’s what I’m going to do in this post: ramble on a bit about what processes are really going to end up looking like. Just a warning: this post is definitely on the half-baked side – it’s much more of a train-of-thought/brainstorming thing than the things I usually post.

Continue reading

Surreal Nimbers: No, that's not a typo!

(A substantial part of this post was rewritten since it was first posted. I managed to mangle things while editing, and the result was not particularly comprehensible: for example, in the original version of the post, I managed to delete the definition of “mex”, which continuing to use mex in several other definitions. I’ve tried to clear it up. Sorry for the confusion!)

This is actually a post in the surreal numbers series, even though it’s not going to look like one. It’s going to look like an introduction to another very strange system of numbers, called nimbers. But nimbers are a step on the path from
surreal numbers to games and game theory.

Nimbers come from a very old game called Nim. We’ll talk more about Nim later, but it’s one of the oldest strategy games known. The basic idea of it is that you have
a couple of piles of stones. Each turn, each player can take some stones from one of the piles. Whoever is left making the last move loses. It seems like a very trivial game. But it turns out that you can reduce pretty much every impartial game to some variation of Nim.

Analyzing Nim mathematically, you wind up finding that it re-creates the concept of ordinal numbers, which is what surreals are also based on. In fact, creating nimbers can end up re-creating the surreals. But that’s not what we’re going to do here: we’re going to create the nimbers and the basic nimber addition and multiplication
operations.

Continue reading