For simplicity, we’ll start by only looking at the surface of the sphere, . Let refer to rotation by (that is, pi degrees) about the -axis and let refer to rotation by about the -axis. The exact degree of the rotation isn’t important, only that it should be impossible via any combination of and to go back to the origin. Let be the set of all rotations that you can get by combining , , and their inverses. Then and form what’s known as the ”free group on two generators“, which is composed of all strings using , , , and as symbols, with the provision that and cannot appear together for . The multiplication for this group is just writing the strings together, subject to the rule that and cancel, as do and . So, for example, . The name arises from the fact that there are two ‘fundamental’ symbols, and , and it is ‘free’, since they don’t commute (that is, ).

Now, one very weird fact about the free group on two generators (written ) is that you can break it into four pieces, rearrange those four pieces, and then reassemble them into two copies of it. To elaborate, let denote the set of strings in that start with , and similarly for the other three symbols; let denote the empty string. Then obviously

How is that relevant? Well, partitions into orbits, where an orbit is a collection of points such that each element of moves points from the orbit into the orbit, and points not in the orbit into another point not in the orbit. For each orbit, we can pick a point inside it; let the set of all these points be . Then we can turn the decomposition of into a decomposition of ; using to indicate the set of all rotations in that start with , we have

Now, there are two omissions in this proof: first off, I ignored the origin. It turns out that you can cut the sphere without the origin up, rearrange it, and then put it back together so that you have the origin. Second, I ignored the axes of the rotations in ; they are the fixed points of these rotations, and so might cause problems; it turns out that if we call those points ; we can again cut up and rearrange it into .

So what does this mean? If we want to have any reasonable definition of volume, then we want translations and rotations to leave it the same. Then, we must have that some of these sets don’t have a well-defined volume; much like how you can construct a subset of the real line that doesn’t have one. We break the sphere down into a number of sets, some of which don’t have a defined volume; then we move them around and reassemble them. There’s no contradiction here, since two sets that don’t have a well-defined volume (or non-measurable sets, as they’re known) might have a union that has a volume. Of course, this is physically meaningless, since you can’t actually perform the required divisions; atoms are not infinitely small, after all.

The phenomenon of the webcomic is not exactly new by any means; Sluggy Freelance, one of the oldest still-running webcomics, is 12 years old, only slightly older than widespread availability of the Internet. So what do I mean when I say that MS Paint Adventures is one of the first first few webcomics? It’s one of the few (that I’m aware of, of course) that actually uses the full potential of a comic that takes place online.

The central thing that makes MS Paint Adventures unique to the best of my knowledge among comics is that the story is in large part driven by the fans. Andrew Hussie, the author, has stated in an interview that he does not plan out the direction the plot will take in advance; although he has some overall ideas of the direction he wants it to go, he lets the reader suggestions dictate it to a larger extent than essentially any other webcomic, or indeed any other form of serial storytelling. The only reason that this is possible is because of the MSPA forum; while it would be possible for this to happen in a world without the Internet, an online forum allows for other users to voice their approval for options that they might otherwise not have thought of, giving Hussie the ability to judge what the readers want. But even elements of discussion that are not necessarily suggestions can generate plot points; the apocalyptic nature of the story was originally unplanned and came about at least partly as a result of discussion on the forums about the posters on the walls of one of the main characters for apocalypse-themed movies.

The various Flash animations and other non-static content that AH occasionally uses to enhance the story are another element of MSPA that fundamentally would not work in a traditional print comic. Although they do not necessarily advance the story any better than a series of corresponding still images would, they make the story more enjoyable and immersive; the end-act flashes are probably the quintessential example of this, reminding the reader of the various active story threads, while providing a bit of progression in each of them; it’s far more effective than a series of still panels could ever hope to be. And the Flash animation/game not only could not be executed without the internet, it positively requires the high-bandwidth connections of today’s modern Internet infrastructure. The soundtracks to the Flash animations are also a key part of the overall ‘experience’, even though Andrew Hussie himself does not compose them; the collaboration between artist and composer is only possible through the Internet.

Although MSPA is certainly not the first comic to use the internet, or even the first one to use it beyond as a medium for publishing images (other comics have certainly had associated discussion fora), I believe that it’s the first one to truly use the full potential of the Internet. And while that doesn’t necessarily make it better than other ones, it definitely moves it from the realm of good to that of great.

Note that I have said that it is one of the few true webcomics, not the only one. The only other one that comes to mind is Kid Radd, which makes extensive use of animation, especially in the later strips, where almost every ‘panel’ is a three-second animation. But it didn’t use Flash, or user suggestions, so as good as it is, I don’t consider it to use the Internet in the same way that MS Paint Adventures does.

