In some points, I’ve tried to fill in the most sketchy and un-articulated points with some simile of what I ended up actually saying.

Combinatorial species started out as a theory to deal with enumerative combinatorics, by providing a toolset & calculus for formal power series. (see Bergeron-Labelle-Leroux and Joyal)

As it turns out, not only is species useful for manipulating generating functions, btu it provides this with a categorical approach that may be transplanted into other areas.

For the benefit of the entire audience, I shall introduce some definitions.

Definition: A category C is a collection of objects and arrows with each arrow assigned a source and target object, such that

1. Each object has its own identity arrow 1.
2. Chains of arrows are associatively composable, with 1 the identity of this composition.

Examples: Sets, Finite sets, k-Vector spaces, left and right R-Modules, Graphs, Groups, Abelian groups.

: finite sets with only bijections as morphisms.

Examples:

• Category of a monoid.
• Category generated by a graph
• Category of a group (groupoid version of the category of a monoid)
• Category of a poset
• Category of Haskell types and functions.

Definition: A functor F is a map of categories, in other words, a pair of maps Fo on objects and Fa on arrows, such that the identity arrow maps to identity arrows and compositions of maps map to compositions of their images.

Examples:
Constant functor: sends every object to A, every map to 1.

Identity functor: sends objects and arrows to themselves.

Underlying set functor, free monoid/vector space/module/… functors.

We are now equipped to define Species:
Definition: A species of structures is a functor .

The idea is a set gets mapped to the set of all structures labelled by the elements in the original set. A bijection on labels maps to the transport of structures along the relabeling.

Examples:
: rooted trees, labels on vertices
: simple graphs, labels on vertices
: connected simple graphs, labels on vertices.
: trees, labels on vertices.
: directed graphs, labels on vertices
: subsets, .
: endofunctions
: involutions
: permutations
: cycles
: linear orders
: sets:
: elements:
: singletons: if and otherwise
: empty set: , otherwise
: empty species: .

In enumerative combinatorics, the power of species resides in the association to each species a number of generating functions:

The generating series of a species F is the exponential formal power series

where we use the convention , and .
Thus:

There are a number other in use for combinatorics, but for my purposes, this is the one I’ll focus on.

Operations on species

The real power, though, emerges when we start combining species, and carry over the combinations to actions on the corresponding power series.

Addition

The number of ways to form either, say, a graph or a linear order on a set of labels is the sum of the numbers of ways to form either in isolation.

This corresponds cleanly to the coproduct in Set, and we may write F+G for the species

(where the second + is the coproduct — i.e. disjoint union — of sets)

In the power series, we get .

Examples: We may define the species of all non-empty sets by

This kind of functional equations is where the theory of species starts to really shine.

Multiplication

A tricoloring of a set is a subdivision of the set into three disjoint subsets covering the original set. The number of tricolorings of size n is

A permutation fixes some set of points. The permutation restricted to the non-fixed points is a derangement. Total number of permutations on n elements is

In both of these cases, the total generating series is a product of the component series, and we end up defining

So .

Thus, tricolorings are and permutations are , where the set is that of fixed points, and the derangement captures the actual action of the permutation.

Composition

Endofunctions of sets decompose in their actions on the points as cycles or directed trees leading in to these cycles.

Since a collection of disjoint cycles corresponds to a permutation, we can consider such endofunctions to be permutations decorated with rooted trees attached to points of the permutations; or even permutations of rooted trees.

To form such a structure on a set U, we’d first partition U into subsets, put the structure of a rooted tree on each subset, and then the structure of a permutation on the set of these subsets.

Thus, the number of such structures on n elements is

This corresponds to the power series , and we write, in general, for the species of F-structures of G-structures on subsets.

Examples:
A = X·E(A)
L = 1 + X·L
B = 1 + X·B·B

Pointing

Picking out a single point in a structure on n points can be done in precisely n ways.

Thus the corresponding generating function will be

