1. I’ve been working with Laurent Gruson and Jerzy Weyman on finding geometric interpretations for orbits in “Vinberg -representations”. I gave a talk on this at Princeton (notes) and Michigan (notes). The Princeton talk is more introductory in nature, and even though there is overlap, the two sets of notes should complement one another (for the record, both talks were approximately 1 hour, 45 minutes).

2. A separate project with Weyman involves trying to understand Koszul homology for certain classes of determinantal-like ideals. The motivation comes from trying to classify minimal free resolutions over quadric hypersurface rings and in trying to understand a certain result of Koike and Terada in combinatorial representation theory. I’m giving a talk on this tomorrow at Michigan (notes).

It’s a bit time-consuming, but I think preparing notes like this can be very useful, especially for projects which haven’t been finished yet (it helps me gain direction). I hope more people try it!

-Steven

As with any object as general as posets, we are mostly interested not in results about all posets, but rather in finding particular families of posets with interesting or unexpected properties.  One such family of posets are the (3+1)-avoiding posets.  These are the posets that do not contain four elements, say a, b, c, and d, such that a < b < c and d is incomparable to the other three.  A short digression to explain the name “(3+1)-avoiding”: one natural class of posets are the chains, finite total orders like the first example in the previous paragraph.  A natural name for the chain with vertices is n, so the chain with three vertices is 3 and the chain with one vertex (the only poset with exactly one vertex) is 1.  There are several natural operations that we can use to combine posets, including the disjoint union, denoted “+”.  Thus, 3+1 is the poset that you get if you add a single isolated vertex to a three-element chain, and a poset is (3+1)-avoiding if it has no four elements that induce the poset 3+1.

It’s a common surprise in combinatorics to find that important objects are characterized by avoiding certain induced subobjects; subposet-avoidance is one particular example of this, and in fact (3+1)-avoiding posets show up in a number of unexpected places.  The simplest and perhaps nicest appearance is in the characterization of semiorders.  Semiorders are posets that arise in the following way: we have a set of data (real numbers generated by some experiment) such that each datapoint has error bars of the same size.  Thus, if two values a and b are separated by at least a fixed distance then we know their true order; but if they are separated by less than this distance, we can’t be certain which value is truly larger.  The relations we can be certain of are the relations of our poset.  It’s not hard to see that this definition is equivalent to the following: a semiorder is a poset whose elements are unit intervals in the real numbers, with one element less than another if and only if it lies entirely to its left.  (Aside: an easy exercise is to show that it doesn’t matter whether our intervals are open or closed.)  The main result of interest is that semiorders are exactly those posets that avoid 3+1 and 2+2.  (If we drop the “unit” in “unit intervals”, we get just (2+2)-avoiding posets.)  These posets have all sorts of nice properties; for example, the number of them with n unlabeled elements is exactly the nth Catalan number, so we immediately know we’re going to get nice combinatorics and lots of connections with other objects.  See Wikipedia and the work of Peter Fishburn for much more information about them.

A second set of connections comes from the following simple observation: a poset P avoids 3+1 if and only if its incomparability graph (i.e., the graph G on the same vertex set such that u is connected to v in G if and only if u is incomparable to v in P) is claw-free, i.e., contains no four vertices a, b, c, d such that d is connected to a, b and c, none of which are connected to each other.  Claw-free graphs are quite interesting; for example, they make an appearance in some recent work of Fadnavis, who proved the following pretty result:

Suppose that we wish to color a graph G with q colors, choosing the color for each vertex at random.  If G is claw-free then to maximize the chance that the resulting coloring is a proper coloring (i.e., no two adjacent vertices have the same color), we should choose colors uniformly at random (i.e., with equal probabilities 1/q).

(Quite surprisingly, this result is not true in general!  To 2-color a star graph with 4 or more points, you’re better off with a more lop-sided distribution.)  Actually this result is just one part of a bigger story; for example, it’s also related to the Stanley-Stembridge conjecture, which asserts that symmetric chromatic polynomial of the comparability graph of a (3+1)-avoiding poset is e-positive.  (For definitions, check the Fadnavis paper, which is really excellent and has a lot of interesting material.)

