22235
>> Alexandra Kolla: It's a pleasure to have Aram Harrow. He did his Ph.D. at
MIT, as he told me, and was a professor in Bristol. Now he's at UW. And he's brave enough to give a blackboard talk today.
>> Aram Harrow: Thanks. So I'm going to tell you about some quantum stuff
I've been working on. But I will use -- I will describe in a way where it doesn't sound quantum at all.
It's a problem which doesn't have to be quantum. Like you could solve it with totally nonquantum techniques, but bizarrely it happens that most of the progress that's been made on it at least from my subjective point of view, but I think objectively has been quantum.
So what's the problem? We're given a tensor AIJK where I, J and K range from 1 to N. And we want to compute an analog of the largest singular value of this tensor. And this thing is called the injective tensor norm and it's related to a way of defining norms on finite [phonetic] spaces and that's actually totally irrelevant to what I'm going to talk about. So we're going to need that only as far as the name.
And what the thing is the following: It's the maximum over unit vectors of this quantity. So if the third dimension didn't exist, this would just be the largest singular value.
And so that's why you can think of it as a generalization of the largest singular value. And there's a few other ways you can think about it. So you can think of it as simply a maximum over X and Y, and whenever I write X and Y from now they're going to be unit vectors -- I'll stop writing all the conditions -- of I, J, K. So instead of the maximum of a number, we can think of it as the maximum norm of a vector.
So EK is the unit vector --
>>: What's the -- is that over K?
>> Aram Harrow: Sorry. Yeah, thanks. Thanks. Right. I'm summing over K but
Z has gone away but K hasn't. Thanks.
And, right, the reason why this is true is just because the maximum product of a vector with another unit vector is the norm of that vector. And you can further write it as simply the maximum over X of the operator norm of a matrix, where this norm, operator norm means largest singular value.
So it has these different interpretations, which is related to the flexibility of a tensor. So a tensor you can think of as a single vector of length N cubed. You can think of it as a linear map from vectors of length N to matrices, think of it as a tri linear form, all these interpretations you can move between.

So I guess in this talk what I want to do, understand the first part giving you a few more equivalences, and I'll reduce it to a form which is a little bit more congenial to work with.
And then I'll talk about an application to planted Cleek and then I'll tell you about various quantum results related to it.
One of the quantum results is one of the paper I'm on. Some of the others are not. And the quantum results all basically give you results about the hardness of this problem.
And I like them because the first instinct of many people is something I heard
Bala tell me a few weeks ago when I told him I was speaking about the hardness problem.
He said: Nobody works on that. It's too unstructured. There's no structure there. And naively it looks really quite general. But it turns out that there is a fair amount you can say about this problem.
Okay. So the way we'll attack it, I want to focus on this interpretation for now.
And I want to make it look like a convex optimization. So the way to do that will be sort of like the way you can write, if you have a normal matrix M, if you want to write the largest singular value of M you can think of it as the largest, the square root of the largest eigenvalue of M star M.
We can do something similar here. We can say that this square of this norm is equal to the max over XY of this quantity squared. And if you write out this quantity squared, it's simply sum over I-1, I-2, J-1, J-2, sum over K, A-1. J-1, K bar. AI-2 J-2 K XI 1 bar and XI 2, YJ 1 bar. YJ 2.
Looks pretty horrifying but it turns out this is is about to get very simple. Because the first thing we can do is we can separate out the part of the input. So that's this thing here. And let's call this a big matrix B. And let's have the matrix be N squared by N squared.
So it's indexed by I-1, J-1 and I-2, J-2.
And when you do it in this way, this has the form of A-star A. So in particular. D is positive definite. And [inaudible] and the operator norm of B is equal to -- let me say it in words first. We can think of A as a map from the K index, which is an N dimensional space to the IJ indices together. Sorry, K is N dimensional to I indices for N squared dimensional. And B -- in that picture, B is just A star A. So the operator norm of B is equal to the square of the operator norm of A when we have you it as a matrix that's N by N squared. So B is a rather simple thing.
The other nice thing about this is so let's the that this is less than or equal to 1.
Overall normalization, the one I'm going to work with.

