Approximate quantum error-correcting codes

Claude Crépeau^{∗}, Daniel Gottesman^{†}, Adam Smith^{‡}

Abstract

It is a standard result in the theory of quantum error-correcting codes that no code of length n can fix more than n/4 arbitrary errors, regardless of the dimension of the coding and encoded Hilbert spaces. However, this bound only applies to codes which exactly correct errors. Naively, one might expect that correcting errors to very high fidelity would only allow small violations of this bound. However, this intuition is incorrect: we construct in this paper quantum error-correcting codes capable of correcting up to n/2 − 1 arbitrary errors with fidelity exponentially close to 1. This demonstrates a severe distinction between exact quantum error correction and approximate quantum error correction.

∗ School of Computer Science, McGill University, Montréal (Qc), Canada H3A 2A7. e-mail: crepeau@cs.mcgill.ca. Supported in part by Québec’s MRST and Canada’s NSERC. Some of this research was done while the author was visiting MSRI, Berkeley CA.

† Perimeter Institute, Waterloo, Ontario, Canada N2J 2W9. e-mail: dgottesman@perimeterinstitute.ca. Some of this research was done while the author was supported by the Clay Mathematics Institute, and some while the author was visiting MSRI, Berkeley CA.

‡ M.I.T., Lab. for Computer Science, Cambridge MA 02139, USA. e-mail: asmith@theory.lcs.mit.edu. Supported in part by U.S. Army Research Office Grant DAAD19-00-1-0177. Some of this research was done while the author was visiting McGill University.

1 Introduction

Quantum computers are likely to be highly susceptible to errors from a variety of sources, much more so than classical computers. Therefore, the study of quantum error correction is vital not only to the task of quantum communications but also to building functional quantum computers. In addition, quantum error correction has many applications to quantum cryptography. For instance, the methods of quantum error correction and fault-tolerant quantum computation can be used to perform multiparty secure quantum computations [8]. For all of these reasons, it is interesting to study bounds on the performance of quantum error-correcting codes (QECCs) in various scenarios.

It is an immediate result of the no-cloning theorem [15] that no quantum error-correcting code of length n can fix n/2 erasures because that would imply that we could reconstruct two copies of an encoded quantum state from two halves of the full codeword. This statement is valid regardless of the dimension of the coding Hilbert space.

Another well known result from the theory of quantum error correction is that a length n code can fix t arbitrary single position errors if and only if it can fix 2t erasure errors [10]. This follows immediately from the quantum error-correction conditions [10]

⟨ψ_{i}|E_{a}^{†}E_{b}|ψ_{j}⟩ = C_{ab}δ_{ij}  (1)

(for basis encoded states {|ψ_{i}⟩} and correctable errors {E_{a}}) and implies that no QECC of length n can fix more than n/4 arbitrary errors, regardless of the dimension of the coding and encoded Hilbert spaces.

In this paper, we show the existence of QECCs of length n that can fix n/2 − 1 arbitrary single position errors with fidelity exponentially close to 1. That is, approximate quantum error-correcting codes have the capability of correcting errors in a regime where no exact QECC will function. This is important for a few reasons:

• It suggests it may be possible to build approximate QECCs which are highly efficient and yet useful in common error correction scenarios, improving on exact QECCs for the same scenarios. In most cases, exact reconstruction of the quantum state is not necessary, so a more efficient approximate QECC would be welcome.

• The approximate QECCs we construct always have efficient decoding algorithms since this procedure depends only on the erasure correction capabilities of a related stabilizer code. Correcting erasures on a stabilizer QECC is always easy as it only requires solving a linear system of equations. This is a highly attractive property, since finding efficient codes with good decoding algorithms is generally a difficult problem.

• It demonstrates that the connection between correcting general errors and erasure errors breaks down for approximate QECCs. This calls into question some of the basic foundations of the theory of quantum error correction, as it suggests there is no sensible notion of distance for an approximate quantum error-correcting code.

• While the codes we present in this paper are not particularly useful for traditional quantum error correction, they may allow verifiable quantum secret sharing (VQSS) and secure multiparty quantum computation (MPQC) beyond previously known bounds (although we do not claim here to construct such protocols). Indeed, the codes we present here show that the purported proof for an upper bound for VQSS which we claimed in a previous paper [8] only holds for exact VQSS.

• It demonstrates that there can be a dramatic difference in behavior between the exact performance of some quantum-mechanical task and approximate performance of the task, even when the approximation is exponentially good. A similar divergence between exact and approximate bounds has recently been seen in the context of private quantum channels [11]. These examples serve as a caution to the entire quantum information community when dealing with approximate performance of quantum protocols.