As an enumerative combinatorialist, all these nice features of (3+1)-avoiding posets make me want to count them.  And, in some sense one should expect this to be not too difficult: claw-free graphs and (3+1)-avoiding posets both have nice structural classifications (due to Chudnovsky & Seymour and to Skandera, respectively), and the related (2+2)-avoiding posets have been enumerated by Bousquet-Mélou, Claesson, Dukes & Kitaev.  But, unfortunately, it seems like none of this is actually directly relevant.  So at least for now, counting (3+1)-avoiding posets remains very much open.

Notes:

0: One of the fundamental objects of combinatorics is the partially ordered set, or poset for short.¹  Posets are just what their name suggests: they are given by an order relation (usually denoted ) that is transitive (i.e., and means ) and antisymmetric (i.e., we never have such that and ), but it is partial in the sense that not every two elements are necessarily comparable (so we might have such that neither nor hold).  Obviously posets are a very flexible family of objects, including things like the usual order on the integers (a partial order than happens to be a total order) or the containment order on the subsets of (the Boolean lattice).

1: Does anyone know the history of how this came to be?  As far as I know, MacMahon didn’t do anything with posets, so my assumption is that one can trace it to Rota, but obviously this is not based on anything concrete at all.

Some of my mathematical hobbies include probability and machine learning. I have recently realized that many simple but effective ideas of these fields really all come from one thing: an independence assumption. It was only until I saw the same example in several different guises, however, before I really caught on. As something Occam would surely approve of, the extreme naiveté this approach embraces can actually go a long way. Our key player is simple: we say that and are conditionally independent given if . This can be written in the more symmetric form . Now I will tell a few stories. Most of these should be old for a specialist, but I hope I’ve included some remarks that even they may appreciate.

Weighing Evidence

(this is mostly stolen from inspired by Jaynes from Probability Theory: the Logic of Science) Suppose we have two hypotheses about the state of the world, say and , and we know that exactly one of them is true. Now suppose we are getting consecutive pieces of data .  How does this data update our belief in or its complement?

A standard use of Bayes’s Theorem gives that Doing the same for and dividing gives

Here, let’s make the naive assumption that the ‘s are conditionally independent given or . Not only are these different, we in fact want the slightly stronger assumption that the ‘s are conditionally independent of the intersection of the previous ‘s given or . If so, on the right we just get a product of . We want to take logs here and rewrite our equation as

where is the odds . We now make the natural guess we are in the world exactly when this is positive (which corresponds to the having higher probability).

The cute thing about this situation is that we are really “weighing” our evidence, as on a balance! Each new piece of data just contributes a number, and we mentally keep a tally and just decide yes or no given the sign of the final sum. Our original “bias” is exactly the odds of given no other information, which exactly corresponds to the Bayesian information contained in our prior knowledge of , so the entire prior information comes into play as a “head start” bias in one direction, as if it were a single instance of data with some weight! This is a very clean way to make decisions, and really makes binary hypothesis testing very intuitive (it is fun/frustrating to try to generalize this to more than hypotheses, where there are quite a few unexpected pitfalls). The key, however, was our conditional independence assumption.

Naive Bayes

A very naive approach to spam filtering is the following (generative) model. Let nature choose whether a message is spam (call this hypothesis ) with some probability and then, for each word in the dictionary, pick whether each word is in the message (abuse notation and call this the event ) with probability (or ). You then pick maximum likelihood over sample data to learn the probabilities, and on a new piece of data just get the ‘s and see whether or was more likely.

So what was the naive assumption? It was that the events were conditionally independent given either hypothesis. Cutely, the final log odds is additive because of this (an exercise I leave to the reader) and extremely easy to calculate (and fast for computers, too!). The punchline is that this additivity is exactly the same additivity we had in the hypothesis testing. The expressions work out such that the inclusion/exclusion of every word will add some positive/negative number to a running total, biased in the beginning by some initial value determined by with no other information, and we choose to classify a message as spam based on whether this running total is positive or not.

