Complexity limitations on one-turn quantum refereed games

02/04/2020 ∙ by Soumik Ghosh, et al. ∙ 0

This paper studies complexity theoretic aspects of quantum refereed games, which are abstract games between two competing players that send quantum states to a referee, who performs an efficiently implementable joint measurement on the two states to determine which of the player wins. The complexity class QRG(1) contains those decision problems for which one of the players can always win with high probability on yes-instances and the other player can always win with high probability on no-instances, regardless of the opposing player's strategy. This class trivially contains QMA∪co-QMA and is known to be contained in PSPACE. We prove stronger containments on two restricted variants of this class. Specifically, if one of the players is limited to sending a classical (probabilistic) state rather than a quantum state, the resulting complexity class CQRG(1) is contained in ∃·PP (the nondeterministic polynomial-time operator applied to PP); while if both players send quantum states but the referee is forced to measure one of the states first, and incorporates the classical outcome of this measurement into a measurement of the second state, the resulting class MQRG(1) is contained in P·PP (the unbounded-error probabilistic polynomial-time operator applied to PP).

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Abstract notions of games have long played an important role in complexity theory. For example, combinatorial games provide complete problems for various complexity classes [DH09], the notion of alternation is naturally described in game-theoretic terms [CKS81], and interactive proof systems [Bab85, BM88, GMR85, GMR89] and many variants of them are naturally formulated as games [Con87, FKS95].

This paper is concerned with games between two competing, computationally unbounded players, administered by a computationally bounded referee. In the classical setting, complexity theoretic aspects of games of this form were investigated in the 1990s by Koller and Megiddo [KM92], Feigenbaum, Koller, and Shor [FKS95], Condon, Feigenbaum, Lund, and Shor [CFLS95, CFLS97], and Feige and Kilian [FK97]. Quantum computational analogues of these games were later considered in [GW05], [Gut05], [GW07], and [JW09].

Our focus will be on one-turn refereed games, in which the players and the referee first receive a common input string, and then each player sends a single polynomial-length (quantum or classical) message to the referee, who then decides which player has won. We will refer to the two competing players as Alice and Bob

for convenience. In the classical case Alice and Bob’s messages may in general be described by probability distributions over strings, while in the quantum case Alice and Bob’s messages are described by mixed quantum states, which are represented by density operators. In both cases, the referee’s decision process must be specified by a polynomial-time generated family of (quantum or classical) circuits. Two complexity classes are defined—

in the classical setting111We note explicitly that this nomenclature clashes with [FK97], which defines in terms of one-round (i.e., two-turn) refereed games, which is with respect to our naming conventions. and in the quantum setting—consisting of all promise problems for which there exists a game (either classical or quantum, respectively) such that Alice can win with high probability on inputs and Bob can win with high probability on inputs , regardless of the other player’s behavior.

In essence, the complexity classes and may be viewed as extensions of the classes MA and QMA in which two competing Merlins, one whose aim is to convince the referee (whose role is analogous to Arthur, also called the verifier, in the case of MA and QMA) that the input string is a yes-instance of a given problem, and the other whose aim is to convince the referee that the input string is a no-instance.

It is known that the complexity class is equal to , which refers to the second level of the symmetric polynomial-time hierarchy introduced by Canetti [Can96] and Russell and Sundaram [RS98]. This class is most typically defined in terms of quantifiers that suggest games in which Alice and Bob choose polynomial-length strings (as opposed to probability distributions of strings) to send to the referee, but the class does not change if one adopts a bounded-error definition in which Alice and Bob are allowed to make use of randomness [FIKU08]. Moreover, the class does not change if the referee is permitted the use of randomness, again assuming a bounded-error definition. An essential fact through which these equivalence may be proved, due to Althöfer [Alt94] and Lipton and Young [LY94], is that non-interactive randomized games always admit near-optimal strategies that are uniform over polynomial-size sets of strings. It is also known that is closed under Cook reductions [RS98] and satisfies [Cai07].

In contrast to the containment , the best upper-bound known for is that this class is contained in PSPACE [JW09]. It is reasonable to conjecture that a stronger upper-bound on can be proved. Indeed, Gutoski and Wu [GW13] proved that , where is a two-turn analogue of , in which the referee first sends polynomial-length quantum messages to Alice and Bob, then receives responses from them, and finally decides which player wins. The classical analogue of , which we denote by , is also known to be equal to PSPACE [FK97].

