Quantum Adversary (Upper) Bound

We describe a method to upper bound the quantum query complexity of Boolean formula evaluation problems, using fundamental theorems about the general adversary bound. This nonconstructive method can give an upper bound on query complexity without producing an algorithm. For example, we describe an oracle problem which we prove (non-constructively) can be solved in $O(1)$ queries, where the previous best quantum algorithm uses a polylogarithmic number of queries. We then give an explicit $O(1)$-query algorithm for this problem based on span programs.


Introduction
The general adversary bound has proven to be a powerful concept in quantum computing. Originally formulated as a lower bound on the quantum query complexity of Boolean functions [6], it was proven to be a tight bound both for the query complexity of evaluating discrete finite functions and for the query complexity of the more general problem of state conversion [8]. The general adversary bound is the culmination of a series of adversary methods [1,2]. While the adversary method in its various forms has been useful in finding lower bounds on quantum query complexity [3,7,11], the general adversary bound itself can be difficult to apply, as the quantity for even simple, few-bit functions must usually be calculated numerically [6,11].
One of the nicest properties of the general adversary bound is that it behaves well under composition [8]. This fact has been used to lower bound the query complexity of evaluating composed total functions, and to create optimal algorithms for composed total functions [11]. Here, we extend one of the composition results to partial Boolean functions, and use it to upper bound the query complexity of Boolean functions. We do this by obtaining an upper bound on the general adversary bound.
Generally, finding an upper bound on the general adversary bound is just as difficult as finding an algorithm, as they are dual problems [8]. However, using the composition property of the general adversary bound, when given an algorithm for a Boolean function f composed d times, we obtain an upper bound on the general adversary bound of f . Due to the tightness of the general adversary bound and query complexity, this procedure gives an upper bound on the query complexity of f , but because it is nonconstructive, it doesn't give any hint as to what the corresponding algorithm for f might look like. The procedure is a bit counter-intuitive: we obtain information about an algorithm for a simpler function by creating an algorithm for a more complex function. This is similar in spirit to the tensor power trick, where an inequality between two terms is proven by considering tensor powers of those terms 1 .
We describe a class of oracle problems called Constant-Fault Direct Trees (introduced by Zhan et al. [13]), for which this method proves the existence of an O(1) query algorithm. While this method does not give an explicit algorithm, we show that a span program algorithm achieves this bound. The previous best algorithm for Constant-Fault Direct Trees has a query complexity that is polylogarithmic in the size of the problem.
In Section 2 we describe the upper bound on the general adversary bound. In Section 3 we apply this bound to Constant-Fault Direct Trees and prove the existence of a constant query algorithm. In Section 4 we describe the span program based quantum algorithm for Constant-Fault Direct Trees.

A Nonconstructive Upper Bound on Query Complexity
Our procedure for creating a nonconstructive upper bound on query complexity relies on the fact that the general adversary bound behaves well under composition and is a tight lower bound on quantum query complexity. The standard definition of the general adversary bound is not necessary for our purposes, but can be found in [7], and an alternate definition appears in Appendix A.
Our procedure applies to Boolean functions.
Given a Boolean function f and a natural number d, we define f d , "f composed d times," recursively as (For background on bounded-error quantum query complexity and quantum algorithms, see [1].) There are seemingly similar results in the literature; for example, Reichardt proves in [9] that the query complexity of a function composed d times, when raised to the 1/d th power, is equal to the adversary bound of the function, in the limit that d goes to infinity. This result gives insight into the exact query complexity of a function, and its relation to the general adversary bound. In contrast, our result is a tool for upper bounding query complexity, possibly without gaining any knowledge of the exact query complexity of the function. One might think that Theorem 1 is useless because an algorithm for f d usually comes from composing an algorithm for f . If J is the query complexity of the algorithm for f , one expects the query complexity of the resulting algorithm for f d to be at least J d . In this case, Theorem 1 gives no new insight. Luckily for us, composed quantum algorithms do not always follow this scaling. If there is a quantum algorithm for f that uses J queries, where J is not optimal (i.e. is larger than the true bounded error quantum query complexity of f ), then the number of queries used when the algorithm is composed d times can be much less than J d . If this is the case, and if the non-optimal algorithm for f is the best known, Theorem 1 promises the existence of an algorithm for f that uses fewer queries than the best known algorithm, but, as Theorem 1 is nonconstructive, it gives no information as to the form of the algorithm.
We need two lemmas to prove Theorem 1: For any Boolean function f : S → {0, 1} with S ⊆ {0, 1} n and natural number d, Høyer et al. [6] prove Lemma 1 for total Boolean functions 2 , and the result is extended to more general total functions in [8]. Our contribution is to extend the result in [8] to partial Boolean functions. While Theorem 1 still holds for total functions, the example we consider later in the paper involves partial functions. The proof of Lemma 1 closely follows the proof in [8] and can be found in Appendix A.
Lemma 2. (Lee, et al. [8]) For any function f : S → E, with S ∈ D n , and E, D finite sets, the bounded-error quantum query complexity of f , Q(f ), satisfies We now prove Theorem 1: Proof. Given an algorithm for f d that requires O(J d ) queries, by Lemma 2, Combining Eq. (3) and Lemma 1, Raising both sides to the 1/d th power, We now have an upper bound on the general adversary bound of f . Finally, using Lemma 2 again, we obtain