Before continuing, I want to put in e-print my long-running gripe that “Naive Bayes” is a misnomer, since the only thing naive I can possibly think about doing with Bayes’s Theorem is conditional independence, and so every such algorithm should be called “naive.” The name offers no information about the particular algorithm that is associated with spam filtering, and the graphical network it corresponds to is not even the unique simplest graph (you can reverse all the arrows, for instance, and get Noisy-Or or any other ICI, but I admit those have another layer of complexity that I am not going into here). Unsurprisingly, there are actually many flavors of Naive Bayes depending on where you want to insert your naivete — see Metsis, Androutsopoulos and Paliouras, Spam Filtering with Naive Bayes – Which Naive Bayes?

The Unreasonable Effectiveness of Naive Bayes

What’s the yoga here? Here’s my take: the conditional independence became a multiplicative condition and thus an additive condition, so the convenience of independence corresponds to the convenience of linearity. Thus, the hyperbolic punchline of this post is that “independence is linearity.”

I see a strange phenomenon (at least among pure mathematicians casually talking about applied math; I’m sure applied mathematicians have a better intuition) that people are very comfortable accepting linear approximations but not as comfortable accepting independence, whereas at least in my very simple setup they are exactly the same. I will audaciously extend my analogy to say that this intuition is inconsistent, and I don’t know why people seem to be completely fine with logistic regression (which really just says the log-odds is additive and is thus a third story equivalent to the two stories I’ve told in this blog post!) while careful about making disclaimers about Naive Bayes.

In fact, Naive Bayes, contrary to popular opinion, is actually also very good (and provably optimal, with certain definitions of optimal) when events are very dependent! It is only in the middle regions where it suffers, and it really doesn’t suffer by much. We also overestimate its problems because we like to think in terms of but errors in classifying are frequently done under zero-one loss (this is a really interesting nuance that I would love to talk about some other time, but this post has gotten long enough). For a more in-depth look, see Domingos and Pazzani, On the Optimality of the Simple Bayesian Classifier under Zero-One Loss.

Appendix: Noisy-Or and Bayesian Networks

When we talk about conditional independence, we really should take the setup of Bayesian networks, which gives a natural excuse to introduce Naive Bayes’ much lesser well-known sister, Noisy-Or (that often does better than Naive Bayes!). I spent some time in my talk going over the basics of d-separation, Markov blankets, etc.. However, I realized that I had no real interesting observations so I won’t talk too much about it in blog format, where the reader is very close to Google and smarter people who know much more than I do. I did have one silly “original” contribution, however, so I share it here.

Here is an example that I thought was surprisingly clean and possibly helpful for someone interested in the basics of Bayesian networks: consider the events A(AC), B(Battery), and C(Computer), corresponding to whether the corresponding electronic gizmo is on or off (with the computer connected to both the AC and the battery). This corresponds to a Bayesian network with two edges and .

It is obvious that and are independent until is observed, which makes them conditionally dependent; if you know the Computer is on or off, then the other two power sources’ integrities are coupled. Otherwise, your blissful ignorance gives you no information. This is starkly different from every other orientation (3 possible) of the edges, where and are dependent but conditionally independent given ! This quirkiness makes the weird d-separation criterion necessary, and I thought this example very mnemonically convenient for marking the “bad” edge-orientation.

-Yan

(Positive knots become negative knots if we switch either our nomenclature or the orientation on , so there are confusions lurking everywhere in this business. Also, note that although we needed on orientation on our knot to define the sign of a crossing, the sign is actually independent of this orientation, and only depends on the embdedding of the knot in ).

A rather amazing theorem is that every positive braid is fibered. What this means is that if we take our positive braid and close it up into a knot in , then the “knot complement” , which we can think of as an open 3-manifold, actually fibers over the circle, with fiber a punctured surface. (Alternatively, if we remove a small tubular neighborhood of the knot, we can think of as a compact 3-manifold with torus boundary). Here’s how to close the braid:

In other words, there is a punctured surface , and a map , fixing the puncture, so that the knot complement is the mapping torus for , as pictured below. Such fibered 3-manifolds are very special.

Note that it is precisely because fixes the puncture that the line above closes up and becomes a knot. I should say, the proof that positive braids are fibered uses an even more amazing theorem of Stallings, which characterizes fibered knot complements in terms of a simple algebraic property of their fundamental group. This particular notion of positivity is one that appears in Matt’s paper. I recently read some work of Etienne Ghys talking about a related notion, and I thought it was so cool that I had to post about it.