In this work we consider two restricted variants of , and prove stronger upper-bounds than PSPACE on these restricted variants. The first variant is one in which Alice is limited to sending a classical message to the referee, while Bob is free to send a quantum state. The resulting class, which we call , is proved to be contained in (the class obtained when the nondeterministic polynomial-time operator is applied to PP

). This containment follows from an application of the Althöfer–Lipton–Young technique mentioned above, although in the quantum setting the proof requires relatively recent tail bounds on sums of matrix-valued random variables, as opposed to a more standard Hoeffding–Chernoff type of bound that suffices in the classical case. In particular, we make use of a tail bound of this sort due to Tropp

[Tro12]. The second variant we consider is one in which both Alice and Bob are free to send quantum states, but where the referee must first measure Alice’s state and then incorporate the classical outcome of this measurement into a measurement of Bob’s state. We call the corresponding class , and prove the containment (the class obtained when the unbounded error probabilistic polynomial-time operator is applied to PP).

2 Preliminaries

We assume the reader is familiar with basic aspects of computational complexity theory and quantum information and computation. There are four subsections included in this preliminaries section, the first of which clarifies a few specific concepts, conventions, and definitions concerning complexity theory. The second subsection is concerned specifically with counting complexity, and presents a development of some results on this topic that are central to this paper. Proofs are included because these results represent minor generalizations of known results on counting complexity. The third subsection discusses a few specific definitions and concepts from quantum information and computation, along with a proof of a fact that may be considered a known result, but for which a complete proof does not appear in published form. The final subsection states the tail bound due to Tropp mentioned above.

Complexity theory basics

Throughout this paper, languages, promise problems, and functions on strings are assumed to be over the binary alphabet . The set of natural numbers, including 0, is denoted .

A function of the form is said to be polynomially bounded

if there exists a deterministic Turing machine that runs in polynomial time and outputs

on input for all . Unless it is explicitly indicated otherwise, the input of a given polynomially bounded function is assumed to be the natural number , for whatever input string

is being considered at that moment. With this understanding in mind, we will write

in place of when referring to the natural number output that is determined in this way. For example, in Definition 1 below, all of the occurrences of in the displayed equations are short for . This convention helps to make formulas and equations more clear and less cluttered.

A promise problem is a pair of sets of strings with . Strings in represent yes-instances of a decision problem, strings in represent no-instances, and all other strings represent “don’t care” inputs for which no restrictions are placed on a hypothetical computation for that problem.

We fix a pairing function that efficiently encodes two strings into a single binary string denoted , and we assume that this function satisfies some simple properties:

  • The length of the pair depends only on the lengths and , and is polynomial in these lengths.

  • The computation of and from , as well as the computation of from and , can be performed deterministically in polynomial time.

One suitable choice for such a function is suggested by the equation

(1)

for . Any such pairing function may be extended recursively to obtain a tuple function for any fixed number of inputs by taking

(2)

for strings , where . Hereafter, when we refer to the computation of any function taking multiple string-valued arguments, we assume that these input strings have been encoded into a single string using this tuple function. For instance, when is a function that represents a computation, we write rather than .

Finally, we define the nondeterministic and probabilistic polynomial-time operators, which may be applied to an arbitrary complexity class, as follows.

Definition 1.

For a given complexity class of languages , the complexity classes and are defined as follows.

  • The complexity class contains all promise problems for which there exists a language and a polynomially bounded function such that these two implications hold:

    (3)
  • The complexity class contains all promise problems for which there exists a language and a polynomially bounded function such that these two implications hold:

    (4)

Counting complexity

Counting complexity is principally concerned with the number of solutions to certain computational problems. Readers interested in learning more about counting complexity and some of its applications are referred to the survey paper of Fortnow [For97]. As was suggested at the beginning of the current section, we will require some basic results on counting complexity that represent minor generalizations of known results. We begin with the following definition.

Definition 2.

Let be any complexity class of languages over the alphabet . A function is a function if there exist languages and a polynomially bounded function such that

(5)

for all .

We observe that this definition is slightly non-standard, as gap functions are usually defined in terms of differences between the number of accepting and rejecting computations of nondeterministic machines (as opposed to a difference involving two potentially unrelated languages and ). It is also typical that one focuses on specific choices for , particularly . Our definition is, however, equivalent to the traditional definition in this case, and we will write GapP rather than so as to be consistent with the standard name for this class of functions. We will also be interested in the case , which yields a class of functions that is less commonly considered.