Example where the General Adversary Upper Bound is Useful
In this section we describe a function, called the 1-Fault Nand Tree, for which Theorem 1 gives a better upper bound on query complexity than any previously known quantum algorithm. The 1-Fault Nand Tree was proposed by Zhan et al. [13] to obtain a super-polynomial speed-up for a partial Boolean formula, and is a specific type of Constant-Fault Direct Tree, which was mentioned in Section 1. We first define the Nand Tree, and then explain the allowed inputs to the 1-Fault Nand Tree.
The Nand Tree is a complete, binary tree of depth d, where each node is assigned a bit value. The leaves are assigned arbitrary values, and any internal node v is given the value nand(val(v 1 ), val(v 2 )), where v 1 and v 2 are v's children, and val(v i ) is the value of the node v i .
To evaluate the Nand Tree, one must find the value of the root given an oracle for the values of the leaves. (The Nand Tree is equivalent to solving nand d , although the composition we will use for Theorem 1 is not the composition of the nand function, but of the Nand Tree as a whole.) For arbitrary inputs, Farhi et al. showed that there exists an optimal quantum algorithm in the Hamiltonian model to solve the Nand Tree in O(2 0.5d ) time [5], and this was extended to a standard discrete algorithm with quantum query complexity O(2 0.5d ) [4,10]. Classically, the best algorithm requires Ω(2 0.753d ) queries [12]. Here, we consider the 1-Fault Nand Tree, which is a Nand Tree with a promise that the inputs satisfy certain conditions. Definition 1. (1-Fault Nand Tree [13]) Consider a Nand Tree of depth d (as described above). Then to each node v, we assign an integer κ(v) such that: • κ(v) = 0 for leaf nodes.
• Otherwise v has children v 1 and v 2 A tree satisfies the 1-fault condition if κ(v) ≤ 1 for any node v in the tree.
Notation: When a node has one child with value 1 and one child with value 0 (val(v 1 ) = val(v 2 )), we call the node v a fault. (Since nand(0, 1) = nand(1, 0) = 1, fault nodes must have value 1, although not all 1-valued nodes are faults.) The 1-fault condition is a limit on the amount and location of faults within the tree. In a 1-Fault Nand Tree, if a path moving from a root to a leaf encounters any fault node and then passes through the 0-valued child of the fault node, there can be no further fault nodes on the path. An example of a 1-Fault Nand Tree is given in Figure 1.
The condition of the 1-Fault Nand Tree may seem strange, but it has a nice interpretation when considering the correspondence between Nand Trees and game trees 3 . The 1-Fault Nand Tree corresponds to a game in which, if both players play optimally, there is at most one point in the sequence of play where a player's choice affects the outcome of the game. Furthermore, if a player makes the wrong choice at the decision point, the game again becomes a single-decision game, where if both players play optimally for the rest of play, there is at most one point where a player's choice affects the outcome of the game.
Zhan et al. [13] describe a quantum algorithm for the d-depth 1-Fault Nand Tree that requires O(d 2 ) queries to an oracle for the leaves. However, when the d-depth 1-Fault Nand Tree is composed log d times, their algorithm requires only O(d 3 ) queries. Here we see an example where the number of queries required by a composed algorithm does not scale exponentially in the number of compositions, which is critical for applying Theorem 1. Applying Theorem 1 to the algorithm for the 1-Fault Nand Tree composed log d times, we find that an upper bound on the query complexity of the 1-Fault Nand Tree is O(1). This is a large improvement over O(d 2 ) queries. Zhan et al. prove Ω(poly log d) is a lower bound on the classical query complexity of 1-Fault Nand Trees. An identical argument can be used to show that Constant-Fault Nand Trees (from Definition 1, trees satisfying κ(v) ≤ c with c a constant) have query complexity O(1).
In fact, Zhan et al. find algorithms for a broad range of trees, where instead of nand, the evaluation tree is composed of a type of Boolean function called a direct function. A direct function is a generalization of a monotonic Boolean function, and includes functions like majority, threshold,

