Quantum Locally Testable Code with Constant Soundness
Abstract
In this paper, we present two constructions of QLTCs with constant soundness. In the first approach, we introduce an operation which we call check product, and show how this operation gives rise to QLTCs of constant soundness, constant rate, and distance scaling with locality. In the second approach, we utilize homological product of codes and prove a special case in which the soundness of component codes is preserved through the homological product. This observation leads us to construct QLTCs of constant soundness, scalable rate and distance, and constant average locality. Our work marks a step towards constructing QLTCs of high soundness and distance, which would give a different construction to the No Low-Energy Trivial States (NLTS) theorem.
1 Introduction
Quantum error correcting codes (QECCs) are essential objects of study in quantum information science due to their broad applications in both practical and theoretical quantum computation. Practically, QECC is the foundation of fault-tolerant quantum computation, which holds the promise to scalable quantum computing. Theoretically, quantum coding theory interacts extensive with quantum complexity theory and information theory, much like how classical coding theory interacts with theoretical computer science. In development of quantum codes for theoretical purposes, we often focus on their asymptotic properties, such as relative rate and distance. In this paper, we study the testability of quantum codes and present two novel constructions.
A classical code is called testable if the syndrome of a proposed code word reveals more than whether belongs to the code: the relative weight of the syndrome is also proportional to the relative distance of from the codespace, and their ratio is called the soundness of . A code is further called locally testable if all of its checks involves at most a constant number of bits from . The theory of code checking, which began with the pioneering work of Blum, Luby, and Rubinfeld [BLR90], has grown into a widely successful area of the theory of computing, affecting PCP theory, combinatorial optimization, combinatorial property testing, program checking and even cryptography.
With the advancement of quantum information science, a quantum notion of locally testable codes (QLTC) was first proposed and studied by Aharonov and Eldar in [AE15]. The existence of such codes gained major interest in 2015, when Eldar and Harrow showed in [EH17] that any QLTC with constant soundness, locality and relative distance could be used to construct Hamiltonians with no low-energy trivial states, which would resolve the famous NLTS conjecture of Freedman and Hastings [FH13]. This conjecture is deeply related to the quantum PCP conjecture [AAV13], one of the most important open problems in quantum complexity theory. Further, classical LTCs are important components in the proofs of the classical PCP Theorem [Aro+98, Din07]. Naturally, the connections between QLTCs and the qPCP conjecture became a topic of major importance in the field.
However, constructing QLTCs of high soundness and distance seemed far-fetched at the time, as the best known quantum LDPC codes (QLDPC) had distance and no bound on soundness. Here we say that a (quantum) code is LDPC if the number of (qu)bits each check involves and the number of checks each (qu)bit is involved in are all bounded by a constant , which we call the locality of the code. The first QLTC with unconditional guarantee on soundness is the hypersphere product code constructed by Hastings [Has17a], which encodes two logical qubits, has soundness , locality and distance . In 2019, Leverrier, Londe and Zémor constructed another family of QLTC called the hemicubic codes [LLZ22], which encodes one qubit and has an improved soundness of , with roughly the same locality and distance. These constructions remain the only known QLTCs, and it was unclear how to improve the soundness to , without reducing the code to have no encoded qubits.
The landscape of QLDPC constructions changed significantly in 2020, following Hastings, Haah and O’Donnell’s breakthrough construction of fiber bundle codes [HHO21] that achieved distance. Their ideas were soon generalized to lifted product codes [PK22a] by Panteleev and Kalachev, and balanced product codes [BE21] by Breuckmann and Eberhardt, culminating in the 2021 result of Panteleev and Kalachev that presented the first family of asymptotically good qLPDC codes [PK22]. It was further shown that embedded in the construction in [PK22] is a -LTC: asymptotically good classical LDPC code (CLDPC) that is locally testable with constant soundness. Around the same time, Dinur, Evra, Livne, Lubotzky and Mozes announced their construction of a -LTC using left-right Cayley complexes [Din+22]. Building upon their works, two other families of asymptotically good QLDPCs are constructed [LZ22, Din+23]. One such family, namely quantum Tanner codes [LZ22] by Leverrier and Zémor, was utilized by Anshu, Breuckmann and Nirkhe [ABN23] to prove the NLTS conjecture. Following these developments, the problem of constructing QLTCs with good parameters became one of major interest.
In this paper, we take a concrete step towards this open problem by constructing the first few families of QLTCs with constant soundness and varying distance.
1.1 Main Results
We begin by presenting a simple idea that transforms a good classical LDPC locally testable code with constant soundness into a quantum LDPC locally testable code with constant soundness and constant rate. However, it has the striking deficit of having distance 2.
Lemma 1.1.
Given a family of classical LDPC codes with parameters that are locally testable with soundness , there exists a family of quantum LDPC codes that are locally testable with soundness and parameters .
It is important to note that the soundness condition is nontrivial, because it concerns the distance of an arbitrary state from the codespace, which can be much larger than the code distance, which is the distance between two codewords. For instance, if is a classical LTC over bits, then the code has distance 2 (since it contains for all ), yet if is far from , then is far from . Our quantum construction is in fact based on this simple classical example. We present this construction in section 3 and discuss how it could be generalized to a new operation which we give the name check product. Using this operation and random quantum codes, we obtain the first main result of our paper, a family of QLTCs with constant soundness, constant rate, and distance scaling with locality.
Theorem 1.2.
Suppose we have a family of classical LDPC codes with parameters that are locally testable with soundness . Then for any , there exists a family of quantum locally testable codes with soundness , locality bounded by , and parameters .
For instance, taking , we obtain QLTCs of constant soundness, constant rate, distance and locality.
Our second main result utilizes the distance balancing technique for quantum codes introduced by Hastings [Has17]. Given a quantum code of distinct and distance, Hastings showed that one could take the hypergraph product of this quantum code with a classical repetition code to obtain a new quantum code with balanced and distance. Notably, this technique balances distance at the expense of soundness – if the original quantum code has soundness and one uses a repetition code of length in the hypergraph product, the soundness of the resulting quantum code would be .
To address this deficiency, we propose a slight yet critical modification to the distance balancing technique such that the soundness of the component quantum code is preserved, at partial expense in locality. We present these results in Section 5, arriving at our second main result.
Theorem 1.3.
Fix integer . Given a family of classical LDPC codes with parameters that are locally testable with checks and soundness , there exists a family of quantum locally testable codes of soundness and parameters , such that a fraction of -stabilizer generators have weight , and at most fraction of the qubits are checked by -stabilizer generators. All other stabilizer generators are constant weight, and all other qubits are checked by a constant number of stabilizer generators.
As an example, choosing , we obtain QLTCs with constant soundness, rate, distance and locality. While this code family is no longer LDPC for any scaling with , we note that the check weights are non-uniform. In particular, we note that the total check weight of all stabilizer generators is , which means the average locality is . While it is unclear whether average locality is an useful measure, we note the constant average locality here since it is an interesting property that arises naturally from our constructions.
We now present a summary of parameters of known QLTCs and our constructions in the following tables. Since some of these constructions have components whose size can be tweaked (such as the length of the repetition code in Theorem 1.3), in table 1 we present the parameters of the general forms of these constructions, and in table 2 we present the parameters of special cases for direct comparison. We further remark that in terms of worst case bounds, the parameters of Theorem 1.2 are strictly better than that of Theorem 1.3. However, the average locality of Theorem 1.3 are both constant, which is not the case in Theorem 1.2.
2 Preliminaries
In this section, we introduce the basic definitions of quantum CSS codes and local testability. Given a vector , we let denote the -qubit Pauli operator , where and . We define similarly.
Definition 2.1 (CSS Codes).
Let and be linear codes of length such that (equivalently, ). The quantum code is the stabilizer code where the -stabilizers have the form for , and the -stabilizers have the form for . Its code space is spanned by following states, where for ranges over .
(1) |
Fact 2.2.
If and are and codes, respectively, then has dimension and minimum distance where and .
In this paper, we consider the following definition of local testability, which is the same as in [LLZ22].
Definition 2.3 (Locally testable code).
A linear code is locally testable with soundness and check weight if it has parity check matrix with rows of weight such that for any we have
(2) |
where and denotes the Hamming distance.
We consider the definition of quantum locally testable codes as in [EH17]. Given a quantum stabilizer code with stabilizer generators all having weight at most , we define the projector operators . For a quantum codespace , we define the -fattening of as
This is the space of states that are at distance at most from the codespace . Let be the projector onto , and let
Definition 2.4 (Quantum Locally Testable Codes).
A -qubit quantum code with stabilizer generators is locally testable with soundness and check weight if all its stabilizer generators have weight at most , and
Local testability of quantum CSS codes and the testability of their classical component codes are closely related, as shown by [EH17]:
Lemma 2.5 (Fact 17 of [EH17]).
A quantum CSS code is a QLTC with soundness if are CLTCs of soundness . Conversely, if is a QLTC with soundness , then are CLTCs of soundness at least .
With this lemma in place, we now proceed to present our constructions.
3 Check Product of Codes
We start by presenting a simple construction that proves Lemma 1.1. All proofs in section 3 and 4, except for that of Claim 3.1, are included in the appendix.
3.1 A Motivating Example
Suppose , is a classical LTC with soundness , rate , distance , and in addition an LDPC with weight . Define , where . Then , which means is a valid quantum code. We now prove the following claim, which justifies considering this approach.
Claim 3.1.
is a LDPC CLTC with soundness , rate , and distance 2.
Proof.
A way to understand the code is through its Tanner graph. Suppose the Tanner graph of consists of bit vertices and check vertices . Then the Tanner graph of is obtained simply by creating a copy of each , where and are connected to the same check bits in . We can therefore represent each as , where . We show
(3) |
Fix such that . Then , which means . Similarly, fix , then we have . This proves (3). Now we see that has distance , because for any , let be the indicator vector of (meaning that it has a one at index , and 0 elsewhere), then . We observe that any weight vector will have non-zero syndrome.
Now note that the check weights of are bounded by , and each qubit is checked by at most checks. Therefore is LDPC. The rate of is also easy to compute – the number of linearly independent checks stay at , while the number of bits is doubled. So the overall rate is .
The more interesting part is to show local testability. We want to show ,
We first note that . Moreover, . By local testability of , we have
which completes our proof. ∎
Corollary 3.2.
The quantum code is a QLTC of soundness , check-weights bounded by , rate , and .
By choosing as a known -LTC, such as the left-right Cayley complex code [Din+22], we obtain Lemma 1.1. It is surprising that such a simple construction could already give us quantum codes of constant soundness. Moreover, this example demonstrates that the soundness and distance of a quantum code are not necessarily related. We generalize this construction in the following section.
3.2 General Check Products
We begin by making the following observation: the matrix of the previous section could also be written as , where is the parity check matrix of the repetition code . More generally, for any two classical codes , we can define the following check product of the two codes:
The following facts are well known.
Lemma 3.3.
Let be classical codes with parameters and . The following hold:
-
1.
. Namely, is the dual tensor code of and .
-
2.
has dimension .
-
3.
has distance .
With this definition formalized, we can extend it to the check product of a classical code and a quantum code, as follows.
Definition 3.4 (Check-Product of classical and quantum code).
Given a classical code and a quantum CSS code given by , we define the check-product of and to be the quantum code .
It is straightforward to see that the commutativity condition is satisfied, so this definition is valid. We now address the distance of this quantum code.
Lemma 3.5.
Given a quantum code , the code has distance . In words, its distance is the minimum of all of its component classical codes’ distance.
The natural question to ask now is — what can we say about the soundness of general check product codes? It is straightforward to see that the check product of a CLTC with a classical code that is not locally testable is also not locally testable, and it is also not clear if the check product of two arbitrary CLTCs remains locally testable. However, as we will show in section 4, the check product of CLTCs with a specific form is indeed locally testable. This enables us to prove Theorem 1.2 by considering the check product of a -LTC with random quantum CSS codes.
4 The Check Product of a CLTC and a QLTC
In this section, we present a construction that proves Theorem 1.2. We once again begin by making a simple observation. Given a classical code , suppose is a matrix with linearly independent rows. We may do Gaussian operations on the rows of , formally multiplying from the left by a non-singular matrix , such that the resulting matrix has the form (up to permuting the columns with a permutation matrix, ):
(4) |
where is the identity matrix, and is a matrix. Note that , and the rows of can have arbitrary weight due to the row operations.
Claim 4.1.
The code with check matrix has soundness , where is the rate of .
This claim directly implies the following simple corollary, which we include without proof.
Corollary 4.2.
Any classical linear code of rate can be turned into a CLTC with soundness at the cost of having arbitrary locality, while keeping the same rate and distance. Similarly, any quantum CSS codes where both component codes are classical linear codes can be turned into a QLTC with soundness at the cost of having arbitrary locality, while keeping the same rate and distance.
We note that the same idea of Claim 4.1 was discussed by Campbell in section 5 of [Cam19], but we only became aware of this correspondence after this paper was finished.
In spite of its simplicity, Claim 4.1 has an important application in our check product construction, as shown in the following lemma.
Lemma 4.3.
Suppose is a CLTC with soundness and locality . Let be a classical code where is a matrix of the form , such that its locality is bounded by . Then is a CLTC with soundness at least and locality .
Theorem 4.4.
Given a -bit classical LTC, , of soundness , dimension , distance and locality , and a -qubit quantum code of dimension , we can reduce to have the form in equation (4), and denote the resulting quantum code . ( and as sub-spaces are the same. What makes them different is their sets of and checks.) Then the check product code has
-
1.
local testability with soundness (in particular, soundness ,
-
2.
distance , where .
-
3.
locality bounded by ,
-
4.
and dimension .
While it is tempting to apply this theorem to a -LTC and a good QLDPC code, we note that the result will have constant distance. Indeed, for a quantum CSS code that is LDPC, we necessarily have . For instance, to argue that , we notice that , and since contains all possible checks for , it also contains the low-weight ones. In fact, to construct QLTC of scalable distance from Theorem 4.4, we want to be as large as possible, which in turn implies that the quantum code has correspondingly large check weights for all possible checks (i.e. checks in and ). In the following theorem, we show that random codes satisfy this property.
Theorem 4.5.
Let , be a random code with dimension . Let be a random subspace of of dimension . Let be the matrix such that its rows span the space , then with high probability and both have linear distances, and the CSS code made from the classical codes and (here check sets do not influence the statement) has rate .
5 Gauge Fixing and Distance Balancing
Theorem 1.2 shows a family of QLTCs where the quantum distance scales positively with the check weight. In this section, we prove Theorem 1.3 by tweaking our construction in section 3.1 and applying distance balancing with our modifications.
5.1 Modifying Stabilizer and Logical Operators
We briefly recall our earlier construction. Given a LDPC CLTC of soundness , dimension and distance , we define , where , and . Let us consider the stabilizers and logical operators of . Consider the set of Pauli operators
We observe that exactly of these operators are independent -logical operators, and the other of them can be generated from the previous operators together with the -stabilizers. There are another set of -logical operators, namely
Exactly logical operators in this set are independent, and they all have linear weight. Together, these operators generate the complete set of -logical operators of . Similarly, by replacing s with s, we found the set of -logical operators of . We see that .
Now suppose we move all the -logical operators of weight 2 into the -stabilizer group. Then the remaining -logical operators all have linear weight, which means we have . On the other hand, all the high-weight -logical operators of the form are no longer valid logical operators, as they do not compute with all the -stabilizers. Therefore, the set of -logical operators that remain is precisely
A more direct way of writing this new code would be the following. Let . Our new code is precisely . The code states of can be explicitly written out as
This code then has . It is locally testable with soundness , LDPC, and has dimension .
5.2 Distance Balancing
We can now apply the distance balancing techniques in [Has17]. Specifically, we consider our code as a chain complex
and we take a repetition code of length , also viewed as a chain complex
where , and is the matrix of the form
(5) |
We take the homological product of the two complexes, and the resulting chain complex is
(6) |
Now we take the sub-chain complex , and view it as a quantum code. From [Has17], the following holds.
Lemma 5.1.
If the original quantum code is a -qubit LDPC quantum code with dimension and distance , then this new code is a -qubit LDPC quantum code with dimension and distance .
We refer the readers to [Has17], statement 7 and 8 of Lemma 2 for the proofs. Moreover, it was also shown in [Has17] that the resulting code is locally testable, albeit having a lower soundness.
Lemma 5.2 (Lemma 7 of [Has17]).
If is a QLTC with constant soundness, then the code is a QLTC with soundness .
Combining these two lemmas, we obtain the following corollary.
Corollary 5.3.
Fix integer . Given a family of classical LDPC codes with paramaters that are locally testable with checks and soundness , there exists a family of quantum LDPC locally testable codes of soundness and parameters .
We choose not to include direct proofs of these two lemmas in this paper, because in the following section we would present a slight modification to the above construction and prove Lemma 5.4 and 5.5. The proof of Lemma 5.4 would be a slightly modified version of the proof of Lemma 5.1 in [Has17], and the proof of Lemma 5.5 would follow a similar scheme as the proof of Lemma 5.2 in [Has17].
5.3 Preserving Soundness
As the primary goal of this paper is to achieve constant soundness, we present a simple modification to the above distance balancing technique that preserves soundness, while sacrificing some locality. We perform column operation on such that it has the following form.
(7) |
Note that as before, is a valid parity check matrix for the repetition code. The rest of the construction remains unchanged.
While this modification seems superficial on first glance, it actually follows important geometric insights. To see that, we construct two graphs from the two matrices in equation (5) and (7). We create a vertex for each bit of the repetition code, which corresponds to rows of , and for each column in , we create an edge that connects the two vertices that has entry at that column. Then the previous matrix (5) gives a line segment, while the new matrix (7) gives a star graph. Intuitively, the star graph has better soundness than a line segment since any collection of edges in the star graph must have at least the same number of vertices on its boundary , while in a line segment a partial line segment have only two vertices on its boundary. This intuition can be formally formulated as boundary and co-boundary expansion of chain complexes, which are directly related to the soundness of classical and quantum codes derived from such chain complexes.
We now prove the following lemmas regarding the parameters of . We suggest that the readers follow the chain complex in equation (6) when reading the following lemmas and proofs.
Lemma 5.4.
is a -qubit quantum code with dimension and distance . A fraction of -stabilizer generators have weight , and at most fraction of the qubits are checked by -checks. All other checks are constant weight, and all other qubits are checked by a constant number of checks.
Proof.
To show the dimension of the new code, we cite the Künneth formula from algebraic topology. Define the th homology group of a chain complex as , then the number of logical qubits of a quantum code is precisely . From the Künneth formula, we have
Note that and . Therefore .
For the distance of , let such that , , and is a -logical operator. Let be the standard basis vector of , and be the standard basis vector of . Write . We describe a simplification procedure that turns into the form , such that .
We begin with . Consider , then
In the stabilizer formalism, this step correspond to multiplying the logical operator with the -stabilizer . Now for all other , we multiply by the -stabilizer specified by and the final vector in will have the form
for some . Since is a valid logical operator, we must have , which means
However, note that , which means for the above equation to hold we must have and . This implies that must be a -logical operator of . Therefore
which means . We also note that since if is a -logical operator of , then is a -logical operator of . We conclude that .
To discuss the distance, we define cohomologies and cite the Künneth formula again. For a chain complex , define the th homology group of a chain complex as , and the Künneth formula in this case states
Since , we have , which means any -logical operator (which corresponds to a chain in ) can be written in the form
where and . Note that the has dimension , which means . Now suppose , and consider the projection of onto the space . It has the form
Since , we must have for all , which means . This shows . We also note that since if is a -logical operator of , then is a -logical operator of . We conclude that .
For the locality of , we note that and are matrices with constant row and column weights. For , exactly fraction of its rows have weight , while the other rows have weight , and all its columns have weight . Let us enumerate the standard basis vector of as , and the standard basis vectors of as . Then we have
-
1.
All the -stabilizer generators corresponding to basis vectors of have constant weight;
-
2.
All the -stabilizer generators corresponding to basis vectors of have constant weight, because has constant row weight;
-
3.
The qubits corresponding to have the form for . Qubits of the form are checked by -stabilizer generators from . All other qubits have constant degree (in both and stabilizer generator checks).
-
4.
The -stabilizer generators corresponding to has the form for . Generators of the form checks qubits from . All other -stabilizer generators have constant weight.
In short summary, at most fraction of the qubits are checked by -stabilizer generators, and exactly fraction of the -stabilizer generators have weight. All other check weights and qubit degrees are constant. ∎
Finally, we prove a lower bound on soundness. Recall that our code has soundness .
Lemma 5.5.
is locally testable with soundness for -operators, and soundness for -operators.
Proof.
Given a -operator where , we once again turn into the following form by multiplying with -stabilizers:
Let be such that and . Then we see that
Therefore, it suffices for us to show that
(8) |
Write . Then we have
Let . For two vectors let denote the vector where if and only if . Then we have
We first observe that since for any ,
The first inequality implies , for the following reason. If , then ; otherwise if , then , which again implies .
Therefore, if , then by soundness of ,
Assuming , we have equation (8). Now if , we also have
and the same calculations as above follows. Therefore, is locally testable with soundness for -operators.
For -operators where , suppose . Note that since , we can multiply by -stabilizers of the form , where
Then for some . In other words, we may assume without loss of generality that all -operators has the form
We will show that . To prove this, we need to use the fact that our has the form . For notation purposes, we let
Further, without loss of generality, we may assume because if , we can add to . Note here that . Now we are ready for the proof.
For clarity purposes, in the following equations, we denote “addition mod 2” as . We have
We abbreviate the above equation into
We now prove by a counting argument. In particular, for any , if at least one of , is 1, then regardless of the values of , , we have . This can be seen from the following table. Note that by our assumptions, , cannot both be 1.
1 | 0 | 0 | 0 | 2 |
1 | 0 | 1 | 0 | 1 |
1 | 0 | 0 | 1 | 3 |
1 | 1 | 0 | 0 | 2 |
1 | 1 | 1 | 0 | 1 |
1 | 1 | 0 | 1 | 1 |
0 | 1 | 0 | 0 | 2 |
0 | 1 | 1 | 0 | 3 |
0 | 1 | 0 | 1 | 1 |
The only case that remains is , and we observe that since , . Combining this observation with the values in table 3, we see that
Therefore, is locally testable with soundness for -operators. ∎
Acknowledgements
We thank Ted Yoder for the discussion on gauge fixing of the check product codes.
Z.H and A.N. thank Eugene Tang and the QLDPC reading group at MIT, especially Aram Harrow and Peter Shor for many helpful discussions. Z.H. also thanks Nikolas Breuckmann for many insightful conversations. Part of this work was done while Z.H. was at IBM T.J. Watson Research Center.
A.C. thanks Aram Harrow and the QLDPC reading group at MIT for helpful discussions. A.C and G.Z. are supported by the U.S. Department of Energy, Office of Science, National Quantum Information Science Research Centers, Co-design Center for Quantum Advantage (C2QA) under contract number DE-SC0012704.
References
- [AAV13] Dorit Aharonov, Itai Arad and Thomas Vidick “Guest column: the quantum PCP conjecture” In SIGACT News 44.2 New York, NY, USA: Association for Computing Machinery, 2013, pp. 47–79 DOI: 10.1145/2491533.2491549
- [ABN23] Anurag Anshu, Nikolas P. Breuckmann and Chinmay Nirkhe “NLTS Hamiltonians from Good Quantum Codes” New York, NY, USA: Association for Computing Machinery, 2023 DOI: 10.1145/3564246.3585114
- [AE15] Dorit Aharonov and Lior Eldar “Quantum Locally Testable Codes” In SIAM Journal on Computing 44.5, 2015, pp. 1230–1262 DOI: 10.1137/140975498
- [Aro+98] Sanjeev Arora et al. “Proof verification and the hardness of approximation problems” New York, NY, USA: Association for Computing Machinery, 1998 DOI: 10.1145/278298.278306
- [BE21] Nikolas P. Breuckmann and Jens N. Eberhardt “Balanced Product Quantum Codes” In IEEE Transactions on Information Theory 67.10, 2021, pp. 6653–6674 DOI: 10.1109/TIT.2021.3097347
- [BLR90] M. Blum, M. Luby and R. Rubinfeld “Self-testing/correcting with applications to numerical problems” In Proceedings of the Twenty-Second Annual ACM Symposium on Theory of Computing, STOC ’90 Baltimore, Maryland, USA: Association for Computing Machinery, 1990, pp. 73–83 DOI: 10.1145/100216.100225
- [Cam19] Earl T Campbell “A theory of single-shot error correction for adversarial noise” In Quantum Science and Technology 4.2 IOP Publishing, 2019, pp. 025006 DOI: 10.1088/2058-9565/aafc8f
- [Din+22] Irit Dinur et al. “Locally testable codes with constant rate, distance, and locality” In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2022 Rome, Italy: Association for Computing Machinery, 2022, pp. 357–374 DOI: 10.1145/3519935.3520024
- [Din+23] Irit Dinur, Min-Hsiu Hsieh, Ting-Chun Lin and Thomas Vidick “Good Quantum LDPC Codes with Linear Time Decoders” In Proceedings of the 55th Annual ACM Symposium on Theory of Computing, STOC 2023 Orlando, FL, USA: Association for Computing Machinery, 2023, pp. 905–918 DOI: 10.1145/3564246.3585101
- [Din07] Irit Dinur “The PCP theorem by gap amplification” In J. ACM 54.3 New York, NY, USA: Association for Computing Machinery, 2007, pp. 12–es DOI: 10.1145/1236457.1236459
- [EH17] L. Eldar and A.. Harrow “Local Hamiltonians Whose Ground States Are Hard to Approximate” In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS) Los Alamitos, CA, USA: IEEE Computer Society, 2017, pp. 427–438 DOI: 10.1109/FOCS.2017.46
- [FH13] Michael Freedman and Matthew Hastings “Quantum Systems on Non--Hyperfinite Complexes: A Generalization of Classical Statistical Mechanics on Expander Graphs” In Quantum Information and Computation 14, 2013 DOI: 10.26421/QIC14.1-2-9
- [Has17] Mathew B. Hastings “Weight reduction for quantum codes” In Quant. Inf. Comput. 17.15-16, 2017, pp. 1307–1334 DOI: 10.26421/QIC17.15-16-4
- [Has17a] Matthew B. Hastings “Quantum Codes from High-Dimensional Manifolds” In 8th Innovations in Theoretical Computer Science Conference (ITCS 2017) 67, Leibniz International Proceedings in Informatics (LIPIcs) Dagstuhl, Germany: Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2017, pp. 25:1–25:26 DOI: 10.4230/LIPIcs.ITCS.2017.25
- [HHO21] Matthew B. Hastings, Jeongwan Haah and Ryan O’Donnell “Fiber bundle codes: breaking the polylog(n) barrier for Quantum LDPC codes” In Proceedings of the 53rd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2021 Virtual, Italy: Association for Computing Machinery, 2021, pp. 1276–1288 DOI: 10.1145/3406325.3451005
- [LLZ22] Anthony Leverrier, Vivien Londe and Gilles Zémor “Towards local testability for quantum coding” In Quantum 6 Verein zur Förderung des Open Access Publizierens in den Quantenwissenschaften, 2022, pp. 661 DOI: 10.22331/q-2022-02-24-661
- [LZ22] A. Leverrier and G. Zemor “Quantum Tanner codes” In 2022 IEEE 63rd Annual Symposium on Foundations of Computer Science (FOCS) Los Alamitos, CA, USA: IEEE Computer Society, 2022, pp. 872–883 DOI: 10.1109/FOCS54457.2022.00117
- [PK22] Pavel Panteleev and Gleb Kalachev “Asymptotically good Quantum and locally testable classical LDPC codes” In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2022 Rome, Italy: Association for Computing Machinery, 2022, pp. 375–388 DOI: 10.1145/3519935.3520017
- [PK22a] Pavel Panteleev and Gleb Kalachev “Quantum LDPC Codes With Almost Linear Minimum Distance” In IEEE Transactions on Information Theory 68.1, 2022, pp. 213–229 DOI: 10.1109/TIT.2021.3119384
Appendix
Omitted Proofs in Section 3
See 3.2
Proof.
We note that the soundness follows from Lemma 2.5, and the LDPC property follows from the fact that both of its component codes are LDPC. The rate can be calculated from the number of checks: there are qubits and checks, which gives rate .
The quantum distance can be seen from the following fact. Consider and for . If is in the stabilizer group for all , then must be a matrix of rank . Equivalently, can be transformed into the identity matrix by row operations, which means the original code is trivial. Therefore there exists some such that and are both logical operators. ∎
See 3.3
Proof.
To prove the first claim, we see that the row space of is exactly . Therefore, the dual of its row space is exactly the dual tensor code . The rate of the new code is also easy to compute, as the number of linearly independent checks is simply .
To argue about the distance of (item 2.) is not hard either. Let , and imagine as an matrix over . We will have shown that if we find any or such that or ( is the Hamming weight).
Let us now run through all checks of (i.e. rows of ), and through all checks of (i.e. rows of ). There are two possibilities.
-
1.
Either all of the above matrix-vector products give the zero vector. In that case is not only in , but also in the smaller , and therefore its distance from the zero vector is at least .
-
2.
One of the above matrix-vector products is non-zero. Notice that for any that is a -check (any that is a a -check), we have (), by definition, since represents an , and now we get a bound for that reason.
This proves that the distance is at least . To prove equality, take and with minimum distances ( and , respectively) from zero. Then and are both valid codewords of . This concludes the proof of our claims. ∎
See 3.5
Proof.
Suppose has physical qubits. We have from Lemma 3.3
Since , we can find , and a standard basis vector such that . Similarly, since , we can find , and a standard basis vector such that . This shows that . On the other hand, we note that from Fact 3 of Lemma 3.3,
Thus . Similarly, we have . This lemma then follows. ∎
Omitted Proofs in Section 4
See 4.1
Proof.
Without loss of generality we assume , since simply permute the bits of the code without changing any of its parameters. Given , it suffices for us to show that . Denote the rows of as , then . Now suppose , then let , where is the standard basis vector, and we see that . We may now repeat this procedure for all rows that give syndrome-bit 1 with respect to , until in steps we arrive at a code word. Finally we notice that . More explicitly, let be the indices of rows violated by . Define
Then , since . Thus, , which proves our claim. ∎
See 4.3
Proof.
The check matrix of is , and since the latter has row and column weight bounded by , the bound on the locality of follows. The more interesting part is to show that has soundness parameter at least .
By definition, every check of is a tensor product of a check for and a check for . The check of contains the bit of the checked word and some other bits that have index beyond , due to the structure of . Given a word to be checked, we write it as where each . Fix , and consider the collection of all those checks of that have the check of as their first component. Then is exactly the number of all checks for (hence is independent of ). Define
(in particular, is one of the participant indices on the r.h.s.). Let be the checks in that violates. These violated checks, due to the tensor product construction, correspond to those checks of that violates. Therefore, due to the soundness parameter of there exists a such that . Adding now to , while keeping all s for the same, we have achieved that all checks in go through, and also we did not affect those checks that are not in , since their component does not contain the bit of . After having the above done for all we get a word that passes all tests, therefore belongs to . Further,
(9) |
where is the number of checks violated by . Relating to , the number of all checks, we get from (9) that
as needed. ∎
See 4.4
Proof.
Local testability with soundness is proved by Lemma 4.3, by applying it to both and (where the check sets associated with and are and ) and taking the minimum. That the minimum of the respective soundness of the two classical parts is a lower bound on the soundness of the CSS code is proven in Lemma 2.5 (originally Fact 17 in [EH17]). The locality bounds also follow from Lemma 4.3, where we use the trivial upper bound on the row and column weights of and . Since and are the same code, they have the same rate and distance, and therefore the distance of is easily given by Lemma 3.3. The dimension can be calculated as follows: the number of stabilizer generators in is , and therefore the number of stabilizer generators in is . ∎
See 4.5
Proof.
First recall that in our construction is a random code with dimension and is a random subspace of of dimension . Due to the above parameters the quantum CSS code made from classical codes and encodes qubits, therefore it has rate .
Next we will show that both and have linear distances with high probability. Let be such that , where is the entropy function. We show that with probability very close to one both and have minimum distance at least , where (from below) as tends to infinity.
That has the above distance is simply the Gilbert-Varshamov (GV) bound for linear codes. This says that if we want to achieve relative distance , then a random linear code with rate will achieve that, where is arbitrary small as grows.
The proof of the GV bound is simple, and the code construction that leads to it, telling the proof with our parameters for simplicity, is the following: We select a random parity check matrix, with rows and colums. The minimum distance of is the minimum number of columns of that sum to zero. To argue for relative distance slightly below , we use the well-known fact, that
The number of ways to select columns is then , for large . The probability that any select columns (no restriction on ) of a random matrix with rows add up to zero is , and we can simply finish the proof by the union bound, since .
Let us now estimate the distance of in a similar way. The dimension of the linear space is , but at this time we have the restriction that must be a subspace of . The way to create a random subspace of of dimension is to add extra rows to the parity check matrix of . Therefore, to continue the construction, we select an additional rows. The added new rows constitute a matrix of dimensions . When we concatenate and (put them together into an matrix, we get a matrix . Here and are random, and the rows of generate . We calculate the probability that the rows of generate any vector of weight less than , where is appropriately, but only slightly less, than .
The number of vectors with weight is upper bounded by similarly to our previous calculation. The probability that any fixed select rows of (over the randomness of ) add up to a any particular vector is . The number of ways we can select a subset of rows of is . Thus:
Thus, the probability that the minimum distance of is at least is arbitrarily close to 1 when is sufficiently large.
By the union bound (at this time applied only on two terms), the probability that the minimum relative distance of either of or fails to be at least , for a randomly chosen becomes arbitrarily small, as goes to infinity. ∎