It's an if and only if. Goes back and forth. If you take B to be any matrix satisfying these you can construct a corresponding A for which this appears.
You can take the square root of any matrix.
That's this side. What about these Xs and Ys? So we can write this maximization. So this thing here equals the max over X and Y -- this is really bad board technique. This is equal to the maximum over X and Y of the trace of B times a matrix depending on the Xs.
What's that matrix going to be? It will be X, X star, tensor Y, Y star. And what this tensor product means is so if you have matrices X tensor Y, this is equal to the block matrix X1, 1 times Y, X1, 2 times Y. X2 times Y and so on.
So this thing is indexed by I 1, I 2, for example. So this is indexed by I 1 and I 2 and this is indexed by J 1 and J 2 and the whole thing is indexed by I 1, J 2. So what's -- the reason -- this is almost like a convex optimization problem. And to make it a convex optimization problem, we'll turn this into a convex set.
So this set right now is definitely not convex. For example, if you were to get rid of the Ys this would be just the set of rank one projectors, which is definitely not convex.
But the convex hull of it is. So let's define the convex hull of this set. And I'll let -- now I'll let the dimensions perhaps be different. And they're still unit vectors. So this set, using quantum notation we'll say this is a set of separable density matrices. So in quantum land this is the set of states where one party has N1 dimension, the second party has two dimensions, and they don't have any entanglement. They're allowed to have classical correlations between their states but no entanglement.
So what this problem is now is I want to introduce one more piece of notation which is if K is a convex set, then the support function of K is H sub K, and it's equal to the maximum of the inner product of X and Y, where Y is in K.
And for matrices, we define the inner product according to the trace. So using this notation, we can now say that this quantity is basically evaluating the support function of set N comma N of B. So why is that? We're optimizing the trace of B times some element of the set of separable, some element of this set.
And the reason why we can replace this thing with the convex hull of all of those is because it's a linear function on that set.
So what does this mean? It means if we're interested in these tensor problems, it turns into a problem of working with this set. And one immediate corollary comes from the fact that optimizing a linear function over a convex set is equivalent to determining membership in that set. So it's just as hard to determine modulars and epsilons, which I won't get into right now. It's just as hard to calculate these tensor norms as it is to determine membership in this set of matrices, which is something that may seem to you like even more obscure problem, but quantum people have worked on this and there's some partial results on this.

Okay. So, fine, so why do we care about these ten sores? One application is to the planted Cleek problem. Maybe I'll briefly say what that is. So let's say you have a graph on N vertices. And we'll define the matrix E, I, J is 1 if there's an edge from I -- between I and J.
And 0 if not. And our model of a random graph will be to just independently place an adjective of probability half between each pair and edge probability half, edge no probability of half.
And the planted Cleek model, the planted Cleek problem is I choose M vertices and connect edges between all of them.
And then choose the remaining edges to either be present or absent with probability of half. And the problem is distinguish a graph with a planted Cleek from without a planted Cleek. And the problem is parameterized by M and N.
And obviously as M gets bigger, the problem gets easier.
If M were equal to N minus 1, it would be very easy. And it turns out that if M is bigger than -- actually, some constant times 3 N, I believe, is that right, it becomes our best algorithms work when M is bigger than a constant times root
N.
>>: Like when you say work, you mean --
>> Aram Harrow: Poly time. So if M is -- actually, this is a question I don't know.
So suppose M is equal to N to the .49. Then do we have an algorithm that's sort of less than two to the N for that.
>>: N to the log N. [inaudible].
>> Aram Harrow: And it's quasi polynomial down to N equals what?
>>: 2 log N.
>> Aram Harrow: I see.
>>: Down to the Cleek up here. 2 log N is already appearing --
>> Aram Harrow: Right. Right. So I should say even with no planted Cleek you'll have a Cleek of size 2 log N. In quasi poly time you could do 2 log N plus 5 or something.
I see. So, right, so this problem is substantially easier than the worst case of
Cleek, which is NP complete. And it was shown by Brubaker and Sempala in the paper 09052381. I actually mean -- this is the archive number.
>>: We don't do that here.
>> Aram Harrow: Well, Brubaker and Sempala.