Span Program Algorithm for Constant-Fault Direct Trees
The structure of Constant-Fault Direct Trees can be quite complex, and it is not obvious that there should be an O(1)-query algorithm. Inspired by the knowledge of the algorithm's existence, thanks to Theorem 1, we found a span program algorithm for Constant-Fault Direct Trees that requires O(1) queries. It makes sense that the optimal algorithm uses span programs, not just because span programs can always be used to create optimal algorithms [8], but because Theorem 1 is based on properties of the general adversary bound, and there is strong duality between the general adversary bound and span programs. Span programs are linear algebraic representations of Boolean functions, which have an intimate relationship with quantum algorithms. In particular, Reichardt proves [9] that given a span program P for a function f , there is a function of the span program called the witness size, such that one can create a quantum algorithm for f with query complexity Q(f ) satisfying Thus, creating a span program for a function is equivalent to creating a quantum query algorithm.
There have been many iterations of span program-based quantum algorithms, due to Reichardt and others [8,9,11]. Zhan et al. create algorithms for direct Boolean functions [13] using the span program formulation described in Definition 2.1 in [9], one of the earliest versions (we will not go into the details of span programs in this paper). Using the more recent advancements in span program technology, we show here: Theorem 2. Given an evaluation tree composed of the direct Boolean function f , with the promise that the tree satisfies the k-fault condition (k a natural number), there is a quantum algorithm that evaluates the tree using O(w k ) queries, where w is a constant that depends on f . In particular, for a Constant-Fault Direct Tree (k a constant), the algorithm requires O(1) queries.
While Theorem 1 promises the existence of O(1)-query quantum algorithms for Constant-Fault Direct Trees, Theorem 2 gives an explicit O(1)-query quantum algorithm for these problems. The proof combines properties of the witness size of direct Boolean functions with a more current version of span program algorithms.
First we define a k-Fault Direct Tree, which is a Boolean evaluation tree made up of a direct Boolean function composed many times, with a promise on the input. The definition of direct Boolean functions are a bit technical and are given in [13]; here we will just use their properties. Given a direct Boolean function f with n inputs, a Direct Tree for f is a depth-d, n-partite complete graph, where each node is given a Boolean value. The value of the node v, val(v) is given by val where v i is the i th child node of v. The values of the leaves are given via an oracle, and the goal is to find the value of the root of the tree. A k-Fault Direct Tree is a Direct Tree with inputs that satisfy certain conditions; the definition is similar to Definition 1 for 1-Fault Nand Trees: Definition 2. Let T be a Direct Tree for f . Let each node be labeled as fault or trivial based on the values of its children and the specific function f used. For each node, depending on the values of its children, a set of its child nodes are labeled strong in relation to the node, and the remaining child nodes are labeled weak. For trivial nodes, all children are strong. Then to each node v we assign an integer κ(v) such that: • κ(v) = 0 for leaf nodes.
If v is a fault, then κ(v) = 1 + max i:v i is strong κ(v i ).
A tree satisfies the k-fault condition if κ(v r ) ≤ k where v r is the root.
Notice that the restriction κ(v r ) ≤ k is slightly relaxed compared to Definition 1, where it was required that κ(v) ≤ 1 for all nodes v in the whole tree. Thus the span program algorithm we describe below applies to an even broader range of trees than were included in the discussion in Section 3.
For f = nand, a node whose two children have the same value (either both 0 or both 1), is trivial, and a node with one 0-valued child and one 1-valued child is a fault. Furthermore, for f = nand, for fault nodes, the 0-valued child is strong, and the 1-valued child is weak. One can verify that with these designations, Definition 1 corresponds to Definition 2 for f = nand.
For a function f : S → {0, 1}, with S ⊆ {0, 1} n , input x ∈ S, and span program P , the weighted witness size on input x is wsize s (P, x) where s ∈ (R + ) n is the weighting vector. When s = (1, . . . , 1), we write wsize 1 (P, x). Following [9], we rewrite Eq. (7) as In [13], Zhan et al. show that for any direct Boolean function f , one can create a span program P with the following properties 4 : • wsize 1 (P, x) = 1 if input x makes the function trivial.
• wsize 1 (P, x) ≤ w, if input x makes the function a fault, where w is a constant depending only on f .
• For wsize s (P, x), s j do not affect the witness size, where the j th input bit is weak.
To create an algorithm, we will combine these facts with Eq. (8) and the following composition lemma: . , x n ), x i ∈ C and g(x i ) ∈ S ∀i. Letx = (g(x 1 ), . . . , g(x n )) ∈ S. Let G be a span program for g, F be a span program for f , and s ∈ (R + ) n×m . Then there exists a span program P for f • g such that where r = (wsize s 1 (G, x 1 ), . . . , wsize s n (G, x n )) and s i is a vector of the i th set of m elements of s.
The main difference between this lemma and that in [9] is that the witness size here is input dependent, as is needed for partial functions. We also use a single inner function g instead of n different functions g i , but we allow each inner function to have a different input. The proof of this result follows exactly using the proof of Theorem 4.3 in [9], so we will not repeat it here. Using the properties of strong and weak nodes in direct Boolean functions, we see that wsize r (F,x) in (9) doesn't depend on r i = wsize s i (G, x i ) for weak inputs i. Thus, we can rewrite Eq. (9) as We now prove Theorem 2: Proof. For a direct function f , we know there is a span program P such that wsize 1 (P, x) ≤ w for all fault inputs and wsize 1 (P, x) = 1 for trivial inputs. We will show that this implies the existence of a span program for the k-Fault Direct Tree with witness size ≤ w k . We will use an inductive proof on k, the number of faults. For the base case, consider a depth 1 tree. This is just a single direct Boolean function. If its input makes the function a fault, using the properties of direct Boolean functions, there is a span program for this input with witness size at most w. If the depth 1 tree has has an input that makes the function trivial, there is a span program for this input with witness size at most 1. Thus there exists quantum algorithm with query complexity O(1) that evaluates this tree.
Consider a depth d, k-fault tree T with input x. We can think of this instead as a single direct function f (with inputx and span program P ), composed with n subtrees of depth d − 1, where we label the i th subtree T i . Let P T i be a span program for T i , and we call the input to that subtree x i . Ifx makes f a fault, then by Eq (10) we know there exists a span program P T for T such that: Now if we take the subtree T i * that maximizes the 2 nd line, then by the definition of k-fault trees, T i * is a (k − 1)-fault tree. By inductive assumption, there is a span program for T i * satisfying wsize 1 (P T i * , x i ) ≤ w k−1 , so T satisfies wsize 1 (P T , x) ≤ w k , and there is a quantum algorithm for the tree that uses O(w k ) queries. Given the same setup, but now assuming the inputx makes f trivial, then by Eq (10) we have: Now if we take the subtree T i * that maximizes the 2 nd line, then by the definition of fault trees, T i * is a κ fault tree with κ ≤ k. But we know if κ ≤ k − 1, then wsize 1 (P T i * , x i ) ≤ w k−1 by inductive assumption, so we're done in that case. So instead we assume κ = k. Thus we have reduced the problem to a smaller depth tree, and we can repeat the above procedure until we find the first subtree with a fault at its root (in which case we are back to the previous case) or show that there are no further faults in the tree (in which case the tree can be evaluated in O(1) queries). Since the tree has finite depth, this procedure will terminate.

