Quantum Error Correction with Reflexive Stabilizer Codes and Cayley Graphs

Long distance communication of digital data, whether through a physical medium or a broadcast signal, is often subjected to noise. To deliver data reliably through noisy communication channels, one must use codes that can detect and correct the particular noise of the channel. For transmission of classical data, error correcting schemes can be as simple as the sending of replicates. For quantum data, and in tandem the development of machines that can process quantum data, quantum error correcting codes must be developed. In addition to a larger set of possible errors, quantum error correcting schemes must contend with other peculiarities of quantum mechanics, such as the no-cloning theorem which can prevent the sending of replicate messages. Stabilizer codes are one family of quantum error correcting codes which can protect and correct errors expressed in terms of the Pauli group, exploiting its group structure and utilizing classical codes and the corresponding duals. We develop and examine a family of quantum stabilizer codes which arise from reflexive stabilizers. Moreover, we provide a mapping from our reflexive stabilizer codes to the well-known CSS codes developed by Calderbank, Shor, and Steane. For the case of a 4-state system we show that these codes can obtain the minimal embedding for code which can correct any flip or phase error. We also provide heuristic algorithms for creating reflexive stabilizer codes starting from the noise of a quantum channel. Furthermore, we show that the problem can be posed in terms of finding maximal Cayley subgraphs with restrictions imposed by the set of potential errors.



There are no comments yet.


page 1

page 2

page 3

page 4


A new family of quantum synchronizable codes from negacyclic codes

Quantum synchronizable codes are kinds of quantum error-correcting codes...

Quantum Synchronizable Codes on Sextic Cyclotomy

Quantum synchronizable codes are kinds of quantum error-correcting codes...

Quantum Data-Syndrome Codes

Performing active quantum error correction to protect fragile quantum st...

Error Thresholds for Arbitrary Pauli Noise

The error threshold of a one-parameter family of quantum channels is def...

On the decoding of 1-Fibonacci error correcting codes

The study of new error correcting codes has raised attention in the last...

Tamper Detection against Unitary Operators

We consider (Enc, Dec) schemes which are used to encode a classical/quan...

Quantum Insertion-Deletion Channels

We introduce a model of quantum insertion-deletion (insdel) channels. In...
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

Error correcting codes are essential tools in communication theory as they provide the means for the reliable delivery of data over noisy communication channels. In classical computing theory we have found that the ability to correct single-bit errors is not only fundamental, but sufficient for most purposes[eccfundamentals]

. This classical computing mindset has influenced the current approach to quantum error correction, with the majority of work focusing on the correction of single-qubit flip, phase and phase-flip errors

[ste98, errortheory, nielsen2002quantum, ortho, nonbinary].

The wealth of research in engineering a quantum computer has resulted in a variety of different systems by companies such as IBM, D-Wave and Google[ibm, google, dwave]. With a different system of qubits comes the possibility of errors intrinsic to a particular system. As such, the importance of finding codes that are resilient to a variety of errors is increasingly important. For instance, considering that entanglement is one of the strongest tools of quantum computation, it is reasonable to predict that entangled or correlated errors may be one of the more common errors. Moreover, correlated errors are already difficult to handle in mathematically, for example in toric quantum codes.

This paper explores a novel approach to quantum error correcting codes which we call reflexive stabilizer codes. We develop an adaptable framework that allows one to begin with a pre-described error set, perhaps intrinsic to a particular computer, and build quantum codes that avoid these errors. Reflexive stabilizer codes are stabilizer codes on qudits; i.e. for states represented by a finite field , where is a power of a prime , is the root of unity, and are single qudit errors defined in Section 2.

Defintion 1.

Let be a linear subspace of . The reflexive stabilizer of is the subgroup of the error group generated by

This simple stabilizer, has one major advantage to most known strategies of quantum error correction, in that it lends itself to a graph theoretic representation in which the errors become an set of edges that the code must avoid. To improve the error correction rate, we then create extended reflexive stabilizer codes, using two linear subspaces , denoted and .

The adaptability of this approach is best illustrated in the main result of this work, a heuristic algorithm, Section 5, built from around the existence of a linear undirected Caley graph [cayley]. As this algorithm is rooted heavily in graph theory, and on top of that a common theme of edge avoidance, it can be benefit from collaboration from this field.

The basic idea is that we start with an error set which contains the quantum errors we would like to be able to correct from our noisy channel, and build a graph, . We then are left with the task to find a linear undirected Caley graph which avoides all the edges of . The main Theorem 5.0.4 (Theorem 1 below), is the main igredident which allows us to make error correcting codes from a graph.