>>: [inaudible].
>> Aram Harrow: Yeah. Well, it's informative. At least the first four digits tell you when it came out. So I mean the idea is originally due to Frieze and Kanan, but this is the recent subject. Good place to start looking at it if you were to look at it?
>>: How do you memorize?
>> Aram Harrow: I wrote it down. My own papers I memorized. So the paper
I'm going to talk about, my paper, we tried to get the first paper of 2010. And I was doing something for New Year's that my co-author was slow on the trigger, so we got the 17th paper. But that I can definitely remember.
>>: Instead of talking to this, write down a list of numbers.
>> Aram Harrow: Yeah. Right. You know this joke about there's the prisoners and they say, yeah. You can't do an Irish accent worth a damn.
So what is the relationship planted Cleek in this item. You define tensor as follows. AIJK is equal to minus 1 is basically the parity of the number of edges in a triangle if IJ and K are distinct. I think this qualifier is a little unnecessary, and 0 otherwise. So if some I equals J or I equals K, whatever you set this to 0. But otherwise you set it to be this weird parity.
And --
>>: EIJ.
>> Aram Harrow: The adjacency matrix, because I already took A. So it's E.
Okay. So what's point of this? Well, suppose you have a planted Cleek.
Suppose there was a Cleek. Then let's set X to be 1 over root M on the vertices in the Cleek. And 0 elsewhere. So they're M vertices in the Cleek. So this is a unit vector. And it has a property that when you apply it to A, all of these entries will be minus 1. So when you do this absolute value, you'll get -- so if there's a
Cleek of size M. So Cleek of size M, means there's a vector that achieves that this thing is greater than or equal to, with up to a constant factor, M to the three halves. Because there's M cubed terms that all contribute minus 1. Doesn't matter if it's plus or minus 1, as long as it's the same sign. And each term is weighted by 1 over M to the three halves. So that's if there is a Cleek of size M.
What if there's no Cleek? So that's where they have to actually do work in this paper, show that for random graph, with high probability, this thing should be small and what it is it's order root N.
In fact, what they do is a little bit more. What they show, they actually consider the version with R indices. You have AI1 through ARI minus 1 to the sum over I all pairs between 1 and R of -- different indices -- JK. EIJK.

This is with three indices, generalize it to our indices and then they find if there's a Cleek, then this thing is bigger than M to the R over 2. And if there's no Cleek, this is less than or equal to still root N but now there's a factor of R log N to the order R.
So if you think of R as pretty small, it's still more or less root N and this gets better and better. So what it means is that if you could solve this thing, then the points where these cross is when M is like N to the 1 over R. So when R is 2, that's our existing algorithm, up to these log factors.
When R is I guess when you put in the log factors you go from difficult algorithm to a really trivial algorithm. But it's stuff we can do. But when R is 3, that's more than we know how to do already. So if you had solved this tensor problem, you know, you'd solve something we didn't know how to solve before.
And what I can almost show is that if you could solve a tensor problem with the right parameters for this, you could do stuff that's a lot harder. I can't quite show that. But I'll tell you what I can do.
So I'd like to translate this into this language now. And to do this, I want to sort of set the right scale. So I want to talk about the operator norm of -- let's just stick with three indices. So the question is: What is the operator norm of A as an N by N squared matrix?
>>: So could I just ask, can you shed any light on why it's minus 1 to the power?
Does this somehow automatically make things cancel out in the random case?
>> Aram Harrow: Yeah, I haven't actually read their proof in great detail, but the point is if there's no Cleek, these things should be pointing in different directions.
So if there's a Cleek, then all the signs come out the same way. And then -- so I mean one way of thinking about it, I think the way the proof works is it's your basic epsilon net sort of thing.
So then what you want to do is you want to take an epsilon net over all vectors X,
Y and Z. And then let's restrict actually to the case when X, Y and Z are flat. So suppose you can decompose X into a sum of things where everything is kind of -- you've got a bunch of terms that are all about the same magnitude and a bunch of 0s. So you're basically looking at subsets of your graph.
And then so you look at any -- what this corresponds to it's sort of like taking rectangular sections, if you fix some rectangular section and take a random graph, you've got a bunch of cancellations, that's pretty much the intuition.
Then it's your usual race of exponentials. You've got your epsilon net versus your concentration function. And then they have some very careful concentration of measure arguments. And that's how the proof goes.
And I forget exactly what is their concentration, major contribution. I mean, it's something -- that's where they have to do their work. But that's the intuition.