Conclusions
We describe a method for upper bounding the quantum query complexity of Boolean functions using the general adversary bound. Using this method, we show that Constant-Fault Direct Trees can always be evaluated using O(1) queries. Furthermore, we create an algorithm with a matching upper bound using span programs.
We would like to find other examples where Theorem 1 is useful, although we suspect that Constant-Fault Direct Trees are a somewhat unique case. It is clear from the span program algorithm described in Section 4 that Theorem 1 will not be useful for composed functions where the base function is created using this type of span program. However, there could be other types of quantum walk algorithms, for example, to which Theorem 1 might be applied. In any case, this work suggests that new ways of upper bounding the general adversary bound could give us a second window into quantum query complexity beyond algorithms.
Beside the practical application of Theorem 1, the result tells us something abstract and general about the structure of quantum algorithms. There is a natural way that quantum algorithms should compose, and if an algorithm does not compose in this natural way, then one knows that something is non-optimal.

Acknowledgements
Many thanks to Rajat Mittal for generously explaining the details of the composition theorem for the general adversary bound. Thanks to the anonymous FOCS reviewer for pointing out problems with a previous version, and also for encouraging me to find a constant query span program algorithm. Thanks to Bohua Zhan, Avinatan Hassidim, Eddie Farhi, Andy Lutomirski, Paul Hess, and Scott Aaronson for helpful discussions. This work was supported by NSF Grant No. DGE-0801525, IGERT: Interdisciplinary Quantum Information Science and Engineering and by the U.S. Department of Energy under cooperative research agreement Contract Number DE-FG02-05ER41360.