The reason that I can state truthfully in formal logic ‘all of my children are mass murderers’ without actually having any children is for the same reason that the sum of an empty set is zero and the product of an empty set is one: if it were any other way, then several useful properties of those operations would not hold. For sum, we would lose the fact that the sum of the two sets A and B is the sum of the set A plus the sum of the set B, and similarly for products. These are true because 0 and 1 are identities of addition and multiplication, respectively. For the case of ‘for all’, we can think of it as first applying the predicate to the set, and then taking the logical and of the result; we then must have that is true when S is empty, or else we would lose the theorem that . While it could certainly be special-cased to take into account the cases where A or B is the empty set, it would detract from its simplicity, and would require proofs involving it to first show that neither of the two is empty (which can be a challenge, and might even require additional axioms if dealing with infinite sets, choice functions, etc.)

One of the interesting things that this implies is that for any predicate , , even when is false for all , much like how . But returning to the linguistics theme, it seems rather odd; this is because the quantifier ‘all’ has an implication that the entities that are being talked about exist; in other words, the statement ‘all x are y’ implies that at least one x exists. If this is known to be false by the speaker, it sounds odd, much like the statement ‘John has two children’ sounds odd if the listener knows that John actually has exactly four children; the statement ‘John has two children’ implicates that he has exactly two.

But… step back and think about it. Put yourself in their position, and suppose you were a fundamentalist Christian who constantly sees the world in terms of good and evil, who perceives everything around them as part of this epic struggle between the forces of good and the forces of evil. Every single person you see that doesn’t follow your particular brand of Christianity is doomed by God to an eternity of brimstone and hellfire, when if only they would accept that you’re right and listen to you, they would instead be enjoying an eternity of unimaginable happiness when they die. And to make it worse, the signs that you’re right are all around you! It’s just common sense, why won’t they listen to you? So you spend as much time as you can afford to proselytizing to the unwashed masses, telling them about your Lord and savior Jesus Christ, all in hopes that at least one person will see the light and be saved from Satan and his minions. And in fact, it would be extremely bad of you to not try your hardest to convert these poor lost souls (not to mention Jesus’s command to be fishers of men).

This isn’t me trying to say that people should stop doing what they do when confronted by the aggressively religious; by all means, confront, debate, ignore, troll, whichever you choose to do. Just don’t assume that they’re acting out of irrationality; to them, it make perfect sense.

In Haskell, every function takes a single argument. A function of multiple arguments, such as map, which applies a function to every element in a list, actually only has one argument; for example, map can be interpreted either as taking a function and a list and returning a list, or as taking a function and returning a function that takes a list and returns a list. More formally, in Haskell, these two type declarations are equivalent:

This process, of taking a multi-argument function and converting it into a series of single-argument functions is known as currying, after the mathematician Haskell Curry (who, obviously, is also the source of the name Haskell); the process of partially applying arguments to a function in this way is known as ‘partial application’, but is also called currying. One of the most obvious examples of currying is in sections: the function (0 ==) is syntactic sugar for (==) 0, and returns whether its argument is equal to zero. Furthermore, we can also partially apply the predicate to filter, to make a function that filters its argument on a fixed predicate. So, these three examples are completely equivalent:

(where /= is Haskell’s not-equal operator). The first is the most explicitly-written version, using no currying at all. The second curries the predicate; (/= 0) x is the same as x /= 0. Finally, since removeZeroes applied to an argument is the same as applying filter (/= 0) to it, we might as well define the former as the latter. Or, to take another example, look at the sortBy: it has type (a -> a -> Ordering) -> [a] -> [a], where Ordering is a datatype that can either be EQ, LT or GT for equal, less than, or greater than. So if you have some custom function you want to sort a list on, you can just say mySort = sortBy f and it will be the same as writing mySort xs = sortBy f xs, only cleaner and neater. Or in my Data.Nimber module (specifically lines 38, 39, and 43), many operations on Nimbers that’re required in order for me to call then ‘numbers’ are just the identity operation. So instead of saying abs x = x, I can just say abs = id.

Furthermore, without currying, you couldn’t have variadic functions; in order to work inside Haskell’s type system, the two types a -> b -> c and a -> (b -> c) have to be the same type. The full explanation involves typeclasses, and is (in my opinion) worth a read, because it’s a good explanation of a pretty horriblexcellent (it’s both at once, you see) type system hack.

As an aside, this also means that id :: a -> a, the identity function, is in a sense the same thing as ($) :: (a -> b) -> a -> b, which is function application. You can see this by substituting (b -> c) for a in the type of id, then removing parentheses:

So, in particular, f `id` x is the same as f $ x, which is just f x. Another way to think of this is that f `id` x = id f x = (id f) x = f x.