So let me tell you one thing I haven't worked out. But I think there would follow from their results. So what is the operator norm of this thing?
I didn't actually do the proof for this. I just did numerics. And the numerics are extremely convincing. I guess in this audience, you know, you guys also use numerics. So there won't be any -- you're not carrying any tomatoes.
So what I can say --
>>: [inaudible].
>> Aram Harrow: What I can say is that this operator norm is about N, or order
N. And --
>>: IJ?
>> Aram Harrow: What this means? It means you group together two indices it becomes an N by N squared matrix. It's a plus or minus 1 matrix. So even a single row has norm N, single row has N squared entries, each plus or minus one. Row minus 1. If the rows were orthogonal, then the whole thing would have norm, operator norm N.
And that's sort of what your intuition would tell you and that's what the numerics say. So let's suppose that's true now. Then what we have is -- so we can instruct some matrix B. B will be -- you could say it's sort of AIJK star times AIJK and then let's divide by N squared.
>>: The same with --
>> Aram Harrow: The same. That's my shorthand for doing this -- basically --
>>: The A that you're using is the same A as before?
>> Aram Harrow: This A is from here. So but now I want to divide so I make this normalized. So B has the property that the operator norm of B is less than 1.
>>: And there's random graphs of AIJ --
>> Aram Harrow: If there's no Cleek then this is true, if there's no Cleek then this is true. I think a Cleek wouldn't change this a whole lot, though.
I haven't worked that out. But when I last thought about this I believe the Cleek wouldn't change it by very much at least a Cleek of size N to the one-third.
So this is now we want to distinguish the two cases. And so what happens is that if there's a Cleek -- so I've said that the injective tensor norm squared is this thing. In this notation, Cleek means that H -- can you read this corner here? No.

So Cleek means that HSEP of N comma N of B is greater than or equal to M cubed over N squared. Collecting constant factors. And no Cleek means that this quantity is less than or equal to 1 over N.
So again when M is bigger than N to the one-third, then you get a real separation. And so if M -- and in particular -- so what you'd like to be able to do is figure out whether this quantity is, say, less than 1 over N or greater than 2 over N. That's pretty much the problem that we want to be able to solve is distinguishing those two cases.
>>: Want to start --
>> Aram Harrow: I will in a sec. Yeah. Which is good because I'm allowed to change topics.
>>: Also known as hidden Cleeks.
>> Aram Harrow: Not just planted Cleek but hidden Cleeks.
>>: Both names are used. So that's why your writing is small versus --
>> Aram Harrow: I see. Oh my God. Can anyone read that?
>>: It's supposed to be hidden.
>> Aram Harrow: Yeah. Well, hidden Cleek is like writing on Alexander's white board, whatever words I add, there's a constant backdrop of previous blackboard markers either present or absent.
>>: [inaudible].
>> Aram Harrow: Okay. So that's one reason we like to know this. So let me tell you now with some actual results. And the first result is not due to me, it's due to
0804.02, otherwise known as entanglement by Aaronson Drucker Fefferman and
Shor, someone else like Beigi.
Usually just called Aaronson, et al. But I think this part is due to Shore. So what is the result? The result is suppose -- actually, just one more piece of notation.
This is SEP on N comma N. So let's suppose we have actually several systems, not just two. But K systems. So this is the K when you have K tensors. I'm just going to call this SEP to the K of N.
So our whole thing was SEP to the 2 of N. So what these showed is the following: K, suppose you take K to be order root N. And I'm actually I'm suppressing some poly logs here. Maybe I'll put those in.
>>: Star over --