A Composition Proof
In this section, we will prove Lemma 1: This proof follows Appendix C from Lee et al. [8] very closely, including most notation. The difference between this Lemma and that in [8] is that f is allowed to be partial. We write out most of the proof again because it is subtle where the partiality of f enters the proof, and to allow this appendix to be read without constant reference to [8]. First, we use an expression for the general adversary bound derived from the dual program of the general adversary bound: where g : C → {0, 1}, with C ⊆ {0, 1} m and all matrices are indexed by x, y ∈ C, so e.g.
[W ] xy is the element of W in the row corresponding to input x and column corresponding to input y. W can always be chosen to be symmetric. G satisfies [G] xy = δ g(x),g(y) , and ∆ i satisfies [∆ i ] xy = 1 − δ x i ,y i , with x i the value of the i th bit of the input x. We call ∆ i the filtering matrix. 0 means positive semidefinite, J is the all 1's matrix, and W • J means take the sum of all elements of W . When • is used between uppercase or Greek letters, it denotes Hadamard product, while between lowercase letters, it denotes composition.
We want to determine the adversary bound for a composed function f • g consisting of the functions g : C → {0, 1} with C ⊆ {0, 1} m and f : S → {0, 1} with S ⊆ {0, 1} n . We consider the input to f • g to be a vector of inputs x = (x 1 , . . . , x n ) with x i ∈ C. Given an input x to the composed function, we denote the input to the f part of the function asx:x = (g(x 1 ), . . . , g(x n )). Let (W, Ω) be an optimal solution for g with ADV ± (g) = d g and (V, Λ) be an optimal solution for f with ADV ± (f ) = d f . To clarify the filtering matrices, we say ∆ g q is indexed by inputs to g, ∆ f p is indexed by inputs to f , and ∆ f •g (p,q) is indexed by inputs to the composed function f • g.
refers to the (pm + q) th bit of the input string.) We assume that the initial input x = (x 1 , . . . , x n ) is valid for the g part of the composition, i.e. x i ∈ C ∀i. A problem might arise ifx, the input to f , is not an element of S. This is an issue that Lee et al. do not have to deal with, but which might affect the proof. Here we show that the proof goes through with small modifications.
The main new element we introduce is a set of primed matrices, which extend the matrices indexed by inputs to f to be indexed by all elements of {0, 1} n , not just those in S. For a primed matrix A , indexed by x, y ∈ {0, 1} n , if x / ∈ S or y / ∈ S, then [A ] xy = 0. We use similar notation for matrices indexed by x = (x 1 , . . . , x n ) wherex ∈ S; we create primed matrices by extending the indeces to all inputs x by making those elements withx / ∈ S have value 0. Notice if the extended matrices (W , Ω ) are a solution to the dual program, then the reduced matrices (W, Ω) are also a solution. For matrices A indexed by {0, 1} n , we define a new matrixÃ indexed by C n , as [Ã ] xy = [A ]xỹ, wherex is the output of the g functions on the input x, and likewise forỹ and y. A expands each element of A into a block of elements.
Before we get to the main lemma, we will need a few other results: Proof. This claim is stated without proof in [8].M is created by turning all of the elements of M into block matrices with repeated inputs. When an index x ∈ {0, 1} n is expanded to a block of k elements, there are k − 1 eigenstates ofM that only have nonzero elements on this block and that have eigenvalue 0. By considering all 2 n blocks (each element of {0, 1} n becomes a block) we obtain 2 n (k − 1) 0-valued eigenvectors. Next we use the eigenvectors v i of M to create new vectors ṽ i in the space ofM . We give every element in the x th block of is the x th element of v i . The vectors ṽ i complete the basis with the 0-valued eigenvectors, and are orthogonal to the 0-valued vectors, but not to each other. However, the ṽ i have the property that ṽ iTM ṽ j = δ ij λ i where λ i is the eigenvalue of v i , so λ i ≥ 0. Thus using these vectors as a basis, we have that u TM u ≥ 0 for all vectors u.
The following is identical to Claim C.1 from [8] and follows because there is no restriction that g be a total function. Thus we state it without proof: Lemma 5. For a function g, there is a solution to the dual program, (W, Ω), such that ADV ± (g) = d g , d g Ω ± W 0, and x:g(x)=1 Ω(x, x) = x:g(x)=0 Ω(x, x) = 1/2.
In Lemma 6, we will show that ADV ± (f • g) = ADV ± (f )ADV ± (g), which implies Lemma 1. Proof. The first thing to check is that U and Υ are valid primed matrices, or otherwise we can not recover U and Υ. Because each of U and Υ are formed by Hadamard products with primed matrices, they themselves are also primed matrices. We next calculate the objective function, and afterwards check that (U , Υ ) satisfy the conditions of the dual program.
The objective function gives: where in the first line we've replaced V by V because adding extra 0's does not affect the sum. In the second line, a i and b i are the i th bits of a and b respectively, and we've changed the order of multiplication and addition. This ordering change is not affected by the fact that f is partial, since the first summation already fixes an input to f . We now examine the sum We consider the cases a i = b i , and a i = b i separately. When Since Ω is diagonal, it only has non-zero values when x i = y i , and using Lemma 5, the sum is d g /2. When a i = b i , then x i = y i , so [Ω] x i y i = 0. In this case, the sum will include exactly half of the elements of W : either those elements with g(x i ) = 0 and g(y i ) = 1, or with g(x i ) = 1 and g(y i ) = 0. Since W is symmetric, this amounts to 1 2 W • J = d g /2. Multiplying n times for the product over the i s and using the definition of the objective function for f gives the final result: Now we show that U and Υ satisfy the conditions of the dual program. We require that [U ] xy = 0 for (f • g)(x) = (f • g)(y). Notice U = 0 wheneverṼ = 0, and [Ṽ ] xy = 0 for (f • g)(x) = (f • g)(y), so this requirement holds. Likewise Υ is a diagonal matrix because it can only be nonzero where Ω ⊗n is non-zero, and Ω ⊗n is diagonal.
[W ] x i y i = 0 for x = y whileΛ is only nonzero for elements [Λ ] xy with x = y, so any terms involving a Hadamard of W andΛ are 0. Similarly, the Ω in the p th tensor product is only nonzero for x p = y p , but for these inputs, the term (∆ f p ) is always zero, so in fact the non-zero terms of this Ω do not contribute. Thus we are free to replace this Ω with d g Ω • ∆ g q . We obtain Finally, the term (∆ f p ) can be written as J − G acting on only the p th term in the tensor product (d g Ω + W ) ⊗n , so we need to evaluate (J − G) • (d g Ω + W ) • ∆ g q . We have (J − G) • Ω = ∆ g q • Ω = 0, and (J − G) • W = W , so we can remove (∆ f p ) without altering the expression. Now the term {J ⊗(p−1) ⊗ ∆ g q ⊗ J ⊗(n−p) } is almost ∆ f •g (p,q) , except it is like a primed matrix; its indeces are all elements in C n , not just valid inputs to f , yet it is not primed, in that some of its elements to non-valid inputs to f are non-zero. However it is involved in a Hadamard product with Ṽ , a primed matrix, so all of the terms corresponding to non-valid inputs are zeroed, and we can make it be a primed matrix without affecting the expression. We obtain 0 d n−1 gΛ • Ω ⊗n ± (Ṽ • (d g Ω + W ) ⊗n • (∆ f •g (p,q) ) , which is precisely the positivity constraint of the dual program. Finally, we need to check that Tr(cd n−1 gΛ • Ω ⊗n ) = 1: Tr(cd n−1 gΛ • Ω ⊗n ) = cd n−1 g a∈S [Λ] aa x:x=a i [Ω] x i x i = cd n−1 g a∈S where all of the tricks here follow similarly from the discussion following Eq. (14).
Lemma 1 now follows from Lemma 6 along with a simple inductive argument.