Here’s the theorem, which Ghys attributes to Freed, Schwarzman, and Sullivan. Let be a compact manifold with a non-vanishing, smooth vector field . First for the background: suppose there is a closed surface which is transverse to the flow of and meets the forward orbit of every point at least once (therefore, it meets every orbit infinitely many times). We get a first return map , simply by taking and flowing it forward until it hits again, say at , and defining . Then it’s not hard to check that must be the mapping torus for , as before, and that is just the natural vector field pointing along the “time” direction of the mapping torus (up to scaling), as depicted below:

In this case, is called the suspension of . The question addressed by the theorem is: given a non-vanishing vector field on , when is it the suspension of a map ? Note that if we have such a suspension, and therefore a fibration over , we can pull back the form on to to get a closed, NON-VANISHING 1-form which is positive on . It’s not so hard to figure out that having such a form is equivalent to being a suspension. The really cool theorem is an apparently much weaker condition which is also sufficient.

The key object is the set of probability measures on which are invariant with respect to . Given any , and any 1-form , we can get a number by integrating:

This associates to any a 1-chain, i.e. something dual to a 1-form. If is exact, the above integral can be shown to be 0, using the -invariance of (use the invariance to rewrite the integrand, when is an exact form, as a total differential). Therefore, we obtain a map

whose image is in fact compact and convex. Now, if was a suspension, then  actually lies entirely in some positive half-space of . Why? Well, remember that in this case we have a closed non-vanishing one-form which is positive on , and by pairing with this form we get a map which is positive on . Therefore lies in a positive half-space of . The rad theorem of FSS is that this is actually sufficient:

Theorem: is a suspension if and only if is contained in some halfspace.

One remark about the measures : note that if we have a closed periodic orbit for , i.e. some closed loop which integrates the flow, then we get a natural set of measures which are concentrated near . In this sense, should be thought of as a set of generalized periodic orbits. The measures associated to actual periodic orbits just get sent by to the class represented by these orbits in .

One way to think about the theorem, and this is how one of the proofs goes, is that just from this positive subset of homology, we can do some fancy functional analysis to create from this an actual dual form, not just a cohomology class, with the right non-vanishing and positivity properties. So somehow, we’re free to work just in homology without losing information, which seems very appealing.

I’m not yet sure exactly what this theorem useful for, but it’s so neat. In a soon to come follow up, I will talk more about positivity on the knot side, and bleg about a concrete question that I’d love to get everyone’s opinion on.

One of the most common physical tricks, however, is not of this category. It is the curiously natural framework: “we have a consistent idea of units.” Here’s a perfectly sound argument to get something that is not entirely obvious:

Take the integral . There is a way to get some information about it without doing the real integral:

Do the substitution . Then the integral becomes

Using a slightly physical language: f we don’t care about the actual constant, just the “order” of (though it is a similar concept, we’re not exactly doing the order of growth of ), we can deduce that the answer is in the “units” of (the complete answer is ), by “isolating” the part of the integral with dependence on .

Even though this is already somewhat trick-sy, it is not quite as far as what a physicist would do. They would (confirmed by experience!) look at this and say something like:

“Let have the units of . The exponential must be unit-less otherwise it doesn’t have a well-defined unit, which means must have units of and the integrand itself must then be unit-less. When we integrate, we then pick up a single unit of in terms of , so it must be for some constant .”

The problem is this makes perfect “sense” to me in a completely sound way (there is no approximation or heuristic here), yet I cannot argue it to my satisfaction in any mathematical matter. All I know is that most people with even elementary physics experience have picked up a very consistent language of “units” that we can use to make definite deductions, but I’m finding it hard to axiomatize them in a clear way. After trying for about half an hour, the only thing I’ve decided is that we really want some sort of valuation on a space of functions that is multiplicative, which I believe is enough to make the differentiation and integration instincts about units work, and that we limit all addition to be done with functions of homogeneous valuation. However, is that really it (for example, I don’t feel this is all that has gone into the logic above)? If so, what is the right way to formalize it? Also, I distinctly remember having seen usage of units to argue more sophisticated chains of logic than the example I’ve given here, though the exact examples don’t come to mind. If anyone has further insight and examples it would be really helpful.

