 So, this talk is going to be about variant of the satisfiability problem in the streaming model of computation. The results in this paper they were from a collaboration between two groups of researchers which is why the long list of authors. What we are going to look at is called the min ones to SAT problem and this problem is a generalization of vertex cover. So, what is the vertex cover problem? In the vertex cover problem you have a graph and you want to find a set of vertices that you can pick. So, that when you remove the vertices the graph that you have left it is edgeless. So, now if you have a vertex cover instance and you have these edges, if you think of these edges as clauses like an edge between u and v, if you think of the edge as the clause u or v then solving this problem is the same as finding a set of k variables that you can set to 1 to satisfy the formula that you would get from translating the clauses that way. So, that is a way of interpreting vertex cover. What you can do now is you can consider a generalization of this problem as a satisfiability problem. So, when you do that what you get is min ones to SAT and a min ones to SAT instance is just a 2CNF formula and what you want to do is set the minimum number of instances to 1 to satisfy the formula it generalizes vertex cover. We will look at this problem in a specific model that is a generalization of the standard streaming model. First of all in the standard streaming model what you have is that the input can only be read sequentially and you may make multiple passes over the input, but you always have to read the input in the same sequence and what you have is that your memory that your algorithm can use is logarithmic in the size of the input. This is the standard streaming model, but now we look at this problem in the parameterized streaming model where we consider a parametrized version of the problem. A parametrized problem is just any problem any decision problem that you have some parameter for and for vertex cover this parameter would be the solution size for problems like dominating set or independent set there would also be solution size. There can be other parameters like tree width if it is a graph problem. So you can have many different kinds of parameters for your problems. A parametrized problem is just a decision problem combined with some parameter. So now we look at min once to set in this as a parameterized problem in the streaming setting. So what we have is we want to solve the problem not in logarithmic space, but in space f of k times log n and we want to do this by making as few passes as possible preferably bounded by some function of the parameter. So in the these two problems are interchangeable if you only care about fixed parameter attractability. So Mishra et al they had a result which showed that min once to set and vertex cover can be reduced to each other while preserving the parameter. This will mean that whatever kernelization algorithms you have for vertex cover will carry over to min once to set and of course if you have a kernelization algorithm for min once to set it carries over to vertex cover. Actually in the general streaming setting we in the standard streaming model what we have is the space is bounded by the log of the problem size in the standard streaming setting. So the maximum time your algorithm can use is polynomial anyway. But now we have this space requirement so we did not need to bound the time requirement in the streaming model because it was logarithmic space it would be polynomial time. But now we generally want to have algorithms that are fixed parameter have fixed parameter attractable running times but there is no explicit bound. So min once to set and vertex cover they are the same basically in the when you consider them as general parameterized problems. But if you look at the streaming model they are different vertex cover is solvable in a single pass using space of k square log n and this was proved in a paper by Chitney Sattal in soda 2015. But we show in the in our paper we show that min once to set in the in the parameterized streaming setting it requires at least k plus 1 passes. Not any arbitrary f there are hard instances which will require k plus 1 passes. You meant this is for any d Satt d greater than or equal to 2. So this is how this is the organization of the talk we have already looked at the problem and the model and what I am going to show next is a k plus 1 pass streaming algorithm for min once to set and then we look at a lower bound that says that if you just care about the number of passes made the k plus 1 passes pass streaming algorithm is optimal. So this is this is the theorem that I am going to prove now you can you can solve instances of min once to set in k plus 1 1 passes using space k plus 2 to the k times 2 to the k plus k squared times log n. And this is this is basically by using a 1 pass kernelization for vertex cover and then using the clauses in clauses in your formula to extend solutions to that vertex cover vertex cover instance. So the way the algorithm works is first it will you have a you have a formula and this is a 2 CNF formula. So you have monotone clauses you have implications and you have anti monotone clauses. What you can do is you you can look at just the monotone clauses and think of them as edges in a graph and you can use the 1 pass streaming kernelization for vertex cover which was from the paper by Chitney Satal you can use that and you can obtain a kernel which has which has size which has size k squared and using that kernel you can obtain a set of starting solutions for your monotone clauses. And then what you do is you make additional passes over your input to extend your starting solutions. So this is how you do it. If you have an instance of vertex cover you can find a set of vertices of size at most k squared which will be equivalent to the original instance when you are only consider solutions of size at most k. So basically a kernel of size k squared you can obtain this in 1 pass. So once you obtain that kernel you can brute force over the kernel and obtain at most 2 to the k minimal solutions for your for your kernelized instance. So what you do is you suppose these are your monotone this is your entire formula and these are your monotone clauses in your formula what you do is you look at them as edges in a graph and then you use your vertex cover kernelization you use your vertex cover kernelization to obtain a set of minimal solutions for these monotone clauses. So you are only looking for solutions of size at most k and you are looking for minimal solutions when you want only solutions of this kind then the number of them will be at most 2 to the k and this you can find using the standard vertex cover kernelization which has also been translated to the streaming model. And then what you do is you find these solutions in 1 pass and then over k additional passes this is what you do you have these solutions will be satisfying all the monotone clauses in your formula. What you want to do is to find to extend these solutions so that they also satisfy the whole formula while you extend these solutions you might find out some are not extensible and you might want to throw them out. So this is what you will do over the next k passes. So in the next k passes what you will do is you will go over the formula and for each clause you look at a satisfying assignment in your set of solutions you will look at a partial satisfying assignment in your set of solutions and you will if your clause is an implication what you will do is you will extend it if it sets some variable appearing in some variable appearing in the clause is set to 1 by your assignment then you also set the corresponding implied variable to 1. This is for when your clause is an implication when it is an anti monotone clause then you know that both the variables in the clause must be set to 0 for the clause to be satisfied. So if your partially satisfying assignment sets both these variables to 1 then you have to remove them remove it from your set of solutions. Once you have done this you will do this for k passes once you have done this you will have you will have extended your solution and you will have possibly reduce their size but if there was a solution for the original instance which set at most k variables to 1 they will still remain in your set of solutions you will only need to extend your partial solutions k times to obtain a complete solution if 1 exists and finally what you will do is you will check if this set of solutions that you have stored in memory you can store this set in memory because the set of solutions is of size at most to do the k. So you can store them in memory and then check if you still have any solutions remaining. So if you do that you will be able to determine whether or not your whole formula can be satisfied by setting at most k variables to 1 any questions about the algorithm. So I will move on to showing that k plus 1 passes is kind of optimal if you restrict the space to if you restrict the space to something less than this which is what we want in our model. So this is the theorem I am going to prove any streaming algorithm for min 1's d set that solves it in k passes this is k not k plus 1 if it solves the min 1's d set in k passes then it will use at least this much space which is not f of k times log n for any f. So what we will obtain is that the algorithm we had previously was optimal when we only care about the number of passes. So in a min 1's 2 set instance the way the previous algorithm worked was you started with a set of solutions and then you were you would extend these solutions by looking at implications. But what if suppose your implication is x implies y but x appears much later than y in the stream and this happens for many clauses then what will happen is that you cannot store all the y's and then y might imply some other variable what you would do is first determine that x implies y so extend a solution to include y and then you would have to extend the same solution to include z. But if these variables were appearing in an adversarial order you would have to make multiple passes over your stream. So this is the kind of instance that will be produced by this problem called post-order pointer chasing. So this problem was introduced in a paper by Guha and McGregor and they showed that any P pass streaming algorithm for this problem I will explain what this expression here means but any P pass streaming algorithm for this problem requires at least space at least this much so it will become clear what these two quantities are in the next diagram. So an instance of this problem is a tree and a function defined on the tree so the tree is a complete tree which has three children per node and it has l plus 1 levels and you want to determine the value of some function at the nodes. So this function comes along with your tree and you want to determine its value so the way it is defined this expression will mean is its value at some leaf node equal to 1. So this is an instance of the problem so the problem is it consists of a tree you have this tree here and its vertices are labeled by a post-order traversal and every vertex is assigned a value by the function. The leaves are only assigned 0, 1 values and the non-leaf nodes the values they are assigned are basically the locations of their children. So the root node here it is assigned the value 2 it is telling you to go to the second child the value here assigned here is 1 it is telling you to go to the first child. So because f is defined this way what this quantity will mean this is in a rough fashion but this is not the exact quantity you have to define a second function to really pose it as a question here but what you want to basically do is you want to follow this path from the root to the leaf and determine the value of f at that leaf. So this is your instance the vertices come to you in post-order traversal fashion and you will be you are given the values of the function at those vertices. Because this these vertices come to you in a post-order traversal you really do not need to know what the vertices are you can just give the values of the function. So a stream for this an instance for an instance of this problem would be the this is this is the branching factor this is the depth and then the values of the function for all the vertices. So this is this is what an instance of your problem would be and what I am going to show next is that you can convert this to an instance of min once to sat. Any questions about this instance so what you can do is this is basically the this problem basically involves following a directed path from the root to a leaf. So the way you can encode this as a these these clauses are too small sorry about that but the way you can encode this information about the directions on the these edges is you can you can form a form clauses for each directed edge. So at 14 the value of the function is 10. So what I have done here which probably cannot see but what I have done here is create a clause x 14 implies x 10 and then again at this node the value of the function is 8 and I have created the clause x 10 implies x 8 and the because the values at these leaf nodes are all 0 1 what I do is I create clauses that say that these nodes need to have 0 1 values so whatever the function values are at those nodes. And now what you what you can do is you can force this the child of the root you find out what the child of the root is you can force it to be set to 1 and if the node you reach by following the path from the root is has a has a function value of function value of 0 then you are the clauses that you produce that will be a no instance for min once to set. So you can you can set you can generate a clause forcing the child of the root that the function points to you can force it to 1 and then you will be able to generate a clause to so but generating this clause involves it might not be clear from this picture that it can be generated in a as a stream but what you need to observe is that all the you know where in this stream a specific vertex in your tree will appear. So once you know the value that is assigned to that vertex you also know what kind of a clause to create because that value will tell you which child of the node you want to point to and just knowing it is the position of this node in the stream will also tell you the position of will also tell you the label of its child and using just using the function value at that node you can you can generate the clause you can generate this clause. So this way you can you can generate a stream which will which will give you give you this equivalence. So you can if you have a t re k plus 1 level instance of the post order pointer chasing problem you can convert it to a min once d set instance where the number of variables is t to the k that is the total number of nodes in the in the tree and the solution size requirement for that instance will be k. So you have this equivalence between P O P C and min once d set and then what you what you can do is you can just plug in your equivalence to into this theorem and because this n is t to the k what you will have here is n to the 1 by k. So if you recall n to the 1 by k by n to the 1 by 2 k by 2 to the k this is this cannot be f of k times log n. So once you have the equivalence you can plug it into the theorem and you can get this you get this result. So any streaming algorithm which solves the min once 2 set d set problem must use k plus 1 passes if it has to use space f of k times log n. So that was the lower bound and what we had shown earlier was that you can solve instances of min once 2 set in this much space and then k plus 1 passes. So if you just care about the number of passes it is optimal and the other results in this paper were d to the k pass algorithm for the problem this is this follows from just simulating the standard algorithm in the streaming model. But one of the nice things about this algorithm is it has a bad number of it uses a really bad number of passes but it uses very little space and we were also this is a typo this should be k plus 2 we were able to obtain a k plus 2 pass kernelization for the problem and that followed from using the vertex cover kernelization and basically doing what the k plus 1 pass algorithm did but storing the results in the kernel it is pretty straightforward. So thank you for listening that was all I wanted to talk about. So if we allow space to be little more than. No there is a lower bound from communication complexity if you do not consider if you do not parameterize the problem if you do not talk about space uses bounded by a function of the parameter times log n if you do not have that kind of a bound on the space you can you can show that the problem will require at least linear space in the size of the input. Because you are parameterizing you are able to obtain this kind of a result it is it is pretty straightforward it is just communication complexity reduction.