Theorem 1.

Let for some prime , and let be two linear subspaces, then (or ) can correct any error set , such that

and if

In Section 4, we show that these codes have the same capabilities in the standard single qubit/qudit error approach as CSS codes [ortho]. We do this by using standard methods from the field to produce weights for the classical code underlying the parameter space of our stabilizer code, which will correct single qubit/qudit errors. For instance, we show in Theorem 4.2.2, the following result giving equal error correction rates as those for CSS codes.

Theorem 2.

Let be linear subspaces, then the codes and can correct up to single-qudit flip, phase and phase-flip errors where

This paper is meant to serve as an introduction to reflexive stabilizer codes. It also provides a new graph theoretic approach to quantum error correction, opening many avenues for further research. As such, we finish with many questions given in Section 6.

2. Preliminaries

In what follows, all codings will be done into strings of qubits or, more generally, the superposition of strings of qudits. All codewords will be strings of elements from a quantum -ary alphabet, , that is the computational basis of dimension . Unlike classical computing, we also consider codewords that are the superposition of those strings from the computational basis. By convention, we choose for some prime and integer , and set the computational basis as which is an orthonormal basis of the Hilbert space . Note that the field with elements is simply the classical alphabet used to represent dits. For sake of calculations we will assume a fixed basis for over , namely .

Next we recall some of the basics of quantum error correction. For a more thorough introduction, see e.g. [fault, goodcodes, gf4, calcliff, nonbinary, ortho, errortheory, mixed, ste98].

2.1. The error group

The type of single qudit errors considered in quantum computation most often fall into 3 types, the Pauli spin matrices. For the case of qubits, the authors of [multiple, mixed] show how these generate all possible single qubit errors. We discuss this case in more detail in Example 2.1.6. We generalize the Pauli spin matrices to errors on qudits in the following definition.

Definition 2.1.1.

We define the following unitary operators and for on any as

known as the flip and phase errors respectively, acting on each of the qudits of a code, where is the primitive root of unity and

for and .

Remark 2.1.2.

It is notable that for error groups there is a wonderful connection between our inner product of and for the standard trace operator see [nonbinary]. We make the choice to not use this trace operator only for ease of calculations. Also, we chose to use a notation similar to that in [ortho].

To be able to have the most agile codes we will also consider the following definition.

Definition 2.1.3.

For we define the phase-flip error as,

Thus for we have

Remark 2.1.4.

As seen in [nonbinary] this definition is equivalent to first defining and for parameters in , which act on . Then for we define and on , as

Remark 2.1.5.

Notice that for we have

Example 2.1.6.

For those more familiar with qubits, one quickly notes that when then and are exactly the Pauli matrices:

Notice, that the set is linearly independent over both or , and hence span the space of all complex matrices. The set also has the property that the real span (i.e. linearly combinations with all real coefficients) forms all hermitian operators, and that each element of are themselves hermitian and unitary. Furthermore, the set form a group with the standard multiplication of matrices.

Remark 2.1.7.

In what follows we assume that a computational basis has been chosen and thus flip and phase errors are chosen. The approach taken in this paper is the set up to eventual use a change of basis, as seen in Section 6 to create optimal codes from a purely graph theoretical approach.

Definition 2.1.8.

For each , , we define

For the collection

from Remark 2.1.5 this collection is a group of order . We will refer to this group as the Error group. Furthermore, we will refer to any non-trivial subset of as an error set.

It is easily seen that the center, , of the group is generated by and therefore has order .

Remark 2.1.9.

Here we enumerate some of the properties of the errors in . For , we have



Remark 2.1.10.

For and then we have the following relations






Therefore, two operators and commute if and only if

This operation is a symplectic inner product on the space .

The objective of quantum stabilizer codes is to be able to protect from any error of a commutative subgroup of errors, , and correct any error from a larger set of errors .

Definition 2.1.11.

Let be a commutative subgroup such that the center is contained in , then a Quantum stabilizer code

is any joint eigenspace of the operators in


The reader less familiar with stabilizer codes is referred to [ste98, ortho, goodcodes, errortheory]

3. Reflexive Codes

In this section we will introduce a special class of quantum stabilizer codes, which we refer to as reflexive codes. These reflexive codes will provide the basic building blocks of our new codes.

Definition 3.0.1.

Let be a linear subspace of . The reflexive stabilizer of is the subgroup of the error group generated by

Remark 3.0.2.

One quickly sees that is commutative as for two elements we have that