Update: after an unnecessarily long discussion w/ Qiaochu (the source of the un-necessity being my muddled thinking about something irrelevant), I now agree the formalism is “easy” and can be done in several ways (though I still find the intuition to be a clearer way to think than the formalism). The method that seems most natural to me is to just think of all functions we care about as lying in a graded algebra with grades indexed by powers of units; Qiaochu prefers to think of the “physical” attributes as living in one-dimensional representations / weight spaces. Pick whatever you like. My request for more “interesting” examples of using units still holds.

-Yan

(thanks to Allan, Yoni, and Josh for teaching me physics)

To start, we need to agree on a model of Turing machines. Usually, theorists work with a single-tape model. Actually, any Turing machine can simulate any other with at most polynomial time overhead. We also distinguish between deterministic Turing machines and non-deterministic Turing machines. The difference is that from each configuration, a non-deterministic Turing machine can go on to more than one possible configuration. The precise formulation of this is that the transition function of a non-deterministic Turing machine maps configurations to sets of configurations rather than single configurations. Furthermore, we can assume that every configuration leads to two possible configurations. This doesn’t really correspond to any real-world physical model, it’s just a theoretical construction. Moreover, a non-deterministic machine accepts if and only if at least one of its branches accepts. It turns out that non-determinism doesn’t give Turing machines any power to recognize more languages. This is because any non-deterministic Turing machine can be simulated by a Turing machine (with potentially exponential time overhead) by trying all branches of the non-deterministic machine “in parallel” by using breadth first search, for example.

Now I introduce some definitions and notation. A -time (or -space) Turing machine is one that uses at most steps (or tape cells) on any input of length .  Define to be the set of languages decidable by an -time deterministic Turing machine, and to be the set of languages decidable by an -time non-deterministic Turing machine. Define and analogously. Now I can define P, NP, co-NP, PSPACE, and more:

Furthermore, for any class C, we define co-C to be the set of languages whose complements are in C, which gives us definitions for co-P, co-NP, co-PSPACE, and co-NPSPACE. So far, I’ve defined a lot of complexity classes, but it turns out a lot of these are the same.

First of all, let’s get some intuition for these. P is the set of problems that can be solved by polynomial-time deterministic algorithms. NP is the set of problems that can be solved by polynomial-time non-deterministic algorithms. What does this actually mean? A non-deterministic algorithm can “guess” the right step to take next. From every configuration, there are 2 configurations to go to, and as long as one path of configurations leads to an accept state, the algorithm accepts. What this means is that if we get lucky, if the algorithm guesses the “correct” configuration to go to every step, then it can reach the answer in polynomial time. An equivalent definition of NP is the set of problems for which a solution can be verified in polynomial time. Examples will come soon. PSPACE is the set of problems that can be solved using polynomial space. EXPTIME is the set of problems that can be solved using exponentially long time.

Why do we lump all the polynomials together? Why not distinguish between linear time problems, quadratic time, etc.? Well, like I mentioned at the beginning, we assumed one particular model of the Turing machine. However, if we change the Turing machine, our run-time and space may change by a polynomial amount. Therefore what’s linear on one machine could be quadratic on another. We want robust classes — classes that are the same no matter what model of Turing machine we choose, which is why we lump all the polynomials together.

Some relationships follow pretty straightforwardly from the definitions. For example, P is contained in NP, since any deterministic TM can be simulated by a non-deterministic one with basically no overhead (you can just view a DTM as a NDTM with one branch at each configuration). Also, PSPACE is contained in EXPTIME. The idea is that if the tape of a TM is bounded by some number, then the number of possible configurations it has is at most exponential in the space bound. The exponential part comes from counting the number of possible strings you could have on the tape (number of possible letters in the alphabet raised to the power of the number of cells). Anyway, if a DTM encounters the same configuration twice, then it must have entered an infinite loop. Therefore, any DTM that solves a PSPACE problem must halt, and hence can run for at most exponentially many steps, since that’s an upper bound on the number of possible configurations.