The following proposition is immediate from the definitions of and .

Proposition 3.

Let be a complexity class of languages that is closed under complementation. A promise problem is contained in if and only if there exists a function such that

(6)

A key feature of the class of GapP functions that facilitates its use is that it possess strong closure properties. This is true more generally for the class provided that itself possesses certain properties. For the closure properties we require, it suffices that is nontrivial (meaning that contains at least one language that is not equal to or ) and is closed under the join operation as well as polynomial-time truth-table reductions. (The join of languages and is defined as .) These properties are, of course, possessed by both P and PP, with the closure of PP under truth table reductions having been proved by Fortnow and Reingold [FR96] based on methods developed by Beigel, Reingold, and Spielman [BRS95].

The lemmas that follow establish the specific closure properties we require. For the first property the assumption that is closed under joins and polynomial-time truth-table reductions is not required; closure under Karp reductions suffices.

Lemma 4.

Let be a nontrivial complexity class of languages that is closed under Karp reductions. Let and let be a polynomially bounded function. The function

(7)

is a function.

Proof.

By the assumption that , there exists a polynomially bounded function and languages such that

(8)

for all and . By the assumptions on our pairing function described above, it is the case that depends only on and , and therefore there exists a (necessarily polynomially bounded) function such that for all and . Define

(9)

By the nontriviality and closure of under Karp reductions, it is evident that . It may be verified that

(10)

for all , and therefore . ∎

For the next lemma, and elsewhere in the paper, we will use the following notation for convenience: denotes the set of all strings over the binary alphabet that have length and contain exactly one occurrence of the symbol 1. It is therefore the case that .

Lemma 5.

Let be a nontrivial complexity class of languages that is closed under joins and polynomial-time truth table reductions. Let and let be a polynomially bounded function. The function

(11)

is a function.

Proof.

Given that , there exists a polynomially bounded function and languages such that

(12)

for all . We may assume further that and are disjoint languages, for if they are not, we may replace and with and , respectively; this does not change the value of the right-hand side of the equation (12), and the languages and must both be contained in for by the closure of under joins and truth-table reductions.

By the assumptions on our pairing function described above, there exists a polynomially bounded function such that for all and . We will write to denote the elements of sorted in lexicographic order. Define two languages and as follows:

  • is the language of all pairs , where and , for which there exists a string having even parity such that

    (13)
  • is the language of all pairs , where and , for which there exists a string

    having odd parity such that

    (14)

Given that and are disjoint and contained in , along with the fact that is closed under joins and truth-table reductions, it follows that . The lemma now follows from the observation that

(15)

for all , where . ∎

Lemma 6.

Let be a nontrivial complexity class of languages that is closed under joins and polynomial-time truth table reductions, let , and let and be polynomially bounded functions. For every string and , define the matrix as

(16)

for all . There exist functions and satisfying

(17)

for all and , where denote the elements of sorted in lexicographic order.

Proof.

By the assumptions on stated in the lemma, there must exist a function satisfying

(18)

for all , , and . The matrix defined as

(19)

for all , and may be visualized as a block matrix:

(20)

We observe that

(21)

Given that is a function, there must exist a function for which

(22)

for all , , and .

Finally, define

(23)

for all and , as well as

(24)

for all and . It follows by Lemmas 4 and 5 that .

Observing that and satisfy the equations (17), which is perhaps most evident from the equation (21), the proof of the lemma is complete. ∎

Quantum information and quantum circuits

The notation we use when discussing quantum information is standard for the subject, and we refer the reader to the books [NC00, KSV02, Wil17, Wat18] for further details. A couple of points concerning quantum information notation and conventions that may be helpful to some readers follow.

First, when we refer to a register

, we mean a collection of qubits that we wish to view as a single entity, and we then use the same letter

in a scripted font to denote the finite-dimensional complex Hilbert space associated with

(i.e., the space of complex vectors having entries indexed by binary strings of length equal to the number of qubits in

). The set of density operators acting on such a space is denoted .

Second, a channel transforming a register into a register is a completely positive and trace-preserving linear map that transforms each density operator into a density operator . (More generally, such a mapping transforms arbitrary linear operators acting on into linear operators acting on .) The adjoint of such a channel is the uniquely determined linear map transforming linear operators acting on  into linear operators acting on that satisfies the equation