for f-structures with a single label distinguished.

Since we’re working with exponential power series, we may notice that

and thus that derivatives are shifts.
Furthermore,
so that the generating function for F-structures with a single distinguished are

In species, this process is called pointing.

In functional programming, Conor McBride related this construction to Huet’s Zipper datatypes.

As it turns out, many of the constructions for species make eminent sense outside the category . In fact, species in Hask are known to programming language researchers as container datatypes and the whole calculus translates relatively cleanly.

Functional equations translate to the standard new data type definitions in Haskell.

Examples:
L = 1 + X·L

data List a = Nil | Cons a (List a)


B = 1 + X·B·B

data BinaryTree a = Leaf | Node (BinaryTree a) a (BinaryTree a)


A = X·E(A)

data RootedTree a = Node a (Set (RootedTree a))

usually, we simulate the Set here by a List. If we need for our rooted trees to be planar, we can in fact impose a Linear Order structure instead, and get something like
Ap = X·L(Ap)

The species interpretation of corresponding to leaving a hole in the structure carries over cleanly, so that is the type of T-with-a-hole.

Two derivatives of lists

We can deal with in two different ways:

1.
DL = D(1+X·L) = D1 + D(X·L) = 0 + DX·L+X·DL
and thus
DL-X·DL = 1·L
so (1-X)·DL = L
and thus
DL = L·1/(1-X)

Now, from L=1+X·L follows by a similar cavalier use of subtraction and division — which, by the way, in species theory is captured by the idea of a virtual species, and dealt with relatively cleanly — that
L = 1+X·L
so
L-X·L = 1
and thus
(1-X)·L = 1
so
L = 1/(1-X)

Thus, we can conclude that
DL = L·1/(1-X) = L·L
and thus, a list with a hole is a pair of lists: the stuff before the hole and the stuff after the hole.

2.
We could, instead of using implicit differentiation, as in 1, attack the derivation we had of
L = 1/(1-X) = 1+X+X·X+X·X·X+…

Indeed,
DL = D(1/(1-X)) = D(1+X+X·X+…) = 0+1+2X+3X·X+…
which we can observe factors as
= (1+X+X·X+X·X·X+…)·(1+X+X·X+X·X·X+…) = L·L

Or we can just use the division rule
DL = D(1/(1-X)) = D(1/u)·D(1-X) = -1/(u·u)·(-1) = 1/[(1-X)·(1-X)] = L·L

Gröbner bases for operads

All of this becomes relevant to the implementation of Buchberger’s algorithm on shuffle operads (see Dotsenko—Khoroshkin and Dotsenko—Vejdemo-Johansson) in the step where the S-polynomials (and thereby also the reductions) are defined. With a common multiple defined, we need some way to extend the modifications that take the initial term to the common multiple to the rest of that term.

For this, it turns out, that the derivative of the tree datatype used provides theoretical guarantees that only partially filled in trees of the right size, with holes the right size, can be introduced; and also provides an easy and relatively efficient algorithm for contructing the hole-y trees and later filling in the holes.

He pointed out that the underlying principle inducing the rule

goes under many names, among those \emph{Inclusion-Exclusion}, favoured among computer scientists (and combinatoricists). He also pointed out that the origin of this principle is the Mayer-Vietoris long exact sequence

In this blog post, I’d like to give more meat to this assertion as well as point out how the general principle of Inclusion-Exclusion for finite sets follows immediately from Mayer-Vietoris.

Inclusion-Exclusion, and the passage from two sets to many

The basic principle of Inclusion-Exclusion says that if we have two sets, and , then the following relationship of cardinalities holds:

A first proof would be performed by referring to an appropriate Venn
diagram, or by pointing out that if we try to count all the elements
of by adding the counts for and , then we’ve overcounted the elements of , and thus need to subtract these.

Now, this is good and convincing for the situation where we have just two sets, but what if we had a whole family? What if we had ? Well, our old friend the complete induction rides to our rescue. Suppose we had already proven that for sets , the following formula holds:

If you think this formula is imposing, let me show you the first few ways it works out, so that you can get a feeling for it:

Here it starts becoming apparent why it is called the Inclusion-Exclusion formula: we include all elements from all sets, but then we’ve gotten too many elements from the pairwise intersections, so we exclude those, but then we’ve gotten too few elements from the triple intersections, so we re-include those, but then we’ve gotten too few elements from the quadruple intersections – and on it goes.

If our assumption holds, we can consider what the appropriate size of the union of different sets should be. We can pick one set, say , and treat it separately. Then, certainly, the union of the rest has size given by the formula, by our induction assumption. So, consider what happens when we add in the elements in . We then overcount all elements in any of the intersections , so we have to subtract those. But we then have undercounted all elements in any intersection on the form , so we need to add those back in. And so we go on, and for each intersection that occurred in the formula for sets, we find ourselves forced to add one new term, of the opposite sign, that counts the intersection of that old term with .

Thus, the new formula takes on the exact guise of the general formula we wanted to prove, since the terms involving are precisely indexed, in that formula, by the terms excluding , but with opposite signs.

Encoding set sizes homologically

So, now that we know that pairwise Inclusion-Exclusion implies the general Inclusion-Exclusion, let us take a look on how we can express Inclusion-Exclusion with homology. We note first of all that counts the number of path-connected components of a space . This follows easily from a few properties. First, a basis for the -chains of is given by the points in . Second, two -chains are homologous precisely if there is a -chain whose boundary is the difference between those -chains. The boundary of a path is the difference of its endpoints, so we end up with two basis elements being homologous precisely if there is a path connecting them.

Thus, two -chain elements are homologous precisely if they’re in the same path-component of . So, the homology classes of -chains are precisely the path-connected components.

So, the -degree homology classes count path-components. How do we use that? Well … if we consider a finite set with the discrete topology – i.e. open sets are single points and any unions of single point sets, then a path is a continuous function , i.e. one where the preimage of any open set is open. Thus, the preimage of any point is an open set. Suppose a path contains more than one point. Then we can partition the interval into two disjoint open sets, by taking one set to be the preimage of one of the points, and the other set to be the preimage of everything else. However, the interval is connected, which means that if there are two such open sets, one of them has to be empty.

Thus, the path-connected components of a discrete topological space are the points themselves. So if is discrete, then .

Long exact sequences in homology and the Mayer-Vietoris sequence

It is a theorem from homological algebra that if we have a short exact sequence of chain complexes

then there is a long exact sequence in homology given by

Almost all interesting long exact sequences in topology are special cases of this particular fact. We will derive one interesting sequence: the Mayer-Vietoris sequence from this.

Take a topological space . The singular chain complex forms a chain complex with the free abelian group of -chains and the differential given by the usual formula.

Suppose we have two spaces: and . Then any -chain on is an -chain on and an -chain on . So we get an inclusion map by . We choose this sign instead of the image to make the next step cleaner. It is an injection because is a free abelian group, and the injections
are set maps on bases for the corresponding chain groups.

Compatibility of this map with the differential is almost as easy. If we first apply the differential and then map into the direct sum, we get the map . If we instead first map into the direct sum, and then apply the differentials, we get the map . These are equal, and thus the map we’ve constructed is a chain map.

So, is an injective map of chain complexes.

If we now have a pair of chains, we can construct a chain on the union of the two spaces. An -chain on is automatically an -chain on . Similarly, an -chain on is automatically an -chain on . So both and inject into by the same kind of argument as with the injection .

The injections we get this way can be put together to a map by, for instance, . I am going to fudge over the issue of whether the -chains on and form a generating set for the -chains on , and just take it on faith that this works. The details are not particularly difficult – they are just obnoxiously long and annoying.