>> Aram Harrow: Actually, let's do this. Let's say N is equal to M poly log M.
And now what we have, should I be writing bigger still, or is this okay?
What we have is a three set formula phi with M variables and order M clauses.
What the result is that you can encode phi into one of these tensor problems.
So there exists B and a size N to the K. So PST means a set of positive definite matrices. So there's just a big B who is operator norm is equal to 1, or less than or equal to 1.
Sub to that, if phi is satisfiable, then this quantity will equal 1. And if phi is unsatisfiable, then this quantity will be less than a half.
So sometimes we call this the completeness and this the soundness. There's a quantum interpretation of this, which is that you have K quantum provers each sending you log N cubits, and the provers are guaranteed to send you unentangled things. That's why you have these separable states. And then you make some measurements, if the thing is satisfiable, you always output yes. If it is unsatisfiable you output yes with probability at most a half. That's why quantum people have been looking at this.
And one consequence of this is so this set -- it's matrices of N to the K so you might think you could optimize over it in time polynomial in that. This says you can't do that. Not even to constant accuracy.
So it says that if you had a poly N to the K algorithm to estimate H, this quantity, plus or minus some constant error, you know, 0.1, if you could do that, then N to the K here is like N to the root N. So it would say you could solve three sat in time N to the root N, which we don't believe is possible. And that would imply that three sat instances of size M would be contained in time X root M poly log M.
So not quite P equals NP but pretty unlikely. So that is I think the first real hardness result of the problem. It says, okay, well not for the two, not for the case of three index tensors but for like ten a ton of indices you can't solve it in time polynomial input.
Okay. So maybe I shouldn't erase this part. That's okay. Does anyone object to me erasing this part? So what if you have -- what if you have three indices?
That's the case that -- this K indices, who knows that's a problem we haven't thought about that much. Three indices seems a bit more basic. So how hard is that problem?
So it turns out that if you -- so what we want to compute is HSEP squared of N up to some error epsilon. So it turns out that three sat of length N can be solved or reduced to this class, with -- if these parameters no longer have a constant gap. Phi equals 1. S equals 1 minus 1 over a little more than N cubed.
So determining this to very high precision is hard. And this is due to 0810.5109, also known as a paper by Salmon Bagi [phonetic]. Actually, the same result has been rederived many, many times. Each time -- because at the beginning I

wrote down all those different equivalences, each time people proving the hardness of each result, different ones of the equivalences. I think the first proof was in 2002.
But this one has slightly better parameters. So that's fine to this, if you want to get it to super high precision. But what about to constant accuracy? That's the case we care about a little bit more. Although, actually, yeah, this one already is a little bit troubling for that case.
I mean, in a sense you could think of this as constant multiplicative error or 1 over additive error.
So one result -- so the result that I have, which actually sort of -- I obtained this result together with Ashley Montenaro [phonetic] before we even knew anything about tensors or anything. This is sort of what led us to think about all these other problems, is that there's a reduction from the K index case to the two index case.
So this is this paper otherwise known as Harrow Montenaro. And what we found is that for any B, N dimension N to the K by N to the K, their exists some matrix C that's a little bit bigger. But the quantity that we're interested in -- so 1 minus -- this is the quantity that before we wanted to approximate. How large -- how close is this thing to one? But this is more or less approximated for the same thing for C.
But now C we can interpret as being separable across a cut of two systems rather than K. So B, we're optimizing against tensor product of K things. C we're optimizing over tensor product of two things. And this thing here means they're related by constant factors in both directions.
And constructing C from B is very easy. You just write -- the constructions of this form. So you take B, tensor product it with a big identity matrix, and sandwich the whole thing by some projector pi. And pi is the span of vectors of this form.
And let me give you a little intuition why this is true. The details are annoying, but the big picture is not that bad.
The idea is that this B that we're testing, we want to optimize it against things that are product across K indices. So let's say K is five. We've got these five systems here. And what we do is for C we double it, basically. We consider five more systems. And we're optimizing across things that are product across this cut.
Because it's a tensor product of things that are XX star here, tensor YY star here.
And we want this to approximate things that are -- we'd like things to be product across these five systems. And so what we do is we project onto the space.
What we do is we really ask for two copies of the proof. So the proof would be like V1, tensor V2, tensor V3, tensor V4, tensor V5. We say I'd like 2 copies give me one up here and give me one down here.