(25)

for all density operators and all positive semidefinite operators acting on . The adjoint of a channel is not necessarily itself a channel, but rather is a completely positive and unital linear map, which means that (for and denoting the identity operators acting on and , respectively). Intuitively speaking, if is a measurement operator in the equation above, one can think of as transforming the measurement operator into a new measurement operator , with the probability of this outcome for the state being the same as if one first applied to and then measured with respect to .

Now we will move on to quantum circuits, which are acyclic networks of quantum gates connected by qubit wires. We choose to use the standard, general model of quantum information based on density operators and quantum channels, as opposed to the restricted model of pure state vectors and unitary operations, when discussing quantum circuits. In this general model, each gate represents a quantum channel acting on a constant number of qubits—including nonunitary gates, such as gates that introduce fresh initialized qubits or gates that discard qubits. Through this model, ordinary classical circuits, as well as classical circuits that introduce randomness into computations, can be viewed as special cases of quantum circuits. One may also represent measurements directly as quantum gates or circuits.

It is well-known that this general model is equivalent to the purely unitary model, as is explained in [AKN98] and [Wat09], for instance. The main benefits of using the general model in the context of this paper are that (i) it allows us to avoid having to constantly distinguish between input qubits and ancillary qubits, or output qubits and garbage qubits, and (ii) it has the minor but nevertheless positive side effect of eliminating the appearance of the irrational number in many of the formulas that will appear.

We choose a universal gate set from which all quantum circuits are assumed to be composed. The gates in this set include Hadamard, Toffoli, and phase-shift gates (which induce the single-qubit unitary transformation determined by the actions and ), as well as ancillary gates and erasure gates. Ancillary gates take no input qubits and output a single qubit in the state, while erasure gates take one input qubit and produce no output qubits, and are described by the partial trace. Any other choice for the unitary gates that is universal for quantum computing could be taken instead, but the gate set just specified is both simple and convenient.

The size of a quantum circuit is defined to be the number of gates in the circuit plus the total number of input and output qubits. Thus, if a quantum circuit were to be represented in a standard way as a directed acyclic graph, its size would simply be the number of vertices, including a vertex for each input and output qubit, of the corresponding graph.

A collection of quantum circuits is said to be polynomial-time generated if there exists a polynomial-time deterministic Turing machine that, on input , outputs an encoding of the circuit . When such a family is parameterized by tuples of strings, it is to be understood that we are implicitly referring to one of the tuple-functions discussed previously. We will not have any need to discuss the specifics of the encoding scheme that we use, but naturally it is assumed to be efficient, with the size of a circuit and its encoding length being polynomially related.

The following lemma relates the complexity of computing circuit transition amplitudes to GapP functions. The essential idea it expresses is due to Fortnow and Rogers [FR99], who proved a variant of it for unitary computations by quantum Turing machines. While a result along the lines of the lemma that follows is suggested in the survey paper [Wat09], that paper does not include a proof, and so we include one below.

Lemma 7.

Let be a polynomial-time generated family of quantum circuits, where each circuit takes input qubits and outputs qubits, for polynomially bounded functions and . There exists a polynomially bounded function and GapP functions and such that

(26)

for all , , and .

Proof.

Consider first an arbitrary channel that maps -qubit density operators to -qubit density operators. The action of on density operators is linear, and can therefore be represented through matrix multiplication. One concrete way to do this is to use the so-called natural representation (also known as the linear representation) of quantum channels.

A description of the natural representation of a quantum channel begins with the vectorization mapping: assuming is a matrix whose rows and columns are indexed by strings of some length , the corresponding vector is indexed by strings of length according to the following definition:

(27)

In words, the vectorization map reshapes a matrix into a vector by transposing the rows of the matrix into column vectors and stacking them on top of one another.

With respect to the vectorization mapping, the action of the channel is described by its natural representation , which is a linear mapping that acts as

(28)

for every -qubit density operator . As a matrix, has columns indexed by strings of length and rows indexed by strings of length . Its entries are described explicitly by the equation

(29)

holding for every and . The equations (26) may therefore be equivalently written as

(30)

It must be observed that the natural representation is multiplicative, in the sense that channel composition corresponds to matrix multiplication: for all channels and for which the composition makes sense. It is also helpful to note that a channel corresponding to a unitary operation has as its natural representation the operator

(31)