Now, given that we believe we can get a generating set by taking the union of the bases for the -chains on and , then this means that the map I gave above is surjective. Indeed, a basis element is hit by the element , and a basis element is hit by the element .

This argument proves exactness at the first and last term of the short exact sequence

and it remains to prove exactness at the middle term. So we need to prove that

Now, since , the inclusion of the image in the kernel is obvious. So, suppose now that , and . Then, in , we know that . But then, since and similarly since . So and . But then this kernel element really is in the image of the inclusion we gave.

So this is a short exact sequence of chain complexes. It follows from the theorem of long exact sequences in homology that there is an associated long exact sequence, called the Mayer-Vietoris sequence:

Putting it all together

Suppose is a discrete topological space. Then any continuous map from a -simplex to is by necessity constant at one point. So all the singular simplices in are constant maps, and thus a basis for any -chain group is given by just the points in as such. The differential acts on such a constant map by sending it to an alternating sum of identical maps the cardinality of which is one more than the dimension of the simplex. So the differential vanishes at every other point in the chain complex, and is an isomorphism on the rest. But then we have exactly two possibilities for a homology computation:

Case 1:

Here, the kernel is the entire chain group. But so is the image. Thus the homology group is trivial.

Case 2:

Here, the kernel is trivial, but then again, so is the image. Thus, again, so is the homology group.

The only part not really covered by this is the homology group , since this is computed from a diagram on the shape . So behaves like we showed above, and is the only non-trivial homology group of the discrete space.

But then, the only bit that remains non-zero in the Mayer-Vietoris sequence is

If we have a short exact sequence of free abelian groups, then this relates the number of basis elements in each of the groups with the structure of the sequence. Let our short exact sequence be given by . then, by injectivity of the map , the cardinality of a basis of the image in is equal to the cardinality of a basis for . By surjectivity of the map , and by Noether’s theorem, the cardinality of a basis of is equal to the cardinality of a basis of the kernel of this map, plus the cardinality of a basis of . By exactness in the middle, this kernel basis is equal to the image basis from A. So, we have, writing for the cardinality of a basis of the free abelian group , that . Thus, .

And if we apply this to the Mayer-Vietoris sequence fragment we acquired, it follows that

and thus

It turns out that it does.

The following are two highlighted versions of the Liechtenstein communal graph.

The embedded K5 with edges in blue.

The embedded K33 with blue and red vertices.

Rahul pointed out that I made errors in transferring the map to a graph. Specifically, I missed the borders Schellenberg-Eschen and Vaduz-Triesen. The post below changes accordingly.

Warning: This post DOES contain spoilers to Brian’s question. If you do want to investigate it yourself, you’ll need to stop reading now. Apologies to those on my planet feeds.

As a first step, we need to build a graph out of it. I labeled each region in turn with the exclaves numbered higher than the “main” region of each organizational unit. And then I build a .dot file to capture them all:

graph Lichtenstein {
  Ruggell -- Schellenberg
  Ruggell -- Gamprin1
  Schellenberg -- Mauren
  Schellenberg -- Eschen1
  Mauren -- Eschen1
  Gamprin1 -- Eschen2
  Gamprin1 -- Vaduz2
  Gamprin1 -- Schaan1
  Gamprin1 -- Planken3
  Gamprin1 -- Eschen1
  Eschen1 -- Gamprin2
  Eschen1 -- Planken1
  Eschen2 -- Schaan1
  Vaduz3 -- Schaan1
  Vaduz2 -- Schaan1
  Planken3 -- Schaan1
  Planken2 -- Schaan1
  Schaan1 -- Planken1
  Schaan1 -- Planken4
  Schaan1 -- Vaduz1
  Gamprin2 -- Eschen3
  Eschen3 -- Vaduz4
  Eschen3 -- Schaan2
  Vaduz4 -- Schaan2
  Vaduz4 -- Planken1
  Schaan2 -- Planken1
  Planken1 -- Schaan3
  Vaduz1 -- Triesenberg1
  Vaduz1 -- Triesen
  Planken4 -- Triesenberg1
  Planken4 -- Balzers2
  Balzers2 -- Vaduz5
  Balzers2 -- Schaan4
  Vaduz5 -- Schaan4
  Schaan4 -- Triesenberg1
  Schaan4 -- Vaduz6
  Schaan4 -- Triesenberg2
  Triesenberg1 -- Vaduz6
  Triesenberg1 -- Triesen
  Triesenberg1 -- Balzers3
  Triesen -- Balzers3
  Triesen -- Balzers1
  Triesen -- Schaan5
  Vaduz6 -- Schaan5
  Triesenberg2 -- Schaan5
}

