Gate robustness:

How much noise will ruin a quantum gate?

Aram Harrow and Michael Nielsen, quant-ph/0212???

Outline1. Why do we care?

– Separable operations cannot create entanglement.– A classical computer can efficiently simulate a circuit

composed of separable* operations.

2. How do we solve it?– The state-gate isomorphism (Choi/Jamiolkowski).– State robustness (Vidal and Tarrach, q-ph/9806094)

3. Do we have any results?– Upper bounds on the accuracy threshold.– The CNOT is the most robust two-qubit gate.– Depolarizing noise is hardest to correct.

Part 1: Motivation.

Separable and separability-preserving operations.

Separable states

• TFAE:– is separable (2Sep).

– =k pk |kihk| ­ |kihk|

– can be created with local operations and shared randomness.

• Sep may be useful for quantum computing.• Sep can be used for non-classical tasks, such as

data hiding states.

Gates states

(E) ´ (EAB­1A’B’) (|iAA’­|iBB’)

A

A0

|iAA’

B

B0

|iBB’

E

(E) + local operations can probabilistically simulate E [Cirac et al]

Alice Bob

Separable operations

TFAE:1. E is a separable quantum operation.

2. E() = k(Ak­Bk)(Aky­Bk

y)

3. (E­1)Sep ½­Sep (E cannot create entanglement)

4. (E)2Sep.

Note: LOCC ( {separable operations}(e.g. decoding data hiding states)

Separability-preserving operations

• E is separability-preserving if E¢Sep½Sep.• Example: SWAP is separability-preserving.• Question: Is {separability-preserving

operations on n parties} = Hull{E±P : E is separable and P is a permutation}?

• Claim: A quantum circuit comprised of separable operations can be simulated efficiently on a classical computer.

Classical simulation algorithm

• Suppose we apply E=k (Ak­ Bk)¢(Aky­ Bk

y) to |1i­|2i.

• Let |ki=Ak|1i­ Bk|2i and pk=hk|ki.• We obtain pk

-1/2|ki with probability pk. • If we use b bits of precision, then the round-

off error is 2-bpk1/2. Since k=1,…,16, it is

very unlikely that we obtain a very small pk (or a very large pk

-1/2).

Part 2: Tools.

How much noise makes a gate separable?

Gate robustness

• Robustness: R(E||F) = min R such that E+RF is separable.

• Random robustness: Rr(E) = R(E||D) where D() = I/d.

• Separable robustness: Rs(E)=minFR(E||F) where F is separable.

• General robustness: Rg(E)=minFR(E||F).• Rg(E) · Rs(E) · Rr(E).

State robustness (Vidal & Tarrach, 9806094)

• Robustness: R(||) = min R such that +R is separable.

• Random robustness: Rr() = R(||I/d).

• Separable robustness: Rs()=minR(||) where is separable.

• General robustness: Rg()=minR(||).

• Rg() · Rs() · Rr().

Robustness of pure states (q-ph/9806094)

• Suppose |i=j aj |ji|ji.

• Rs(|i)=Rg(|i) = (j aj)2-1.

• Rr(|i)=d2a1a2.

Schmidt decomposition of unitary gates

• Any unitary gate U can be decomposed as U = k Ak ­ Bk, with k |k|2=1 and TrAjAk

y=TrBjBky=djk.

• The Schmidt coefficients of (U) are {k}.

• Thus Rr(U)=Rr((U))=d412.

• For qubits (d=2), Rr(U)· Rr(CNOT)=8.

“Unital” gates.

• If U=k k Ak ­ Bk with AkAky=BkBk

y=I/d, then Rs(U)=Rg(U)=Rs((U))=(k k)2-1.

• For example, Rg(CNOT)=1. The optimal noise process is a classical CNOT.

Part 3: Results

The threshold theorem

• For arbitrary two-qubit gates subject to independent depolarizing noise, the threshold is pth<(8-p8)/7¼0.74.

• Different models give different bounds on the threshold.

Optimal gates vs. optimal noise processes

• Rr(U) is maximized for the CNOT, with Rr(U)· Rr(CNOT)=8 for all two-qubit gates.

• Conversely, the completely depolarizing channel, D, is the most effective noise process against arbitrary gates:

minE maxU R(U||E)=maxU R(U||D)=d4/2.

Goals

• Tighter bounds on the threshold.

• General formulas for Rs(U) and Rg(U).

• Characterize the set of separability-preserving operations.

• Determine how much entangling power is necessary for computation.

Simulating separability-preserving gates

• Theorem: Let C be a quantum circuit involving only separability-preserving gates and single-qubit measurements. If C uses T gates, then there exists a classical algorithm that can reproduce the measurement statistics of C to accuracy in time T poly log(1/).