Now let us turn to the family . Because this family is polynomial-time generated, there must exist a polynomially bounded function for which for all . We may therefore write

(32)

for being either identity channels or channels that describe the action of a single gate of tensored with the identity channel on all of the qubits besides the inputs of the corresponding gate that exist at the moment that the gate is applied. We also observe that the number of input qubits and output qubits of each must be bounded by .

Given that

(33)

we are led to consider the natural representation of each channel . It will be convenient to identify each operator with the matrix indexed by strings of length , as opposed to being indexed by strings whose lengths depend on the number of qubits in existence before and after

is applied, simply by padding

with rows and columns of zero entries.

The natural representations of the individual gates in the universal gate set we have selected are as follows:

  • Hadamard gate:

    (34)
  • Phase gate:

    (35)
  • Toffoli gate:

    (36)
  • Ancillary qubit gate:

    (37)
  • Erasure gate:

    (38)

Based on these representations, it is straightforward to define GapP functions (or, in fact, FP functions) and such that

(39)

for all , , and , where we write to denote the elements of sorted in lexicographic order. It now follows through a straightforward application of Lemma 6 there must exist GapP functions and satisfying (26) and therefore (30), for all , , and , as required. ∎

A tail bound for operator-valued random variables

We will make use of the following tail bound on the minimum eigenvalue of the average of a collection of operator-valued random variables. This bound follows from a more general result due to Tropp. In particular, the bound stated in the theorem below follows from Theorem 5.1 of

[Tro12] together with Pinsker’s inequality, which relates the relative entropy of two distributions to their total variation distance.

Theorem 8 (Tropp).

Let and be positive integers, let and be real numbers, and let be independent and identically distributed operator-valued random variables having the following properties:

  • Each takes positive semidefinite operator values satisfying .

  • The minimum eigenvalue of the expected operator satisfies .

It is the case that

(40)

3 Complexity classes for one-turn quantum refereed games

In this section we define the complexity classes to be considered in this paper: , , and . The definitions of these classes all refer to the notion of a referee, which (in this paper) is a polynomial-time generated family

(41)

of quantum circuits having the following special form.

  • For each , the inputs to the circuit are grouped into two registers: an qubit register and an -qubit register , for polynomially bounded functions and .

  • The output of each circuit is a single qubit, which is to be measured with respect to the standard basis immediately after the circuit is run.

Given that classical probabilistic states may be viewed as special cases of quantum states (corresponding to diagonal density operators), this definition of a referee can still be used in the situation in which either or both of the registers and is constrained to initially store a classical state.

We are interested in the situation that, for a given choice of an input string , the input to the circuit is a product state of the form , where is a state of the register and is a state of the register . The state is to be viewed as representing the state that Alice plays, while represents the state Bob plays. When the single output qubit of the circuit is measured with respect to the standard basis, the outcome 1 is interpreted as “Alice wins,” while the outcome 0 is interpreted as “Bob wins.”

Now, consider the quantity defined as

(42)

Given that and are compact and convex sets, and the value is bilinear in and , Sion’s min-max theorem implies that changing the order of the minimum and maximum does not change the value of the expression. That is, this quantity may alternatively be written

(43)

This value represents the probability that Alice wins the game defined by the circuit , assuming both Alice and Bob play optimally. With that definitions in hand, we may now define the complexity class , which is short for one-turn quantum refereed games.

Definition 9.

A promise problem is contained in the complexity class if there exists a referee such that the following properties are satisfied:

  • For every string , it is the case that .

  • For every string , it is the case that .

We also define .

In this definition, and may be constants, or they may be functions of the length of the input . A short summary of known facts and observations concerning the complexity class follows.

  • . This is because the referee’s measurement may simply ignore Bob’s state and treat Alice’s state as a quantum proof in a QMA proof system.

  • is closed under complementation: . For a promise problem , one may obtain a one-turn quantum refereed game for by simply exchanging the roles of Alice and Bob.

  • It is the case that for a wide range of choices of and , similar to error bounds for BPP, BQP, and QMA. In particular, provided that and are polynomial-time computable and satisfy

    (44)

    for some choice of a strictly positive polynomially bounded function .222Error reduction may be performed through parallel repetition followed by majority vote. An analysis of this method for QRG(1) requires that one considers the possibility that the dishonest player (meaning the one that should not have a strategy that wins with high probability) entangles his or her state across the different repetitions, with the claimed bounds following from a similar analysis to parallel repetition followed by majority vote for QMA [KSV02]. We note that there is no “in place” error reduction method known for QRG(1) that is analogous to the technique of [MW05] for QMA.

  • [JW09].

