## 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

(2.1) |

and

(2.2) |

###### Remark 2.1.10.

For and then we have the following relations

(2.3) |

where

(2.4) |

and

(2.5) |

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

where

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,

(3.1) |

where

(3.2) |

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(3.3) |

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 choosewhere , , 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

(3.4) |

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 .

###### Proof.

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.

###### 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 .

###### Proof.

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:

(3.6) |

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

(4.1) |

Furthermore, we define the avoidance set as

(4.2) |

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

(4.3) |

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.

###### 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

###### Proof.

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.

Let

Comments

There are no comments yet.