Compiling this, we get the graph

Now, with this it is an easy job to get the adjacency graph for the communes. We can just delete all numbers in the above dot file. Graphing that, we get instead

Note, however, that the massive duplication of adjacency edges makes this rather hard to read. So we can just amalgamate all those edges into one single edge each. So in the end, the Liechtenstein graph turns out to be

Now, as Brian points out, there is a 5-clique in this map, given by Schaan, Balzers, Vaduz, Planken, Triesenberg.

Edited: Michael Lugo pointed out in the comments that my exclusion criterion for 6-cliques is obviously and trivially false. Discussion below here changed appropriately

If there were a 6-clique in the map, there would have to be 6 communes each of which have at least 5 edges connected to them. We can construct the table of degrees for all communes, to see whether this helps:
Balzers: 5
Eschen: 6
Gamprin: 5
Mauren: 2
Planken: 6
Ruggell: 2
Schaan: 7
Schellenberg: 3
Triesen: 4
Triesenberg: 5
Vaduz: 7

So, we have enough edges in Balzers, Eschen, Gamprin, Planken, Schaan, Triesenberg and Vaduz. This gives us 7 candidates for a 6-clique. Thus if two of these have too many edges outside this group, we know that there cannot be a 6-clique in the commune-graph.

Now note that Triesenberg borders to Triesen, so at most 4 of those 5 edges can be within a 6-clique. Also, Gamprin borders to Ruggell, so at most 4 of Gamprin’s 5 edges can be within a 6-clique. Thus the graph contains no 6-cliques.

Does this, though, mean that we can construct a 5-coloring of the graph? Try this on:

I would recolor the Liechtenstein map using this color choice, but I haven’t gotten around to installing a decent picture editing program just yet. That’ll have to wait.

The next couple of weeks will be spent doing homology of simplicial complexes, singular homology, equivalence of the two, neat things you can do with them; and then we’ll start moving towards a Borsuk-Ulam-y topological combinatorics direction.

I might end up pulling combinatorics papers from my old “gang” in Stockholm on graph complexes, and graph property complexes, and poke around those with them.

One subject I spent a lot of time thinking about this spring was taking tensor products of A_∞-algebras. This turns out to actually already being solved – having a very combinatorial and pretty neat solution.

Recall that we can describe ways to associate operations and homotopy of associators by a sequence of polyhedra K_n, n=2,3,.., called the associahedra. An A_∞-algebra can be defined as being a map from the cellular chains on the Associahedra to n-ary endomorphisms of a graded vector space.

If this was incomprehensible to you, no matter for this post. The essence is that by figuring out how to deal with these polyhedra, we can figure out how to deal with A_∞-algebras.

A tensor product of algebras is basically the direct product of the polyhedra, and we can get precisely the thing we want if only we find a map from the cellular chains on K_n to the cellular chains on K_nxK_n fulfilling a few neat properties.

This map is what is known in the literature as the Saneblidze-Umble diagonal from the people who presented it in a paper from the late 90s. They describe in that paper, and more clearly in a later paper, how to actually get hold of one map with the right properties. The road goes over basic matrices, derived matrices and connecting matrices to trees describing associations. I’d like to take this opportunity to work through the implementation I just wrote of an enumerator for these, displaying the code and discussing it a little bit.