Moreover, for deterministic classes C like P, PSPACE, and EXPTIME, in fact C = co-C. This is because you can just construct a DTM which runs the original DTM and then spits out the opposite answer. If is a language and decides , then construct to spit out the opposite answer of . Now, decides , since it accepts if and only if rejects if and only if .

Note, however, that this trick doesn’t work for non-deterministic machines, and so we can’t deduce that NP is the same as co-NP. In fact, their relationship is still not known! The reason this trick doesn’t work is that a non-deterministic machine might have some accepting branches and some rejecting branches for certain inputs. In this case, constructing a machine that reverses the answer will have some rejecting branches, corresponding to the accepting branches of the original machine, and some accepting branches corresponding to the rejecting branches of the original machine. In other words, on a given input, if the original machine accepts, the reversed-answer machine might ALSO accept, which is why the trick doesn’t work.

Another neat fact, known as Savitch’s Theorem, is that non-deterministic Turing machines can be simulated by deterministic Turing machines with at most quadratic space overhead. This implies that PSPACE = NPSPACE! Finally, the time hierarchy theorem tells us that allowing a DTM more time (by more than a log factor) the set of problems it decides is strictly larger. This immediately tells us that P is strictly contained in EXPTIME.

To deduce that NP is contained in PSPACE, we use the concept of completeness. For a given complexity class C, a problem is C-hard if, intuitively, it’s at least as hard as every problem in C. Technically, a language L is C-hard if every language in C is polynomial-reducible to L. A is polynomial-reducible to B, written , if there exists a polynomial-time computable function such that for all . Intuitively, this means that B is as hard as A, since if we have a polynomial time algorithm for B, we can use it to solve A by first transforming the input using (in polynomial time), then feeding the result into our algorithm for B and returning the answer. A problem is C-complete if it is C-hard and it is itself in C. This intuitively means it is one of the hardest problems in C, and any polynomial time algorithm for a C-complete language gives us a polynomial time algorithm for every language in C.

The “canonical” NP-complete problem is SAT, the language of satisfiable boolean formulas. A boolean formula is just an expression involving variables and the boolean operators OR, AND, and NOT, and it is satisfiable if there is an assignment of truth values to the variables which makes the entire expression evaluate to TRUE. This is in NP, since given an assignment of truth values, we can verify that it satisfies the boolean formula in polynomial time why simply plugging in the values. This problem is also NP-complete, and the proof is way too technical to write out here, so I’ll just give the main idea. To reduce any NP problem L to SAT, you can construct a boolean formula which “simulates” the machine for L, in a manner reminiscent of how modern electronic circuits simulate Turing machines (and are really just evaluating boolean expressions). The boolean formula constructed will be satisfiable if and only if the simulated machine accepts the input.

It turns out SAT is in PSPACE. You can solve it using polynomial space (linear, in fact) by successively plugging in possible truth assignments. If there are variables, you just try all possible assignments, but at any given time you only need to keep track of values. But since SAT is NP-complete, the entire set NP is contained in PSPACE. In retrospect, this is not surprising at all. Intuitively, space should be more powerful than time, since we can re-use space but we can’t re-use time. So, in summary, we have

and moreover we know that at least one of the containments is strict, but we don’t know which! Most theoreticians believe that every one of them is strict.

The interesting about NP and co-NP is that intuitively they should be different, but we really don’t know for sure. The complement of SAT, the language of unsatisfiable boolean formulas, is co-NP-complete. We don’t know if it’s in NP. While it’s easy to verify that a formula is satisfiable by exhibiting a satisfying assignment, there seems to be no easy way of verifying that a formula is not satisfiable. A problem that is in both NP and co-NP is PRIMES, the language of all prime numbers. It’s in co-NP because it’s easy to verify that a number is not prime by simply exhibiting a proper divisor.

I hear most theoreticians believe that P is not equal to NP. But what if P = NP? What would happen? Well, for one, it would mean it takes barely any more time to find a solution than it does to check one. We would be able to automate many processes so far believed to be difficult. Pretty much every cryptography system would fall apart since it would not take much longer to crack a key than it would to create it. A lot of good would come along with some bad. But this speculation is most likely pointless. Although the relationship hasn’t been proven, intuitively it seems clear that the two sets should not be equal, the same way the Jordan curve theorem was intuitively clear but was not proven until the early 1900s.

