 So, I will talk about two results on AC0 parity, but let us just start with some quickly go through some definitions. So, Boolean circuits are directed acyclic graphs and each vertex computes a Boolean function which is represented by its gate and the and then you have the vertices without enablers they are inputs and there is a special vertex called output output. And so, we are mostly interested in or and then parity gates. So, formula is a special circuit where the underlying graph is a tree and size is the number of vertices and so, because for most part we will be dealing with formulas number of vertices and wires is more or less same. So, and depth is the number is the longest output to literal path. So, if we have a family of circuits one for each size we say it accepts a language if the circuit corresponding to inputs of size n exactly accepts words from the language which are of size n. And so, AC0 and AC0 parity are circuits where AC0 uses and and or gates AC0 parity uses and or and parity gates. Well the definition really wants that the circuits have constant depth and polynomial size, but we abuse this notation throughout. So, we can say something like an AC0 parity of depth log log n of size exponential in root n or something. So, AC0 just means the black part not the gray part strict like as an abuse of language. So, the first result is about restricted hierarchy theorems for AC0 parity. So, hierarchy theorems say that informally that the more a resource computational model has the larger is the class of problems it can solve. And so, the result we have is similar to the one that we are mentioning here that. So, if we look at AC0 circuits of fixed depth then we can separate size S with size let us say S to the 0.001. So, there are problems that can be solved with circuits of sizes, but we cannot do that in a much smaller polynomial of S. And we want to say something a similar thing about AC0 parity here. So, in AC0 parity this recent result that Aditya also mentioned it uses tight lower bounds on coin problem to separate AC0 depth D circuits. So, it says that they are explicit formulas. So, only for formulas this result is for formulas AC0 formulas. There are explicit AC0 formulas of sizes which cannot be and the same function cannot be commuted by circuits of much smaller size for same depth. So, here I want to say that we are not really in the regime of fixed depth and polynomial size. So, the size hierarchy theorem we had for AC0 really works for like more or less the entire range of AC0 for depth all the way to log log log n by log log n. And we also have like tight lower bounds all the way up to log n by log log n. For lower bounds it is we have lower bounds for AC0 parity also till the same regime, but the hierarchy theorem goes for a very small window it is only till D smaller than log log n. So, the recent result kind of does not go all the way to log log n, but we make some progress here. So, here is the extension of size hierarchy theorem. So, we can make formulas of size s and no formulas of size s to the 0.01 compute the same function, but we can go in depth up to root log n by log log n. So, this is the progress in this paper compared to the previous one. So, I will quickly mention another result and then we can quickly brush up through the proof of this result. So, this other result we want to say that are randomized circuits more powerful than deterministic circuits in AC0 or AC0 parity setting. So, here we like if we will just look at constant depth or let us say depth D circuits, we know that we can do some increase in depth to convert any random randomized circuit to a deterministic circuit. In AC0 we can afford we have to pay an extra depth of 2 and in the setting of AC0 parity we have to pay an extra depth of 3. So, given any AC0 parity circuit of depth D computing a Boolean function we can get a deterministic circuit of depth D plus 3. So, the thing is that in the first case one can show that the requirement of 2 is necessary. So, in the second case we want to answer the we want to say the same thing. So, we want to see whether the increase in depth by 3 is necessary or not, but we have some progress. So, in the case of AC0 we can say that the increase in depth by 2 is necessary. In the case of AC0 parity we can slightly say something better we can say that we have to pay for at least one increase in depth. So, it is not like ideally what the complete thing we want, but it is half way through. So, I will go through the first result about so through the coin problem. So, coin problem is sorry I already talked about it. So, we want to distinguish between slightly biased probability distributions. So, we have so 1 minus delta. So, around half 1 minus delta by 2 and 1 plus delta by 2 and we want to say that a function is 1 with high probability in one distribution and 0 with high probability in the other distribution. And we say that f solves the coin problem that happens if we can find such an f. So, again the majority function solves the coin problem. So, we can sample let us say 100 times 1 by delta square times and like law of large numbers we can just like from we can see from this simply that this function majority function simply solves the delta coin problem. The thing is that we are here we are interested in the circuit complexity of coin problem. We want to see how small AC 0 parity circuit can be that is also that is also coin problem. And majority slightly bad in that because majority is AC 0 complexity is it turns out in if you take 1 by delta square samples is not quite the optimum. So, we have a lower bound that says it is exponential in 1 by delta to the 1 by d minus 1. We also happen to have matching lower bound this is through the earlier paper. And so majority does not do that for in majority there is a term of 2 that comes in there 2 by d minus 1. So, it is pretty bad in that case. So, for majority if you want to solve delta coin problem you cannot do in less than the same size, but there is a term of 2 that comes here and the 2 makes it much worse. So, majority is not going to help in solving the delta coin problem. So, there. So, we can do with a just take a randomized circuit in fact a randomized formula that solves the delta coin problem and it uses the optimal number of samples. So, we cannot do less than 1 by delta square that is folklore and. So, using a randomized formula we can solve the coin problem in 1 by delta square samples and the optimal size. So, we want to de-randomize this thing. So, I will just go through some earlier papers. So, this is our goal and. So, we already have matching lower bound due to O'Donnell and Wimmer and Amano. The thing is that. So, I want to mention why we want optimal sample complexity in the right number of samples because it turns out that when we use these results to obtain size hierarchy theorem. The problem is that we have a this O'Donnell, Wimmer and Amano circuit that solves the coin problem. If like it the size of the circuit is same as the number of its linear circuit or like it is worst like it is some polynomial size circuit. So, it is not really going to give much, but. So, if you bring down the sample complexity we have a larger window of depth in which we can solve the coin problem. So, if we are able to obtain the 1 by delta square. So, if you are able to obtain the optimal deterministic circuit we have actually solved the coin. We have actually obtained the hierarchy theorem all the way up to log n by log log n, but we are still quite short. We can go up to 1 by delta to the order d. So, I will just quickly go through both the constructions and the first one and the last one because. So, both the constructions are based on O'Donnell, Wimmer and Amano's construction and it is a simple skeleton and we try to build on it. So, it is. So, for depth 2 it is just very simple it is a it is a ore of ants and all the gates at the same level have same size. So, all the gates on level 1 have fan in m and all of them have distinct variables on the leaves. So, it really is like too many variables. So, it is really what was happening there it is as many variables as there are as the size of the circuit. So, the circuit solves the coin problem, but its simple complexity is too much. We want to reuse the variables in such a way that it is easy to analyze. So, if we quickly go through the analysis of Amano's construction. So, we choose some parameters m and capital M. So, that things work out nice. So, and it is very easy to analyze because it is all independent case analysis right. So, on the. So, all gates on level 1 output oh yeah I have not mentioned it on the figure. So, so small. So, this is the fan in of the top gate is capital M and the fan in of the bottom gate is small m. So, and like I will mention how this looks like in larger depths, but let us just go through depth 2 once. So, for some suitable choice of m and capital M like just simple independence case analysis shows that it solves the coin problem straight forward. And it is like from here we can go to larger depths also. We just repeat the same process except the fan ends look like small m on the bottom then m times 2 to the m roughly on each layer till the last one where you have 2 to the m. And the same argument the same calculation goes through till the top and says that it solves the coin problem. And m is slightly small in that case m to m square delta is constant or m cube m to the d minus 1 delta is constant for depth d circuits. We want to reuse the variables, but we also want it to be easy to be analyzed. So, we already have a tool for written computer science we have Janssen's inequality. It says that if you have a or of some monotone functions then if the things were independent if let us say c 1 and c m they use different variables. Then the probability of the top gate let us say outputting 0 is the product of the each of the gates outputting 0, but we might not have that, but if the things behave still more or less independent in the sense that let us say very few of those pairs of circuits share any variables and then they do not share too many variables. We want them we want we will want it to behave more or less like a independent case and that actually happens. So, the first side follows through monotone city. So, c i's are all monotone circuits and the second part which is the statement of Janssen's inequality says that well there is this parameter epsilon that measures kind of how independent those circuits are intuitively. And if the parameter is small then we can just like just go through independence case analysis and forget that they share any variables and all. So, epsilon formally is this quantity. So, we sum over all pairs of distinct circuits that share any variable and the common probability that the probability that both of them output one and if we are managed to make get a hold on epsilon and make it small then like the same analysis goes through. So, like basically we have solved this coin problem in a hopefully smaller polynomial number of samples polynomial little m. So, here is what we do. So, we want to not use distinct label for all leaves. We do not want distinct variables at all the leaves. We want to reuse variables and one nice way to do this is using low degree polynomials. So, we try to use graph of low degree polynomials and that too in a small grid. So, instead of looking at graphs in F cross F we look at graphs in A cross F where is this A is a much smaller subset of a field F and F is some finite field some large enough finite field for our purposes. So, if you look at graphs in a narrow grid we may expect most of them would not even intersect most pairs would not intersect and whenever they do they will not intersect in too many places. So, intuitively that is the reason we want we expect such a thing to work and it turns out that if we like we can actually the main technical claim is that we can actually show that epsilon is much small it is in fact, smaller than delta the parameter of the coin problem for suitable choice of small m. So, here is what we want we want to. So, in the case of depth 2 each gate on level 1 we let us rename it as some polynomial and let us take polynomial of like just enough degree so that we have capital M of them. We want capital M distinct polynomials of degree less than equal to d once we have them. So, the children of each gate that are feeding into this AND gate they are just distinct points in the grid A cross F corresponding to the graph of that polynomial. So, now we do not have distinct variables like we do not have. So, different gates on level 1 will share variables, but we expect that things will work out nice in this case. So, in larger depth what we do is that we so at the top level we just have a OR gate on top let us say without loss of generality on each subsequent level we can label the gate with a tuple of polynomials on level 1 we can label them with a single polynomial as we go down on level 2 we can label them with two polynomials. And in the bottom the d minus 1 yeah so d th d minus 1th layer you have it is labeled by d minus 1 distinct polynomials. And the variables feeding into it are just the graph of the degree d 1 dimensional curve in A cross F to the d minus 1. So, in depth t we are doing the same thing, but we are just looking at a like a larger grid in d dimensions and we are looking at degree d 1 dimensional curves over there. And the main lemma is set the technical lemma is that the parameter epsilon that we had in the Jensen's theorem we can make it much smaller for suitable choice of m. And the thing is that this the number of variables is so let us say the size of field is poly m. So, the number of variables is poly m say we have come down from exponential m to poly m that gives us a like much larger window for a size hierarchy theorem in this case. So, that is it.