I'm thinking of this as something where there's a prover who is trying to convince -- I'm going to test trace B against whatever gets sent to me or trace C against whatever gets sent to me and the prover is trying to maximize by choosing something here that's going to maximize that inner product.
And the original problem they're allowed to choose something of this form and the new problem, they're aallowed to choose totally arbitrary state up here, totally arbitrary state up here but at least they have to be product against this cut. And then what I do is I say these are the states I want and I'm going to project on to the span of all of those states. That's what this pi does. It says you know allow anything that's a linear combination of those states.
And it turns out that that gives you a reasonable approximation. Going from the set of all those states to their span doesn't give them that much opportunity for cheating. And for Y that's true. It's details. But that's sort of the idea. So what you do is you first test, is the state even of the right form. Then once you're convinced of the right form you can test one of these against your original state
B, think of B as your first test. And once you know that your states are of the desired form, you apply B to some of those.
So that's why this works. And what does that mean? That means that we can take this three sat formula, create this test, and then turn it into something that's a two index test.
So that means that determined -- so distinguishing whether H SEP 2 of N to the 2
K is bigger than -- actually, let's say N to the 2 root N is either equal to 1 or less than one-half. And I know that constants change, but still you can make this about half again, is at least as hard as a three sat instance of length N over poly log N.
So we've got the same basic hardness result, but now for SEP 2 which corresponds back to 310 sores. So constant factor approximation, if you can do it in poly time then you can solve three sat in sub exponential time.
Okay. So what does all this have to do with planted Cleek? So here we're always talking about completeness one is soundness constant or completeness one and soundness almost one.
With planted Cleek, we have let's say completeness 2 over N and soundness 1 over N. So how hard is that? Well, I believe -- so basically I don't know. I think that by modifying this construction, you can get that this is as hard as 3 sat. And what that would mean is that this is not actually a very good way of self-implanted Cleek. Because you know consult three sat --
>>: Still hardness approximate --
>> Aram Harrow: Yeah. I actually -- I only started thinking about this last night when preparing for this talk. And it almost seemed like it was working but then it didn't quite work. So basically it's something I'm thinking about now.

It feels more like it should work than it shouldn't. But you know --
>>: What should work?
>> Aram Harrow: You take the protocol they did for this. Basically let me tell you a little bit about the completeness for this protocol. So the reason you're taking K to be root N, is that you're demanding -- you're in fact demanding K copies of the exact same state. And then you're doing some tests -- you're doing something to each one that produces a random outcome between 1 and N. And in order to have a meaningful test, you want to have a birthday collision. That's why K has to be root N.
But if you take K to be less than root N, you should still get a collision with probability K squared over N, which is true. And what this does is it's very permissive. It says you take K to be like 10 root N you're overwhelmingly like to have a collision, if you have a collision there's a bunch of further tests you do. If you don't have a collision you're very for giving you just accept anyway.
So the modification would just be strict. If you don't find a collision, you reject right then. And then the good state should -- the yes instance should still have an advantage over the no instance. That's sort of the rough intuition. It's unclear of the details work.
If you think of this as a proof system there's a lot of ways to cheat these proofs.
And the details of this involve going into the bowels of this paper. And it's nothing terribly complicated, it's just a lot of epsilons.
So let me say one --
>>: 2x [inaudible] polynomial time?
>> Aram Harrow: Yeah, they multiply N they add up and the worst is when you take the square root of epsilon, eighth root of epsilon.
Okay. So these are all hardness results. What about algorithms? So I mean that would be I think quite exciting. So it's nice to get a quantum reason why this basic problem is hard. It would be another thing to have a quantum derivation of a classical algorithm. That would be pretty cool too.
That's what this other paper, 1010.750, otherwise known as faithful squashed entanglement, does not sound like an algorithm paper by Brandau Christando and Yard [phonetic]. Probably a lot of people haven't heard of. What they show is the following: That, okay -- actually let me say a little bit more about this.
Suppose if you can do it in poly time you can do it three sat two to the root N.
But suppose H SEP squared of N plus or minus epsilon --
>>: Poly time --
>> Aram Harrow: You could solve this in time polynomial in this quantity here, then you could solve three sat in time 2 to the root N. Let's suppose rescale.