The idea of using a randomized encoding algorithm is not new in QECC. In particular [5] have devised codes that can correct more (malicious) errors on average than any deterministic QECC. However, their model significantly differs from ours in one of two ways: they assume either that the errors occur at random or that the code is randomly agreed by the coder and the decoder but is kept secret from the adversarial noise source. This model does not seem suitable in applications such as VQSS and MPQC [8]. In our model no secret is shared by the coder and decoder. However, part of our code can be viewed as providing a way for the coder to information-theoretically encrypt the necessary secret. (This is possible since the adversary only has access to part of the transmitted state, though it could be any part.)

The codes we build are somewhat peculiar since they will be linear but of fractional dimension. We now introduce some notation for such objects. A classical [n, k, d]_{Q} code is a linear subspace of dimension k of length n vectors of 𝔽_{Q}-components such that for any two distinct codewords c_{1}, c_{2} we have that c_{1} differs in at least d (out of n) positions from c_{2}. Let 𝔽_{q} be a subfield of 𝔽_{Q} such that q = p^{m} and Q = p^{M} for some prime p and integers m < M. An [n, k, d]_{Q} code contains p^{kM} codewords (it is a (n, Q^{k}, d)_{Q} linear code). If it contains only q codewords associated to the information words of 𝔽_{q} then the resulting code will be an [n, m/M, d]_{Q} code (it is a (n, q, d)_{Q} linear code). Since m < M this code has fractional dimension, and it is linear only over the small field 𝔽_{q}, not over 𝔽_{Q}.

Stabilizer QECCs encoding k Q-dimensional registers in n Q-dimensional registers with quantum distance d (i.e., they are capable of correcting d − 1 erasure errors or ⌊(d − 1)/2⌋ general errors) are conventionally denoted with the notation [[n, k, d]]_{Q}, or ((n, Q^{k}, d))_{Q} for nonstabilizer codes. As in the classical case, we may define stabilizer QECCs with fractional dimension [[n, m/M, d]]_{Q} to be ((n, q, d))_{Q} stabilizer codes. The codes we construct will be approximate QECCs and will not have a well-defined notion of distance, but we will use this notation to indicate codes that can correct d − 1 erasure errors exactly, but may correct more than ⌊(d − 1)/2⌋ general errors approximately.

Note that the no-cloning argument above also trivially applies to QECCs of fractional dimension. Similarly, the relation between error correction and erasure correction mentioned above also applies to such fractional dimension codes: exactly the same proof can be used [10]. This implies that no (fractional dimension) QECC of length n can fix more than n/4 arbitrary errors, regardless of the dimension of the coding Hilbert space.

In clear contrast, the main result of this paper is the construction of [[n, Θ(\frac{1}{n+s}), n/2]]_{Θ(n(n+s))} QECCs that can correct n/2 − 1 arbitrary errors with fidelity at least 1 − 2^{−Ω(s)}.

2 Preliminaries

Classical Authentication In the classical setting, an authentication scheme is defined by a pair of functions A : K × M → C and V : K × C → M × {valid, invalid} such that for any message μ ∈ M and key k ∈ K we have completeness

V_{k}(A_{k}(μ)) = ⟨μ, valid⟩

and that for any opponent O, we have soundness

Prob[V_{k}(O) ∈ {⟨μ̂, invalid⟩|μ̂ ∈ M}] ≥ 1 − 2^{−Ω(t)}

for any message μ ∈ M, Prob[V_{k}(O(A_{k}(μ))) ∈ {⟨μ, valid⟩} ∪ {⟨μ̂, invalid⟩|μ̂ ∈ M}] ≥ 1 − 2^{−Ω(t)}

where t = lg #C − lg #M is the security parameter creating the tradeoff between the expansion of the messages and the security level. Note that we only consider information-theoretically secure schemes, not schemes that are based on computational assumptions.

Wegman and Carter [6] introduced several constructions for such schemes; more recently, Gemmel and Naor [9] introduced a nearly optimal construction using 5t+lg m bits of key (where m is the number of bits of the message). This compares quite well to the known lower bound of t + lg m for such a result [9]. The same work [6] also introduced a technique to re-use an authentication function several times by using one-time-pad encryption on the tag, so that an opponent cannot learn anything about the particular key being used by A and B. Thus, at a marginal cost of only t secret key bits per authentication, the confidentiality of the authentication function h is guaranteed and thus may be re-used. (an aribtrary number of times).

The canonical instances that satisfy this definition come through the notion of a Family of Universal Hash Functions (FUHF) which is a class H of hash functions from M to T (C = M × T) such that • for any message μ ∈ M and tag τ ∈ T, when h is chosen at random from H,

