 The second speaker is Mark Vinalz. He's a graded PhD from KTH, and then he was a postdoc TIFR, yep, and now he is at Technion, and he's an expert in proof complexity and lifting, and he has some really nice results both in lifting and especially applied to proof complexity, proving time-space trade-offs for proof systems and SAT solving, so it's my pleasure to introduce you. So thanks, Tony, and I'm basically going to talk about how lifting can be useful to proof complexity in this talk. So let's start by talking about proof complexity. Just an easy question. So is this formula over here satisfiable? Any guesses? Okay, yes, it is satisfiable. Why is that? Well, here's a satisfying assignment. So just check if these six variables, so take each of these clauses, and you will find out that this assignment satisfies these clauses. Now here's a slightly different formula. Is this formula satisfiable? Who said no? Can you prove it? Okay, it's not satisfiable. If you keep asking me, can you prove it, I will say that I promise it's not satisfiable, but please don't ask me more. If you really insist, then maybe I will say, okay, let me write all this to the six assignments, so there are six variables, not so many assignments. Try all of them, you will see that none of them satisfies the formula. But of course, this is not a great state of affairs. So we would like to have shorter proofs, like just one assignment that everyone can verify easily. So instead of just this enumerating business, let's try to use some logic to find the proof of this formula. So we're going to use the resolution proof system. Look at these two clauses over there in red. You'll see that they share one variable, x32. It's positive in one and it's negative in the other. So now what happens? Imagine that there is a satisfying assignment, then at least one of x32 must be either true or false. So if it's false, then the left part of the x31 clause must be true. If it's true, then the left part of x22 bar must be true. So we know that in either case, one of the parts is true or the other part is true, so we can just go and write this down here. We can have that x32 or x22 bar must be true. So we derived something new from these clauses that we had. And now, of course, we can keep doing that, so now we have a new clause. So maybe we want to do the same reasoning with this new clause and one of the previous clauses. There is something new and we kept doing this, getting some information. Now, for instance, we derived that x11 must be false. So that's already quite a lot of information that we have from the formula. And now we can do some different steps derived that this variable must actually be true and that's a contradiction. So this is a bit shorter than enumerating all these two to six assignments, but it's still not great. So let's try to do something different. And this workshop is about extension complexity. Let's do something that has something to do with polytops. We're going to talk about the cutting-place proof system. So we're going to take this formula that's encoded in CNF and re-encoded using linear inequalities, just like this. So what I did is the following. I had an or, every clause is an or. That's saying that one of the variables must be true, one of the literals actually. So I just said that well, then the sum of all the literals must be at least one, at least one of the literals must be true. Just that. But now we have these negative variables, negative literals. What does a variable be negative mean here? Well, if the variables are zero or one, then in order to say that the variable must be zero, we can just write one minus the variable, like this. And now we have some constants on the left. Let's put all the constants on the right and we'll get this formula and this is our final formula. Of course, this encodes a polytope and now we want to find out whether this polytope has solutions over zero one, over the integers. So let's do that. So we'll start by doing some operations on these inequalities. For instance, we can take these middle inequalities, sum all of them together and we'll get this result over here. Now I don't like these tools on the left, so I'm just going to divide everything by two. But of course, I also don't like fractional numbers very much. So I would like to get rid of that minus three halves. So how do I do that? Well, of course, I could just round down that's always something that's possible to do. But we're not interested in fractional solutions, we're interested in integer solutions. We have a sum of three things, all of which are integers. So we know that the result is an integer. If that integer is greater than some fractional number, well, it's also greater than the integer that's immediately greater than that fractional number. So in fact, I can go and round up. Yeah, since these are negative numbers, rounding up means a smaller number. But here I could do some step using the fact that I'm working with integers that I could not do if I had fractional numbers. And this is the rounding. I can do a very similar thing with three inequalities below. Now you might start getting an idea of what is this formula saying. So what do these two inequalities below say, the ones that have three variables? They're saying that the sum of these variables must be at most one. What are the three inequalities on the very top saying? It's saying that some of some variables must be at least one. So if you've seen the pigeonhole principle before, that is exactly what this formula is saying. Okay. So now we can solve this very quickly. Just some of these two inequalities over here. We'll get that sum of all variables must be at most two. Some of the three inequalities on top, some of all the variables must be at least three. So this cannot happen at the same time. Get zero greater than equal than one. That's a contradiction. Okay. And this, we didn't see the previous proof completely, but this is really much shorter than what we could do with resolution. And this was just talking about six variables. Now if you had n variables, you would see that you can do this in polynomial time. But if you had resolution, you would need exponential length, say. So this is what proof complexity is about. It's about looking at formulas, seeing what's the shortest way that we can prove them using different sets of rules. I didn't talk about the rules too much. We'll care more about which objects we are reasoning with than the exact rules. Of course, the rules are very important, but in this talk, I'm going to skip them. Okay. So with this being said, let me tell you a bit about a few proof systems. So we talked about the resolution a bit. That was the, this proof system where you talk with clauses. There's another proof system where you translate your formula into polynomials. Then you reason with polynomials. That's called polynomial calculus. We've also seen this cutting planes business where you work with linear inequalities. And one other important proof system is called bounded Fregge in which you work with AC0 circuits. So your lines are AC0 circuits. Here's a picture of these proof systems. This is how they look like when you try to relate them. So resolution is a very weak proof system. All of these other proof systems can simulate it. By simulated, I mean that if you have a proof in resolution, then you can rewrite it using one of the other proof systems without most of the polynomial loss. And we also know that all of these proof systems are strictly better than resolution in that there are some formulas like the pigeonhole principle before where one of these proof systems can do it in polynomial length, but resolution needs exponential length. And we also know that, for instance, there are formulas that cutting planes can do better than polynomial calculus or formulas that polynomial calculus can do better than bounded Fregge and so on. So today we'll see some other members of this family and we'll see a bit more about these relations. And for this, we're going to use the lifting technique. So let's talk about lifting now. So in general, as in every other complexity area, what we want to do with lifting is, well, we know that proving lower bounds is hard, so we want to prove lower bounds in an easier model. And so in this case, we start with a formula, some formula F, that happens to be hard for some weak measure. Now we're going to lift that formula and to build some new formula F composed with G. Then we'll have to prove a lifting theorem, but that's a generic lifting theorem that has nothing to do with F, only with G, hopefully. And that will give us a formula that is hard for some stronger measure, that's the measure that we're really interested in. Now this, if you stay within proof complexity, there are many examples of proofs following this idea. And often, you don't really need to prove such a hard lifting theorem. So very often, your lifting is just, I don't know, composed with XOR, hit the formula with a random restriction, and now you'll get that the formula is hard for some proof system. And many results follow this pattern. But today we'll move to the special case where the lifting theorems go through communication complexity. The idea then is that we want to prove that our lifted formula is hard in communication complexity, so not for some proof system, and then use the hardness in communication to derive that the problem is hard in proof complexity. So we'll not talk too much about one. Yeah, these are usually not too hard things to do. I'll talk about two in a moment, and then after that we will see a few examples of how to do... Well, we want really proof lifting theorems, we will see mostly how to go from step four to step five. So how to, assuming hardness in communication, how to derive hardness in proof complexity. Great then, let's see step two, how do you lift the formula? We know how a lifted function looks, that just take a function, replace every variable by the gadget, here's your new function. In proof complexity it's basically the same, so we still take a formula, replace every variable with a gadget, but now we have to go back into CNF. Let me tell you what I mean with this, so here's a very simple formula. I want to lift it with XOR, so I just go to every clause, take a variable, replace that variable by the XOR of two variables. But now this is not a CNF, so instead of staying with this, we're going to take each of these three Boolean functions and now express them in CNF. So this is what you would do, for instance the first lifted clause gets expanded into these four clauses and so on. Okay, another tool that we will need then is that if we want to talk about communication problems, well then we need the communication problem. So let's build the communication problem using formulas. The canonical communication problem of a formula or falsified clause search formula is this. So we start with the formula F and now we are getting an assignment. So F is something that's given in the universe, everyone can see that. What we as the people who have to solve a problem get is this assignment to the variables of F. And now our task is to give a clause that is falsified by that assignment. Since we will always talk about unsatisfiable formulas, there's always a clause that is falsified by the assignment. So here's an example with that previous formula from before, XOR, Y, not X or Y, not Y. Imagine that our input is that X equals zero and Y equals one. Well then is the first clause falsified, no, it's satisfied. Second clause is also satisfied. Third clause is falsified. So we're going to output not Y. So this is basically the problem that we're going to be proving lower ones for all the time. And to see why this is very related to proof complexity let's see a small example. Of how you can go from a proof to a decision tree. So imagine that we have this resolution proof of this very small formula from before. And in fact it's a very special proof because it's tree like. So if we draw the proof like here in a graph then there are no merging nodes. This is just a tree. Well in this case we can very easily take a small proof and convert it into a decision tree for the falsified clause search problem on that formula. How does this happen? Well, that's, there should be a thing on the left should be just our Y without the bar. Okay, so how do we get the contradiction from these two formulas? By resolving over Y. Y is the important variable on the last step. So that means that if we want to figure out, if we have an assignment and we want to figure out which part of the tree we should go, we should first query Y. So that's what the decision tree does. First query Y. And then it goes into the falsified direction. So if the answer is zero that means that we're falsifying Y we should go to the left. And vice versa. The general structure is a DAG. If the general structure is a DAG then you can then you get the decision DAG whatever that means. But I'm not telling you more because actually that's going to be in the next talk. So, okay. And we keep asking questions and at some point we are going to reach the leaves and these are the original clauses of our formula. And now since we've been always keeping a falsified assignment in our tree we know that whatever clause we reach is falsified. And now we can just go and answer that. Okay. This is a problem though that if we tried to use this idea to prove lower bounds proof cannot be balanced. So we can use these to prove depth lower bounds. That's fine. That's fine. Yes, so if the last step in your proof is to resolve Y then you query Y first. Oh no, so now how did we get Y from these two clauses? That was by resolving over X. So since we're resolving over X the next query is over X. And that's how it works. Okay. Right, so we can use this model to prove depth lower bounds but if we want to prove something stronger like size lower bounds then decision trees are not going to work because we cannot balance them. So instead that's why we want to use communication complexity. Okay. That was the introduction. But now let's see a few examples of how to use this in the real world. So let's start with the nineties. Something that happened a while ago is that people were trying to prove lower bounds for cutting planes. And this was a very hard task. Instead people tried to prove lower bounds for tree like cutting planes instead. So these are easier to handle. And one of the questions that was open was what was the relation between tree like cutting planes and dog like proof systems? So are tree like proof systems stronger? And as you can imagine, dog like proof systems are stronger. But it can happen that having this cutting plane proof system that was very strong, much stronger than resolution. What happens now if you add the tree like restriction? How does that compare with resolution? Well then the answer is that these proof systems are actually incomparable. So it turns out that we have some formulas where adding the tree like restriction to cutting planes makes it much worse than resolution. So there are some formulas where resolution has proofs of polynomial length that is dog like resolution. But cutting planes with the tree like restriction needs exponential length. So to put that in our picture we have now one another proof system tree like cutting planes. And there are both formulas where tree like cutting planes is better than resolution and formulas where it is worse. And how do we prove this? Well it must be a lifting theorem otherwise we wouldn't be here. The length is the number of lines in your proof. But any reasonable measure like number of variables, total number of variables in the proof or something like this will also work. Right. So let's talk a bit about what's the kind of lifting theorem that we would need for this. Right. As I said we want to use communication complexity. So let's see how to do that. And I'm going to show you, so like before we had this resolution proof we wanted to build the decision tree. Now we're going to have a cutting planes proof, a tree like though, and we're going to see how to build the communication protocol for it. Now since this is a communication problem the inputs are split between the two players. So in this case I chose a weird way to distribute the variables. But when we use lifting theorems then there's always going to be some more natural way to partition the variables. Usually that's going to be determined by the gadget. And now what happens is that each player then gets half of the input, half of the assignment and their task is still to produce one clause that is falsified by this assignment. Okay. So let's see how to do this. We start at the contradiction. That's always false. And then we have to figure out where to go left or right. So we're going to pick one of the nodes arbitrarily. We could both pick the left or the right inequality. That doesn't matter at this point. And now something that we can do is that Alice looks at her variables, evaluates the inequality over her input and sums of all of these variables. So in this case she would just get the value minus one. That's the sum of these three variables evaluated when... So x11 is zero. That doesn't count. x31 minus x31 is minus one, minus x22 is minus one. Minus x31 is zero. The only variable that is not zero is x22. That's why the answer is... That's why she sends minus one to Bob. So now Bob has enough information to compute to evaluate this inequality to figure out whether it's true or not. In this case it happens to be false. So since this inequality is false and we're always searching a false path, we know that the next step in the proof is this node. So now we are moving to this inequality in the proof. And now we do the same procedure again. So this has two... Two child pick one of them no matter which evaluated. Bob tells the answer to Alice. In this case Bob tells Alice that this equality is satisfied. So we should move to the other one instead. And now they keep doing this until they reach a close. And in this case they are going to reach a linear inequality but that corresponds to a close. And then they answer with that close. One detail though is that this protocol works great when the coefficients of your proof are quite small. But if you have larger coefficients then you might want to do something smarter. You would like to solve the greater than problem so that's okay. But then this means that the deterministic communication is not going to work great because the deterministic communication cannot solve the greater than problem very efficiently. So how could we fix that? Well we could of course use randomized communication. So if we use randomized communication then we can solve greater than efficiently. But these are the 90s and we don't have lifting theorems for randomized communication. So instead we're going to look at a different communication model that's called deterministic communication with a greater than oracle. What is this model? Well here we have a third element in the protocol which is this greater than oracle. And now the players no longer talk between themselves they just talk to the oracle. What they do is send numbers to the oracle like this. We don't charge them for sending numbers to the oracle. They need infinitely many bits to send real numbers. That's not a problem. What we do charge them for is the answers that the oracle gives. So in this case the oracle says that Alice's number was greater than Bob's number and that caused one bit or one call to the oracle. So if you think for a moment you'll see that you can simulate normal communication with this model. And you can also see that randomized communication can simulate this model. So it's a good thing that it's a simpler model so it might be easier to prove a lifting theorem for it. And that's indeed the case. So here's the lifting theorem that these people proved. What they showed is that the communication cost in this deterministic communication with a greater than oracle model. That's at least the decision tree depth, normal decision trees. So deterministic nothing special here times log n is the size of the gadget. And just to give you an idea of how one would go and prove this. This is basically the same proof that you would use for the first theorem that Arkadev talked about. The deterministic theorem of Rosmakensi, Gospitasi Watson. Except that you do a crucial but important twist to it. Which is the following. So in normal communication, when the player sends one bit of communication, the inputs get partitioned into two rectangles. And then what the proof of the lifting theorem would do is, I always want to go to the larger rectangle. And then you can show that these measures that Arkadev talked about, they don't decrease too much if you always go to the largest rectangle. Here instead, when you send one bit of communication, or when you talk to the oracle ones, the inputs don't get partitioned into rectangles. They get partitioned into something a bit more weird, but not that weird. They get partitioned into triangles. And now what you can do is to look at your triangles. And inside the triangle, you can always find the rectangle. And there's always going to be at least one of the two rectangles that you can find inside the rectangles. It's going to be large enough. Not as large as half, but it's going to be at least one quarter of the inputs. So using these, you can still show that the measures that Arkadev talked about will not decrease too much. And you can prove the lifting theorem. If what I said didn't make any sense, there's no problem. This only makes sense if you know how to prove a lifting theorem. But yeah, don't worry about it. So that's the end of this example. So this is the lifting theorem. What we now need to do is then to take a formula, lift it, use this lifting theorem to prove that it's hard for communication. And then that immediately implies that it's hard for three-light cutting planes. We have to be a bit careful, though, in that I said that we wanted to separate two things. So we wanted to say that there were some formulas that were hard for cutting planes, but easy for resolution. So when we pick our original formula, we have to be careful that that's an easy formula for resolution, and that when we lift it, it will keep being easy. But this can be done. So we were able to determine all you need is to determine what works against the easy way to do it. But suppose if you do the right-hand direction, it's hard. Right. No, it does. So it's just that you will get a few slightly worse numbers from going from randomized to here. Might lose some polynomial factor, but no big deal really. It's just that if you work with the greater than model, that's easier to work with. And if you're trying to, it's not so much this kind of lifting theorem. If you wanted to prove new lifting theorems, then it's probably going to be easier to prove them with a greater than oracle first. Right. You would have to, but you can prove that exponential coefficients are always enough. And that means that, right, so you will have n many bits. So then you can solve greater than in communication login. So it was that when you do the cutting plate, you say if the coefficients might be larger, they feel like the polynomial gets larger. That might be larger. But if you work with a tree-like model, if you make an n sense, you will get very split n times. Oh, no. You might go very deep. So proofs, you cannot, there's no need that the proof needs to be balanced. So. Right. No, no, no, no. I didn't talk about multiplying, but even just with adding things, they can grow faster quickly. If you're wondering why you might ever want to do that, I'm going to talk about this in shortly. Okay. Let me also mention something that can be proved for cutting planes using lifting theorems, which is that, so let's go back to very close to the present. And now it turns out that we can prove lower bounds for that like cutting planes using lifting theorems. And one way that you can prove is that now you can separate this polynomial calculus and cutting planes proof system that we mentioned before. So using a lifting theorem, you can prove that there are some formulas where polynomial calculus can do great, but cutting planes cannot do that. So just let me show the picture again. So now we have these are over here. Now it is two-sided. So now know that polynomial calculus and cutting planes are incomparable. So instead of talking about this, let's talk about the coefficients so that I will answer your question. What do we know about coefficients in, well, not in cutting planes, but in Boolean functions? We know that if you have a function that can be represented by linear inequality, then it's enough to use coefficients that are of size at most n factorial. And we know that this is in fact tight. So there are some Boolean functions where you will need very large coefficients. And well, of course, you could ask what happens in cutting planes. Well, then we know that something similar happens. So if you have a formula that has a cutting planes proof of some length L, then you can show that there's going to be another proof whose length is at most polynomially larger than my first proof. And whose coefficients are of size at most 2 to the L. Note, by the way, that I'm writing L here, not n. So if L is exponential, this could be really, really large. When I mean size, I mean magnitude. So the representation is log of the size. So you can ask a very similar question here. Do we need coefficients that are this large? Could you just work with coefficients of size 2 to the n, or maybe even polynomial? But we don't know that. And I find that very annoying. Something that we are working on should be out any day now is that we can show that large coefficients are needed if you restrict your proofs to be tree-like. We can show something like this, that there are some formulas. If you want to have a tree-like proof, then you're going to either have exponentially long proofs or you're going to need to use large coefficients. And of course, if you want to be dug like, then this does not apply. So what does this mean in our picture? It means that we have this proof as 3p star. Star is a convention that means that cutting planes is using polynomially large coefficients at most. So tree-like cp star is tree-like cutting planes with polynomial coefficients. That would be logarithmically representable coefficients. And now we know that normal tree-like cutting planes is strictly stronger than cutting planes with small coefficients. Here's a caveat to this result, though, that we only know the lower bound for on this result is perfectly fine. But the upper bound is something that we only know to work for the semantic cutting planes proof system. So if you know what semantic cutting planes, now you know what this means, otherwise don't worry about it. How do we prove this? So remember when we were talking about how to convert the cutting planes proof into a communication protocol, that we had a simulation theorem, if we had small coefficients, and if we had larger coefficients, then we had to go to this p to the greater than model. So we would like to prove a lifting theorem that works for the thermistic communication, but fails to work for p to the greater than. And what would be a nice gadget for this? Well, of course, it's something that greater than can do, like maybe the gadget should be greater than or equality or something like this. Well, let's look at equality. And let's think how you would encode using cutting planes that many pairs of variables are all equal. You could just go and write these two n inequalities, one for two for each pair of variables, but you could also try to combine these into one big equality, like this over here. But now you need to use the very large coefficients in order to use this. So this large equality is just expressing an ant of smaller equalities. And now, of course, this is cutting planes, you have to really encode this with two inequalities, but that's not a problem. So it seems that the quality that cutting planes might be good at using the equality gadget. So if we can build a formula where you have to talk about very large equalities, then that's a formula that might be a good separation. Okay, so let's see what kind of lifting theorem do we need for this. This is a somewhat particular lifting theorem, and this is building on some previous results of Tony and Robert Revere, but adapting this to more gadgets. What we have is that the deterministic communication cost of solving the search problem on f-compose with g is at least something called the Nulstein's degree that we'll define in a moment. As long as the rank of your gadget, by rank I mean the rank of the communication matrix, is at least n the number of variables over this degree. So for instance, if this degree is linear, then you will be able to work with a constant size gadget. If the degree, in our case, this degree is going to be something like n over log n, and in that case we're happy with a gadget that has rank about log n, so size log log n. And what is the Nulstein's degree of a formula? Well, we have it over here. So take your formula and interpret it as a set of polynomials. Now, by Hilbert's Nulstein's ads, we know that we can find some other polynomials g i, so that this happens, sum of f i g i equals 1. But of course we are free to choose different g i's, so we would like to minimize the maximum degree of any of these f i g i expressions. So now, given a set of g i's, their degree is the maximum of f i g i's, and then we want to pick a set of g i's that minimize that, and the minimum is the Nulstein's degree of a formula. Some of these f i's will include the Boolean ads here. They will. That's probably also why we can always assume that the degree bound for Nulstein's a trivial bound will be N also. A trivial bound will be N. Let's instead go towards the future and discuss a few lifting theorems that I would like to be proven. So it would be very nice if we would have duct-like lifting for intersection of rectangles. Why is that? Well, if you remember that AC0 Frege thing in the family picture that we never really talked about, there's some much stronger proof system that's, at least stronger proof system that's AC0 parity Frege. It's one of the proof systems for we don't have any lower bounds. We'd like to fix that. But in fact, we don't have lower bounds for something much weaker that's resolution with parities. And it feels like we should try to prove these lower bounds for resolution with parities first. And a way to do this would be to prove a duct-like lifting theorem. I think that we might see more details of this in a while. Something that would also help is if we could prove multi-party lifting. This would tell us things about semi-algebraic proof systems such as sums of squares. Would be very nice if we could prove this lifting theorem I mentioned before, this lifting theorem with a quality gadget using a simulation-based approach. So the proof of that theorem is basically algebraic. And there is, we would like a more constructive proof that you, where you take your protocol build a decision tree. And that is hard because if we use the previous techniques, then they would probably generalize to P3EQ, and we know that that cannot happen. And there's also some work in this by Shachnik, Mohod Padhyay and Bruno Lof. But the result does not quite work for us. So could one try to get the best of both worlds? Why would it be helpful? Well, if you have, if you had such a simulation theorem, then you would, you could try to make the, your lifting theorem aware of rounds, or you could maybe try to think of making this duct-like, or at least it will, it would let us understand this better. Right, so this is what I think about the feature. To finish, my main message is that if you can prove a lifting theorem, talk to someone in proof of complexity, I'm sure there's going to have some use for it. Just to understand the family picture that you put a couple of times, the dashed arrows mean what exactly? The dotted and the bold ones is clear. What was the dashed arrow supposed to mean? Okay, you mean the dashed or the dots? That means that the proof system on top can simulate the proof system on the bottom, as in every proof in the bottom can be done in the proof system on top. And it also means that it's strict so that there's some formula that one on top can do, but the one on the bottom cannot do. Okay. And now in this picture is the community looking at a certain comparison more prominently than other? I would say that one of the open questions was this, whether what happened over here, that's now solved. And there are some other proof systems that are not in the picture, like this AC0 party, and I think that that's what people might be looking at next. So it's not known whether AC0 can simulate anything stronger than resolution? Oh yeah, it is known because it can do things that resolution cannot do. Yeah, sure. Anything stronger than that? It's not known that AC0 frigate can do Cp or Ccp? No, not cutting planes. Yeah, I'm going to say no. In one of your slides, from a resolution proof, you constructed a decision tree or a decision diagram. But usually you're looking at unsatisfiable formulas and trying to get a proof that they're unsatisfiable. So it's not known from decision trees to resolution proof as well. Yeah, okay. So that conversion was very syntactical. So the same thing that you did in one direction, you can do it in the reverse direction. Thanks, man.