 We're going to talk about descriptive complexity and polynomial time. And this will be, this is essentially a talk over 2 and 1 half hours an hour today and 90 minutes tomorrow, in which I'm going to explore the question and the question naturally arising. I will say a bit more about it. I have slides to show you of giving a descriptive characterization to polynomial time in the same way that Fagan's theorem gives a characterization for NP. Raman Rajam gave us a really excellent introduction to the topic this morning. And what I'll do in the first 15 minutes or so now is a quick recap of what he said. And then I'll go on and talk more specifically about some results about polynomial time. I think what I'll get to talk about in today's talk is really, shall we say, old stuff. And then hopefully in tomorrow's talk, I'll leave you up to more recent work on the subject. So we're talking about descriptive complexity. And the way I look at it is descriptive complexity provides an alternative way of looking at computational complexity. Classically, we think of computational complexity. We talk about complexity is about measuring the use of resources, such as space, time, et cetera, and some machine model of computation. And we typically define it as complexity of a language. That is a set of strings. That's our classical notion of a decision problem. While in descriptive complexity, we depart on these two fronts. So instead of talking about some machine model of computation and the resources, we talk about measuring the complexity in some sort of formal logic. So our resources, instead of being space and time, instead of a machine model, we have some logical model. And our resources are things like quantified variables, higher order operators. And those are the different kinds of resources. And we want to measure essentially how much of these you need to express a problem. And secondly, instead of talking about strings, we'll be talking directly about classes of structures. So this is in some sense a very natural step when we talk about the complexity of deciding whether a graph is a Hamiltonian. Graph, we really mean, we want to think of the input as a graph, rather than a string encoding a graph. And the fact of encoding the structure as a string, which we have to do in computational complexity, does introduce a slight mismatch, which is going to be the focus of some of what I'm going to say. So of course, what's interesting is that these two different views of complexity are linked, but there are also differences. And shall we say, the interesting work is all in the tension between them. OK. So with that, I mean, we've had an excellent introduction this morning. So this is going to be a very quick skim through the background. For first order logic, let's talk about what is the computational complexity of the problem given a structure A, deciding if A satisfies a sentence phi. In other words, how complex is the collection of finite models of phi? Now, I should say something about finite model, because the title of this workshop is Finite and Algorithmic Model Theory. If you fix phi, and I say give the structure A, and I want to decide whether A is a model of phi, phi has to be presented in some particular way. And Ramon Ujum talked a lot about encoding it as a string. Of course, that assumes that the structure is finite. There are infinite structures which have finite descriptions. And there is, of course, in some sense, when one talks about algorithmic model theory, beyond finite model theory, that's the sort of thing what one's interested in is doing this for structures where A is not necessarily finite, but has a finite description, and then the input is that description. But that's a completely different problem. That's not going to occur in my talk. I'm assuming that the structure A is finite and given by some encoding, like in Ramon Ujum's talk. In fact, I'll make the encoding explicit. Here's an encoding. And we may as well sort of fix it once and for all. So say we have a structure A, which consists of a universe A, relations r1 to rm and functions f1 to fl. Now each relation, once I fix a linear order, and like we saw this morning, you need to fix a linear order in order to talk about encoding the structure as a string, fix a linear order on the universe A, then any relation of arity k can be expressed as a bit string of length n to the k. It's because the ordering induces a lexicographical ordering of k tuples. And now for each k tuple, there's one bit of information of whether it's in this relation or not. Any function of arity k can be encoded by a bit string of length n to the k times log n. Again, for every k tuple, you need to specify what it takes the k tuple to. And that's log n bits of information for every k tuple. So I enter the k times log n. And all of this, of course, is dependent on fixing the order. So I will write it this way. This notation means the encoding of the structure A under the ordering given by this last term. So the string that encodes the structure A under this particular ordering. And of course, note that the exact string obtained depends upon the choice of order. Different choices of order on the same universe will give you different strings encoding the same structure. But the fact, of course, is that if you look at the set of strings, which encode models of a particular first order sentence, in other words, the decision problem, we started with now expressed as a set of strings. It has this natural invariance property that if two strings are really encodings of the same structure, then they're both in this language or both out. Because whether A satisfies phi is the property of the structure A. It doesn't depend upon which order you put. It doesn't depend upon the encoding. So this set of strings has this invariance property. It's invariant under this equivalence relation, which I define, which says two strings are equivalent if they are representations of the same structure under different orderings. In other words, that there are some structure A and two orders less than 1 and less than 2, such that w1 is the encoding of A under less than 1 and w2 is the encoding of A under less than 2. And so this equivalence relation, so the languages we are interested in, whose complexity we're going to be talking about, are all invariant under this equivalence relation. This equivalence relation is itself. You can ask, what's the complexity of deciding this equivalence? And this really is the structure isomorphism problem. Two strings are equivalent if they represent isomorphic structures. And in particular, this is, of course, equivalent to the graph isomorphism problem, whose complexity is in the subject of much study. It's not known to be in polynomial time. It's in NP, but not believed to be NP complete. It's one of these intermediate problems, whose status is really not fixed. OK. Now, having fixed the idea of an encoding, we can ask what is the complexity, as I said. So we're now asking about the complexity of the set of strings, such that A satisfies phi, and this is some order on A. The complexity of this is, as Robinogen pointed out, it's logarithmic space, polynomial time, if you fix phi. So for fixed phi, because to be precise, it's in time L times n to the m, where L and m are really parameters, which depend only on the formula. And n is the size of the structure. And m log n space. So if L and m are constants, in other words, the formula is fixed, this is polynomial time and logarithmic space. Otherwise, it's exponential time and polynomial space, if we consider L and m to be part of the input. In other words, we're looking at the problem where both structure and formula are given as part of the input. OK. Now, it was also pointed out that there are computationally fairly easy problems. As Robinogen put it, the converse miserably fails. There are computationally easy problems in logarithmic space, which are not first-order definable. And these are two examples, in particular he mentioned. So there's no way of defining in first-order logic, no way of saying that the number of elements in the structure A is even. OK. And the proof is a straightforward application of the Ehrenpoise-Frasay games that Abhishek presented this morning. Similarly, there's no formula, say, with two free variables x and y, which says of a binary relation E, which defines the transitive closure of the binary relation E. That's also that essentially follows from the game that Abhishek showed us this morning. And both of these are log-space properties. I mean, the evenness is kind of trivially, so it's constant space. You need one bit of space to decide whether the thing is even. The second one is log-space by a highly non-trivial result due to wrangled. OK. But these are both log-space properties, which we can prove are not first-order definable. So we move on to, say, second-order logic. And that is we allow ourselves relational quantifiers. So we allow ourselves to say things like there exists x phi, where x is now a relation symbol. And this leads to Fagan's theorem, which Ramanujan presented this morning, which tells us that if we allow just existential second-order quantifiers, so existential second-order quantifiers in front of a first-order prefix, that gives us exactly the complexity class NP. And what this means is a class of finite structures is definable by a sentence of existential second-order logic. If and only if it's decidable, and when we say it is decidable, we mean precisely that the set of strings encoding it, encoding the structures in this class, is decidable by a non-deterministic polynomial time machine. That's the sense in which, yeah, so it captures NP. And we saw more detailed proof. But roughly in one direction, if you start with an existential second-order sentence, we know a non-deterministic machine can simply guess an interpretation for each of the relation symbols, which simply means write out the string in non-deterministic fashion, which represent these interpretations for these symbol p1 to pm, and then verify whether the formula phi is true. And because we've said that for any fixed formula phi, it's polynomial time, the whole thing is non-deterministic polynomial time. And in the other direction, as we saw, you start with a machine m and a polynomial bound on its running time, so say an integer k says that the running time is bounded by n to the k. And then we write down an existential second-order sentence phi, so it's that structure satisfies phi if and only if m accepts the encoding of this structure for some ordering of it in n to the k steps. Now, I just want to stress one little point here. We start with any machine m. And in particular, I'm not assuming that the language accepted by m is invariant under my equivalence relation, remember? My equivalence relation, which says that two strings code encoding is of the same structure. I'm not assuming the string that m is invariant under this. So what do I mean by the class of structures accepted by this machine m when it may accept the encoding of one structure and reject that of another? I mean precisely what it says that. I basically take the set of strings accepted by this machine m and close it under this equivalence relation. I take the set of those strings, which are equivalent to some string accepted by m. And that's the class that this formula defines, this construction, which Armand Rijm presented, OK? Right. And that's basically achieved by the first quantifier, which says there is an order. So given a structure, I say, if there is some ordering of it, which leads to an accepting computation, then that structure is accepted by my sentence. Right. Now, Fagan's theorem leads sort of naturally to the question, which was first sort of pulsed by Chandran Haral in a paper back in 1982, which has, so for now nearly 30 years, been the main open question in the field of descriptive complexity is whether we can do a similar characterization for polynomial time. Ramand Rijm gave you two characterizations, one in terms of second order horn logic, and one in terms of fixed point logic, at least fixed points. But they were specifically on ordered structures. And the question is, is it possible to characterize polynomial time without making that restriction to ordered structures? OK. Because the restriction to ordered structures is to make this equivalence relation trivial. If these structures come with an order, then they have a natural encoding as a string. And they're really, in some sense, strings in disguise. And the difficulties that arise from having to deal with this go away. OK. So what does it mean to give a logic? I mean, I said they pose this question. It's a natural question. I think if we had a positive answer, if I demonstrated a logic, we might all be able to agree that this is an answer. What would a negative answer amount to? Well, that was proposed by Gurevich in a paper in 1988, in which he gave a precise mathematical conjecture. Which he actually conjectured that there was no logic and gave a precise mathematical statement of what that would mean. OK. He conjectured that there's no logic for polynomial time. In particular, he says, let's be very generous of what it means to be a logic. Any recursively innumerable set of sentences. As long as there's a computable translation which will take any sentence and give you a polynomially clocked Turing machine which accepts a class of structures. And what do I mean by accepts a class of structures? Exactly that it's invariant under this equivalence relation. And of course, you have to get every polynomial time property of structures should be obtainable through this translation. Let's make this a bit more precise. OK. As I've already said, for a given structure A with n elements, there are as many as, say, n factorial different strings which encode the structure. I say as many as n factorial, if you think about it, if the structure has no automorphisms, then there are actually n factorial different strings. Because every ordering will give you a different string. The four, in general, the number of different strings encoding the structure will be n factorial divided by the automorphism group, besides the automorphism group of the structure. OK. So now, so what am I saying here? We can enumerate, take deterministic Turing machines, a deterministic Turing machine and a polynomial. Consider the pairs like this. And I think of this as a clocked machine. In other words, given an input, I run this machine counting the number of steps until I reach this polynomial of the size of the input. And at that point, I cut it off, rejecting if the machine has not accepted so far. So this gives me a polynomial time machine, guaranteed running time. And obviously, so I enumerate all such pairs of Turing machine and polynomials. And clearly, this enumeration includes all polynomial time languages. It includes a recognizer for every polynomial time language. Many of these will not be invariant under my equivalence relation. What I want to know is, can I enumerate some subsequence of those which are invariant and include up to equivalence every polynomial time language which is invariant? That's what it would mean to have a recursive enumeration of the polynomial time properties. And that's equivalent to Gurevich's question of, is there a logic for P? And his conjecture is that this is impossible. This is actually his formulation. What I've given you is an equivalent one. We say that class polynomial time is recursively indexable. If there are some recursive set, i, and a machine m, think of i as the logic for P time and m as the compiler for this language. So what does m do? On any input i, m produces the code for a machine mi and a polynomial pi. And mi, running, I should say, within time bounds pi, accepts the class of structures in P time. Actually, the second point is really not necessary if we have the polynomial pi explicitly. And then for each class of structure, seeing any polynomial time class of structures, there are some i's such that mi accepts c. OK. So this is, as I said, Gurevich's conjecture is that P time is not recursively indexable. It's a strong conjecture. In particular, it implies that P is different from NP. I mean, sometimes people say, if there's no logic for P, then P is different from NP, simply because there is a logic for NP. But it's actually not the slight subtlety to the argument. Because the fact that there's a logic for NP simply gives you a translation to NP machines. And it's, at first, conceivable that there is a logic for NP, and P is equal to NP, but there's no computable translation from the NP machines to equivalent polynomial time ones, and therefore no logic for P. But it's easy to rule out that possibility. And here's one way to do it. Say that a machine m canonically labels graphs. Now I'm talking about graphs. You could do this for general relational structures. I'll often switch back and forth. In general, my example of a relational structure will be graphs. I'll consider structures with one binary relation only. So a machine m canonically labels graphs. If whenever you give it an input, which is a representation, a string representing a graph, the output is a string representing the same graph, but possibly a different one under a reordering. And if you give it two different encodings of the same graph, the outputs are identical as strings. In other words, this machine picks a canonical element from each equivalence graph of my equivalence relation. And given an input, it produces an output. Now if you can do this in polynomial time, then there's a logic for P in the sense we described before. That is, why is that? Well, the point is you take the enumeration of all polynomially clocked machines we had before. And you now just replace these machines, the machine MI PI, by what I call MMI PI. Sorry, I should really write this this way. In other words, you first, on an input string, you first produce a canonical representative and then run this. What class of strings is accepted by this? It's exactly the closure of the language accepted by this machine under this equivalence relation. No, that's not quite right. It's the class of strings. Well, the point is that the language accepted by this is definitely invariant under this equivalence relation because if you give it two equivalent strings, you get identical strings here. And they're both accepted or rejected. And the class of strings is basically the ones whose canonical representatives are accepted by this machine. And for any polynomial time property now, if this M runs in polynomial time, this whole thing runs in polynomial time, and for any polynomial time property of graphs, there is some such machine that will do it. And that gives us a recursive indexing of P. So if canonical labeling can be done in polynomial time, we have a logic for P. On the other hand, we know that canonical labeling is certainly in the polynomial hierarchy. It can be shown to be delta P2, so second level of the polynomial hierarchy. So the argument goes, if there's no logic for P, that means that canonical labeling cannot be done in polynomial time. That means delta P2 is different from P, which implies P is different from MP. So that's the bottom line there. If there's no logic for P, then P is different from MP. OK. Now, I'm going to talk a little bit about inferst order logic. When Ramanujan was talking about encodings, just the general properties of what is an encoding, Supratik asked this question of, what does it mean for it to be first order definable? And I'm going to sort of pin that down a bit more precisely because I want to use that idea in a slightly more general context. So say we have two relational vocabularies, sigma and tau. I say by relational here, I mean they have no functions in moves. You can do this with functions, it will just get messier. But let's keep it clean. So tau, for instance, consists of the relations R1 to R, little R. And the arity of each R i is n i. Then a first order interpretation of the vocabulary tau in sigma is as follows. It's a sequence of first order formulas, OK? One which we'll call pi u. And then there's one for every relation symbol in tau. And these formulas are sigma formulas, OK? The free variables of pi u are among x1 to xk for some k. And the free variables of pi i are x1 to xk times n i, so k times the arity of the relation R i. So think of the way to think about this is this is intended to define a map from sigma structure to tau structures. The idea is we think of first order logic as, so far we've been thinking of it as representing decision problems on structures. Now I want to think of it as defining functions from structures to structures. So how do we talk about such a function being first order definable? Essentially, there is a single tuple of first order formulas, which if you interpret it in the structure A will give you the structure B. And what does it mean to interpret it in A? Well, pi u is going to define some set of k tuples in A, and that's going to be the universe of B. And pi 1 will define a relation of arity n1 on those k tuples. And that's going to be my interpretation for R1 in B, et cetera, et cetera. So these basically define the relations in B, OK? So we call k the width of the interpretation. And so this is what it says. An interpretation of tau and sigma, an interpretation of the capillary tau and sigma, defines a map from sigma structures to tau structures. This is pretty much what I just said, OK? And having this now allows us to define the notion of a first order reduction from a class of structures, C to a class of structures D, OK? So C1 is a class of structures of a sigma. C2 a class of structures of a tau. We say that pi, which is an interpretation of tau and sigma, is a first order reduction of C1 to C2, if and only if. It maps structures in C1, the structures in C2, and structures which are not in C1, the structures which are not in C2, OK? It's just the usual notion of a reduction, but now it's a reduction that's first order definable, OK? If such a pi exists, we say C1 is first order reducible to C2. So think of it this way. We, I mean, in complexity theory, of course, you'll often look for very weak reductions. And you know when two problems are reducible to each other, let's say under very weak reductions, they're pretty much almost equivalent. Well, first order logic is very weak in terms of its expressive power. We've seen this. It's certainly in sublog space and miserably so to you to borrow a homologous phrase. Well, these are pretty miserable reductions, then, right? These are miserably weak reductions. But still, it turns out that there are problems which are NP-complete. Sorry? Miserly reductions, OK? There it turns out that there are problems which are NP-complete under these reductions. But it's not straightforward, not every problem you think is NP-complete turns out to be. The first reference that I know that proves an NP-completeness reduction under this kind of reduction appears in a paper by Lovash and Gatch back in 1977 who showed that satisfiability in a certain encoding. I mean, now, what do I mean by satisfiability? What's the class of structures? Well, they basically define, I think I can tell you, it's general CNF SAT where you have a set of clauses, a set of variables, and two binary relations, P and N. P, which tells you this variable appears positively in this clause. And N, which tells you the variable appears negatively in a clause. You're given this structure, and you're asked, does this represent a satisfiable set of clauses. And they prove this problem is NP-complete under first order reductions. It's an open question whether 3SAT is NP-complete under first order reductions in any reasonable encoding. As far as I know, it's never been shown. Dahlhaus in a paper in 1984 showed that Hamiltonicity and CLEIC suitably defined. I mean, Hamiltonicity just is naturally defined as a class of graphs. CLEIC, you need to encode a number as well as a graph. So he gives a way of doing that. These turn out to be NP-complete under first order reductions. But for instance, three-colorability is not. It's NP-complete under log space reductions, you know. But in a paper I had with Eric Gradle back in 95, we showed not just this. We showed that the class of problems reducible to three-colorability obey what's called a 0-1 law. So it certainly doesn't include all of NP. And we'll hear more about 0-1 laws in Ben Rossman's talk tomorrow. So what I'm saying is that the landscape of NP-complete problems is interesting. What about P-completeness? Can we come up with a problem? I mean, first order reductions are very weak. It's a natural thing to ask. Is there a problem that's complete for P-time with respect to first order reductions? Well, suppose we had such a problem, Q. What I would say is now I could write down, I would introduce, for each K, a new quantifier symbol, Q to the K. And let's define a logic in a very loose sense where I could write down sentences like QK and apply it to a couple of formulas, pi U, pi 1, up to pi S, where pi 1 to pi S, these form an interpretation into the vocabulary of Q. So I'm assuming Q, vocabulary of Q, is R1 to RS. And so that pi 1 to pi S is an interpretation into Q. And I interpret that sentence to mean, it's true in a structure. If when you apply that interpretation pi to that structure, the resulting structure is in Q. That's my interpretation. Then the collection of such sentences is a logic for P. Because if the problem is P-complete, then everything in P is reducible to it. So everything is represented by such a sentence. And then it's not difficult to show that from the sentences, you can go to Turing machines. You just need, because the reduction itself is first order, so has a natural translation into a polynomial-time machine. And we have a polynomial-time decider for Q. Together, they give us a polynomial-time machine for the thing that reduces to Q. So if we had a complete problem in P under first order reductions, we would have a logic for P settling this problem. And it turns out that the converse is true. If there is a logic for P, we can actually construct a complete problem under first order reductions. This is actually just an instance of a fairly general phenomenon in complexity theory, where if you have a recursive enumeration of some complexity clause, you can construct a complete problem for it. I'm not going to go into the details of the proof. I'll just give you a proof idea. You're given a recursive indexing of polynomial-time. Then essentially, you encode the natural, if you will, the halting problem. So we want to encode the problem as the following problem as a class of finite structures. It's a set of pairs ix, so that mi accepts the input x in time bounded by the polynomial pi of the length of x. Now, it's clear that everything reduces to this. But the way I've written it is not polynomial time, because, well, obviously, your recursive indexing will include polynomials of arbitrary high degree. And therefore, this problem is not going to be polynomial time. So you actually need to pad this. So when you put ix, you need to pad the input by something of length pix at the same time to force the whole problem to be in linear time. But still, you have enough room to reduce anything to it. And what's interesting is you can do the whole thing as a class of finite structures if the reductions are first order reductions. You can do it as a class of finite structures, which is invariant. I mean, it doesn't depend upon any ordering. I mean, even though you are encoding numbers such as i and there, it turns out you don't need any ordering if the reductions are all hutch. Yes. OK, as I said, I'm not going to go into much more detail than that. But I just want to let you know that we have this converse, which basically leads us to this thing that this open question, is there logic for p time, has several different formulations. I've given you one in terms of recursive indexability of the class. That's equivalent. If it's recursively indexable, then there's a logic capture in p, which is of the form an extension of first order logic with a collection of quantifiers, which are all vectorizations of the same problem. It's a fairly uniform, in fact, natural logic. Well, how natural it is will depend upon how natural this complete problem is. And it's equivalent to there's a complete problem in p under first order reductions. These turn out to be all equivalent statements. And one way of looking at this is as a dichotomy, and I'm sort of grateful to Martin Goehr for pointing this out, he says, what this says is that this question, either there's a logic for p or there's no logic for p. If there is one, there's a complete problem under first order reductions, which really means that everything in p is up to first order reductions, which are very weak, reducible to one particular problem. So everything in p can be obtained as a slight variation of one particular problem in p. Conversely, if there's no recursive indexing, that means really there's no way of reasonably classifying the problems in p, not even recursively, giving a classification of all the polynomial time properties of finite structure. So it's a very sharp dichotomy. Either there's a very neat classification with one complete problem and everything being first order variation of it, or there's really no reasonable classification at all. And so the open question is, is there a logic for p is really deciding which of these two is the case? Right. Now we heard from Dr. Amaraj, I'm right at the end of his talk of how fixed point logic is captures polynomial time on ordered structures. And I want to say a little bit more about that, but I'm going to introduce a slightly different variation by talking about inflationary fixed points rather than least fixed points of monotone operators. This is simply because in tomorrow's talk, I'll be looking at extensions of this and extending this logic further by adding counting operators and other operators. And it turns out that defining it as in terms of inflationary fixed points gives us a somewhat more robust definition. You don't have to worry about monotonicity and so on. But so let me tell you what inflationary fixed points are. So say we have a formula in the vocabulary sigma along with the relation symbol R as we had before. And this defines an operator just the way Jam defined it, which takes in a structure A, the operator capital phi takes a relation in the structure A and defines a new relation, which is a set of tuples, which satisfy phi when the symbol R is interpreted by this relation. Now I'm not going to assume this operator is monotone. Instead, I'm just going to take the sequence of relations you get by starting with the empty relation and then iterating the application of this operation. But at each point, taking what it defines and adding it to what we had before. So phi 0 is the empty relation. And phi m plus 1 is the union of phi m with the result of applying phi to phi m. The fact that we take the union forces the sequence to be non-decreasing, which means it must stabilize. I won't call it a fixed point because it's not a fixed point of phi. But it's stabilized in a number of steps, which is at most n to the k, where k is the arity. It is k, right? So k is the arity of the relation. So in at most n to the k steps, it must stabilize because you're starting with 0. There are at most n to the k tuples. And at each stage, you're either adding something or if you're not adding anything more, then you've stabilized. That limit to which it's stabilized we call the inflationary fixed point of phi. As I said, there's a bit of a misnomer because it's not actually a fixed point of phi, necessarily, right? OK. And we now define the logic IFP by taking first order logic and closing it under an operator, which allows us to form inflationary fixed points, right? So if phi is a formula of a capillary sigma with r, then this is the notation I'll use. Let me, IFP r, let me see, OK? So what does this mean? Well, this is an operator which, in this formula, binds the relation symbol r and the first order variable x bar. And this whole thing defines a relation. It's the relation which is, when interpreted in a structure A, it's the relation which is the inflationary fixed point of the operator defined by phi. And this formula basically says that the interpretation of these terms t is in that relation, OK? So the formula, as I said, is read as the tuple t is in the inflationary fixed point of the operator defined by phi, OK? And LFT, as was mentioned, is similar. If instead of inflationary fixed point, we take least fixed points of monotone operators to ensure monotonicity, we restrict phi to formulas in which r appears only positively. And so on. In terms of expressive power, LFT and IFP are the same. This was proved specifically in relation to finite structures in paper by Guravij and Shilabak in 1986. And then Stefan Koetser showed that even without the restriction to finiteness, they turn out to have the same expressive power, OK? If you take arbitrary structures. OK, so that's IFP. Now, IFP properly extends first order logic. That's clear by this example, which shows how to use the inflationary fixed point operator to define the transitive closure of the relation E, OK? So that formula, OK, what I've written there is actually defining the reflexive transitive closure of E, OK? So this is a formula in a vocabulary with just 1 by the relation E. The relation symbol t is a bound variable. It's bound by the IFP operator, OK? So we take to write this formula inside out. If you take x equals y, or, right, that's the formula of which we take the fixed point, binding the variables t and x and y, right? So this is a formula which defined the binary relation with three variables x and y. Given any interpretation of t, we start with t being empty. So that is just false. So it defines all the pairs for which this is true. Then t is interpreted as a set of pairs for which that is true. And then you see it defines a set of pairs for which there's a path of length 1. And then you interpret t by that relation. And this will define the set of pairs which have a path of length at most 2, et cetera, et cetera. The fixed point is a set of all pairs for which there is a path. And then we apply this to a pair of free variables u and v to say that u and v are in the transitive closure. So this is now a formula with two free variables u and v. And this proves that IFP properly extends the power of first-order logic because we know that we can't do this in first-order logic. We know we can't do connectivity. And connectivity, of course, now just is easy from this. If I say for every pair is in the transitive closure, in the reflexive transitive closure of the edge relation, this just says that a graph is connected. OK. And the theorem of Emmerman and Vardy says that when structures come equipped with a linear order, then IFP expresses exactly the properties that are in p-time. Again, one direction is simply observing. You have first-order logic. That keeps you in p-time. And you observe that as long as this property is in p-time, then the fixed point can be computed in polynomial time. And that's simply because you're iterating a polynomial-time computation a polynomial number of times because the number of iterations needed to reach a limit is at most n to the k. The other direction, well, you look at the proof of Fagan's theorem where you start with a machine and construct a formula. This is my slide of Fagan's theorem. And note that if the machine is deterministic, then rather than quantifying the symbol's state, head, and tape, and so on, you can build them up inductively. They have inductive definitions when the machine is deterministic. The first quantifier there is an order you can't get rid of. You can't inductively create an order. Well, that's why in the Emmerman and Vardy theorem we just assume that the structures are ordered because we can't get rid of that. OK. I've already told you about canonical representations. And the idea that you can't inductively build up an order is related to the fact that we don't know whether in polynomial time you can come up with a canonical string representation of a structure. But we can say more. If you don't require, let me take that middle remark, suppose I take the set of all formulas of IFP which have an ordering symbol but are invariant under the choice of the order. That means in any structure A, if I take a structure A and two different orderings of it, they'll either both satisfy this or neither will. These are the order invariant sentences of IFP. These define the class of polynomial time properties in some sense. But, and this is what Jamal alluded to at the end of his talk, this is not a recursively innumerable set. You can show not only is it undecidable whether a formula is an order invariant, it's actually not recursively innumerable. It's not even semi-decidable, in other words. So this doesn't give us a logic for P. We can ask, well, is there some subset which is recursively innumerable, but which up to equivalents includes them all, right, up to logical equivalents? And that is just another formulation of the question, is there a logic for P? It's just equivalent to that same question. Well, here's a particular subset of the formulas which are order invariant, namely those that don't mention the order at all. That's just plain old IFP without order. But this we know is too weak. This we know doesn't express all of P. In particular, we can prove that evenness is not definable in IFP, right? So recall that my two examples of first order properties, sorry, log space properties that were not first order definable were reachability and evenness. Reachability we've sort of solved by throwing in these fixed points. But evenness remains. And it turns out you still can't define it, even with fixed points. And now I'll sort of run you through an argument Y. And the argument takes us into looking at finite variable logics, which is a thing that will reoccur, I think, in some of the other talks. OK. So what's finite variable logics? Again, I keep alluding to Romano-Gem's excellent introduction. He referred to the width of a formula as the maximum number of free variables appearing in any sub-formula, OK? Now, if you have a formula of width k in that sense, you can rename the bound variables so that the total number of variables used are just x1 to xk, right? Because variables that don't occur together free in some sub-formula, you can always use the same name for them just by renaming. So I write lk for those formulas, which contain only the variables x1 to xk, possibly reused. This is exactly the same as the first-order formulas of width k, width at most k. And we say that just to avoid confusion or possibly to create it, I don't know, Abhishek used the notation a is n equivalent b, equivalent subscript n, to say that a and b are equivalent in first-order logic with first-order formulas with quantifier rank at most n. I'm going to use this notation a with equivalence with a superscript k to say that a and b cannot be distinguished in first-order logic with at most k variables, which is not the same thing, OK? Certainly anything with quantifier rank at most n can be rewritten to use at most k variables, but the converse is certainly not true, OK? More generally, rather than just structures, I will say structures and a tuple to mean that these two tuples, there's no formula which is true of this tuple, but false of this would use at most k variables, OK? Now, if I start with a formula with k variables and relations in belong, and I look at the sequence of relations which this formula defines in leading up to the inflationary fixed point, in other words, start with the empty relation. And at each stage, take phi m union phi applied to phi m, turns out that each of those relations for constant values of m, I can write down as a formula, first-order formula, in L2k, right? Remember, the fixed point, of course, would be the infinite disjunction of all of these. So that's not a first-order formula, generally. But cutting it off at any finite point, I get a formula, and the number of variables I need doesn't increase with m. That's the key point here, OK? 2 times k is enough. And the reason for this is, if you have the formula phi, what you're trying to do, to define phi m, what you want to do, sorry, let's say, no, that's right. To define phi m, you want to take phi or, let's put phi m plus 1 is equivalent, to phi m or, and now you want to take the formula phi, and as it were, replace the relation symbol r by the formula which defines phi m, OK? Now, you may have to rename some variables to avoid capture, and I'm not going to do this in detail. But the fact is that because we know in phi, no sub-formula contains more than k free variables, and you're replacing a sub-formula with some number, p of free variables, by another one, with some number, p of free variables, and which blow it again by inductive hypothesis, doesn't contain any more, contain no sub-formula with large numbers of free variables. You don't blow up the width of the formula overall, and there's a bit hand wavy, but I think one can, you know, you can do this, and the total number of variables can be bounded by 2 times k, OK? So the point of this is that this gives us a method for proving that something is not definable in IFP, because just as when Abhisekh talked about Aaron Poiseguin's, he said in order to prove that something is not definable in first order logic, essentially we need to prove that it's not invariant under this equivalence relation for any fixed value of n, right? For every possible n, we can find an a and a b which are distinguished by the property we're interested in, but not distinguished by this equivalence relation. That proves that the property is not first order definable. Well, we're going to use this for similar purposes to prove that evenness is not definable in IFP. We show that it's not invariant under this equivalence relation for any fixed value of k, OK? And the method for proving it is a similar game to the kinds of games he talked about, generally something called the capable game, essentially introduced in some form by bar wise, though there are different variations appeared more or less independently in papers by Poiseguin and Imman. The game is as follows. So we have two structures, a and b. And we have our old friend, Spoiler and Duplicator. And they play using k pairs of pebbles, a1, b1, up to ak, bk. At each move in the game, Spoiler picks up one of the pebbles and places it on an element of the corresponding structure. In other words, if it's an ai, he picks up. It'll be on an element of a. Or if it's a bi, he'll place it on an element of b. Duplicator responds by taking the matching pebble. In other words, the other one in the same pair and placing it on an element of the other structure. Now this is very much like the es game that Abhishek introduced. Except that we're not limiting the number of moves beforehand. We're limiting the total number of pairs of pebbles. The number of moves can exceed the number of pairs of pebbles, which means at some point, you have to remove pebbles from the board and replace them. This is exactly because we're talking about formulas where we can reuse variables, re-quantify the same variable over and over again. It's just that the maximum number you have available simultaneously is bounded by k. Again, at any stage of the game, if the map on pebble points is not a partial isomorphism, Spoiler has one. He has demonstrated the difference between the two structures. If Duplicator can survive for Q moves, has a strategy for surviving for Q moves, it follows that the two structures A and B agree on all sentences of Lk of quantifier rank at most Q. Now the number of variables and the number of, and the quantifier rank are independent parameters, Q can be much bigger than K. In particular, yeah. If for every Q, Duplicator has a winning strategy for the Q round capable game, then we say that they're K equivalent. And that is really equivalent to saying that Duplicator has a strategy for playing forever. That's equivalent because we're dealing with finite structures. And in finite structures, if for arbitrarily large Q you can play, then you have a game in which a move position repeats. And that means that really you can play forever, right? Okay, so now to show that evenness is not definable, we just have to show that there are structures, for every K we can find a pair of structures, one has an even number of elements and the other has an odd number of elements, so they can't be distinguished in this pebble game. But this is easy. Take A to be a structure with K elements and B to be a structure with K plus one. One of those numbers is even, the other one is odd, whatever K is. But Duplicator has a strategy. I mean, there are no relations on these structures at all other than equality. So Duplicator just has to preserve equality, but since they're only K pebbles to place on each side, spoiler can never demonstrate the difference. Okay, that's the proof that evenness is not definable. And okay, I'm out of time. So I wanted to say one remark because I, this is the last slide and then I have a summary. I talked about complete problems. Now forget about first order reductions. Obviously there are polynomial time problems which are P complete under weak reductions like log space reductions or AC zero reductions and a natural one, for instance, is alternating trans-declosure. This is P complete under AC zero reductions. It's definable in IFP, okay? So we can conclude from this that IFP is not closed under AC zero reductions, right? Because it expresses the P complete problem, but it doesn't express all of P, okay? We can also conclude that ATC is not P complete under first order reductions, right? As a candidate for a problem, I mean the problem of is there a logic for P is there a complete problem under first order reductions? This is not a non-starter as a candidate because it's definable in IFP, but IFP is closed under first order reductions. And so if this was P complete, IFP would express all of P and we've just shown it doesn't, okay? In fact, what it turns out to be true is that alternating trans-declosure is complete for IFP under FO reductions. So everything that's definable in IFP is first order reducible to alternating trans-declosure. Just in the presence of order, you can then show, so if the first order reductions can use an order, then it turns out that that means that all of P is reducible to ATC using first order reductions with order, okay? So now, I mean one way to think about this is, here we have our class P. We have ATC, which is a P complete problem, right? In terms of complexity, IFP is picking out a vertical slice of this complexity class and even that sits outside it, right? This is a slice which is closed under first order reductions, but not say under AC0 reduction. What's the important distinction between these two reductions? This is whether they're invariant under our crucial equivalence relation and whether they're order invariant, AC0 reductions are not. We want something that we want to restrict ourselves to reductions which are order invariant and we don't really care about the fact that FO is computationally weak. We can replace FO with IFP and say, is there a problem in P complete under IFP reductions? That's again equivalent to, is there a logic for P? Okay. Okay, and that's it. So this is just a summary. I think I'll not run over it. I'll leave it up there for you to read and stop, yeah.