This post will be written as literate Haskell, so copy the text into a file, and then just save it as SaneblidzeUmble.lhs and you’re ready to go.

So, we will build a module named SaneblidzeUmble that shall contain the code:

We’re going to juggle a lot with lists, and a little with potentially failing calculations, so we’re going to include a couple of standard utility function sets too.

Permutations and staircase matrices

The issue we’ll want to solve in the end is to enumerate all the terms entering into a diagonal on K_nxK_n for one fixed n. These terms are, using the later to be mentioned terms, in correspondence to derived matrices of staircase matrices with entries from [1,..,n-1]. A staircase matrix is one with one entry for each diagonal (parallel to the main diagonal), and such that along each row and column, all entries are adjacent and strictly increasing down and to the right.

As an example, we have the matrix

.14
25.
3..

Given a permutation of [1,..,n-1], we can write the images in the order they occur, and then just take this as a description of the entries from lower left to upper right of a staircase matrix.

It turns out that the basic matrices involved in this process are in bijection to permutations of [1,..,n-1] by placing the digits into the matrix, going up whenever the next entry is lower, and going to the right whenever it is larger.

Thus, the example above is given by the permutation (32514).

So, to handle this, we need to be able to list all permutations as well as pick out all rising and all falling part runs of a permutation

This is almost readable as it stands. The permutations of [1..n] are just the permutations of the list [1..n].
There are no permutations of an empty list, the list with one element has one permutation of itself, and for any larger list we pick out one element at the time, permute the rest and prepend this element. The collected results are compiled into a single long list and returned.

Solves, by recursion, neatly and with a lot of connection to the mathematical thought behind it our problems.

Now, for the chopping permutations into monotonic runs, I’ll solve it all in a manner slightly decreasing the amount of code repetition. We have a “factory function”

and two use cases of this

Using this, we can build the matrix out of a given permutation. The only really interesting thing for the diagonal about such a matrix is the contents of the rows and of the columns, so we shall just use that. This means we can represent a matrix as the list of rows and the list of columns. Since row and columns “look basically the same”, they’ll be represented by the same type. So we have

The reason we use map sort and reverse is to make the result fit with the conventions chosen by Saneblidze and Umble. Note: when actually reading the results, users should take care to read the Columns backwards.

Deriving staircase matrices

Deriving the matrices is done with so called moves. We have a downward move, and a rightward move – both consisting of picking a subset of elements in one row or one column, and pushing them over to the next – given the condition that all the moved elements have to be larger than the largest they move over to. They also have to move to empty positions, but the ordering conditions for the staircase matrices will guarantee that if they really are larger, then the corresponding position is already empty.

So, we can write a a function that gives us all the subsets of the first column/row that might possibly be moved to the second in a given column/row-list of a matrix

This function picks out all the subsets of elements that fulfill the requirement of being larger than the largest element of the next row. But hang on – this subset-function actually isn’t defined yet. No worries – it’s easily done:

Again, we define everything recursively, relying on a base case of “blinding” simplicity, and end up with a very mathematical looking description. Here, the subsets of the empty set is just the empty set itself, and the subsets of any set with one element existing in it consists of the subsets containing that element and those that do not contain it. We simply list first those with and then those without.

Now, for the actual deriving move, we might run into a host of trouble, so we’ll just let it be able to return an error condition. It first checks a few possible error cases, and then writes down the actual move by picking out the rows it needs, modifying those, and putting it all together again in the end.

Supposing we have some set m we want to move, and we have a list of the rows where it could be moved, then we’ll want to first check whether all of m is in a single row together. Thus, for each row, we pick out all elements that are in our set m. But we don’t really care for what the elements are – we only need the number in each. So we compile a list of the lengths of these filtered out pieces.

We shall require the number of rows that have all the pieces we want to move to be 1, and also for that single row to have a good position within the matrix.