and hence follows from Remark 2.1.10. Therefore a reflexive stabilizer is indeed a quantum stabilizer.

Definition 3.0.3.

Let be a linear subspace and let be the reflexive stabilizer defined by . We define the Reflexive Stabilizer Code (RSC) to be the quantum code generated by


is a particular choice of eigenvector for each

. In what follows we give particular choice of . In Theorem 3.0.5, we will prove that these codes are indeed stabilizer codes.

Fix a prime and a positive integer , and let . Given a reflexive stabilizer , we will choose a linear character; i.e. a joint eigenspace, for an RSC. We begin by fixing a computational basis . For a linear subspace of , we denote by the orthogonal subspace with respect to the inner product in Equation 2.5; i.e.

Additionally, we let denote the individual basis elements for our -dimensional basis, , of over . Note that for a given that, from Equation (2.3), we have,




Due to Equation (3.1), in order to understand the eigenspaces of , it is enough to understand the eigenspaces of . Thus, the last piece that we need is to examine the eigenspaces of in .

First, for

, the eigenvalues for

are , where each eigenspace is 1-dimensional and spanned, respectively, by


For , the eigenvalues are for

, and again the respective eigenspaces are each one-dimensional. In what follows, we will choose a unit vector to span each, and denote denote it by

. In general, one option is to choose

where , , and for , for

The next example illustrates this construction for .

Example 3.0.4.

Again, we begin by considering the case and work out a general formula for any linear subspace . The eigenspace decomposition for this case is as follows:

Now for any we have the following quantum code word in


where is the vector with all ones, and for gives the number of matching entries.

For each , we denote by the eigenvector, given explicitly by

which for the eigenvalue where . We are now ready to prove that the codes defined in Definition 3.0.3 are indeed stabilizer codes.

Theorem 3.0.5.

Given a linear subspace the code is a reflexive stabilizer code for the reflexive stabilizer . Thus is a quantum stabilizer code which embeds logical qudits into physical qudits, where .


To prove this result, we need only show that all of the vectors of lie in the same eigenspace for any operator (by Definition 2.1.11). The result is trivial for as every vector lies in the eigenspace.

For the remainder of the proof we need only show, for each , that all of the vectors lie in the same eigenspace of . This follows from Equation (3.1) since for and we have that


where and each defined in Equation (3.2). Equation (3.5) depends only on , and we are done. ∎

Example 3.0.6.

Let be the 2-dimensional code consisting of the following vectors

By taking tensors of the eigenvectors in Equation 

3.3, we embed the logical qubits into the physical qubits of as follows:

One can check the error correction capabilities of using the results presented in Section 4. Specifically, using Theorem 4.1.4, can correct any error from the error set .

3.1. Extension of reflexive codes

In Section 4 we see that reflexive codes, have limitations in error correction, to overcome these limitations we extend these reflexive codes. This extension is a similar to CSS codes [goodcodes, ortho]. We establish two extensions that protect against phase and flip errors, respectively.

Definition 3.1.1.

Let , be linear subspaces and let be the Reflexive QECC associated to . We then define two extensions of reflexive codes. The first will be referred to as a phase-error extension by , and is the quantum code generated by

The second extension will be referred to as an flip-error extension by , and is the quantum code generated by

One sees that in either case, two of the above code words and match if and only if , and hence the dimension of (or ) is .

Theorem 3.1.2.

Let be a linear subspaces, then both and are stabilizer codes, and the stabilizer is generated by the elements of and for , and and for .


We will only show the result for as the other follows similiarly. First, note that for any and , the operators and commute because

since . Now we show that for any and that . This follows from the observation that for for any that so

The result for general is follows and thus the result follows. ∎

The next results is an immediate consequence.

Corollary 3.1.3.

Let be linear subspaces, and be the stabilizer for and be the stabilizer for then we have

where is the set of operators which commute with operators in .

Remark 3.1.4.

One will notice that CSS codes are in one-to-one correspondence with extended reflexive codes via another choice of error basis. That is, an error basis which was instead generated by and from Example 2.1.6, and obtained if we were to define:

That is to say sticking with the standard basis on , the parameter space of the Error Basis, we can build a linear isomorphism

It is now a simple exercise to show that the above isomorphism takes the stabilizer for a reflexive stabilizer code (with ) to a stabilizer of a CSS code. In the following section we show that reflexive stabilizer codes have the same correction capabilities for single-qubit errors.

The next two examples help elucidate the application Definition 3.1.1. Moreover, these examples utilize well-known classical and quantum codes, providing context for reflexive codes.

Example 3.1.5.

