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 The Strangeness of Nimber Addition

Using Bad Math to Create Bad Models to Produce Bad Results

An astute reader pointed me towards a monstrosity of pompous bogus math. It’s an oldie, but I hadn’t seen it before, and it was just referenced by my old buddy Sal Cordova in a thread on one of the DI blogs. It’s a “debate” posted online by Lee Spetner, in which he rehashes the typical bogus arguments against evolution. I’m going to ignore most of it; this kind of stuff has been refuted more than enough times. But in the course
of this train wreck, he pretends to be making a mathematical argument about search spaces and optimization processes. It’s a completely invalid argument – but it’s one which is constantly rehashed by creationists, and Spetner’s version of it is a perfect demonstration of exactly what’s wrong with the argument.

Continue reading Using Bad Math to Create Bad Models to Produce Bad Results

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 Moving on: π-calculus and common programming idioms

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

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

A Great New SciBling!

Our corporate masters at Seed have added a new blog to ScienceBlogs, and it looks like a real winner. It’s called the Denialism Blog, and it’s off to a roaring great start with “The Unified Theory of the Crank. Go check it out!

Why am I doing this Pi-Calculus Language Thing?

Since my post on datatypes for my π-calculus language, I’ve gotten a bunch of questions from people who (I guess) picked up on the series after the original post where I said that the idea of the series was to see if I could create a programming language based on it. The questions are all variations on “Why design another programming language? Do you really think anyone will ever use it?”

Continue reading Why am I doing this Pi-Calculus Language Thing?

True Pathology: A Multilingual Quine

While browser over at, I came across something simultaneously hideous and amazing.

I’ve showed quines before as part of the pathological programming posts: a quine is a program which, when run, generates itself as an output. I’ve even written about a programming language where the only way to create a loop is through quining the program.

But I’ve never seen anything like this before. It’s a multilingual quine: the program below is not just a quine, but it’s simultaneously a quite in three different languages: OCaml, Haskell, and Scheme. I have no idea how the author managed to figure out how to do this; and I probably don’t want to. 🙂

Continue reading True Pathology: A Multilingual Quine

The beauty of math; the humor of stupidity.

%d bloggers like this: