TL;DR
This paper links Kerdock codes to quantum stabilizer states, showing they form unitary 2-designs with efficient Clifford circuit implementations, simplifying quantum state sampling and circuit synthesis.
Contribution
It introduces a novel connection between classical Kerdock codes and quantum stabilizer states, enabling simplified construction of unitary 2-designs using Clifford gates.
Findings
Kerdock codes produce stabilizer states that form unitary 2-designs.
The automorphism group acts transitively on Pauli matrices, ensuring Pauli mixing.
Efficient Clifford circuit synthesis for unitary 2-designs on up to 16 qubits.
Abstract
The non-linear binary Kerdock codes are known to be Gray images of certain extended cyclic codes of length over . We show that exponentiating these -valued codewords by produces stabilizer states, that are quantum states obtained using only Clifford unitaries. These states are also the common eigenvectors of commuting Hermitian matrices forming maximal commutative subgroups (MCS) of the Pauli group. We use this quantum description to simplify the derivation of the classical weight distribution of Kerdock codes. Next, we organize the stabilizer states to form mutually unbiased bases and prove that automorphisms of the Kerdock code permute their corresponding MCS, thereby forming a subgroup of the Clifford group. When represented as symplectic matrices, this subgroup is isomorphic to the projective special linear…
| 0 | |||||
| Symplectic Matrix | Clifford Operator |
|---|---|
| ‘Permute’ | [1,6,3,5,4,2] |
| ‘CNOT’ | [3,1] |
| ‘CNOT’ | [4,1] |
| ‘CNOT’ | [5,1] |
| ‘CNOT’ | [6,1] |
| ‘CNOT’ | [6,4] |
| ‘CNOT’ | [6,5] |
| ‘CNOT’ | [4,5] |
| ‘CNOT’ | [3,6] |
| ‘CNOT’ | [2,3] |
| ‘H’ | [1,2,3,4,5,6] |
| ‘P’ | [3,4,5] |
| ‘CZ’ | [1,3] |
| ‘CZ’ | [1,4] |
| ‘CZ’ | [1,5] |
| ‘CZ’ | [2,6] |
| ‘CZ’ | [3,5] |
| ‘CZ’ | [4,5] |
| ‘CZ’ | [4,6] |
| ‘CZ’ | [5,6] |
| ‘H’ | [1,2] |
| ‘CNOT’ | [2,3] |
| ‘CNOT’ | [2,4] |
| ‘CNOT’ | [2,5] |
| ‘CNOT’ | [2,6] |
| ‘Z’ | [2,6] |
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Code & Models
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
Kerdock Codes Determine Unitary 2-Designs
Trung Can1, Narayanan Rengaswamy1, Robert Calderbank, and Henry D. Pfister 1These two authors contributed equally to this work. This work was presented in part at the 2019 IEEE International Symposium on Information Theory [1].T. Can is currently with the Department of Mathematics, California Institute of Technology, Pasadena, CA 91125, USA. Most of this work was conducted while he was with the Department of Mathematics, Duke University, Durham, North Carolina 27708, USA. Email: [email protected]. Rengaswamy, R. Calderbank and H. D. Pfister are with the Department of Electrical and Computer Engineering, Duke University, Durham, North Carolina 27708, USA. Email: {narayanan.rengaswamy, robert.calderbank, henry.pfister}@duke.eduThis work was supported in part by the National Science Foundation (NSF) under Grant Nos. 1718494 and 1908730. Any opinions, findings, conclusions, and recommendations expressed in this material are those of the authors and do not necessarily reflect the views of these sponsors.Copyright (c) 2017 IEEE. Personal use of this material is permitted. However, permission to use this material for any other purposes must be obtained from the IEEE by sending a request to [email protected].
Abstract
The non-linear binary Kerdock codes are known to be Gray images of certain extended cyclic codes of length over . We show that exponentiating these -valued codewords by produces stabilizer states, that are quantum states obtained using only Clifford unitaries. These states are also the common eigenvectors of commuting Hermitian matrices forming maximal commutative subgroups (MCS) of the Pauli group. We use this quantum description to simplify the derivation of the classical weight distribution of Kerdock codes. Next, we organize the stabilizer states to form mutually unbiased bases and prove that automorphisms of the Kerdock code permute their corresponding MCS, thereby forming a subgroup of the Clifford group. When represented as symplectic matrices, this subgroup is isomorphic to the projective special linear group PSL(). We show that this automorphism group acts transitively on the Pauli matrices, which implies that the ensemble is Pauli mixing and hence forms a unitary -design. The Kerdock design described here was originally discovered by Cleve et al. (2016), but the connection to classical codes is new which simplifies its description and translation to circuits significantly. Sampling from the design is straightforward, the translation to circuits uses only Clifford gates, and the process does not require ancillary qubits. Finally, we also develop algorithms for optimizing the synthesis of unitary -designs on encoded qubits, i.e., to construct logical unitary -designs. Software implementations are available at https://github.com/nrenga/symplectic-arxiv18a, which we use to provide empirical gate complexities for up to qubits.
Index Terms:
Heisenberg-Weyl group, Pauli group, quantum computing, Clifford group, symplectic geometry, Kerdock codes, Delsarte-Goethals codes, Gray map, stabilizer states, mutually unbiased bases, unitary -designs
I Introduction
Quantum computers promise enormous computational speedups over the best classical supercomputers in certain problems. It has been established that even constant-depth quantum circuits provide an advantage over classical computation [2]. Today these devices are moving out of the lab and becoming generally programmable [3]. Since quantum computers are noisy, they will most likely employ quantum error-correcting codes (QECCs) to ensure reliability of computation. Classical error-correcting codes inspired the discovery of the first QECC by Shor [4], the development of CSS codes by Calderbank, Shor and Steane [5, 6], and the development of stabilizer codes [7, 8] by Calderbank, Rains, Shor and Sloane and by Gottesman. A QECC protects logical qubits by embedding them in a system comprising physical qubits. In fault-tolerant computation, any desired operation on the logical (protected) qubits must be implemented as a physical operation on the physical qubits that preserves the code space. The most common QECCs are stabilizer QECCs, that are derived from commutative subgroups of the Heisenberg-Weyl group (also known as the Pauli group), and the simplest quantum circuits are composed of unitary operators from the Clifford group (see Section III for formal definitions). Note that throughout this paper. The Clifford group normalizes , so each element of induces an automorphism of under conjugation. Since elements can be efficiently represented as binary length- vectors, Clifford operators can be efficiently represented as binary symplectic matrices that preserve the group structure of under the binary mapping. A central theme in this paper is that beyond inspiring the construction of QECCs, interactions between the classical and quantum worlds still prove mutually beneficial for other purposes, especially via the binary representations of and .
Prior to running applications, a quantum computer needs to be assessed for its quality, in terms of the fidelity of the quantum operations executed on the system. The randomized benchmarking protocol, introduced by Emerson et al. [9, 10], is a well-established scheme that estimates the fidelity of the noise in the system by twirling the underlying channel through a randomized sequence of gates and calculating the fidelity of the resulting depolarizing channel. The depolarizing channel can be interpreted as the quantum analogue of the binary symmetric channel in classical communication theory. Since the fidelity is shown to be an invariant of this twirling process, the protocol indeed estimates the fidelity of the actual noise (under some additional assumptions). This protocol works on the physical operations in the computer, so the fidelity estimates then need to be translated into the quality of the logical operations (on the protected qubits) for an error-corrected quantum computer. Since this translation might not be reliable, the procedure has recently been extended to the logical randomized benchmarking protocol [11] that directly estimates the fidelity of the logical operations more reliably.
Randomized benchmarking requires that the sequence of gates be sampled from an ensemble of unitaries that form a unitary -design. A unitary -design is an ensemble of unitaries, bestowed with a probability distribution, that approximates the Haar distribution on the unitary group up to the -th moment. Section VI makes this precise by discussing linear maps called twirls over the full unitary ensemble and the finite ensemble. When the two linear maps coincide the finite ensemble is a unitary -design. It is easy to analyze protocols that randomly sample unitary matrices with respect to the Haar measure, but such sampling is infeasible, hence the interest in finite ensembles of unitary matrices that approximate the Haar distribution. is known to be a unitary -design [12], and the proof by Webb involves the concepts of Pauli mixing and Pauli -mixing, which we introduce in Section VI. However, has size (up to scalars ) which is much larger than the lower bound of for any unitary -design, established by Gross, Audenaert and Eisert [13], and by Roy and Scott [14]. They also discuss the existence of Clifford ensembles that saturate this bound. Although random circuits are known to be exact or approximate unitary -designs [15, 16], deterministic constructions of such ensembles facilitate practical realizations. Cleve et al. [17] have recently found an explicit subgroup of that is a unitary -design. The central contribution of this paper is to use the classical Kerdock codes to simplify the construction of this quantum unitary -design and its translation to circuits (see Section VI).
There are many other applications of unitary -designs. The first is quantum data hiding (the LOCC model described in [18]), where the objective is to hide classical information from two parties who each share part of the data but are only allowed to perform local operations and classical communication. The data hiding protocol can be implemented by sampling randomly from the full unitary group but it is sufficient to sample randomly from a unitary -design. Other applications of unitary -designs are the fidelity estimation of quantum channels [19], quantum state and process tomography [20], and more recently minimax quantum state estimation [21]. In quantum information theory, they have been used extensively in the analysis of decoupling [22, 14, 23, 16].
The next section discusses the flow of ideas in the rest of the paper, and points to related work and applications.
II Main Ideas and Discussion
The first result in the paper is to use the (quantum) commutative subgroups of to simplify the derivation of weight distributions for the (classical) Kerdock codes.
Recall that Hermitian matrices that commute can be simultaneously diagonalized. The Kerdock and Delsarte-Goethals binary codes are unions of cosets of the first order Reed-Muller (RM) code , the cosets are in one-to-one correspondence with symplectic forms, and the weight distribution of a coset is determined by the rank of the symplectic form (see [24, Chapter 15] for more details). Section IV-A reviews the description of these codes given in [25]. Section IV-B shows that when we exponentiate codewords in these cosets of we obtain a basis of common eigenvectors for a maximal commutative subgroup of Hermitian Pauli matrices. The operators that project onto individual lines in a given eigenbasis are invariants of the corresponding subgroup [26], and the distance distribution of the code is determined by the inner product of pairs of such eigenvectors (see [Section IV, Lemma 10]). When calculating weight distributions, this property makes it possible to avoid using Dickson’s Theorem [24, Chapter 15] to choose an appropriate representation of the symplectic form. The correspondence between classical and quantum worlds simplifies the calculation (of the weight distribution) given in [24] significantly. In order to demonstrate this simplicity, we provide the proof of the weight distribution here. For most parts of the proof, we only need a brief description of the Kerdock set, Kerdock code, and the Gray map. See Section IV for formal definitions, constructions, and results used in the following proof.
In [27], the Kerdock set is defined to be a collection of binary symmetric matrices that is characterized by the following properties: it is closed under binary addition, and if are distinct, then is non-singular. The codewords of the length- -linear Kerdock code can be expressed as , where chooses the symbol index in a codeword, and the codeword is determined by the choice of and . One can obtain complex vectors of quaternary phases by raising to the integer powers in the (-valued) codeword vector. We will refer to this operation as exponentiating the codeword by . The Gray map is an isometry from (length- vectors of quaternary phases, Euclidean metric) to (, Hamming metric) defined by and . Note that the domain of the map can equivalently be taken as in which case the metric is the Lee metric (defined in Section IV-B). The codewords of the binary non-linear Kerdock code of length are obtained as Gray images of the -valued codewords described above.
Theorem 1
Let be odd. The weight distribution of the classical binary Kerdock code of length is as follows.
Proof:
We explicitly use Lemma 10 and Corollary 16 to calculate the weight distribution. Fix a vector of quaternary phases obtained by exponentiating a codeword
[TABLE]
in the -linear Kerdock code. Consider any vector of quaternary phases obtained by exponentiating a second codeword
[TABLE]
(Lemmas 11 and 15 consider so that the eigenvalues are (and not in ), but we account for these factors here.)
Let be the number of indices for which , for . Since the Gray map preserves the Lee metric, the Hamming distance between the Gray images of and is . Since we simply have to relate and to obtain . Observe that . Lemma 10 implies
[TABLE]
Now we observe three distinct cases for the codeword . Note that there are codewords in .
- (i)
: If then we have the all-zeros codeword, and if then we have the all-ones codeword. However, if then and this determines two codewords of weight (more precisely, at distance from ).
- (ii)
: From Corollary 16, irrespective of , we have , which implies and hence the distance is . This determines another codewords of weight .
- (iii)
: From Corollary 16 we have , which implies . Since is odd, and are non-negative integers, direct calculation shows that this means and therefore . More formally, since the Gaussian integers are a unique factorization domain, we have and this gives weights . Thus, we have codewords remaining and it is easy to see that the signs occur equally often. Hence there are codewords of each weight. ∎
Lemma 11 shows that the (normalized) length- vectors of quaternary phases obtained by exponentiating Kerdock, or more generally Delsarte-Goethals, codewords are common eigenvectors of maximal commutative subgroups of . These eigenvectors are called stabilizer states in the quantum information literature [28] (also see end of Section III). They can equivalently be described as those quantum states obtainable by applying Clifford unitaries to the basis state [29]. Clifford elements act by conjugation on , permuting the maximal commutative subgroups, and fixing the ensemble of stabilizer states (see Section V). The Clifford group is highly symmetric, and it approximates the full unitary group in a way that can be made precise by comparing irreducible representations [30, 26]. Kueng and Gross [31] have shown that the ensemble of stabilizer states is a complex projective -design; given a polynomial of degree at most , the integral over the -sphere can be calculated by evaluating the polynomial at stabilizer states, and taking a finite sum. Stabilizer states also find application as measurements in the important classical problem of phase retrieval, where an unknown vector is to be recovered from the magnitudes of the measurements (see Kueng, Zhu and Gross [32]). A third application is unsourced multiple access, where there is a large number of devices (messages) each of which transmits (is transmitted) infrequently. This provides a model for machine-to-machine communication in the Internet-of-Things (IoT), including the special case of radio-frequency identification (RFID), as well as neighbor discovery in ad-hoc wireless networks. Here, Thompson and Calderbank [33] have shown that stabilizer states associated with Delsarte-Goethals codes support a fast algorithm for unsourced multiple access that scales to devices (arbitrary -bit messages).
Section V constructs the eigenbases (of stabilizer states each) determined by the Kerdock code of length over , and shows that the corresponding maximal commutative subgroups partition the non-identity Hermitian Pauli matrices. The eigenbases are mutually unbiased, so that unit vectors in different eigenbases satisfy , and hence each eigenbasis looks like noise to the other eigenbases. The Kerdock ensemble of complex lines is extremal; Calderbank et al. [34] have shown that any collection of unit vectors for which pairwise inner products have absolute value [math] or has size at most , and that any extremal example must be a union of eigenbases. The group of Clifford symmetries of this ensemble, represented as binary symplectic matrices, is shown to be isomorphic to the projective special linear group , and hence its size is . We note that the Kerdock ensemble also appears in the work of Tirkkonen et al. [35].
Section VI defines a graph whose vertices are labeled by (scalar multiples of) all non-identity (Hermitian) Pauli matrices, where two matrices (vertices) are joined (by an edge) if and only if they commute. This graph is shown to be strongly regular; every vertex has the same degree, and the number of vertices joined to two given vertices depends only on whether the two vertices are joined or not joined. The automorphism group of this graph is the group of binary symplectic matrices . A subgroup of containing is proven to be Pauli mixing if it acts transitively on vertices, and Pauli -mixing if it acts transitively on edges and on non-edges. These properties imply that Pauli mixing ensembles are unitary -designs and Pauli -mixing ensembles are unitary -designs [12]. The Clifford symmetries of the Kerdock ensemble (of stabilizer states), again represented as symplectic matrices, are shown to be transitive on the vertices of and hence a unitary -design. Since the Clifford symmetries include all Hermitian Paulis, in addition to PSL(), the size of the Kerdock unitary -design is , which almost saturates the bound by Gross et al. [13] discussed above. The next step is to translate these symmetry elements into circuits for, say, randomized benchmarking.
T. Can has developed an algorithm [36] that factors a binary symplectic matrix into a product of at most elementary symplectic matrices of the type shown in Table I. The target symplectic matrix maps the (Hadamard) dual basis (see Section III for notation) to a dual basis . Then, row and column operations by the elementary matrices return to the original pair thereby producing a decomposition of the target symplectic matrix.
Section VI uses this decomposition to simplify the translation of the Kerdock unitary -design into circuits. The elementary symplectic matrices appearing in the product can be related to the Bruhat decomposition of the symplectic group (see [37]). When the algorithm is run in reverse it produces a random Clifford matrix that can serve as an approximation to a random unitary matrix. This is an instance of the subgroup algorithm [38] for generating uniform random variables. The algorithm has complexity and uses random bits, which is order optimal given the order of the symplectic group (cf. [39]). We note that the problem of selecting a unitary matrix uniformly at random finds application in machine learning (see [40] and the references therein). The algorithm developed by Can is similar to that developed by Jones, Osipov and Rokhlin [41] in that it alternates (partial) Hadamard matrices and diagonal matrices; the difference is that the unitary -design property of the Clifford group [12] provides randomness guarantees.
Finally, Section VII constructs logical unitary -designs that can be applied in the logical randomized benchmarking protocol of Combes et al. [11]. In prior work [42], we have developed a mathematical framework for synthesizing all physical circuits that implement a logical Clifford operator (on the encoded qubits) for stabilizer codes (up to equivalence classes and ignoring stabilizer freedom). Circuit synthesis is enabled by representing the desired physical Clifford operator as a binary symplectic matrix. For an stabilizer code, every logical Clifford operator is shown to have symplectic solutions, and these are enumerated efficiently using symplectic transvections, thus enabling optimization with respect to a suitable metric. See https://github.com/nrenga/symplectic-arxiv18a for implementations.
It is now well-known that different codes yield efficient (e.g., low-depth) implementations of different logical operators. However, computing environments can change dynamically so that qubits or qubit links might have varying fidelity, and thus low-depth alone might not be desirable. Under such circumstances it is necessary to leverage all degrees of freedom in implementing a logical operator, and a compiler might use the above framework for this purpose. More generally, a compiler might usefully switch between several codes [43] dynamically, depending on the state of the system. Then this algorithm enables the compiler to be able to determine logical operators for a code quickly depending on the user-input circuit (on the protected qubits).
Section VII provides a proof of concept implementation of the Kerdock unitary -design on the protected (logical) qubits of the CSS code using the above logical Clifford synthesis algorithm. The logical randomized benchmarking protocol requires a unitary -design on the logical qubits, and Combes et al. use the full Clifford group for this purpose, which is much larger than the Kerdock design as shown above.
In summary, the purpose of this paper is to emphasize that interactions between the classical and quantum domains still prove mutually beneficial, as much as they helped inspire the first QECC more than two decades back. Specifically, we make four main theoretical contributions:
Use of quantum concepts to simplify the calculation of classical weight distributions of several families of non-linear binary codes [44, 45, 46, 47, 48, 49, 24, 50]. 2. 2.
Elementary description of symmetries of the Kerdock code, and the stabilizer states determined by this code [27, 51, 35, 33]. 3. 3.
Demonstration that the symmetry group of the Kerdock code is a unitary -design and that sampling from it is straightforward. Introduction of elementary methods for translation to circuits without using ancillary qubits. 4. 4.
Provide a proof of concept construction for unitary -designs on the logical qubits of a stabilizer code [42, 11].
We also provide software implementations of all algorithms, at https://github.com/nrenga/symplectic-arxiv18a. Using this utility, we provide empirical estimates of the gate complexity for circuits obtained from the Kerdock design. We believe this paves the way for employing this design in several applications, specifically in randomized benchmarking [10, 52].
III The Heisenberg-Weyl and Clifford Groups
Quantum error-correcting codes serve to protect qubits involved in quantum computation, and this section summarizes the mathematical framework introduced in [5, 7, 8, 53], and described more completely in [54] and [42]. In this framework for fault-tolerant quantum computation, Clifford operators on the -dimensional complex space afforded by qubits are represented as binary symplectic matrices. This is an exponential reduction in size, and the symplectic matrices serve as a binary control plane for the quantum computer.
Remark 2
Throughout the paper, we adopt the convention that all binary vectors are row vectors, and -, real- or complex-valued vectors are column vectors, where is the ring of integers modulo . The values , where , are called quaternary phases.
A single qubit is a -dimensional Hilbert space, and a quantum state is a superposition of the two states which form the computational basis. Thus , where satisfy as per the Born rule [55, Chapter 3]. The Pauli matrices are
[TABLE]
where and is the identity matrix [56, Chapter 10]. We may express an arbitrary pure quantum state as
[TABLE]
We describe -qubit states by (linear combinations of) -fold Kronecker products of computational basis states, or equivalently by -fold Kronecker products of Pauli matrices.
Given row vectors define the -fold Kronecker product
[TABLE]
where denotes the group of all unitary operators. The Heisenberg-Weyl group (also called the -qubit Pauli group) consists of all operators , where . The order is and the center of this group is , where is the identity matrix. Multiplication in satisfies the identity
[TABLE]
The standard symplectic inner product in is defined as
[TABLE]
where the symplectic form (see [7, 42]). Therefore, two operators and commute if and only if .
The homomorphism defined by
[TABLE]
has kernel and allows us to represent elements of (up to multiplication by scalars) as binary vectors.
The Clifford group consists of all unitary matrices for which for all , where is the Hermitian transpose of [54]. is the normalizer of in the unitary group . The Clifford group contains and its size is (up to scalars ) [7]. We regard operators in as physical operators acting on quantum states in , to be implemented by quantum circuits. Every operator induces an automorphism of by conjugation. Note that the inner automorphisms induced by matrices in preserve every conjugacy class and , because (5) implies that elements in either commute or anti-commute. Matrices are symmetric or anti-symmetric according as or , hence the matrix
[TABLE]
is Hermitian. Note that . The automorphism induced by a Clifford element satisfies
[TABLE]
is a binary matrix that preserves symplectic inner products: . Hence is called a binary symplectic matrix and the symplectic property reduces to , or equivalently
[TABLE]
(See [57] for an extensive discussion on general symplectic geometry and quantum mechanics.) The symplectic property encodes the fact that the automorphism induced by must respect commutativity in . Let denote the group of symplectic matrices over . The map defined by
[TABLE]
is a homomorphism with kernel , and every Clifford operator projects onto a symplectic matrix . Thus, is a normal subgroup of and . This implies that the size is (also see [7]). Table I lists elementary symplectic transformations , that generate the binary symplectic group , and the corresponding unitary automorphisms , which together with generate . (See [42, Appendix I] for a discussion on the Clifford gates and circuits corresponding to these transformations.)
We use commutative subgroups of to define resolutions of the identity. A stabilizer is a subgroup of generated by commuting Hermitian matrices of the form , with the additional property that if then [56, Chapter 10]. The operators project onto the eigenspaces of , respectively.
Remark 3
Since all elements of are unitary, Hermitian and commute with each other, they can be diagonalized simultaneously with respect to a common orthonormal basis, and their eigenvalues are with algebraic multiplicity . We refer to such a basis as the common eigenbasis or simply eigenspace of the subgroup , and to the subspace of eigenvectors with eigenvalue as the +1 eigenspace of .
If the subgroup is generated by , then the operator
[TABLE]
projects onto the -dimensional subspace fixed pointwise by , i.e., the eigenspace of . The subspace is the stabilizer code determined by . We use the notation code to represent that encodes logical qubits into physical qubits.
Let denote the subspace of formed by the binary representations of the elements of using the homomorphism in (7). A generator matrix for is
[TABLE]
where [math] is the matrix with all entries zero.
Given a stabilizer with generators , we can define subgroups where the index represents that is generated by , for . Note that the operator
[TABLE]
projects onto , and that
[TABLE]
Hence the subspaces , or equivalently the subgroups , provide a resolution of the identity, and elements (errors) in simply permute these subspaces (under conjugation).
Given an stabilizer code, it is possible to perform encoded quantum computation in any of the subspaces by synthesizing appropriate logical Clifford operators (see [42] for algorithms). If we think of these subspaces as threads, then a computation starts in one thread and jumps to another when an error (from ) occurs. Quantum error-correcting codes enable error control by identifying the jump that the computation has made. Identification makes it possible to modify the computation in flight instead of returning to the initial subspace and restarting the computation. The idea of tracing these threads is called as Pauli frame tracking in the literature (see [58] and references therein).
A stabilizer group defined by generators is called a maximal commutative subgroup of and is called a maximal isotropic subspace of . The generator matrix has rank and can be row-reduced to if , or to the form if is disjoint from . We will denote these subgroups as and , respectively. The condition implies , and any element of can be expressed in the form for some . Note that . Since , the subgroup fixes exactly one vector. The eigenvectors in an orthonormal eigenbasis for are defined up to an overall phase and called stabilizer states [28, 29]. The number of non-zero entries in a stabilizer state is determined by the intersection of with [59].
IV Weight Distributions of Kerdock Codes
Kerdock codes were first constructed as non-linear binary codes [45], as was the Goethals code [47] and the Delsarte-Goethals codes [49]. In this section, we describe the Kerdock and Delsarte-Goethals codes as linear codes over , the ring of integers modulo . These -linear codes were constructed by Hammons et al. [25] as Hensel lifts of binary cyclic codes, and this description requires Galois rings. The description given in Section IV-A requires finite field arithmetic, but is entirely binary and follows [27]. Our construction of unitary -designs in Section VI uses the matrices that are defined in Section IV-A. In Section IV-B, we make a connection between the Kerdock and Delsarte-Goethals codes and maximal commutative subgroups of via stabilizer states, use this relation to compute inner products between stabilizer states, and hence calculate weight distributions of Kerdock codes.
IV-A Kerdock and Delsarte-Goethals Sets [27]
The finite field is obtained from the binary field by adjoining a root of a primitive irreducible polynomial of degree [60]. The elements of are polynomials in of degree at most , with coefficients in , and we will identify the polynomial with the binary (row) vector .
The Frobenius map is defined by , and the trace map is defined by
[TABLE]
Since for all , the trace is linear over . The trace inner product defines a symmetric bilinear form, so there exists a binary symmetric matrix for which . In fact
[TABLE]
The matrix is non-singular since the trace inner product is non-degenerate (if for all then ). Observe that is a Hankel matrix, since if then . The matrix can be interpreted as the primal-to-dual-basis conversion matrix for , with the primal basis being (see [17]).
The Frobenius map is linear over , so there exists a binary matrix for which . Since
[TABLE]
the rows of are the vectors representing the field elements . Note that square roots exist for all elements of since is invertible.
We write multiplication by as a linear transformation . For , and for the matrix for , where is the matrix that represents multiplication by the primitive element . The matrix is the companion matrix of the primitive irreducible polynomial over the binary field. Thus
[TABLE]
and we have chosen rather than as the companion matrix since we are representing field elements in by row vectors (rather than column vectors).
Lemma 4
The matrices , and , for , satisfy:
- (a)
; 2. (b)
; 3. (c)
; 4. (d)
, and ; 5. (e)
* and .*
Proof:
Identities (a) through (d) follow directly from the arithmetic of . Specifically, for (c), observe that
[TABLE]
and (d) can be proven similarly. To prove part (e) we observe and verify that for all ,
[TABLE]
Definition 5
For and for define the bilinear form . Note that is represented by the binary symmetric matrix
[TABLE]
The Delsarte-Goethals set consists of all such matrices . The Kerdock set consists of all matrices , where .
Lemma 6
The Delsarte-Goethals set is an -dimensional vector space of symmetric matrices. If then . Matrices in the Kerdock set are non-singular.
Proof:
Closure under addition follows from part (b) of Lemma 4. Observe . If is in the nullspace of , i.e., using its vector representation , then for all and we obtain
[TABLE]
This holds for all , so must be identically [math], i.e., is a root of the polynomial. Since the polynomial has at most roots, the nullspace of has dimension at most , which implies that . ∎
Remark 7
Note that since the dimension of the vector space of all binary symmetric matrices is , the set contains all possible symmetric matrices. For the remainder of this paper we represent a general symmetric matrix as simply , thereby dropping the subscripts unless necessary. We will continue to represent Kerdock matrices as .
IV-B Delsarte-Goethals Codes and Weight Distributions
Hammons et al. [25] showed that the classical nonlinear Kerdock and Delsarte-Goethals codes, defined by quadratic forms in [45, 48], are images of linear codes over under the Gray map. In this section, we begin by reviewing this construction using the Kerdock and Delsarte-Goethals sets of matrices, and demonstrate that exponentiating these -valued codewords entry-wise by produces stabilizer states. For stabilizer states of and , we calculate their Hermitian inner products using the trace of certain projection operators, and show that the distribution of inner products depends only on . Then, since for all , we compute the weight distribution of Kerdock codes by relating these Hermitian inner products to the histogram of values in the difference between two -valued codewords. In order to calculate the weight distribution of Delsarte-Goethals codes, we would need to determine the distribution of ranks in the Delsarte-Geothals sets . While this question is straightforward for , it remains open for general and will be investigated in future work.
Definition 8
The -linear Delsarte-Goethals code is given by
[TABLE]
This code has size and is of type [50, Section 12.1]. The Kerdock code .
Here the notation represents a -valued column vector with each entry indexed by the vector .
Definition 9
For the Lee weight of is defined as , where denotes the number of entries of with value , and the Lee distance (between and ) is defined as .
Figure 1 defines the Gray map which assigns integers modulo (or quaternary phases) to binary pairs (see Remark 2 for details). For a vector, the map is applied to each entry and concatenated row-wise to return a row vector, thereby adhering to our convention for binary vectors (see Remark 2). The shortest distance around the circle defines the Lee metric on and Gray encoding is an isometry from (, Lee metric) to (, Hamming metric). However, since , the Gray map is non-linear. Hence the binary Kerdock and Delsarte-Goethals codes obtained by Gray-mapping the codewords in and , respectively, are non-linear (see [50, Chapter 12]).
The Gray map is also a scaled isometry from (length- vectors of quaternary phases, squared Euclidean metric) to (, Hamming metric). Note that for this set of quaternary phases, squared Euclidean distance is indeed a metric. This is formalized in the following lemma.
Lemma 10
Let be two length- vectors of quaternary phases. Then
[TABLE]
*where denotes the Hamming distance. *
Next, we prove a lemma establishing the relation between and the common eigenspace of determined by a binary symmetric matrix (see Remark 7). Note that we denote the maximal commutative subgroup determined by the rows of as , and that we do not normalize eigenvectors (stabilizer states) in this section, since the Gray map needs to be applied to quaternary phases.
Lemma 11
Given a binary symmetric matrix , the (column) vectors are common eigenvectors of the maximal commutative subgroup . Each eigenvector has Euclidean length .
Proof:
It is possible to prove this result by direct calculation, i.e., by calculating for some , but the following argument uses the mathematical framework described in Section III. Note that
[TABLE]
where denotes the standard basis vector in with a in the position and [math] elsewhere.
The columns of the Walsh-Hadamard matrix , where indexes the column, are common eigenvectors of the maximal commutative subgroup . The Clifford operator corresponds to the binary symplectic matrix (see Table I). Hence conjugation by maps to , i.e., , and so the common eigenvectors of are
[TABLE]
It is easily verified that for any ,
[TABLE]
Now we have the following important observation. Given , define
[TABLE]
Lemma 12
- (a)
* is commutative.* 2. (b)
There is a -* correspondence between maximal commutative subgroups of and stabilizer states.*
Proof:
- (a)
If then
[TABLE] 2. (b)
If is a stabilizer state then is a maximal commutative subgroup of . ∎
Remark 13
Any stabilizer state of a maximal commutative subgroup of disjoint from can be obtained by exponentiating Delsarte-Goethals codewords, and multiplying the quaternary phase vector by . The maximal commutative subgroups determined by the Kerdock matrices intersect trivially. Together with , they partition all non-identity Hermitian Pauli matrices. Hence, given a non-identity Hermitian Pauli matrix , it follows that there is a sign such that is in one of the subgroups determined by all and .
Therefore, stabilizer states connect the classical world of Kerdock and Delsarte-Goethals codes and the quantum world of maximal commutative subgroups of . This synergy has proven successful in several applications [27, 31, 32, 51, 35, 33] and our construction of a unitary -design here, from stabilizer states, is yet another instance.
Remark 14
Note that in Lemma 11 we only considered while exponentiating codewords . This is to ensure that the resulting eigenvector corresponds to a eigenvalue (and not a value in ). However, Theorem 1 considers all while calculating the weight distribution.
Given , we scale the common eigenvectors of by to obtain a set of length- vectors of quaternary phases. (Note the similarity to the notation used in Section III, and observe that here we consider all eigenvectors, albeit unnormalized, and not just the eigenspace.) Therefore, if we can compute the Hermitian inner products between these unnormalized stabilizer states then we can use Lemma 10 to calculate the weight distribution of Kerdock and Delsarte-Goethals codes. Note that despite being non-linear codes the weight and distance distributions of these codes coincide, as shown in [24, Chapter 15] (which follows from -linearity and Gray isometry).
Lemma 15
Let be distinct. Fix and let run through . If then
[TABLE]
Proof:
Let represent a basis for the subspace formed by intersecting the spaces generated by and . Then . Let be a basis for , and complete to bases for and by adding vectors and respectively. Since is fixed, using (14), there are fixed such that
[TABLE]
and since the only constraint for is to be from ,
[TABLE]
where are variable. Since it only remains to calculate . If , then
[TABLE]
so that
[TABLE]
Expanding the right hand side, the only term with nonzero trace is the identity with trace . Hence in this case . The eigenvalues can be freely chosen, so there are eigenvectors in this case.
If for some , then
[TABLE]
and . There are such eigenvectors.
Finally, if then . ∎
Corollary 16
For , since the inner products are
[TABLE]
This result is the primary tool that allowed us to simplify the derivation of the weight distribution of Kerdock codes in Theorem 1. Note that Theorem 1 is the only result in this section that is restricted to Kerdock codes but not general Delsarte-Goethals codes (and requires to be odd).
V Mutually Unbiased Bases from
In this section, we will organize the columns of (i.e., the common eigenbasis of ) and all stabilizer states determined by into a matrix to form mutually unbiased bases, and analyze its symmetries. This symmetry group will eventually lead to the construction of the unitary -design. We first state a result that holds for stabilizer states determined by matrices from general Delsarte-Goethals sets.
Definition 17
Given a collection of unit vectors in (Grassmannian lines) the chordal distance is given by
[TABLE]
It follows from Lemma 15 that the Delsarte-Goethals set determines complex lines (stabilizer states) in with chordal distance (cf. [61]).
Definition 18
Two unitary matrices and are said to be mutually unbiased if for all columns of , and all columns of . Each matrix is interpreted as an orthonormal basis and collections of such unitary matrices that are pairwise mutually unbiased are called mutually unbiased bases (MUBs). Vectors in each orthonormal basis look like noise to the other bases (due to the small inner product).
Corollary 16, when applied to normalized eigenvectors, shows that the eigenbases determined by the Kerdock set are mutually unbiased (also see Remark 13). Let denote the collection of these eigenbases (of for all ) along with the eigenbasis of . This is a set of mutually unbiased bases and they determine an ensemble of complex lines (stabilizer states) that is extremal [34]. In this section, we provide an elementary description of their group of Clifford symmetries.
V-A The Kerdock MUBs
Recollect from Section IV-A that the Kerdock matrices are , where is a symmetric Hankel matrix with binary entries that satisfies and represents multiplication by , both in . Using the result of Lemma 11, define mutually unbiased bases
[TABLE]
where , for , is the Walsh-Hadamard matrix of order . Note that and that all columns of have Euclidean length . Complete the MUBs by appending the matrix . The common eigenspaces of the maximal commutative subgroup are the columns of and the common eigenspaces of are the standard unit coordinate vectors. Hence the set of Kerdock MUBs
[TABLE]
is a maximal collection of mutually unbiased bases [34].
V-B Symmetries of Kerdock MUBs
Let be the matrix given by
[TABLE]
Note that and .
Definition 19
A symmetry of is a pair such that , where is an unitary matrix, and is a generalized permutation matrix, i.e., where is a permutation matrix and is a diagonal matrix of quaternary phases.
Observe that for any such symmetry, can undo the action of if and only if induces a (generalized) permutation on the columns of . Moreover, since is unitary it has to preserve inner products, so Corollary 16 implies that can only permute the bases and permute columns within each basis, or equivalently permute the corresponding maximal commutative subgroups and permute elements within each subgroup, respectively, by conjugation.
Lemma 20
For any symmetry of , the unitary matrix is an element of the Clifford group .
Proof:
A Pauli matrix that fixes can be written as , where for all . Since permutes the eigenbases , it follows that , for some , is fixed by which must again be a Pauli matrix. Hence is a Clifford element. ∎
We first observe the symmetries induced by elements of .
V-B1 Pauli Matrices and
The group of Pauli matrices fixes each column of and acts transitively on the columns of each of the other blocks. The group of Pauli matrices fixes each column of and acts transitively on the columns of each of the remaining blocks.
Definition 21
The projective special linear group is the group of all transformations
[TABLE]
acting on the projective line . The transformation is associated with the action of the matrix on -dimensional spaces, since
[TABLE]
The projective linear group is the group of all transformations
[TABLE]
and . The orders are
[TABLE]
Now we analyze the symmetries induced by elements of the binary symplectic group .
V-B2 Clifford Symmetries of
The group is generated by the transformations , and . The group is enlarged by the Frobenius automorphisms discussed in Section IV-A. We realize each of these transformations as a symmetry of . We recall that from part (c) of Lemma 4, and for convenience we work with maximal commutative subgroups , i.e., the Kerdock matrices are . Note that every field element is a square, so this is equivalent to .
- (i)
[TABLE] 2. (ii)
[TABLE] 3. (iii)
[TABLE]
Note that if we start with , i.e., the subgroup , then since is invertible the final subgroup is , interpreted as . 4. (iv)
[TABLE]
Let be the group of symplectic transformations generated by (i), (ii) and (iii) above, and let be the group enlarged by the generators (iv). Thus, using notation in Table I, we have
[TABLE]
Although , in the unitary group we have . Therefore the corresponding Clifford elements will generate a group larger than and . Each symplectic matrix in the above groups can be transformed into a quantum circuit (or simply a unitary matrix) by expressing it as a product of standard symplectic matrices from Table I (see [42, Section II]).
Remark 22
Note that but , which means does not permute columns of but does. Hence, for example, to map to one sequence would be , where satisfies . This does not force .
Lemma 23
Any element of can be described as a product of at most basis symplectic matrices given in Section V-B2.
Proof:
Using the results in this Section, a general block permutation is realized as
[TABLE]
It can be verified that the above is a valid symplectic matrix and satisfies all conditions in (10). We now show that this matrix can be decomposed as a product of basis matrices.
We use the results in Lemma 4 and observe the following:
[TABLE]
[TABLE]
[TABLE]
Hence we set so that and the resultant matrix matches the general symplectic matrix given above. ∎
Corollary 24
Let be such that . The isomorphism can be defined as
[TABLE]
Observe that this provides a systematic procedure to sample from the group . By choosing uniformly at random, a symmetry element can be constructed as
[TABLE]
The first two factors provide transitivity on the Hermitian matrices of all maximal commutative subgroups except , and the last factor enables exchanging any subgroup with (see Lemma 31).
We complete this section by observing that the symmetry group can be enlarged by including the Frobenius automorphisms from Section IV-A.
Lemma 25
An arbitrary element from specified by and takes the form
[TABLE]
with , and realizes the block permutation
[TABLE]
Proof:
See Appendix A. ∎
VI Unitary 2-Designs from the Kerdock MUBs
In this section, we show that the unitary transformations determined by , along with Pauli matrices , form a unitary -design. We first define a graph on Pauli matrices, where Clifford elements act as graph automorphisms. We then show that a group of automorphisms that acts transitively on vertices forms a unitary -design. Finally we show that a group of automorphisms that acts transitively on vertices, on edges, and on non-edges forms a unitary -design.
Definition 26
The Heisenberg-Weyl graph has vertices, labeled by pairs with where vertices labeled and are joined if commutes with . We use to represent the vertex labeled and to represent an edge between two vertices.
Remark 27
Elements of the Clifford group act by conjugation on , inducing automorphisms of the graph . We shall distinguish two types of edges in . Type edges connect vertices from the same maximal commutative subgroup , or from . Type edges connect vertices from different maximal commutative subgroups.
To see that , determine a symplectic matrix to reduce an arbitrary graph automorphism to an automorphism that fixes , then show that fixes every vertex. This essentially amounts to solving for a symplectic matrix satisfying a linear system.
Definition 28** ([62, Def. 2.4])**
*A strongly regular graph with parameters is a graph with vertices, where each vertex has degree , and where the number of vertices joined to a pair of distinct vertices is or according as are joined or not joined respectively. *
Lemma 29
The Heisenberg-Weyl graph is strongly regular with parameters
[TABLE]
Proof:
A vertex joined to a given vertex is a solution to (due to (5)). This is a linear system with a single constraint, and after eliminating the solutions and we are left with distinct vertices joined to .
Given vertices a vertex joined to both and is a solution to a linear system with two independent constraints. When is not joined to , we only need to eliminate the solution . When is joined to we need to eliminate and . ∎
Remark 30
The number of edges in is . The number of type- edges is and the number of type- edges is .
Lemma 31
- (a)
The symplectic group acts transitively on vertices, on edges, and on non-edges of . 2. (b)
The groups and act transitively on vertices of .
Proof:
Part (a) is well-known in symplectic geometry, and can also be proven by direct calculation using symplectic matrices.
(b) Since acts transitively on maximal commutative subgroups (see (34) and (36)), we need only show that is transitive on a particular subgroup, say . If then there exists such that , and it follows from (35) that the symplectic matrix maps to . ∎
Remark 32
The groups and are not transitive on edges of because they cannot mix type- and type- edges.
Definition 33** ([12] [63, Chap. 7])**
Let be a positive integer. An ensemble , where the unitary matrix is selected with probability , is said to be a unitary -design if for all linear operators
[TABLE]
where denotes the Haar measure on the unitary group . The linear transformations determined by each side of (45) are called -fold twirls. A unitary -design is defined by the property that the ensemble twirl coincides with the full unitary twirl.
We define the Kerdock twirl to be the linear transformation of determined by the uniformly weighted ensemble consisting of along with Pauli matrices , where (from Section III). Similarly, we define the -fold action (in (45)) of the ensemble determined by as the enlarged Kerdock twirl.
Definition 34
An ensemble of Clifford elements is Pauli mixing if for every vertex the distribution is uniform over vertices of . The ensemble is Pauli -mixing if it is Pauli mixing and if for every edge (resp. non-edge) the distribution is uniform over edges (resp. non-edges) of .
Theorem 35
Let be a subgroup of the Clifford group containing all , and let be the ensemble defined by the uniform distribution. If acts transitively on vertices of then is a unitary -design, and if acts transitively on vertices, edges and non-edges then is a unitary -design.
Proof:
Transitivity means a single orbit so that random sampling from results in the uniform distribution on vertices, edges, or non-edges. Hence transitivity on vertices implies is Pauli mixing and transitivity on vertices, edges and non-edges implies is Pauli -mixing. It now follows from **[12]** or **[17]** that Pauli mixing (resp. Pauli -mixing) implies is a unitary -design (resp. unitary -design). ∎
Corollary 36
Random sampling from the Clifford group gives a unitary -design and random sampling from the groups followed by a random Pauli matrix gives unitary -designs.
Puchała and Miszczak have developed a useful Mathematica® package IntU [64] for symbolic integration with respect to the Haar measure on unitaries. For small , we used this utility to verify the equality in (45) explicitly for the Kerdock -design.
Sampling uniformly from the groups can be achieved using the systematic procedure shown in (41). The resultant symplectic matrix can be transformed into a quantum circuit (or simply a unitary matrix) by expressing it as a product of standard symplectic matrices from Table I (see [42, Section II]). Although our unitary -design is equivalent to that discovered by Cleve et al. [17], the methods we use to translate design elements to circuits are very different and much simpler. While they use sophisticated methods from finite fields to propose a circuit translation that is tailored for the design, our algorithm from [36] (whose details are discussed in [42, Appendix II]) is a general purpose procedure that can be used to translate arbitrary symplectic matrices to circuits. They have been able to show Clifford-gate-complexity assuming the extended Riemann hypothesis is true, or unconditionally, both of which are near-linear when compared to the gate-complexity for general Clifford elements. Our open-source implementation111Implementations online: https://github.com/nrenga/symplectic-arxiv18a allows one to construct the design for a specified number of qubits, and we use this utility to calculate worst-case gate complexities on up to qubits.
In our sampling procedure (41) we have three elementary forms , and , which translate to phase and controlled- gates, permutations and controlled-NOT gates, and Hadamard gates on all qubits, respectively (see [42, Appendix I]). Note that has the same elementary form as , although is fixed for a given . The Hadamard gates add only complexity. Figures 2, 3, and 4 plot the worst-case complexities of the gates , and obtained using our procedure. The only form that seems to grow faster than is , and we are currently investigating methods to calculate this gate complexity via analytical arguments that leverage results in the classical computation literature. A curious data point is in Fig. 4, where the matrix has zeros everywhere except the anti-diagonal, which translates to a single permutation of the qubits. Since the decomposition in (41) involves a constant number of factors, the overall complexity is that of the factor with largest order term. We will also investigate if our circuits can always be organized to give a depth of just as Cleve et al.
Hence, we have provided an alternative perspective to the quantum unitary -design discovered by Cleve et al. by establishing a connection to classical Kerdock codes, and simplified the description of the design as well as its translation to circuits. Since we also appear to achieve competetive Clifford-gate-complexities, and provide implementations for our methods, we believe this paves the way for employing this -design in several applications, specifically in randomized benchmarking [10, 52].
VII Logical Unitary -Designs
In this section, we apply our synthesis algorithm [42] to logical randomized benchmarking, which was recently proposed by Combes et al. [11] as a more precise protocol to reliably estimate performance metrics for an error correction implementation, as compared to the standard approach of physical randomized benchmarking. Using this procedure, they are able to quantify the effects of imperfect logical gates, crosstalk, and correlated errors, which are typically ignored. They use the full logical Clifford group to perform benchmarking as this group forms a (logical) unitary -design (as well as -design). Our construction can be used to implement their protocol with a much smaller -design () and our synthesis algorithm can be used to realize the design at the logical level.
Here we show by example that we can efficiently translate any unitary -design of Clifford elements into a logical unitary -design, i.e., for a given stabilizer code, produce -qubit physical Clifford circuits that form a unitary -design on the protected qubits. As a proof of concept, we translate the Kerdock design on the logical qubits of the CSS code [53, 65] into their physical -qubit implementations. The stabilizers of this code are
[TABLE]
The logical Pauli operators are
[TABLE]
Consider constructed by adjoining to a root of the primitive polynomial . Consider the element in identified by the tuple , or equivalently in . In this case the matrices defined in Section IV-A are
[TABLE]
Then, using the isomorphism in Corollary 24 and the direct form in Lemma 23, we can express the element in as
[TABLE]
Using the explicit decomposition in (53), we map the elementary symplectic matrices to standard Clifford gates (as discussed in [42]) and get the following circuit (CKT1).222We list circuits instead of giving their circuit representation to align with the MATLAB® cell array format we adopt in our implementations.
[TABLE]
Here the indices corresponding to ‘Permute’ imply the cycle permutation , i.e., the first qubit has been replaced by the fourth, the fourth by the third, the third by the second, and the second by the first. (Note that we do not simplify circuits to their optimal form here but simply report the results of our synthesis algorithm.) An alternative procedure is to directly input the final symplectic matrix (63) to the symplectic decomposition algorithm in [36] (also see [42, Section II]), yielding the following circuit (CKT2).
[TABLE]
The difference in depth of the two circuits is very small in this case, but we found that for about half of the elements in the explicit form in Corollary 24 had smaller depth, while for those remaining, the direct decomposition was better.
Next we translate this logical circuit into its physical implementation for the CSS code. We apply our synthesis algorithm [42], which can be summarized as follows.
Compute the action of either of the above circuits on the Pauli matrices , for , under conjugation, i.e., compute where represents the circuit. 2. 2.
Translate these into logical constraints on the desired physical circuit by interpreting above as their logical equivalents . 3. 3.
Rewrite the above conditions as linear constraints on the desired symplectic matrix using (9). Add constraints to normalize (or just centralize) the stabilizer . 4. 4.
Solve for all symplectic solutions, compute their corresponding circuits and identify the best solution in terms of smallest depth, with respect to the decomposition in [36] (also discussed in [42, Section II]). 5. 5.
Verify the constraints imposed in step 2 and check for any sign violations (due to signs in (9)). In case of violations, identify a Pauli matrix to fix the signs.
Using this algorithm, we computed the circuit with smallest depth (relative to other solutions decomposed using the same algorithm) and obtained the following solution (CKT3).
We used the same procedure to translate all elements of into their (smallest depth) physical implementations for the code, and the synthesis took about minutes on a laptop running the Windows 10 operating system (64-bit) with an Intel® Core™ i7-5500U @ 2.40GHz processor and 8GB RAM. Note that for this case each element of translates to symplectic solutions during the above procedure, and we need to compare depth after calculating circuits for all solutions. In future work, we will try to optimize directly for depth without computing all solutions as this procedure is expensive for codes with large redundancy (). However, since this translation needs to be done only once for a given set and an stabilizer code, the circuits can be precomputed and stored in memory.
VIII Conclusion
In this paper, we provided a simpler calculation of the Hamming weight distribution of the classical binary non-linear Kerdock codes by appealing to the connection with maximal commutative subgroups of the Heisenberg-Weyl group from the quantum domain. Using this connection, we also described the group of Clifford symmetries of the mutually unbiased bases determined by the Kerdock sets of symmetric matrices. We then used this result in the classical domain to construct small unitary -designs. Finally, we demonstrated an efficient procedure for translating any unitary -design consisting of Clifford elements into a logical unitary -design for a given stabilizer code. This work demonstrates yet again that interactions between the classical and quantum domains are still mutually beneficial, both theoretically and practically.
Appendix A Proof of Lemma 25
We proceed as in the proof of Lemma 23 to derive the general form of an element in . Introducing the new generators , and using identities from Lemma 4, we calculate
[TABLE]
In this case the relations between and that will yield the desired map are unclear. Hence, we first determine the transformation on in terms of and . Again, we repeatedly invoke identities from Lemma 4.
[TABLE]
where we have simplified the last term as
[TABLE]
Now we have the following simplifications for the three terms.
[TABLE]
Applying this back we get
[TABLE]
Now we define and . Then we get
[TABLE]
Hence we have proved that performs the permutation
[TABLE]
We note that the above definitions for also satisfy the special case of that corresponds to the proof in Lemma 23. We now substitute these back in and observe the following simplifications.
[TABLE]
These imply that the general form of an element in is
[TABLE]
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] T. Can, N. Rengaswamy, R. Calderbank, and H. D. Pfister, “Kerdock codes determine unitary 2-designs,” in Proc. IEEE Int. Symp. Inform. Theory , pp. 2908–2912, 2019.
- 2[2] S. Bravyi, D. Gosset, and R. König, “Quantum advantage with shallow circuits.,” Science , vol. 362, no. 6412, pp. 308–311, 2018.
- 3[3] E. Conover, “Quantum computers are about to get real,” Science News , vol. 191, no. 13, p. 28, 2017. https://www.sciencenews.org/article/quantum-computers-are-about-get-real.
- 4[4] P. W. Shor, “Scheme for reducing decoherence in quantum computer memory,” Phys. Rev. A , vol. 52, no. 4, pp. R 2493–R 2496, 1995.
- 5[5] A. R. Calderbank and P. W. Shor, “Good quantum error-correcting codes exist,” Phys. Rev. A , vol. 54, pp. 1098–1105, Aug 1996.
- 6[6] A. M. Steane, “Simple quantum error-correcting codes,” Phys. Rev. A , vol. 54, no. 6, pp. 4741–4751, 1996.
- 7[7] R. Calderbank, E. Rains, P. Shor, and N. Sloane, “Quantum error correction via codes over GF(4),” IEEE Trans. Inform. Theory , vol. 44, pp. 1369–1387, Jul 1998.
- 8[8] D. Gottesman, Stabilizer codes and quantum error correction . Ph D thesis, California Institute of Technology, 1997.