This post is already running much longer than I planned, so I’m going to save discussion of the interesting-ness of PSPACE for a follow-up post. I find PSPACE particularly interesting because it naturally captures the difficulty of many two-player games.

As always, leave a comment if you have questions or if you catch a mistake. Or if you disagree with me about P vs. NP.

-Alan

Let . The problem statement implicitly assumes is finite, but this is not difficult to show, especially when you’re wielding the rocket launcher that is commutative algebra. Notice that is a affine semigroup, which just means that it’s isomorphic to a finitely generated subsemigroup of for some . The saturation  of an affine semigroup is what you get when you take the group generated by intersected with the nonnegative cone generates. In symbols, . The difference between an affine semigroup and its saturation is that the saturation “fills in the gaps” of the original affine semigroup so that it looks like it came from an actual group. In our case, . A basic result (Exercise 7.15 from Combinatorial Commutative Algebra by Miller-Sturmfels) says that any affine semigroup contains a translate of its saturation.  Well, that means contains a translate of , so there’s some number after which every number is in .

The generating function for is a polynomial, and furthermore it is minus the Hilbert series for , since the monomials in are precisely the ones whose exponents are in . So now if we could find a nice form for , then we’d be done.

We can view as a module over where and . Then we have an exact sequence

where the second map from the left is inclusion and the third map is , which is a surjection, so it suffices to show that we have exactness in the middle. Let and let . Now, it is straightforward to see that . On the other hand, since which is not a field, we know that is not a maximal ideal, hence , where here is the Krull dimension. We know that and the ideal is prime and , so . But the containment implies that , so we have , hence . To show that , we just need to show that is prime, but this follows from the fact that .

Now, note that the Hilbert series for is just since , so by rank-nullity,

.

We have

hence

where is a polynomial since is. Now, the final answer to our problem is . But

so

Since the degrees of both sides must be equal, we have , whence . So our answer is . Yay! And we solved it using purely algebra!

One can ask a similar question for higher dimensions. For example, the answer to the Frobenius problem also answers the question “Where does the translate of the saturation of start?” (after adding 1). There’s probably some similar question you can ask about higher dimensions, although now it’s not as clear what the “minimal” place where the saturation starts should be. I think it would make the most sense if an answer to such a question would take the form of a set of “generators”, where everything in the ideal generated by the “generators” is in the saturation. Anyway, if anyone knows the answer already, please let me know! I think the answer might lie in a paper of Maclagan and Smith titled Multigraded Castelnuovo-Mumford Regularity, but since I don’t even understand Castelnuovo-Mumford regularity in one variable, I have little hope of comprehending that paper.

Like always, if you catch any mistakes or have questions, leave a comment!

-Alan

To understand undecidability, you first have to know what a Turing machine is. A Turing machine is just a theoretical model of a computer, with a work tape, a tape head which points to a cell on the tape, and a set of states. These three things determine a configuration of the TM. In addition, the TM comes with a transition function which dictates how the TM changes its configuration. Lastly, one of its states is designated the initial state, which is the state that the TM starts in every time it runs on an input, and some of its states are designated accept states, while others are designated reject states. A precise definition of a Turing machine can be found in any textbook on theory of computation, but it’s not terribly important for our goal here. The thing to take away is that a TM is given an input (written on its tape), then its transition function dictates what it does (like an algorithm), and if the TM lands on an accept state, then it accepts the input, and if it lands on a reject state, then it rejects the input. Note that it is also possible for infinite loops to occur for certain inputs, in which case the TM is considered to not accept or reject.

I didn’t mention what kind of inputs are allowed for Turing machines. It can be any finite alphabet , but I like to think of the allowed alphabet as since that’s what we use in modern electronic computers, and two letters is enough to do everything you want to do, so from now on we’ll assume Turing machines take binary string inputs. A language is a set (possibly infinite) of binary strings. The language recognized by a Turing machine is the set of strings that it accepts. So, when we talk about “problems”, such as the primality problem (given an positive integer, determine if it’s prime) or the SAT problem (given a boolean formula, determine if it’s satisfiable), we are really talking about languages. For example, we can view the primality problem as the set of binary strings which represent prime numbers. Then the question of whether there exists an algorithm for deciding primality is actually whether there exists a Turing machine which decides the corresponding language.