Our next example uses the classical example of the [7,4,3]-Hamming code, that is the linear subspace of consisting of the following vectors:


Shor used this code in [goodcodes] to build a quantum stabilizer code which encoded one qubit into seven qubits.

For reflexive codes, we will embed three qubits into the seven qubits. We set as the classical Hamming code given in Equation (3.6) and we set . Then consists of all elements of with even Hamming weight. It follows from Theorem 4.2.1 that our code will correct any single-qubit flip or phase error. From Definition 3.1.1, we find the code words for the flip-error extended code

One could write out these code words using the computational basis, as in Example 3.0.6, but doing so would be cumbersome as each is a linear combination of 58 basis elements. This example encodes three times the information as Shor’s code given in [goodcodes] but cannot correct phase-flip errors by Theorem 4.2.2.

Example 3.1.6.

Now, we provide an extended RCS which obtains the same rate as the [5,1,3]-Perfect Code introduced in [perfect]. Unlike the Perfect Code, the code presented here is on a 3-state system. Let , be the 2-dimensional code consisting of the following vectors:

Similar to Example 3.1.5 above, we choose . Hence the extended flip-error extended code has code words:

By Theorem 4.2.1, one easily checks that this code can correct any single-qudit flip or phase error. Thus this code embeds one logical qudit into five physical qubits and corrects any single-qudit flip or phase error. Notice that cannot correct against single-qudit flip-phase errors, by Theorem 4.2.2, and therefore does not match the correction capability of the Perfect Code [perfect].

4. Error correction

Before we examine the error correction capabilities of reflexive codes we cover a basic property of stabilizer codes. Given a commutative subgroup then clearly a quantum stabilizer code associated to can protect from error in . For a quantum code to be able to protect from any error in an error set , it is necessary and sufficient [errortheory, mixed] for any two code words , in our quantum code with , and any two errors , we have

It is of note that we will always assume as one should always protect from no errors occuring.

Definition 4.0.1.

Given any two errors from an error set , we will refer to as a conjugate error of . Furthermore, we will denote the set of conjugate errors of by


Furthermore, we define the avoidance set as


To find codes later we will use the power of our parametric treatment of these error operators. Specifically, for any subgroup such that , we associate a linear subspace of given by


It remains only to define a joint eigenspace of ; i.e. we need only find a basis for , and then choose eigenvalues for , denote these as . Thus it follows from Equation 2.3 that the errors of permute the eigenspaces of .

The following theorem follows identically to that in [ortho, Theorem 1] and [nonbinary, Theorem 3]. We include it for later reference.

Theorem 4.0.2.

Let be a commutative subgroup of which contains the center, i.e. , and let be the subgroup such that with respect to the inner product from Equation 2.4. Further, let be an error set. Then any stabilizer code for is an error-correcting code which will correct any error from if and only if every conjugate error satisfies either or .

Next we specialize to the case of reflexive codes.

4.1. Reflexive codes

Now we begin exploring the basic error correction capabilities for these new codes.

Definition 4.1.1.

Given a linear subspace we define the non-detection group, denoted as the subgroup of generated by


where is the orthogonal space with respect to the inner product in Equation 2.5. It is easy to check that this satisfies from the previous theorem, where is given in Equation (4.3).

An immediate consequence of Theorem 4.0.2 and Theorem 3.0.5 is the following.

Corollary 4.1.2.

Let be a linear subspace, and be an error set. Then is an error-correcting code which will correct any single error from if and only if, for any conjugate error , either or .

We now dive into the error correction capabilities and limitations of a Reflexive QECC . We begin with general qudit errors and provide a complete description of the possible error sets which can correct.

Definition 4.1.3.

For an error set we define the difference set of as the set

Theorem 4.1.4.

Let be a non-trivial linear subset. Then can correct any error of an error set if and only if


By Theorem 4.0.2 (or Corollary 4.1.2), can correct any error from if and only if, for any conjugate error , either or . We see that if and only if , since for any the following must hold

Hence, if and only if and , and thus our theorem follows.

Now we consider some special cases of the above theorem.

Definition 4.1.5.

In lieu of the second condition of Theorem 4.1.4, we aim to construct the largest error set so that has nothing of the form . Let , we first denote

where is the standard basis element of . Now define the -qudit error set for as:

where is the number of non-zero entries in .

Remark 4.1.6.

One quickly notes that consists of all single-qudit flip errors, and consists of all single-qudit phase errors. In general, specifies the expected locations of phase errors, allowing for flip errors on the remaining qudits.

Lemma 4.1.7.