Now this is the size N. Suppose you can solve this -- solve in time F of N. So we know F of N is poly N you get this thing. In general, this means that you can solve three sat N in time F of X of root N poly log N.
So if F is polynomial, you know, this is the situation, but then you can say, well, how large should F be because of this? And this argument says if you think three sat takes exponential time, then F of N should be bigger than X log squared
N.
Or in other words N to the log N. Modular some poly logs which I won't write down. Tilde.
So now these guys Brandau Christando and Yard gave an algorithm with this runtime.
>>: You --
>> Aram Harrow: Yes, almost what you want. So let me write it down. So what they get is --
>>: Stepping of a random graph or there's --
>> Aram Harrow: Well, not quite. Let me say what they do. So they compute H
SEP squared N of B plus or minus epsilon in time X log squared N over epsilon squared. But there's a big asterisk.
>>: Which [inaudible].
>> Aram Harrow: Yes, exactly. So B, of course, should be in this parameter range, but B also has to be what's called a quantum -- B has to correspond to a quantum measurement. Quantum measurements always have this form but B further has to have the property that it can be achieved with local operations and classical communication between two parties.
So one way of saying this is that B should be of the form sum over I, XI tensor YI, where the XIs are all non-negative. They add up to the identity. And the YIs are anywhere between 0 and identity. You can think of this as one side does a measurement corresponding to XI, sends the outcome to the other side who does a binary measurement.
There's actually -- that's one round of communication. For many rounds what you could say is that B -- here's a more general setting. B is of the form sum over IJ root XI tensor root YI times BIJ times root XI tensor root YI, where XI and
YI are non-negative.
So, this is YJ. And they sum to identity. And the BIJs are each recursively of this form or their identity. That's sort of the most general class of things that they cover. So it's a general class of things. But it doesn't -- it's not fully general. On the other hand, our reduction gives you not a fully general B either. If you want to match our reduction, you don't need to simulate the most general possible B,

but the B you need to simulate so hardness is for B of the form sum over I, XI tensor YI, where these are just any positive operators.
So there's sort of a Gulf between these two types of Bs. I feel this runtime, you know, is some evidence of this as the right runtime. But we can restrict B -- we can show that for a general B it's enough to solve it for B of this form. And this form looks kind of similar, but it's not quite the same.
This is somewhat -- this corresponds to one round of communication. This corresponds to many rounds of communication. And these are measurements that cannot create entanglement, but we know that some of these are -- it's generally it's a more general class.
So one big open problem I'd like to resolve is to close this gulf, and it's not a gulf of completeness soundness parameters but of the types of Bs that can be simulated.
And another open problem which I have not thought about for very long at all but
I think is nice is to see whether the parameters that are good enough for planted
Cleek are also good enough for three sat, which I guess would close the door on one approach.
But on the other hand it would say that these ten sores, if we can reduce back and forth between ten sores and three sat problems, then maybe ten sores are not a beast of their own but they fit more naturally into existing hardness.
That's it. Any questions?
[applause].
>>: So you're saying that this doesn't give another algorithm for planted Cleek in each of the log squared N.
>> Aram Harrow: It doesn't, because we don't know that the matrices, the ten sores they construct are of the right form.
>>: So it could be simple [inaudible] is exactly B to the log square N. So --
>> Aram Harrow: If the Cleek is size 2 log N.
>>: Right. For the random graph, which is --
>> Aram Harrow: Wait. Only need to beat --
>>: The random graph, you only need to beat 2 log N.
>> Aram Harrow: I see. If my conjecture held, it wouldn't even then. Because the problem is if my conjecture held then you could get a constant additive error.
But that's not enough to distinguish these.

