 This is going to be a joint work with my colleague, David Gossett, who is an organizer of this conference and Robert Koenig from the University of Munich. And so let me begin with some motivation for why we are interested in shallow circuits. And suppose we want to build a quantum computer using noisy qubits and noisy gates. And then basically we have two options. Option one is to encode each qubit using some quantum error-correcting codes, say the surface code, and perform logical gates on encoded qubits. Then they know that in principle we can perform arbitrarily long computation as long as our error rate is below some constant free-shot value around 1%. And option two is to apply gates directly to physical qubits without error correction. And this completely avoids the quantum fault-orderance overhead that can be quite large. But now there will be a certain limit on the maximum size of a computation they can do. And the first approximation we can use this rough estimate, and basically it says that the average number of faulty locations in our circuit is upper bounded by inverse error rate. And so the total number of locations that can potentially be faulty is just the number of qubits n times the number of computational step d, or circuit depth. And so n times d is upper bounded by inverse error rate, and this is a constant, but hopefully this constant can be quite large, perhaps 1,000 or even 10,000. And somehow this bound leads to interesting trade-offs. So we can try to do very long computations described by deep circuits, but then we can only afford a few qubits. And of course any quantum circuit acting on a few qubits can be efficiently simulated on a classical computer. So in some sense this is a boring regime. Alternatively, we can consider shallow circuits with a small depth, and now we can afford much more qubits, perhaps 100 or something of this order. And it is strongly believed that such circuits are impossible to simulate classically. So the question is whether we can realize any useful computation using shallow quantum circuits. And so the study of shallow circuits was pioneered by Barbara Terchel and David Devenchampso back in 2002 when they were here at IBM. And they gave convincing arguments showing that even constant depth circuits with depth 3 or larger are hard to simulate classically. And quite recently people developed some ideas of what can we do with shallow circuits. So we have heard from Eddie Talk about approximate optimization algorithm. And if we apply this algorithm to problems such as Max-Cut on bounded degree graphs, it can be realized by constant depth circuits. Then we can try to do variational quantum eigen-solver. And this may have applications in quantum chemistry simulations. And quite recently there was a lot of work on complexity of sampling problems that we can realize with constant depth circuits and for indications that somehow such sampling problems are hard for classical computers. So we can achieve this quantum supremacy. Now if we increase the depth from constant to something logarithmic in the number of qubits, we can do much more interesting things. For example, if we allow ancillary qubits, we can realize a short factor in the algorithm. And we can implement any circuit composed of Clifford group gates. Then there are interesting variational states called Mera that can be prepared with logarithmic depth circuits. And this Mera states is a good approximation to ground states of gapless spin systems. And perhaps we can even study, we can learn something about quantum gravity. In particular, it's known that random logarithmic depth circuits exhibit a property called information scrambling and these reminiscence of dynamics describing black holes. And of course, if we allow depth polynomial in the number of qubits, we basically have universal quantum computer. So we can realize anything in BQP. In this talk, I will restrict myself to constant depth circuits. And so let me start from some terminology. So a circuit of depth D consists of D time steps such that each time step is a product of these joint gates. So this is an example of depth five circuit composed of two qubit gates. And so this circuit has some classical input and classical output. And say input is just k bit stink and we initialize the first k qubits in 0 or 1 according to this input stink. And there could be some ancillary qubits that we initialize in 0. And at the end of the day, we measure some subset of qubits in 0, 1 basis and this defines output stink of the circuit. And so the main object we are interested in is this output probability distribution. It tells us what is probability of observing some output Z provided where the input is x. And so what I mean by constant depth circuits is actually an infinite family of such circuits parameterized by number of qubits n. And the depth of the circuits is bounded by some constant independent of n. And I'm going to consider a fixed gate sets also independent of n. Now I guess the most important question is there's a constant depth quantum circuits can outperform classical computers. That is solve some problem which is hard for polynomial size classical circuits. As I said, we believe that probably the answer is yes, but we cannot hope to get unconditional proof. Because if we can prove that the answer is yes, we can separate complexity class BQP from the class BPP which would imply some major breakthroughs in classical complexity theory. For example, we would separate p-space from p. And somehow here we ask perhaps a simpler question. We ask whether constant depth quantum circuits can solve some computational problem which is hard for constant depth classical circuits. So we are comparing quantum circuits and classical circuits, but in both cases we restrict to constant depth. And we will see that this is a much simpler question. But it turns out that the answer depends on what exactly do we mean by a computational problem. And usually in complexity theory people study decision problems. So what it means is that input of the problem is some b string x and output is just a single bit z which tells whether x has or doesn't have some property. But it's not hard to see that if a constant depth quantum circuit can solve a decision problem, it can also be solved by a very simple classical circuit. And basically we can use causality to show that somehow this output bit z can only depend on a constant number of input bits. So you suppose we have some constant depth circuit Q that solves a decision problem and then we can compute probability distribution of z by measuring expectation value of some single qubit observable or say acting on the first qubit on the final state produced by the circuit. And so this expectation value is given by this equation. And so you can see that this operator, well if u is a constant depth circuit this operator acts only on constant number of qubits. So this is some quantum circuit which has only constant size. And of course we can simulate it by a classical circuit of constant size. So somehow for decision problems the answer to this question is no. And so next let's consider search problems. So here the input is still a b string but the output is not a single bit it could be a set of some n bit strings. So for each input there are many possible outputs and each output is a bit string. And one example of such search problem would be a combinatorial optimization like solving a three set problem. So here input x describes some system of equations with binary variables and a set of solutions z is just a set of bit strings that satisfy all equations. So these search problems appear naturally in many areas. And we can say that a quantum circuit solves a search problem if for any input x it outputs a valid solution perhaps with some small error probability epsilon. So we want to have this condition for any input x. Remember that this thing is the output probability distribution of the circuit. And so this is a summary of our results. So I will show you one example of a search problem that can be solved with certainty by a constant depth quantum circuit. And moreover this quantum circuit only requires nearest neighbor gates on a two dimensional grid of qubits. On the other hand we prove that somehow if some classical circuit solves this problem with non-negligible error probability such circuit must have logarithmic depth. So in the quantum case the depth is constant and in the classical case it's at least logarithmic. And in the classical case somehow we allow arbitrary gates to have to be nearest neighbor or geometrically local in any sense. But as usual there is some fine print. You can probably not read this. But what it says is that this problem can be solved classically in polynomial time. So somehow we don't achieve quantum speedup similar to Schur's algorithm. But this is a quantum advantage if we restrict both quantum and classical to a constant depth. Anyway, and this is the plan for the rest of my talk. So first of all I will formally define this problem. We call it hidden linear function problem. Then I will show you a constant depth quantum algorithm that solves this problem. And in the rest of the talk I will sketch the proof that basically gives you a lower bound on the depth of a classical circuit that solves this problem. Okay, so let me define what is hidden linear function problem. So suppose we are given some binary matrix A and it has to be symmetric. Then we can define several things. We can define null space of this matrix. And this is a set of n-bit strings that are annihilated by this matrix modulo 2. So just the usual null space, but it's defined modulo 2. And we can define a quadratic form. So here we take the argument of this form is n-bit string. So these variables are binary. And so here I use matrix vector notations. So x is column vector and this is x transpose is a row vector. And for technical reasons I evaluate this form modulo 4. Now let me just illustrate this by example. Suppose we have three variables and we have this symmetric binary matrix. Then what is the null space of A? Well, we have to solve this system of equations. And well, it's not hard to check that the null space consists of all zero vector and all one vector. And the quadratic form associated with A would be given by this equation. So this x1 and x3 comes from diagonal matrix elements. And because x are binary variables, say x1 is the same as x1 squared. And the purpose of this example is to illustrate one distinction between real-valued quadratic forms and binary ones. So say if x is a real vector which is annihilated by A, then of course this quadratic form evaluates to zero. But surprisingly, this is not the case for binary quadratic form. Say if you look at this example and we pick x as all-month vector, then this quadratic form evaluates to something non-zero. And more generally, one can easily show the following property. If we take this binary quadratic form and restrict it to null space of A, then we get some Boolean linear function. So more precisely, we can represent q of x as 2 times some Boolean linear function L of x, and this is true for all x in the null space of A. And any Boolean linear function can be parameterized by this secret bit string z. So the linear function is just in a product between z and x, up to this factor of 2. And the problem I'm going to consider is defined as follows. The input of the problem is a binary symmetric matrix A of some size n, and the output is just with a secret bit string z. So we ask that if we restrict this quadratic form to the null space of A, then it coincides with linear function just in a product between x and the secret string z. Yes, so this is the problem that I'm going to consider. And the first thing we can note is that for a given matrix A, there are many solutions z. Say if z is one solution, we can pick any vector of y from the binary orthogonal complement to the null space of A, then z plus y is another solution. So this is what I call a search problem. For a given input, we have multiple solutions z. And another property is that this problem can be solved classically in polynomial time using just basic linear algebra. Say we can first compute a set of basis vectors for this null space of A, and then we just need to solve a linear system of equations modular too. So it turns out that this problem is closely related to this Bernstein-Vazirani problem. And in the Bernstein-Vazirani settings we also have some hidden linear function parameterized by a bit string z. But this linear function is given to us as an oracle. And the oracle implements this unitary operator. So here the goal is to find this secret string z using as few queries to the oracle as possible. And in the quantum case, we can find z using a single query. We just need to implement this simple quantum circuit. But in the classical case, we need to evaluate this linear function at least n times to learn z. So the only difference between our problem and Bernstein-Vazirani is that in our case there is no oracle. So the linear function is specified by this quadratic form. And the quadratic form is given by a list of coefficients. And I'm going to consider a certain restricted version of this hidden linear function problem defined on a two-dimensional grid. So we assume that these variables x live at sides of a two-dimensional grid with n sides. And matrix A basically is adjacent to matrix for some subgraph of the grid. So we only allow non-zero matrix elements if i and j are nearest neighbor sides. And then non-zero matrix... non-zero of diagonal matrix elements correspond to some subset of edges of the grid. And non-zero diagonal elements correspond to some subset of vertices of the grid. And so in the rest of the talk, I'm going to consider this two-dimensional version of the problem. So next let me show a quantum algorithm that solves this problem. And the algorithm is actually quite simple. So we are going to have two registers. One register consists of n qubits and it's initialized in zero state. And the second register is basically classical and it stores the input matrix A. And then we implement this quantum circuit. So we have layer of Hadamars and then we have a layer of CZ gates. But each CZ gate controlled by this classical register. So if we have a pair of qubits i, j with non-zero matrix element of A, we are going to apply a CZ gate. And then we do similar layer of control S gates. So for every qubit with diagonal matrix element of A equals to one, we apply the S gate. And finally, we measure each qubit in zero one basis. So we get some output and bit string Z. And what we can show is that this Z is always a solution of the hidden linear function problem. And moreover, the output distribution of this circuit is the uniform distribution on the set of all solutions. And so you can see that the gate set used by this circuit consists of only of Clifford gates. But most strictly, these are classically controlled Clifford gates. This is not too important. And moreover, all gates are geometrically local on a two-dimensional grid. So we only use nearest neighbor gates. Now, let me give you some intuition why this algorithm works. Well, it's not hard to compute the output distribution and it turns out to be given by this equation. So it's Fourier transform of a phase function controlled by this quadratic form. And this is very similar to output distribution of IQP circuits that we saw in Michael's talk on the first day. And using the fact that QFX is a quadratic form, one can show that basically we can restrict this sum to new space of A. And if x belongs to the new space of A, we know that this quadratic form becomes some linear function L of x. And this expression looks very similar to output distribution of the Bernstein-Wazirani algorithm. So basically if z is not solution of the problem, some terms in this sum are plus one, some terms are minus one, and you have cancellations. So the sum evaluates to zero. But if z is solution, then you have constructive interference and the probability is not zero. Now let's move to classical circuits and just some terminology. So a classical gate basically computes a Boolean function. So we have some number of input bits k, which is called fan in of the gate. And we have some number of output wires called fan out of the gate. And the function computed by the gate is copied to every output wire. And I'm going to consider circuits with bounded fan in. So the number of input wires is bounded by some constant k. And a depth D classical circuit basically consists of D time steps. And like in this example, we have just two time steps. And each time step is a product of this joint gates. And so this is our main technical results. So this gives a lower bound on the depth of a classical circuit that solves two-dimensional instances of the hidden linear function problem. And this bound grows logarithmically with number of qubits n. And this constant depends only on fan in, which is some constant. Now, here I'm considering probabilistic circuits. And what it means is that the circuit takes as input this binary symmetric matrix A and some random bit strings are, which can be drawn from some arbitrary distribution. And then we apply some sequence of gates. And what we can show is that if the output of this circuit is a solution of the HLF problem, this high probability then the depth of the circuit must be logarithmic in n. Sorry, this capital N should be actually little n. And to prove this result, we exploit the fact that input-output correlations of this HLF problem exhibit quantum non-locality, which is very similar to quantum non-locality in Bell experiments or JHD experiment. And on the other hand, we will show that classical circuit will input-output correlations of classical circuits cannot somehow achieve this form of non-locality. And the proof proceeds in several steps. So I will start from completely local classical circuits, which are basically local hidden variable models. Then we shall consider classical circuits with geometrically local gates. And then finally, constant depth classical circuits. And just let me give you a few definitions. So suppose we have classical circuit with some inputs x and some outputs z. Then we can look at some output bit and find all input bits that are causally connected to this output. So this subset of input bits is what I call the light-con of this output bit. And in a similar fashion, we can look at some input variable x1 and consider a set of all output bits causally connected to x1. So this will be the light-con of x1. So let's start from completely local classical circuits. And I'm going to use this jg-type relation. So suppose we have a classical circuit, these inputs x1, x2, x3, and outputs z1, z2, z3. And suppose that input-output correlations of the circuit are there with jg-t relation. And here I assume that output variables are plus minus one instead of zero one, but it's not too important. Then what can we say about locality of such circuit? They're known that it's impossible to satisfy with jg-t relations using these local hidden variables. And what it means is that each output bit is a function of the corresponding input bits and some shared random variable h. And more generally, one can prove this result that if a classical circuit obeys this jg-t relation with high probability, then the light-con of some input bit must contain a distinct output bit. So in that sense, the circuit cannot be completely local. On the other hand, if somehow we allow shared entanglement, we can just take 3 qubit jg-state distributed between these three parties, and then each party measures its qubit of jg-state in either x or y basis depending on the value of the input variable. And one can check that the measurement outcomes always satisfy this jg-t relation. So in that sense, quantum non-locality bits are completely local classical circuits. And in the following, I will consider more complicated relations like this one. And I will write such relations in a compact form. So we just have some relation that depends on inputs x and output z. And we want it to be satisfied if input bits sum up to 0, modulo 2. So let's move to geometrically local classical circuits. And instead of jg-state, I'm going to consider these graph states defined on a cycle or a ring of n qubits. So we start from O0 state, apply a layer of Hadamars, and then we apply a CZ gate for each nearest neighbor pair of qubits. And now I define certain pattern of measurements on this graph state. So I'm going to pick some triple of qubits, u, v, w, that are measured in either x or y basis. And all remaining qubits are measured in x basis. So this defines these input-output correlations. So I have three input bits that determine measurement basis at u, v, and w. And I have n outcomes z that determine measurement outcomes on all n qubits. And we are going to use a nice result from this paper by Barrett et al. So they showed that these input-output correlations obey a certain relation, which is a generalization of jg-state relation. And I'm going to call this a cycle relation. And this relation, I'm not going to write it down explicitly, but the rough intuition is that if you can see the reduced state of qubits u, v, w, after all other qubits have been measured, this is actually the jg-state. And there is some power correction that depends on this measurement outcomes z. So what we can show is the following result. So suppose we have a classical circuit that satisfies this cycle relation with a high probability. Then we can find some input variable xi, such that its light cone contains a distant output variable. Say this could be x, y, could define measurement basis for this qubit. Then its light cone would contain some remote output variable. Now, how is this related to our hidden linear function problem? So let me remind you this quantum circuit that solves a HLF problem. And you can think of the first half of the circuit as preparation of a graph state defined on a certain graph depending on A. And this is basically the graph with adjacency matrix A. And you can think of the second half of the circuit as a bunch of single qubit measurements, and we measure each qubit either in x-bases or y-bases depending on the diagonal matrix element of A. So this is actually very similar settings to what I showed you before in this one-dimensional graph state. And because we are free to choose this adjacency matrix A as we like, we can choose it as adjacency matrix of one-dimensional cycle embedded in this grid. And we can choose diagonal matrix elements, such that we have this triple of qubits, w located on this cycle, and these qubits are measured in either x-bases. So if you have some classical circuit that solves all two-dimensional instances of the HLF problem, it must also solve all instances of this one-dimensional cycle problem. Okay, and finally, let's consider general constant-depth classical circuits, and such circuits have the property that the light-con of each output variable contains a constant number of input variables, because the circuit has constant depth and each gate has constant number of input wires. And we use this property to prove the following result. So suppose this classical circuit has depth sufficiently small, then we can find some triple of vertices on this grid, u, v, w, and we can find a cycle gamma that passes, that contains u, v, and w, such that light-con of input variables associated with u, v, and w do not contain any output variables that belong to gamma and are located far from u, v, and w. And basically this property implies that such classical circuit cannot solve, cannot satisfy this cycle relation on this red cycle. And this implies that it cannot solve all instances of two-dimensional HLF problem with high probability. So this basically proves the desired low-bound on the depth of classical circuit. Now I want to conclude with some open problems. So as I mentioned, we know that this HLF problem has polynomial time classical algorithm. And basically one way to get such algorithm is just to classically simulate a quantum circuit that solves the problem. So the quantum circuit uses only Clifford gates, and we can simulate it using, say, Aronson-Gottesmann algorithm. And using the fact that all gates are nearest neighbors on a grid, you can do this simulation in time n squared. On the other hand, the quantum circuit has a constant depth, so it runs in time linear in n. And we conjecture that actually n squared is the best classical algorithm that we know. So it's possible that we actually have a square root quantum speedup for this problem. Then you can ask whether this quantum advantage that we observed is robust to noise. And for HLF problem defined on a grid, the answer is probably no. But it would be interesting to consider the generalization of this problem defined on other sparse graphs. And you can also define, well, the question is whether we can define the generalization of this problem by replacing a quadratic form with some more general function, say, cubic polynomial. And yes, so there are interesting open problems related to this complexity of sampling. So if instead of considering all possible inputs, we can try to restrict the circuit to a single input and ask whether we can sample the output distribution using constant depth classical circuit. And let me conclude here. Thank you for your attention. Questions? Is this working? Good. So thanks for the talk. It's like a very beautiful result. I wonder if the original work of Barrett has sort of this connection to bounding the communication in these non-local correlations. Is there a way to turn this into one of these classes of Bell inequalities with communication? So we write down a normal Bell inequality says local hidden variables won't work. Is there a way to immediately take this and sort of write down an experiment that people can run that sort of say that in order to simulate that experiment there'd have to be this much communication? Yes, so I think this was the motivation for this work by Barrett at all. And we tried to, as you said, we tried to generalize local hidden variable models to the case with some bounded communication. And so this cycle relation is basically a generalization of the Bell inequality to this setting. So I guess you probably, I think in that paper they had to restrict their classical communication to the nearest neighbors. And your result sort of implies that a model where you can broadcast actually can still result in that. Is that correct? Yes, I think you're right. Thank you. Other questions? I have the mic. Is this working? Yeah. So you show that classically this problem is in polynomial time and there's an n-squared time algorithm. Do you know what is the smallest classical complexity class into which you can put this 2D HLF problem? Like is it in log space or something? Well, it's basically it amounts to solving a system of linear equations modulated to. So I don't know the answer to your question but my conjecture would be it's probably in NC class because we know that linear systems can be solved in NC. We have time for one more question. Okay, so another question. Let's thank Sergey. Okay.