Prob[h(μ) = τ] = 1/#T.

• for any two distinct messages μ_{1}, μ_{2} ∈ M, when h is chosen at random from H,

Prob[h(μ_{1}) = h(μ_{2})] = 1/#T.

Here the encoding function E(μ) = μ|h(μ) and the decoding function D(μ|τ) = \{ \begin{matrix}⟨μ, valid⟩ & if τ = h(μ) \\ ⟨μ, invalid⟩ & otherwise \end{matrix} .

Wegman and Carter [6] have suggested several FUHFs for the special case M = {0, 1}^{m}, T = {0, 1}^{t}. For instance the class H = {h|h(m) = am⌋_{t} ⊕ b, a ∈ GF (2^{m}), b ∈ GF (2^{t})} where m is considered as an element of GF (2^{m}) and where ⌋_{t} means “truncated to the t least significant bits” is a FUHF with key size m + t.

Wegman and Carter also introduced a technique to re-use an authentication function several times by using one-time-pad encryption on the output of the function, so that an opponent cannot learn anything about the particular function which is used by A and B. Thus, at a marginal cost of only t secret key bits per authentication, the confidentiality of the authentication function h is guaranteed and thus may be re-used, on and on.

For the remainder of this paper, we assume the reader is familiar with the basic notions and notation of quantum computing (see textbooks such as [12]).

Quantum Authentication At an intuitive level, a quantum authentication scheme is a keyed system which allows A to send a state ρ to B with a guarantee: if B accepts the received state as “good”, the fidelity of that state to ρ is almost 1. Moreover, if the adversary makes no changes, B should always accept, and the fidelity should be exactly 1.

However, a reasonable definition for quantum authentication requires a tradeoff between B’s chances of accepting, and the expected fidelity of the received system to A’s initial state given his acceptance: as B’s chance of accepting increases, so should the expected fidelity.

There is no reason to use the languages of both probability and fidelity here: for classical tests, fidelity and probability of acceptance coincide. With this in mind we first define what constitutes a quantum authentication scheme, and then give a definition of security:

Definition 1 A quantum authentication scheme (qas) is a pair of polynomial time quantum algorithms A and V together with a set of classical keys K such that:

• A takes as input an m-qubit message system M and a key k ∈ K and outputs a transmitted system C of m + t qubits.

• V takes as input the (possibly altered) transmitted system Ĉ and a classical key k ∈ K and outputs two systems: a m-qubit message state M̂, and a single (verdict) qubit V which indicates acceptance or rejection. The classical basis states of V are called |acc ⟩, |rej ⟩ by convention.

For any fixed key k, we denote the corresponding super-operators by A_{k} and V_{k}.

Note that B may well have measured the qubit V to see whether or not the transmission was accepted or rejected. Nonetheless, we think of V as a qubit rather than a classical bit since it will allow us to describe the joint state of the two systems M̂, V with a density matrix.

There are two conditions which should be met by a quantum authentication protocol. On the one hand, in the absence of intervention, the received state should be the same as the initial state and B should accept.

On the other hand, we want that when the adversary does intervene, B’s output systems have high fidelity to the statement “either B rejects or his received state is the same as that sent by A”. One difficulty with this is that it is not clear what is meant by “the same state” when A’s input is a mixed state. It turns out that it is sufficient to define security in terms of pure states; one can deduce an appropriate statement about the fidelity of mixed or entangled states.

Given a pure state |ψ⟩ ∈ H_{M}, consider the following test on the joint system M̂, V: output a 1 if the first m qubits are in state |ψ⟩ or if the last qubit is in state |rej ⟩ (otherwise, output a 0). The projectors corresponding to this measurement are

P_{1}^{|ψ⟩} = |ψ⟩⟨ψ| ⊗ I_{V} + IM̂ ⊗ |rej ⟩⟨rej |
− |ψ⟩⟨ψ| ⊗ |rej ⟩⟨rej |
P_{0}^{|ψ⟩} = (IM̂ − |ψ⟩⟨ψ|) ⊗ (|acc ⟩⟨acc |)

We want that for all possible input states |ψ⟩ and for all possible interventions by the adversary, the expected fidelity of V’s output to the space defined by P_{1}^{|ψ⟩} is high. This is captured in the following definition of security.

Definition 2 A qas is secure with error ϵ for a state |ψ⟩ if it satisfies:

Completeness: For all keys k ∈ K: V_{k}(A_{k}(|ψ⟩⟨ψ|)) = |ψ⟩⟨ψ| ⊗ |acc ⟩⟨acc |

Soundness: For all super-operators O, let ρB be the state output by B when the adversary’s intervention^{1} is characterized by O, that is:

ρB = 𝔼_{k}[V_{k}(O(A_{k}(|ψ⟩⟨ψ|)))] = \frac{1}{|K|} ∑_{k} V_{k}(O(A_{k}(|ψ⟩⟨ψ|)))

where “ 𝔼_{k}” means the expectation when k is chosen uniformly at random from K. The qas has soundness error ϵ for |ψ⟩ if:

Tr (P_{1}^{|ψ⟩}ρB) ≥ 1 − ϵ

A qas is secure with error ϵ if it is secure with error ϵ for all states |ψ⟩.

We will actually want authentication protocols that have an additional composibility property: If (A_{k}, V_{k}) is a qas for key k, then the concatenated protocol

(⨂_{i=1}^{n} A_{k_{i}}, ⨂_{i=1}^{n} V_{k_{i}})  (2)

should be a qas for the key (k_{1}, …, k_{n}), with the understanding that the concatenated verification protocol rejects if any of the tensor components rejects (i.e., the concatenated verdict qubit is the AND of the individual verdict qubits, identifying |acc ⟩ with TRUE and |rej ⟩ with FALSE).

Quantum authentication protocols satisfying definition 2 were constructed in [3]. We do not know if the above composibility property follows in general from definition 2, but the protocols constructed in [3] certainly do. This follows because they are constructed from stabilizer purity testing codes (PTCs), which clearly statisfy a corresponding property (if Q_{k} is a stabilizer PTC with error ϵ, then ⨂_{i=1}^{n} Q_{k_{i}} is a stabilizer PTC with error nϵ).

3 Definition of approximate QECC (AQECC)

At an intuitive level, an approximate quantum error-correcting code allows A to send a state ρ to B with a guarantee: the fidelity of the state received by B to ρ is almost 1.

Let q = p^{m} and Q = p^{N} for some prime p and integers m < N. We first define what constitutes an AQECC over 𝔽_{Q}, and then give a definition of correctness:

Definition 3 An approximate quantum error correcting code (AQECC) is a pair of polynomial time quantum algorithms E (encoder) and D (decoder) such that:

• E takes as input a m-quqit message system M and outputs a (mixture of) codeword(s) C of n quQits.

1We make no assumptions on the running time of the adversary.

• D takes as input the (possibly altered) transmitted system Ĉ and outputs a m-quqit message state M̂.

We will define the correctness of an AQECC on pure states, but it follows from a result of [4] that the output of the AQECC also has high fidelity to an input which is mixed or part of an entangled state.

Given a pure state |ψ⟩ ∈ H_{M}, consider the following test on the system M̂: output a 1 if the first k quqits are in state |ψ⟩ (otherwise, output a 0). The projectors corresponding to this measurement are

P_{ψ} = |ψ⟩⟨ψ|
P_{ψ}^{⊥} = (IM̂ − |ψ⟩⟨ψ|)

We want that for all possible input states |ψ⟩ and for all possible interventions by the adversary, the expected fidelity of B’s output to the space defined by P_{ψ} is high. This is captured in the following definition of correctness.

Definition 4 An AQECC is t-correct with error ϵ for a state |ψ⟩ if for all super-operators O acting on at most t quQits,

Tr (P_{ψ}ρB) ≥ 1 − ϵ,

where ρB is the state output by B when the adversary’s intervention^{2} is characterized by O, that is:

ρB = D(O(E(|ψ⟩⟨ψ|))).

A AQECC is t-correct with error ϵ if it is t-correct with error ϵ for all states |ψ⟩.

4 A length 3 quantum code approximately correcting one arbitrary error

We start with a small example, from a well known code. The code c corrects one erasure error:

|0⟩ → |000⟩ + |111⟩ + |222⟩
|1⟩ → |012⟩ + |120⟩ + |201⟩  (3)
|2⟩ → |021⟩ + |102⟩ + |210⟩

Let H_{1} ⊗ H_{2} ⊗ H_{3} be the coding space of the original code

c|ψ⟩ ∈ H_{1} ⊗ H_{2} ⊗ H_{3},

and let (A_{k}, V_{k}) be a quantum authentication scheme as constructed in [3].

We construct a three-component code c′ as follows:

c′|ψ⟩ = ⟨A_{k_{1}}(H_{1}), k_{2}, k_{3}⟩ ,
⟨A_{k_{2}}(H_{2}), k_{1}, k_{3}⟩ ,  (4)
⟨A_{k_{3}}(H_{3}), k_{2}, k_{1}⟩ .

Let H′_{1} ⊗ H′_{2} ⊗ H′_{3} be the coding space of the new code

c′|ψ⟩ ∈ H′_{1} ⊗ H′_{2} ⊗ H′_{3}

Note that k_{1}, k_{2}, and k_{3} are random classical strings which we use as keys for the quantum authentication protocol A_{k}. Thus, the H′_{i}s contain both quantum and classical information. Intuitively, we use the qas to ensure that an adversary cannot change the quantum state of a single register without being detected; thus, we can transform general errors into erasure errors, allowing us to correct one faulty register out of three (no exact QECC can do this). Then we distribute the authentication keys among the three registers so that B can recover them. We must, however, do so in a way that prevents an adversary with access to a single register from either learning the key applying to her own register (which would allow her to change the quantum state) or from preventing reconstruction of the classical keys.

2We make no assumptions on the running time of the adversary.

Theorem 1 If A_{k} is a qas secure with error ϵ then c′ is a 1-correct AQECC with error prob. poly(ϵ), correcting one arbitrary error.

We postpone the proof of this theorem to Section 5 where we will prove more general result.

4.1 Reconstruction

In all cases, the reconstruction has two phases. First we reconstruct the classical keys and use them to verify and decode the quantum authentications. This may result in discarding one register, but at least two remain, which is enough for the erasure-correcting code to recover the original encoded state.

• All k_{i}’s agree in H′_{1}, H′_{2}, H′_{3}:

Recover k_{i} from either H′_{j}, j ≠ i, check that A_{k_{i}}(H_{i}) properly authenticates H_{i}. If one authentication fails, ignore the improperly authenticated H_{i} and reconstruct the valid codeword as c|ψ⟩ ∈ H_{1} ⊗ H_{2} ⊗ H_{3} using the erasure recovery algorithm from both H_{j}, j ≠ i.

• Some H′_{i} disagrees with H′_{j}, H′_{h} on both keys k_{h} and k_{j}: Discard register i, which must be corrupted. Recover k_{j} from H′_{h} and k_{h} from H′_{j}, and decode the authentications A_{k_{j}}(H_{j}) and A_{k_{h}}(H_{h}) (which should both pass, since only one register can fail). Reconstruct the valid codeword as c|ψ⟩ ∈ H_{1} ⊗ H_{2} ⊗ H_{3} using the erasure recovery algorithm from H_{j} and H_{h}.

• H′_{i} and H′_{j} disagree on key k_{h}, while H′_{h} agrees with everyone: Either register i or j is corrupt. Get k_{i} and k_{j} from H′_{h} and check that A_{k_{i}}(H_{i}) properly authenticates H_{i}, and that A_{k_{j}}(H_{j}) properly authenticates H_{j}. If neither fail, reconstruct the valid codeword as c|ψ⟩ ∈ H_{1} ⊗ H_{2} ⊗ H_{3} using the erasure recovery algorithm from H_{i} and H_{j}. If one fails, say A_{k_{i}}(H_{i}), then conclude register i is corrupt and recover k_{h} from H′_{j}, decode A_{k_{h}}(H_{h}), and reconstruct the valid codeword as c|ψ⟩ ∈ H_{1} ⊗ H_{2} ⊗ H_{3} using the erasure recovery algorithm from H_{h} and H_{j}.

Other cases cannot arise, since only one register can have been changed from the original encoding.

5 A general n-component approximate QECC family correcting up to d − 1 < n/2 arbitrary errors

In order to generalize the above construction to cases with n registers, we need to systemize the distribution of the classical keys. Recall that we needed two conditions: First, the adversary should not be able to learn the classical key for her register, but the receiver B should be able to reconstruct the keys. Second, the adversary should not be able to interfere with B’s reconstruction of the keys.

We ensure the first condition by encoding the keys in a classical secret sharing scheme [14]. Then to achieve the second condition, we further authenticate the shares of the classical secret sharing scheme using a classical authentication scheme. Of course, this requires further classical keys; in particular, we introduce one for each ordered pair of distinct registers, and use all the keys ℓ_{ij} to authenticate share j. Note that this construction is essentially a simplification of those in [13, 7]. They essentially produced approximate error-correcting codes for classical data, on the way to building multi-party computing protocols.

Let Q be a QECC that can correct d − 1 < n/2 arbitrary erasure errors: Q = [[n, k, d]]. Such a code can be constructed over sufficiently large dimension Q; for instance, use a polynomial quantum code [1]. The coding space of Q is defined as

Q|ψ⟩ ∈ H_{1} ⊗ H_{2} ⊗ H_{3} ⊗ ... ⊗ H_{n}.

We assume dim(H_{1}) = dim(H_{2}) = ... = dim(H_{n}).

We construct a new code Q′ over larger Hilbert spaces that can correct d − 1 < n/2 arbitrary errors except with small probability. Register i of the n-component code Q′ contains the following:

⟨A_{k_{i}}(H_{i}), s_{i}, [ℓ_{ij}(∀j ≠ i)], [h_{ℓ_{ji}}(s_{i})(∀j ≠ i)]⟩,  (5)

where we have used the classical authentication scheme (in systematic form):

m, ℓ → (m, h_{ℓ}(m)),  (6)

which has error ϵ, and (s_{1}, …, s_{n}) ∈_{R} SS_{n,d}(k_{1}, …, k_{n}), a secret sharing scheme such that any d − 1 s_{i}’s contains no information about (k_{1}, …, k_{n}) whereas any d of those s_{i}’s completely define (k_{1}, …, k_{n}).

For instance, the n = 3 case of this construction is as follows:

c′|ψ⟩ = ⟨A_{k_{1}}(H_{1}), s_{1}, [ℓ_{12}, ℓ_{13}], [h_{ℓ_{21}}(s_{1}), h_{ℓ_{31}}(s_{1})]⟩ ,
⟨A_{k_{2}}(H_{2}), s_{2}, [ℓ_{21}, ℓ_{23}], [h_{ℓ_{12}}(s_{2}), h_{ℓ_{32}}(s_{2})]⟩ ,  (7)
⟨A_{k_{3}}(H_{3}), s_{3}, [ℓ_{31}, ℓ_{32}], [h_{ℓ_{13}}(s_{3}), h_{ℓ_{23}}(s_{3})]⟩ .

Let H′_{1} ⊗ H′_{2} ⊗ ... ⊗ H′_{n} be the coding space of the new code

Q′|ψ⟩ ∈ H′_{1} ⊗ H′_{2} ⊗ ... ⊗ H′_{n}

Theorem 2 If A_{k} is a qas secure with error ϵ then Q′ is a QECC correcting d − 1 arbitrary errors except with prob. O(2^{d/2}\sqrt{nϵ}).

5.1 Reconstruction

The reconstruction procedure is similar to that for the previous protocol, but slightly more involved, since we must verify the classical authentications as well. Rather than breaking the procedure into different cases, in this version of the protocol, we can systematically go through four steps: First, verify the classical authentications and discard any invalid classical share. Second, reconstruct the keys k_{i}. Third, verify and decode the quantum authentications. Fourth, discard any invalid quantum register and reconstruct the encoded quantum state.

1. Verify classical authentications:

For each s_{i}, consider it valid if at least half its authentications are correct according to ℓ_{ji}, j ≠ i. Discard any share s_{i} which is not valid.

2. Reconstruct the keys k_{i}:

Up to d−1 shares s_{i} can have been discarded in the first stage, so at least n−d+1 ≥ n/2+1 > d shares remain. Use these to reconstruct (k_{1}, …, k_{n}). If the remaining shares are not all consistent with a single value of the secret, B aborts and outputs the quantum state |0⟩.

3. Verify and decode the quantum authentications: Use the key k_{i} to verify and decode the quantum authentication A_{k_{i}}(H_{i}).

4. Reconstruct the encoded quantum state:

Discard any registers which failed the quantum authentication, and use the remaining registers to reconstruct the valid codeword as c|ψ⟩ ∈ H_{1} ⊗ … ⊗ H_{n} using the erasure recovery algorithm. (At most d − 1 have been discarded.) If the remaining registers are not consistent with a single quantum codeword, B aborts and outputs the quantum state |0⟩.

Proof:

Clearly, if no errors occurred, the above procedure will exactly reconstruct the original encoded state. We need to show, however, that it still approximately reconstructs the state when there are up to d − 1 arbitrary errors in unknown locations. Let S be the set of registers attacked by the adversary, and let T be the remaining (i.e., correct) registers.

Note that the first two steps are purely classical. The adversary must output classical bit strings for the registers in S. However, if she alters any of the shares s_{i}, B will reject it in step 1 unless she successfully forges at least one authentication h_{ℓ_{ji}}(s_{i}) (for j ∈ T). This again is a purely classical task, and by the information-theoretic security of the classical authentication protocol, her probability of successfully doing so is at most ϵ per attempt, thus yielding a total probability bounded by (n − d + 1)ϵ ≤ nϵ for the n + 1 − d parallel attempts.

Conversely, any share s_{i} from T will always be accepted by B, since it will pass at least those authentications h_{ℓ_{ji}}(s_{i}) for j ∈ T, which comprise at least half of all of its authentications. Therefore, in stage 1, B always keeps at least n − d + 1 shares. With probability at least 1 − dnϵ, the values s_{i} of the kept shares are the same as when the state was encoded, and therefore are all consistent with a single value of the secret. That is, for any strategy by the adversary, B’s probability of aborting in stage 2 is at most dnϵ. Otherwise, B reconstructs the correct set of keys (k_{1}, …, k_{n}).

Now, the adversary is left with the task of mounting a quantum attack against the qas protecting the quantum part of each register. In doing so, she is limited by the security condition for a qas : While the authenticated quantum state itself provides some information about the keys k_{i}, the adversary would need additional information in order to successfully attack the scheme, and the classical secret sharing scheme ensures that the adversary, with access to only d − 1 shares, cannot get any additional information.

Therefore, we know that the quantum authentications A_{k_{i}}(H_{i}) will, when decoded by B, produce states with fidelity at least 1 − ϵ to the subspace formed by the input state and |rej ⟩. Furthermore, by the composibility property of our qas , a similar condition (with fidelity 1 − mϵ) holds for any set of m registers.

Now, in stage 3, B measures |acc ⟩ or |rej ⟩ and keeps only those registers with |acc ⟩. Let this set of registers be V. We know T ⊆ V, but V might be strictly larger than T, depending on the adversary’s attack. That allows the possiblity that the reconstructed state might not be exactly the original encoded state, or that reconstruction might be impossible due to an inconsistency in the accepted registers.

We know from proposition 12 of [3] that the density matrix held by B, conditioned on acceptance, has fidelity at least 1 − ϵ/p_{acc} to the input density matrix, where p_{acc} is the probability of B accepting the state. Therefore, let p_{W} be the probability that, if B were to test only the set W, he would accept that set. Some sets W will have large p_{W}, whereas for others, p_{W} will be quite small. However, p_{W} is at least as large as the probability that B’s complete accepted set V = W.

Therefore, let us consider the probability that V, the set of accepted registers, has p_{V} < 2^{−(d−1)/2}\sqrt{nϵ}. Since B always accepts the registers in T, the only question is whether B accepts a given set of registers in S. There are therefore at most 2^{d−1} possible subsets that B could accept that have probability p_{V} < 2^{−(d−1)/2}\sqrt{nϵ}. Thus, the probability that B actually accepts one of these sets is at most 2^{(d−1)/2}\sqrt{nϵ}. Otherwise, the fidelity of the reconstructed state on V to the actual input on those registers is at least 1 − 2^{(d−1)/2}\sqrt{nϵ}. That means that, with probability at least 1 − 2^{(d−1)/2}\sqrt{nϵ}, B reconstructs in stage 4 a state that has fidelity at least 1 − 2^{(d−1)/2}\sqrt{nϵ} to the original input state. Since there was also a probability ϵ that the adversary could force the protocol to abort at stage 2 of the reconstruction, the overall fidelity of the final reconstructed state to the initial input state is at least

(1 − dnϵ) · [1 − 2^{(d−1)/2}\sqrt{nϵ}]^{2} .  (8)

□

5.2 Specific examples

Let be a power of two n = 2^{m}. Let C_{1} be a [2^{m}, 2^{m−1}, 2^{m−1} + 1]_{2^{m}} Extended Reed-Solomon code and C_{2} be a [2^{m}, 2^{m−1} + 1, 2^{m−1}]_{2^{m}} Extended Reed-Solomon code.

The CSS code obtained from C_{1}, C_{2} can correct 2^{m−1} − 1 = n/2 − 1 erasure errors:

Q = [[2^{m}, 1, 2^{m−1}]]_{2^{m}} = [[n, 1, n/2]]_{n}.

The related code obtained from our construction would need 2m + 20s + 2 log m ∈ Θ(m + s) bits [9, 3] of quantum authentication key per component, to obtain ϵ < 2^{−Ω(m+s)} error probability. Each component also contains a secret share of n such keys, thus needs w ∈ Θ(2^{m}(m + s)) bits per s_{i} [14]. The classical authentications will each require Θ(s + log w) bits [9] per key for a total of Θ(2^{m}(s + log w)) per component to obtain ϵ < 2^{−Ω(m+s)} error probability. To summarize, a total of Θ(2^{m}(m + s)) bits per component are necessary to obtain error probabilities ϵ < 2^{−Ω(m+s)}.

The resulting fidelity

(1 − dnϵ) · [1 − 2^{(d−1)/2}\sqrt{nϵ}]^{2} ∈ (1 − 2^{−Ω(s)}) · [1 − 2^{(d−1)/2}2^{−Ω(s)}]^{2}

is exponentially (in s) close to 1 as long as s ∈ Ω(n) ⊆ Ω(d).

We conclude that the resulting code is an [[n, Θ(\frac{1}{n+s}), n/2]]_{Θ(n(n+s))} QECC correcting n/2 − 1 arbitrary errors with fidelity at least 1 − 2^{−Ω(s)}.

6 Discussion and open questions

We have constructed quantum error correcting codes that are capable of correcting general errors when up to half the registers are affected. This contrasts considerably with known upper bounds that limit a QECC to correcting errors on less than one-fourth of all registers. The price for being able to violate this bound is that we only correct the state approximately; however, we do so with exponentially good fidelity.

In general, extrapolating from exact performance of a quantum task to approximate performance is dangerous, but possible. Factors of the dimension may arise, and since the dimension is exponential in the number of qubits, dramatically different behavior becomes possible. This phenomenon is likely behind the performance of our codes, and suggests that high-fidelity AQECCs are only possible when working in high dimension. It remains an interesting open question, however, if it is actually possible to construct AQECCs with both high efficiency and high fidelity in the usual model where the encoded subspace has the same dimension as each register of the code.

Our codes instead consist of a small logical subspace and large registers containing both quantum and classical information. As such, they are not so useful for practical problems in quantum error correction, but do serve as an interesting in-principle demonstration of the potential power of approximate error correction. In addition, they may be directly useful for VQSS and MPQC. Any such construction must be more complex, however, to take account of dishonest senders and receivers, and to allow the participants in the protocol to alter a state in the correct way without altering it in any unapproved manner. Indeed, it remains possible that the prior bound of n/4 cheaters does in fact restrict VQSS and MPQC; however, we have shown here that the existing proof of that bound does not apply to VQSS and MPQC protocols which only guarantee approximate reconstruction of the quantum state.

Acknowledgements

Thanks to Umesh Vazirani for helpful discussions.

References

[1] D. Aharonov and M. Ben-Or. Fault tolerant quantum computation with constant error. In Proc. of 29th STOC, pages 176–188, El Paso, Texas, 4–6 May 1997. This is a preliminary version of [2].

[2] D. Aharonov and M. Ben-Or. Fault tolerant quantum computation with constant error rate. quantph/9906129. Preliminary version in STOC ’97. Submitted to SIAM J. Comp., June 1999.

[3] H. Barnum, C. Crépeau, D. Gottesman, A. Tapp, and A. Smith. Authentication of quantum messages. In proceedings of The 43rd Annual IEEE Symposium on Foundations of Computer Science (FOCS’02), November 16 - 19, 2002 Vancouver, BC, Canada, pages 449–458. Complete version (including Proposition 12): Quantum Physics, abstract quant-ph/0205128, 22 pages, May 2002.

[4] H. Barnum, E. Knill and M. A. Nielsen, ”On Quantum Fidelities and Channel Capacities,” quantph/980901, IEEE Trans.Info.Theor. 46 (2000) 1317-1329.

[5] C. H. Bennett, G. Brassard, S. Popescu, B. Schumacher, J. A. Smolin, and W. K. Wootters, “Purification of Noisy Entanglement and Faithful Teleportation via Noisy Channels.”, Phys. Rev. Lett. 76 (1996) 722-725, Quantum Physics, abstract quant-ph/9511027.

[6] J. L. Carter and M. N. Wegman, “New hash functions and their use in authentication and set equality”, Journal of Computer and System Sciences, Vol. 22, 1981, pp. 265 – 279.

[7] R. Cramer, I. Damgård, S. Dziembowski, M. Hirt and T. Rabin. Efficient Multiparty Computations with Dishonest Minority In Proc. of EUROCRYPT 1999.

[8] C. Crépeau, D. Gottesman, and A. Smith. Secure multi-party quantum computation. In Proceedings of 34th Annual ACM Symposium on Theory of Computing, May 19-21, 2002, Montréal, Québec, Canada. ACM, 2002, pages 643–652.

[9] P. Gemmell and M. Naor. Codes for interactive authentication. In D. R. Stinson, editor, CRYPTO, volume 773 of Lecture Notes in Computer Science, pages 355–367. Springer, 1994.

[10] D. Gottesman, “An Introduction to Quantum Error Correction.”, Quantum Physics, abstract quantph/0004072, 15 pages, talk given at AMS Short Course on Quantum Computation.

[11] P. Hayden, D. Leung and A. Winter, Personal communications, 2002-2003.

[12] M. Nielsen and I. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2000.

[13] T. Rabin and M. Ben-Or. Verifiable Secret Sharing and Multiparty Protocols with Honest Majority. In Proc. of STOC 1989, p. 73–85.

[14] A. Shamir. How to share a secret. Communications of the ACM, 22:612–613, 1979.

[15] W. K. Wootters and W. H. Zurek, ”A single quantum cannot be cloned”, Nature 299, 802, 1982 .