That monstrous expression at the end is known as a guard expression. It works through the cases until something actually is true, and then returns whatever is after the equal sign as the value. The conditions I listed weed out all the pathologies, and lets the program pick out something sensible whenever possible.

So, we can list all possibilities of one row, and we can move them. This should be enough to simply generate all derived matrices, right? Let’s start simple. Let’s start with all we can do on one side of the pair – either all possible down moves or all possible right moves (they are essentially the same anyway…)

Guiding you through this piece of code – when encountered with a list of rows, we look at each starting point, list all the possibly movable sets at that point, and move the corresponding sets, placing all the results at the back of a queue that we work through. Once the queue is empty, we know we have worked through all the results from all the moves we could find, and that no others can be found.

So, if we have our pair of row-lists? We first move to the right, and then down. At each point, we keep the other half fixed, and simply add it on to all the results of moving in the first part.

This first works through one direction, taking all derived rows, and tacking on the constant second half, then when that’s done, changes to the same but for the other half of the pair.

Now, we’re almost able to state what a specific diagonal looks like. There is only one more thing to handle: we might not want the results of a particular computation. More specifically, we recognize something we do not want by it having a row that isn’t consecutive, not even when including previously occurring rows. So, we need to check that.

Now it’s just a matter of putting the pieces together

Previously, a student of Ron Umble has done an implementation of the same task in C++. This cannot, according to Umble, handle anything larger than n=5. This Haskell implementation, while being surprisingly short and readable, has on my (64 bit, modern, high memory) workstation been able to meet the following execution parameters:

Conway’s Look-and-say sequence

This is, in fact, true. It’s a corollary to one of the prettiest theorem conglomerates I have ever seen: the Borsuk-Ulam theorem(s). Alas, I haven’t got my sources on it here at the moment, so I won’t give you the deep indepth survey I want to give; but I do want to give a bit of overview as to why the claim CJ supports her insane theory with is actually true.

Temperature can be seen as a function from location to the thermometer. For each place on the earth, there is a temperature rating. Furthermore, this function is continuous, since there are no discontinuities – no sudden jumps in temperature between close points.

This sudden jump thing merits closer explanation. It says that by measuring closer and closer together, you can get the difference in temperature as small as you want to. It doesn’t prevent steep temperature shifts, it only prevents insane. This assumption, as such, is a valid one since temperature differences tend to flatten themselves out – if you place a hot and a cold bit close to each other, the cold one heats and the hot chills.

So, we know that it’s continuous. This, it turns out, is an incredibly powerful to know. It brings in the entire toolbox of topology. Which, in turn, brings us closer to the topic of the post – the Borsuk-Ulam theorem.

The theorem has a million different equivalent statements. Borsuk himself proved that for any antipodal function from the sphere to itself (meaning that ) has odd degree. I won’t enter into what this means more precisely, but it has a few cool corollaries:

1. Any family of closed sets covering has a member containing an antipodal pair.
2. Any map from the sphere to the plane must send some antipodal pair to the same point

1 has a few fun interpretations. I will feed you with those when I get hold of my material again, or actually, you know, think of them.

2, on the other hand, is what we need to prove CJs statement. Our temperature function can be used to construct a function from the sphere to the plane by sending a point on the earth to the point . This function, in turn, has an antipodal fixpoint, so there are some points and such that . But this also means , so there are some pair of antipodal points on the earth with the same temperature.

Thanks to nerdy2@#math:ircnet for reminding me of the details of Borsuk-Ulam, and giving the construction of .

Edit: It was pointed out to me later that all this is really unnecessary. In fact, we can use Borsuk-Ulam straight off to show that on each great circle on earth, there is such an antipodal pair. Indeed, a great circle is , and the temperature map takes to , and thus qualifies for the setup for 2 above, since the dimensions of “sphere” and “plane” don’t really matter. Thus, on each great circle there is an antipodal pair with equal temperature. And since there are many, many great circle’s on earth, there are also many, many such points.