So it's possible that if this conjecture holds and you further modify this tensor, because basically you've got these like big eigenvalues. If you can somehow truncate those without screwing up the completeness. So if two big modifications held then this would give another algorithm which matched the trivial algorithm.
So, yeah, I guess it's not --
>>: Proofs of each [inaudible].
>> Aram Harrow: Yeah. So for Cleeks, I'm more on the negative -- basically my thoughts for Cleeks are on the negative side. But for the other problem is --
>>: Would there be a way to get a negative job for Cleeks somehow showing that if you could solve planted Cleek, then you can --
>> Aram Harrow: Oh, yeah.
>>: -- then ten sores, and you could get V --
>> Aram Harrow: That's a great question. I guess you could say how much of the reduction can you run backwards. So maybe a general tensor already kind of looks a little bit like their form and the hard part of it is sort of Cleek-like. Yeah, that would be great.
I haven't thought about that too much. I mean, I thought of it very briefly, and it looks like the tensors that they have are of a very specific form.
>>: When [inaudible] was here he was saying that he expects planted Cleek should be easy for any Cleek size of N to the epsilon.
>>: [inaudible].
>>: No.
>>: That's what he said.
>> Aram Harrow: Yeah. So --
>>: That's what he told me. I'm serious.
>> Aram Harrow: Maybe he believes these are different extents.
>>: No, he --
>>: [inaudible].
>> Aram Harrow: So if --
>>: I don't subscribe to either of those beliefs.

>> Aram Harrow: Well, if you don't -- if you strongly disbelieve -- if you believe the exponential time hypothesis for three sat, then if you can show that general tensor problems could be reduced to planted Cleek, that would be some pretty strong evidence that planted Cleek is hard.
>>: Planted Cleek for random graphs you know if the log is --
>> Aram Harrow: Upper bound.
>>: Upper bound.
>> Aram Harrow: So it can't be that hard.
>>: Right.
>> Aram Harrow: Yes. So it's -- yeah, that's -- basically that's -- you can think about these reductions in either direction. It would be -- it would be very interesting if the general difficulty of -- and I guess one thing that's nice about this is this is a question of what values of B do you -- what choices of B do you allow?
And I think one lesson is if you allow fully general B you get stuck earlier. And so just to show that there's some large class of B that reduces to finding a Cleek I think would be quite nice.
>>: But one thing that just the construction suggests is maybe you could try
[inaudible] approach by planted Cleek by building some huge matrix.
>> Aram Harrow: Yes. N to the log N or something.
>>: But still polynomial size, matrix, done by [inaudible] where some, which you build in some sophisticated way by looking at triangles or perhaps path of unstandard graph, and the eigen value matrix --
>> Aram Harrow: The way this thing works it reduces the problem to a matrix of this size and finds the largest eigenvalue of that matrix. And there's -- yeah.
So --
>>: This is the STP? [inaudible].
>> Aram Harrow: What's the watch system?
>>: What do you use to prove this? Prove like three [inaudible].
>> Aram Harrow: Similar to that. They actually -- they sometimes describe their thing as an STP, but it's just the largest eigenvalue problem.
>>: STPs in --
>> Aram Harrow: Well, sometimes you have to do more work to solve an STP.
Yeah, it's simpler -- I think it's simpler than the watcher's thing as far as I

understand the watcher's thing. Maybe another time I can describe what their algorithm is. It's pretty simple. It's just the analysis of it that's tricky.
>> Alexandra Kolla: Let's thank Aram again.
[applause]