I just used the term “decide” but I haven’t defined it yet. Whereas a machine recognizes a language if it accepts precisely those strings in it, a machine decides a language if it recognizes the language and halts on every input. The cool thing is that there are problems that are recognizable but not decidable, and showing that is the main goal of my post.

Consider the language

where just means a binary string encoding concatenated with the binary string , with a delimiter in between so the Turing machine knows where the encoding of ends. In other words, the problem is to determine if a given Turing machine accepts a given binary string . This problem is recognizable. You can design a Turing machine , called the “universal Turing machine”, which can simulate any other Turing machine. Then, given input , just simulate on and accept if accepts and reject if rejects . Clearly our machine will accept if and only if accepts , so it recognizes . It doesn’t decide , however, since if goes into an infinite loop on , then so does our machine, but we want our machine to reject when this happens.

To show that is undecidable, we prove it by contradiction. Suppose we had a machine which decides . Note that every Turing machine has some encoding as a finite length binary string, so we can enumerate them as and construct the following table:

where the entry in row , column is a if accepts and is a if not. I just made up the numbers for concreteness. We can construct this table since we have (to determine the value of an entry, just run on . Now, consider the Turing machine which, given input , does the opposite of what does on input (if the input happens to not be a proper encoding of any Turing machine, then it’s irrelevant what does). That is, accepts if the entry corresponding to in our table is a , and rejects if the corresponding entry is a . Now, ask yourself: which is ? For each , our machine differs from on the input , so it can’t be any of these. But we’ve enumerated all the Turing machines, so we have a contradiction! Therefore, is not decidable.

That ends the proof. I hope you found this as cool as I did when I first saw it. Anyway, feel free to leave comments if you have any questions about the proof, or corrections to it if I made a mistake.

-Alan

P.S. It’s also straightforward to see that there are languages that aren’t even Turing-recognizable, since there are countably many Turing machines but uncountably many languages.

My underdeveloped academic homepage can be found here.

In my spare time, I devoutly follow hedonism by enjoying food, music, movies and video games.

Given a standard Young tableau T, we can define the JDT path on T, as follows: starting from the (1, 1) entry of T (which happens always to be filled with the number 1), move to the smaller of the entry directly below (1, 1) and the entry directly to the right of (1, 1). (Here we work in English notation.) Then repeat this process: always move down or to the right, to whichever box has the smaller entry, until you reach the boundary of the shape.

It’s possible to ask a variety of probabilistic questions related to this path, but I’m going to narrow in very quickly on the particular case of interest: given the shape p, we can choose a tableau T of shape p at random. We may then ask which boxes of p lie on the JDT path of T. For example, with the shape , it’s easy to show (e.g., by exhaustive enumeration; there are 768 tableaux of this shape) that it is equally likely that the (1, 3), (2, 2) and (3, 1) entries lie on the JDT path of a random tableau of shape p. (Incidentally, the fact that these three cells are equally likely is just a convenient freak coincidence for this shape.) However, after running 75,000 trials on Mathematica, I find that the command RandomTableau[{4,3,2,1}] generates a tableau in which the JDT path contains (2, 2) about 31.5% of the time. For reference, the probability of a given side coming up only 31.5% of the time when flipping a fair three-sided coin 10,000 times is only about 0.00005, and this happened 7 times in a row.

After that (fairly conclusive) experiment, I also tried keeping track of which tableaux are most favored and which are least favored by Mathematica. Running through about 150,000 random tableaux suggests that tableaux that look like

1 5 8 10
2 6 9
3 7
4

are favored (appearing roughly 50% more often than expected) while those like

1 3 5 10
2 4 8
6 9
7

are disfavored (appearing roughly 30% less often than expected).

I submitted a short description of the problem to the Mathematica support desk in February, got an e-mail back saying they’d look into it and let me know if they wanted to hear more, and haven’t heard anything since.

For those who are curious, the equivalent command in Sage works like a charm.