The question that originally motivated the work reported in this paper is whether the containment can be improved. We do not succeed in improving this containment, but we are able to prove stronger bounds on two interesting restricted variants of , which we now define.

The first variant of we define is one in which Alice’s state is restricted to be a classical state. We will call this class .

Definition 10.

A promise problem is contained in the complexity class if there exists a referee such that the following properties are satisfied:

  • For every string , the circuit takes the form illustrated in Figure 1. That is, takes an -qubit register and an -qubit register as input, measures each qubit of with respect to the standard basis, leaving it in a classical state, and then runs the circuit on the pair , producing a single output qubit.

  • For every string , it is the case that .

  • For every string , it is the case that .

We also define .

Figure 1: A referee. The register is initially measured (or, equivalently, dephased) with respect to the standard basis, causing a classical state to be input into , along with the register , which is unaffected by this standard basis measurement.

Formally speaking, the standard basis measurement suggested by Definition 10 can be implemented by independently performing the completely dephasing channel on each qubit of . This channel can be constructed using the universal gate set we have selected using a Toffoli gate with suitably initialized inputs as follows:

Tr

Tr

Here the square labeled is an ancillary gate, the square labeled denotes an ancillary gate composed with a not-gate (for and denoting Hadamard and phase-shift gates), and the square labeled Tr denotes an erasure gate.

In effect, a referee that satisfies the first requirement of Definition 10 forces the state Alice plays to be a classical state (i.e., a state represented by a diagonal density operator). That is, for any density operator that Alice might choose to play, the state of that is input into takes the form

(45)

for some probability vector over -bit strings, and therefore the state that is plugged into the top qubits of the circuit represents a classical state. Given that the standard basis measurement acts trivially on all diagonal states, we observe that Alice may cause an arbitrary diagonal density operator of the form (45) to be input into . In short, the set of possible states that may be input into the top qubits of the circuit is precisely the set of diagonal -qubit density operators.

The second variant of we define is one in which Alice and Bob both send quantum states to the referee, but the referee first measures Alice’s state, obtaining a classical outcome, which is then measured together with Bob’s state (as illustrated in Figure 2).

Figure 2: An referee.
Definition 11.

A promise problem is contained in the complexity class if there exists a referee such that the following properties are satisfied:

  • For every string , the circuit takes the form illustrated in Figure 2. That is, takes an -qubit register and an -qubit register as input, and first applies a quantum circuit to , yielding a -qubit register , for a polynomially bounded function. The register is then measured with respect to the standard basis, so that it then contains a classical state, and finally a quantum circuit is applied to the pair , yielding a single qubit.

  • For every string , it is the case that .

  • For every string , it is the case that .

We also define .

In essence, an referee measures Alice’s qubits with respect to a general, efficiently implementable measurement, which yields a -bit classical outcome, which is then plugged into along with Bob’s quantum state.

It is of course immediate that

(46)

a CQRG(1) referee is a special case of an MQRG(1) referee in which is the identity map on qubits, while an MQRG(1) referee is a special case of a QRG(1) referee. We also observe that both and are robust with respect to error bounds in the same way as was described above for .

4 Upper-bound on CQRG(1)

In this section, we prove that CQRG(1) is contained in . The proof represents a fairly direct application of the Althöfer–Lipton–Young [Alt94, LY94] technique, although (as was suggested above) the quantum setting places a new demand on this technique that requires the use of a tail bound on sums of matrix-valued random variables. We will split the proof of this containment into two lemmas, followed by a short proof of the main theorem—this is done primarily because the lemmas will also be useful for proving in the section following this one. Some readers may wish to skip to the statement and proof of Theorem 14 below, as it explains the purpose of these two lemmas within the context of that theorem.

The first lemma represents an implication of Theorem 8 due to Tropp to the setting at hand.

Lemma 12.

Let and be positive integers, let be a probability distribution on -bit strings, let be a positive semidefinite operator satisfying for each , and let . For strings sampled independently from the distribution , it is the case that

(47)
Proof.

Define to be independent and identically distributed operator-valued random variables, each taking the (operator) value with probability , for every . The expected value of each of these random variables is therefore given by

(48)

By taking and in Theorem 8, we find that