Classical simulations of Abelian-group normalizercircuits with intermediate measurements

Classical simulations of Abelian-group normalizer circuits with intermediate measurements


Quantum normalizer circuits were recently introduced as generalizations of Clifford circuits [VDNest_12_QFTs]: a normalizer circuit over a finite Abelian group is composed of the quantum Fourier transform (QFT) over , together with gates which compute quadratic functions and automorphisms. In [VDNest_12_QFTs] it was shown that every normalizer circuit can be simulated efficiently classically. This result provides a nontrivial example of a family of quantum circuits that cannot yield exponential speed-ups in spite of usage of the QFT, the latter being a central quantum algorithmic primitive. Here we extend the aforementioned result in several ways. Most importantly, we show that normalizer circuits supplemented with intermediate measurements can also be simulated efficiently classically, even when the computation proceeds adaptively. This yields a generalization of the Gottesman-Knill theorem (valid for -qubit Clifford operations [Gottesman_PhD_Thesis, gottesman_knill]) to quantum circuits described by arbitrary finite Abelian groups. Moreover, our simulations are twofold: we present efficient classical algorithms to sample the measurement probability distribution of any adaptive-normalizer computation, as well as to compute the amplitudes of the state vector in every step of it. Finally we develop a generalization of the stabilizer formalism [Gottesman_PhD_Thesis, gottesman_knill] relative to arbitrary finite Abelian groups: for example we characterize how to update stabilizers under generalized Pauli measurements and provide a normal form of the amplitudes of generalized stabilizer states using quadratic functions and subgroup cosets.

1 Introduction

Investigating the power of restricted families of quantum circuits is a fruitful approach to understanding how the power of quantum computers compares to that of classical ones. A celebrated result in this respect is the Gottesman-Knill theorem, which states that any quantum circuit built out of Clifford gates (Hadamards, CNOTs, -phase gates) and Pauli measurements can be efficiently simulated on a classical computer [Gottesman_PhD_Thesis, gottesman_knill, nielsen_chuang]; thus, a quantum computer that works exclusively with these operations cannot achieve exponential quantum speed-ups.

The Gottesman-Knill theorem illustrates how subtle the frontier between classical and quantum computational power can be. For example, even though Clifford circuits can be simulated efficiently classically, replacing the -phase gates by a -phase gate immediately yields a quantum universal gate set [Boykin_etal_99_Clifford_pifourth_is_universal_OPEN, Boykin_etal_00_Clifford_pifourth_is_universal_ELSEVIER]. Another interesting feature is that, even though the computing power of Clifford circuits is not stronger than classical computation, their behavior is genuinely quantum: they can be used, for instance, to prepare highly entangled states (such as cluster states [raussen_briegel_01_Cluster_State, nest06Entanglement_in_Graph_States, raussen_briegel_onewayQC]), or to perform quantum teleportation [gottesman_knill]. Yet, in spite of the high degrees of entanglement that may be involved, the evolution of a physical system under Clifford operations can be tracked efficiently using a Heisenberg picture: the stabilizer formalism, a fundamental tool in quantum error correction [Gottesman_PhD_Thesis, gottesman_knill, nielsen_chuang].

In this work we study the computational power of normalizer circuits. These circuits were introduced in [VDNest_12_QFTs] by one of us, as a class of quantum computations generalizing the Clifford circuits, as well as standard extensions of the latter to qudits [Gottesman98Fault_Tolerant_QC_HigherDimensions, dehaene_demoor_hostens]. A normalizer circuit over a finite Abelian group is a quantum circuit comprising unitary gates that implement the quantum Fourier transform (QFT) over , quadratic functions of the group and automorphisms. If is chosen to be (i.e. the group of -bit strings with addition modulo 2), normalizer circuits precisely coincide with the unitary Clifford circuits (i.e. those composed of CNOT, and phase gates). In [VDNest_12_QFTs] it was shown that arbitrary normalizer circuits (acting on computational basis states and followed by computational basis measurements) can be simulated classically efficiently.

An interesting feature of the normalizer circuit formalism is the presence of QFTs over any finite Abelian group. Of particular interest is the group , since its corresponding QFT is the “standard” quantum Fourier transform [nielsen_chuang]; which lies at the core of several famous quantum algorithms, such as factoring and computing discrete logarithms [Shor]. More generally, QFTs over Abelian groups are central ingredients of quantum algorithms to find hidden subgroups of Abelian groups [lomont_HSP_review, childs_lecture_8, childs_vandam_10_qu_algorithms_algebraic_problems]. In contrast with the role of QFTs in quantum speed-ups, the normalizer circuit formalism provides a nontrivial example of a family of quantum computations that cannot yield exponential speed-ups, in spite of usage of the QFT.

Here we further extend the classical simulation results of [VDNest_12_QFTs]. We do so by considering normalizer circuits where intermediate measurements are allowed at arbitrary times in the computation—whereas in [VDNest_12_QFTs] only terminal measurements were considered. More precisely we define adaptive normalizer circuits over to comprise the following three fundamental ingredients:

  • Normalizer gates over , i.e. QFTs, automorphism gates, quadratic phase gates.

  • Measurements of generalized Pauli operators over at arbitrary times in the computation.

  • Adaptiveness: the choice of normalizer gate at any time may depend (in a polynomial-time computable way) on the outcomes obtained in all previous measurement rounds.

If is chosen to be , the corresponding class of adaptive normalizer circuits precisely corresponds to the class of adaptive Clifford circuits allowed in the original Gottesman-Knill theorem.

This paper contains several results, summarized as follows:

  • A Gottesman-Knill theorem for all finite Abelian groups (Theorem LABEL:thm_main). Given any Abelian group , every poly-size adaptive normalizer circuit over , acting on any standard basis input, can be efficiently simulated by a classical computer. That is, we show that the conditional probability distribution arising at each measurement (given the outcomes of the previous ones) can be sampled in classical polynomial time.

  • A stabilizer formalism for finite Abelian groups. Generalizing the well-known stabilizer formalism for qubits, we develop a stabilizer formalism for arbitrary Abelian groups. This framework is a key ingredient to efficiently track the evolution of quantum states under normalizer circuits. In particular, our results are:

    • We provide an analytic formula, as well as an efficient algorithm, to compute the dimension of any stabilizer code over a finite Abelian group (Theorem 3).

    • We provide an analytic formula, as well as an efficient algorithm, to compute the update of any stabilizer group under Pauli measurements over arbitrary finite Abelian groups (Theorem LABEL:thm_Measurement_Update_rules).

  • A normal form for stabilizer states (Theorem LABEL:thm_Normal_form_of_an_stabilizer_state). We give an analytic formula to characterize the amplitudes of stabilizer states over Abelian groups and show how to compute these amplitudes efficiently. It follows that all stabilizer states over Abelian groups belong to the class of Computationally Tractable (CT) states, introduced in [nest_weak_simulations]. The interest in this property is that all CT states can be simulated classically in various contexts well beyond the setting of the present work—cf. [nest_weak_simulations] for a discussion.

In all the results above the term efficient is used as synonym of “in polynomial time in ” (where denotes the cardinality of the group ). All algorithms presented show good performance regarding computational errors: the sampling algorithm given in theorem LABEL:thm_main is exact (i.e. it samples the output probability of the adaptive normalizer circuit exactly in polynomial time3), whereas the algorithms in theorem LABEL:thm_Normal_form_of_an_stabilizer_state yield exponentially accurate estimates of state amplitudes and normalization constants.

An important technical difference (and difficulty) compared to the original Gottesman-Knill theorem is that in the context of arbitrary finite Abelian groups (such as ) arithmetic is generally over large integers. This is in contrast to where arithmetic is simply over i.e. modulo 2. The difference is in fact twofold:

  First, is a field. As a result, it is possible to describe the “standard” stabilizer formalism for qubits with vector space techniques over . In this context methods like Gaussian elimination have straightforward analogues, which can be exploited in the design of classical algorithms. General Abelian groups are however no longer fields. This complicates both the analytic and algorithmic aspects of our Abelian-group stabilizer formalism due to, for instance, the presence of zero divisors.

  Second, in arithmetic is with small numbers (namely 0s and 1s), whereas in general finite Abelian groups arithmetic is with large integers. For example, this is the case with . Of course, one must beware that some problems in number theory are widely believed to be intractable for classical computers: consider, for instance, the integer factorization problem or computing discrete logarithms. One of the main challenges in our scenario is to show that the “integer arithmetic” used in our classical simulation algorithms can be carried out efficiently. For this purpose, a significant technical portion of our work is dedicated to solving systems of linear equations modulo a finite Abelian group, defined as follows: given a pair of finite Abelian groups and (both of which are given as a direct product of cyclic groups), and a homomorphism between them, we look at systems of the form where and . We present polynomial-time deterministic classical algorithms for counting and finding solutions of these systems. These efficient algorithms lie at the core of our classical simulations of normalizer circuits.

Finally, we mention that the stabilizer formalism has been used in a variety of settings (both for qubits and -level systems) beyond the context of the Gottesman-Knill theorem. This includes e.g. measurement-based quantum computation [raussen_briegel_onewayQC, ZhouZengXuSun03, Schlingemann04ClusterStates], quantum error-correction and fault-tolerance [Gottesman98Fault_Tolerant_QC_HigherDimensions, BravyiKitaev05MagicStateDistillation, CampbellAnwarBrowne12MagicStateDistillation_QUTRITS, CampbellAnwarBrowne12MagicStateDistillation_in_all_prime_dimensions], secret-sharing [Hillery99Quantum_Secret_Sharing, Cleve99Quantum_Secret_Sharing, Gottesman00Quantum_Secret_Sharing], topological systems [kitaev_anyons, BombinDelgado07HomologicalQEC, BullockBrennen07QUDIT_surface_code, DuclosCianci_Poulin13ToricCode_QUDITS] and other applications. The mathematical tools developed in the present work may therefore also have applications outside the realm of classical simulations of quantum circuits.

1.1 Relation to previous work

In [VDNest_12_QFTs] it was proven that one can sample classically in poly-time the output distribution of any non-adaptive normalizer circuit followed by a terminal measurement in the standard basis. Our work extends this result in various ways, as outlined above in I-II-III. Main differences are the fact that here we consider adaptive normalizer circuits, and two different types of simulations: sampling output distributions and computation of amplitudes.

To our knowledge, ref. [VDNest_12_QFTs] and the present work are the first studies to investigate normalizer circuits over arbitrary finite Abelian groups, including those of the form where can be an exponentially large number, such as ; they are also the first to consider normalizer operations that act on high-dimensional physical systems without a natural tensor product decomposition (such as   where is an exponentially big prime number), or clusters of heterogeneous qudits (e.g. when are different, as opposed to ).

Restricting to groups of the form where is constant, our work recovers previous results regarding classical simulations of Clifford circuits for qudits. We emphasize that in this second scenario is a fixed parameter that does not scale; this is in contrast with the cases studied in [VDNest_12_QFTs] and in the present paper. We briefly summarize prior work on qudits.

  • Results when is a constant prime number: if , the ability to sample classically efficiently follows from the Gottesman-Knill theorem [Gottesman_PhD_Thesis, gottesman_knill], whereas the computation of amplitudes from [dehaene_demoor_coefficients]; for prime values of larger than 2, techniques given in [Gottesman98Fault_Tolerant_QC_HigherDimensions] yield efficient sampling simulations also for adaptive Clifford circuits.

  • Results when is an arbitrary constant: techniques given in [dehaene_demoor_hostens] can be used to simulate non-adaptive Clifford circuits followed by a terminal standard basis measurement (sampling output distributions and computation of amplitudes); tools developed in [deBeaudrap12_linearised_stabiliser_formalism] can be used to sample in the adaptive case.

Finally, our work also connects to previous studies on the simulability of Abelian quantum Fourier transforms (QFTs), such as [aharonov_AQFT, yoran_short_QFT, brown_QFT]. The relation between normalizer circuits to the quantum circuits considered in those works was discussed in [VDNest_12_QFTs].

2 Outline of the Paper

This paper is organized as follows.

Section 3 summarizes the key concepts of this work: Pauli and Clifford operators, and normalizer circuits. Sections 4 and 5 contain technical preliminaries. Section 4 gives an introduction to the theory of finite Abelian groups, including a number of efficient classical algorithms to solve algebraic computational problems: the methods presented therein form the basic technical machinery used this work. Section 5 gives a detailed account of the mathematical properties of Pauli, Clifford and (unitary) normalizer operations.

The remaining sections contain the main results of our work. In section 6, a theory of Abelian-group stabilizer codes is developed. Section 7.2 explains how intermediate (generalized) Pauli operator measurements can be implemented, and how they transform Abelian-group stabilizer states. In section LABEL:section_Gottesman-Knill_theorem we show how to simulate adaptive normalizer circuits classically, discuss the power of these operations for state preparation and give normal forms for stabilizer states.

3 Summary of Concepts

In this section we introduce the most prominent quantum-mechanical concepts that feature in this article, namely, the notions of Pauli/Clifford operators and normalizer circuits over finite Abelian groups, as defined in [VDNest_12_QFTs]. Our aim is to illustrate the main ideas behind these group-theoretical quantum circuits by presenting, without details, some key definitions with several examples. The latter will also explain how normalizer circuits generalize the notions and Clifford operators for qubits [nielsen_chuang] and qudits [Knill96non-binaryunitary, Gottesman98Fault_Tolerant_QC_HigherDimensions]. The technical aspects of these quantum operations will be postponed to section 5.

3.1 The Hilbert space associated with a group

Let be the additive group of integers modulo . Then


denotes a finite Abelian group, whose elements are -tuples of the form with . Addition of two group elements is component-wise modulo . Every finite Abelian group can be expressed as a product of the type (1) via isomorphism, yet computing this decomposition is regarded as a difficult computational problem4; throughout this paper, a product decomposition (1) of is always explicitly given. The order (or cardinality) of is denoted by , and fulfills .

Any group as in (1) is naturally associated to a -dimensional Hilbert space with a basis labeled by group elements


This basis is henceforth called the standard basis.

3.2 Pauli operators

We now introduce the following operators acting on :


Here and is a homomorphism5 from into the multiplicative group of nonzero complex numbers , defined as


the functions are known as the character functions of . All operators , are unitary. Indeed, acts as a permutation on the standard basis; second, since is a complex phase, the operator is unitary as well.

With definitions (34), a Pauli operator over (hereafter often simply denoted Pauli operator) is any unitary operator of the form


where is a primitive root of unity, and . The triple describing the Pauli operator is called the label of . It is important to observe that, although is a matrix, its label is an efficient description of itself comprising bits; from now on, we will specify Pauli operators in terms of their labels, and refer to the latter as the standard encoding of these operators.

It was proved in [VDNest_12_QFTs] that the set of all Pauli operators over forms a (finite) group, which we call the Pauli group (over ); this is reviewed in section 5.

3.3 Clifford operators and normalizer circuits

A unitary operator on is called a Clifford operator (over ) if maps the Pauli group onto itself under the conjugation map . It is easy to see that the set of all Clifford operators forms a group, called the Clifford group . Formally speaking, the Clifford group is the normalizer of the Pauli group in the full unitary group acting on .

Next we define three basic classes of unitary operators on which are known to belong to the Clifford group [VDNest_12_QFTs].

  • Quantum Fourier transforms. The quantum Fourier transform (QFT) over is the following unitary operator on :


    where the sum is over all . The QFT over the entire group is given by , which acts on the entire space . Any operator obtained by replacing a subset of operators in this tensor product by identity operators is called a partial QFT.

  • Automorphism gates. Given an automorphism of , the associated automorphism gate maps .

  • Quadratic phase gates. A function from to the nonzero complex numbers is called quadratic if there exists a bilinear6 function such that for every it holds that


    Given a quadratic function on , the quadratic phase gate is the diagonal operator mapping . For every quadratic function the complex number fulfills and is therefore a complex phase [VDNest_12_QFTs]; as a result, every quadratic phase gate is a (diagonal) unitary operator.

    The mathematical properties of quadratic functions are reviewed in section 4.2.

A unitary operator which is either a (partial) quantum Fourier transform or its inverse, an automorphism gate or a quadratic phase gate is generally referred to as a normalizer gate. A quantum circuit composed entirely of normalizer gates is called a normalizer circuit over . The size of a normalizer circuit is the number of normalizer gates of which it consists. A full description of every normalizer gate that is part of a normalizer circuit (type, action, number of qubits on which it acts, etc) can be stored efficiently (with polylog bits of memory) in a computer, using—what we call—the standard encodings of these gates (to be properly defined in section 5.2); it follows that every polylog normalizer circuit can be described efficiently as a list of normalizer gates.

3.4 The relationship between normalizer and Clifford operations

It was proven in [VDNest_12_QFTs] that every normalizer gate (and circuit) is a Clifford operator, but it is not known whether all possible Clifford operators can be implemented via normalizer gates. Such a question is of considerable relevance, since the finding of a non-normalizer Clifford operation could lead to a new quantum gate. However, the authors believe that such an operation does not exist; we conjecture that any Clifford operator can be implemented as a poly-size normalizer circuit (conjecture 1). We refer to section 5.2.2 for a discussion and some supporting evidence.

3.5 Examples

Here we give examples of Pauli and normalizer operations for several groups. We illustrate in particular how the definitions of the preceding section generalize existing notions of Pauli and Clifford operators for qubits and qudits.

In this case the standard definition of -qubit Pauli operators is recovered. To see this, first note that we have i.e. the Hilbert space is a system of qubits. Let and denote the standard Pauli matrices and let be an -bit string. Then, applying definition (3) one finds that


Here is an -bit string: i.e. . In short, is a tensor product of -matrices and identities, and is a tensor product of -matrices and identities. Therefore, every Pauli operator (3) has the form where each is a single-qubit operator of the form for some . This recovers the usual notion of a Pauli operator on qubits [nielsen_chuang].

It was shown in [VDNest_12_QFTs] that the CNOT gate and the CZ gate (acting between any two qubits), the Hadamard gate and the Phase gate diag (acting on any single qubit) are examples of normalizer gates for . Note that these gates are the standard building blocks of the well known class of Clifford circuits for qubits. In fact, the entire Clifford group for qubits is generated by this elementary gate set [nielsen_chuang].

In this case the Hilbert space is a system of -level systems (qudits) and Pauli operators have the form , where each is a single-qudit operator of the form for some . Here and are the usual generalizations of and , respectively [Knill96non-binaryunitary, Gottesman98Fault_Tolerant_QC_HigherDimensions]. These operators act on a single -level system as follows:


where the sums run over all . Examples of normalizer gates over are generalizations of the CNOT, CZ, Hadamard and Phase gates to qudits, as follows:


Here and rum over all elements in . To show that SUM is a normalizer gate, note that is indeed an automorphism of . The gates and are quadratic phase gates; see Ref.[VDNest_12_QFTs]. In addition, the “multiplication gate” is also a normalizer gate, for every which is coprime to . Indeed, for such the map is known to be an automorphism of . It is known that the entire Clifford group for qubits (for arbitrary ) is generated by the gates SUM, , and [dehaene_demoor_hostens].

One can also consider to be a single cyclic group, such as . In this case, is a -dimensional Hilbert space with standard basis . Comparing with the previous examples, the important difference with e.g.  is that the structure of does not naturally induce a factorization of the Hilbert space into single-qubit systems. As a consequence, normalizer gates over act globally on , in contrast with the previous examples.

Examples of normalizer gates are now given by , and , following the definitions of the previous example with . Note that is the “standard” QFT used in e.g Shor’s algorithm and the phase estimation quantum algorithm.

4 Preliminaries on Finite Abelian Groups

This section is reserved for the main group-theoretical notions used in this work, and their computational aspects. The concepts and algorithms introduced in this section will be essential to construct a theory of stabilizer codes for physical systems of the form (cf. eq. (2)), where can be any finite Abelian group (1).

4.1 Conventions

Throughout this section we fix the canonical decomposition to be , as in (1); this choice is completely arbitrary. In computational complexity theory a (classical or quantum) algorithm is said to be efficient if it solves a given computational problem of input-size in (classical or quantum) polyn) time: when one looks at problems related to finite Abelian groups, this will be synonym of “in polylog time”, being the groups involved in a problem of interest (we look at concrete problems in section 4.5).

Last, we introduce a set of canonical generators of . For every ranging from 1 to , denotes the group element which has in its -th component and zeroes elsewhere, where in slot represents the neutral element in . The elements generate , for any element can be naturally written as , and play a similar role as the canonical basis vectors of vector spaces like or (though is not a vector space).

4.2 Character and quadratic functions

The character functions of (eq. 4), form a finite Abelian group with the multiplication , called the character group or dual group ; the latter is isomorphic to via . Moreover, for every the following equalities hold:


Relationships (14) are useful to manipulate characters symbolically.

All character functions are quadratic functions: indeed, it is trivial to check that function fulfills


for every , , , so it is bilinear; can then be used to write every character in the form (7). Furthermore, the set of all quadratic functions of forms a finite Abelian group with the multiplication , which contains the character group as a subgroup [VDNest_12_QFTs]: finiteness follows from ; eqs. (7,15) can be used to check closure, associativity, commutativity and that the inverse of any quadratic function (its complex conjugate ) is again quadratic.

We finish this section with some examples of quadratic functions over finite Abelian groups (more examples can be found in ref.[VDNest_12_QFTs]).

Example 1: We consider . Letting be an matrix with entries in and letting , the following functions are quadratic:


where and is computed over (i.e. modulo 2). Note that the exponent in is polynomial of degree 2 in , whereas the exponent in has degree 1. To prove that these functions are quadratic in the sense used in this work, we note that


Identity (18) can be proved by distinguishing between the 4 cases . The above identities can be used to show that and are quadratic.

Example 2: Considering a single cyclic group , examples of quadratic functions are


We refer to [VDNest_12_QFTs] for a proof.

4.3 Orthogonal subgroups

The character functions give rise to a set-theoretical duality, sometimes called orthogonality of Abelian subgroups (although it differs from the usual orthogonality of vector spaces). Given a subgroup of the finite Abelian group , its orthogonal subgroup is defined as


Note that is indeed a subgroup of . The main properties of are summarized below.

Lemma 1 (Orthogonal subgroup).

Consider a finite Abelian group as in (1) and let and be two arbitrary subgroups. Then the following statements hold:

  • if and only if


(a-b) are well-known, see e.g. [lomont_HSP_review]. (c) is proved straightforwardly by applying definitions. We prove (d). Since is contained in both and if follows that and . Therefore . We show , which implies the reversed inclusion. This comes from the fact that implies and , or equivalently, and . ∎

4.4 Homo-, iso- and auto- morphisms

Given two finite Abelian groups and , a group homomorphism from to is a map that fulfills for every . (In other words, is linear.) An isomorphism from to is an invertible group homomorphism. An automorphism of is an isomorphism of the form , i.e. from a group onto itself. The set of all automorphisms of forms a group, called the automorphism group.

Throughout this work, group homomorphisms between Abelian groups are to be described in terms of matrix representations, which are defined as follows:

Definition 1 (Matrix representation).

Given a homomorphism between groups and , an integer matrix is said to be a matrix representation of if its columns are elements of , and if it holds that


Conversely, an integer matrix is said to define a group homomorphism from to if its columns are elements of and the operation is a group homomorphism.

In (21) we introduced some conventions, that we will use: first, the element is seen as a column of integer numbers onto which acts via matrix multiplication; second, (mod ) indicates that multiplications and sums involved in the calculation of are performed within , taking remainders when necessary.

The main properties of matrix representations are now summarized.

Lemma 2.

Every group homomorphism has a matrix representation. Moreover, an matrix with columns defines a homomorphism iff its columns fulfill the equations


First, given , we show that , where , is a matrix representation. Since every decomposes as , it follows, using linearity of , that


The right implication of the iff comes readily from


For the converse, we let act on , and without taking remainders; we obtain


Recalling associativity of and , the latter expression shows that defines a function from to , and, thus, is a function from to . Last, it holds for every that for some integers , since (by definition of the group ) is the remainder obtained when is divided by ( is the quotient). It follows, subtracting modularly, that for every , ; and, due to, defines a linear map. ∎

4.5 Computational group theory

Computational aspects of finite Abelian groups are now discussed; our discourse focuses on a selected catalog of computational problems relevant to this work and efficient classical algorithms to solve them. Since this section concerns only classical computational complexity, we will tend to omit the epithet classical all the way throughout it.

To start with, we introduce some basic notions of computer arithmetic. From now on, the size of an integer is the number of bits in its binary expansion. Observe that every group (1) satisfies the inequalities and , for every . It follows readily that is , and that one needs at most a polylog amount of memory to store an element (in terms of bits).

We discuss now how to perform some basic operations efficiently within any finite Abelian group (1). First, given two integers and of size at most , common arithmetic operations can be computed in poly time with elementary algorithms: such as their sum, product, the quotient of divided by , and the remainder [brent_zimmerman10CompArithmetic]. Therefore, given , the sum can be obtained in polylog time by computing the remainders . Similarly, given an integer , the element can be obtained in polylog time by computing the remainders mod .

In connection with section 4.4, it follows from the properties just introduced that matrix representations can be stored using only a polynomial amount of memory, and, moreover, that given the matrix representation we can efficiently compute . Specifically, given a matrix representation of the homomorphism , we need polylog space to store its columns as tuples of integers, and polylog time to compute the function .

Periodically, and at crucial stages of this investigation, some advanced algebraic computational problems are bound to arise. The following lemma compiles a list of group theoretical problems that will be relevant to us and can be solved efficiently by classical computers.

Lemma 3 (Algorithms for finite Abelian groups).

Given , , two subgroups of , and , , polynomial-size generating-sets of them, there exist efficient classical algorithms to solve the following problems deterministically.

  • Decide whether belongs to ; if so, find integers such that .

  • Count the number of elements of .

  • Find a generating-set of the intersection .

  • Find a generating-set of .

  • Given the system of equations , find elements such that all solutions can be written as linear combinations of the form .

The proof of the lemma is divided in two parts which are fully detailed in appendices LABEL:Appendix:_Algorithms_for_Finite_Abelian_Groups and LABEL:Appendix:_System_of_linear_congruences_modulo_Abelian_group. The rest of this section describes the high-level structure of the proof.

In short, appendix LABEL:Appendix:_Algorithms_for_Finite_Abelian_Groups contains a proof of the following statement.

Lemma 4.

Problems (a-e) in lemma 3 are polynomial-time reducible to either counting or finding solutions of systems of equations of the form ; where is a group homomorphism between two (canonically-decomposed) finite Abelian groups, and , to which , respectively belong; given that a matrix representation of is provided.

Mind that, since is a linear map, the set of solutions of such a system is either empty or a coset with the structure


By finding solutions we refer to the action of finding one particular solution of the system and a (polynomially-large) generating set of .

To provide an example, we prove now lemma 4 for the problems (d-e) in lemma 3; for the rest of cases, we refer to the appendices.

Example: [proof of the (d,e)th cases of lemma 3] First of all, notice that problem (d) reduces to (e) by setting all to be —this yields the system (20), whose solutions are the elements of the orthogonal subgroup. Therefore, it will be enough to prove the (e)th case. Moreover, since the equations can be fulfilled for some only if all are th-roots of the unit, this systems can only have solutions if all are even numbers. As we can determine it efficiently whether these numbers are even, we assume from now on that it is the case.

Now define a tuple of integers coefficient-wise as ; use the later to re-write . Also, denote by the group generated by the elements . By letting multiply numerators and denominators of all fractions in (4), the system of complex exponentials can be turned into an equivalent system of congruences . Finally, by defining a matrix with coefficients the system can be written as


where belongs to , being the number of generators , and we look for solutions inside . Moreover, the coefficients of fulfill ; hence, condition (22) is met and defines a homomorphism.

Finally, can be computed in using aforementioned algorithms to multiply and divide integers. It is now routine to check, using the concepts developed thus far, that both and are ; as a result, the input-size of the new problem, as well as the memory needed to store and , are all . ∎

Remark: Note that the group homomorphism fulfills . Therefore, if we substitute with in the procedure above, given generators of , we would obtain an integer matrix that defines a second group homomorphism such that


As a result, our algorithm to compute generators of leads also to an efficient method to construct, given any subgroup of , a homomorphism whose kernel is . This fact will be used later in the text, in section LABEL:section_Gottesman-Knill_theorem. ∎

The final ingredient to complete the proof of lemma 3 is the following theorem.

Theorem 1 (Systems of linear equations over finite Abelian groups).

Given any element of the group and any matrix which defines a group homomorphism from to , consider the system of equations . Then, there exist classical algorithms to solve the following list of problems in polylog time.

  1. Decide whether the system admits a solution.

  2. Count the number of different solutions of the system.

  3. Find such that all solutions of the system are linear combinations of the form .

The main ideas underlying the proof of theorem 1 are as follows: first, we show how to reduce in polynomial-time to an equivalent system of linear congruences modulo , where is suitably upper-bounded; second, we apply fast algorithms to compute Smith normal forms to tackle the latter problem [storjohann10_phd_thesis]. For details, we refer to appendix LABEL:Appendix:_System_of_linear_congruences_modulo_Abelian_group.

5 Pauli Operators and Normalizer Circuits over Abelian Groups

5.1 Manipulation of Pauli operators

First, note that every Pauli operator factorizes as a tensor product relative to the tensor decomposition of i.e.  can be written as where acts on . This property simplifies several proofs; it can be verified straightforwardly by applying (3) and the definition (4) of the characters of .

Basic manipulations of Pauli operators can be carried out transparently by translating them into transformations of their labels: we review now some of these rules. First, the Pauli matrices (3) obey the following commutation rules:


Combinations of these rules straightforwardly lead to the next two lemmas.

Lemma 5 (Products and powers of Pauli operators [VDNest_12_QFTs]).

Consider Pauli operators and and a positive integer . Then , and are also Pauli operators, the labels of which can be computed in polylog time on input of and the labels of and . Moreover, .

Lemma 6 (Commutativity).

Consider two Pauli operators and . Then the following statements are equivalent:

  • and commute;

  • ;

  • and are orthogonal elements of i.e. .

Lemma 5 implies that the set of all Pauli operators over forms a (finite) group, called the Pauli group (over ).

5.2 Normalizer quantum circuits

Hitherto we have not considered technical aspects of normalizer circuits, such as how to describe normalizer circuits efficiently, or how to compute their action on Pauli operators; we address these questions in this section.

Describing normalizer operations

In this paper we will be interested in classical simulations of normalizer circuits. To make meaningful statements about classical simulations one must first specify which classical descriptions of normalizer circuits are considered to be available. In the case of Pauli operators over (which are particular examples of normalizer operations [VDNest_12_QFTs]), we saw that it is possible to describe them using few (polylog) memory resources, by choosing their labels as standard encodings; this property holds for all normalizer gates and—hence—circuits [VDNest_12_QFTs]: all of them admit efficient classical descriptions. This is discussed next.

  • First, a partial quantum Fourier transform is described by the set of systems on which it acts nontrivially.

  • Second, an automorphism gate is described by the matrix representation of the associated automorphism (cf. section 4.4).

  • Third, let be an arbitrary quadratic function. Since , there exists such that for every . It was shown in [VDNest_12_QFTs] that the integers and comprise an efficient description of and, thus, of the associated quadratic phase gate.

Henceforth we will assume that all normalizer gates are specified in terms of the descriptions given above, which will be called their standard encodings. The standard encoding of each type of gate comprises polylog bits. The standard encoding of a normalizer circuits is the sequence of classical descriptions of its gates.

Normalizer equals Clifford?

The following theorem states that every normalizer gate belongs to the Clifford group, and the action of any normalizer gate on a Pauli operator via conjugation can be described efficiently classically.

Theorem 2 (Normalizer gates are Clifford [VDNest_12_QFTs]).

Every normalizer gate is a Clifford operator. Furthermore let be a normalizer gate specified in terms of its standard classical encoding as above, and let be a Pauli operator specified in terms of its label; then the label of can be computed in polylog time.

It is unknown whether the entire Clifford group can be generated (up to global phase factors) by normalizer gates in full generality. However, it was proven in [dehaene_demoor_hostens] (see also the examples in section 3.5) that this is indeed the case for groups of the form (i.e.  qudit systems); more strongly, every Clifford group element (over ) can be written as a product of at most polylog such operators. We conjecture that this feature holds true for Clifford operators over arbitrary finite Abelian groups.

Conjecture 1.

Let be an arbitrary (canonically decomposed) finite Abelian group. Then, up to a global phase, every Clifford operator over can be written as a product of polylog normalizer gates.

Finally, in the following lemma we provide some partial support for this conjecture. We show that both automorphism gates and quadratic phase gates have a distinguished role within the Clifford group, characterized as follows:

Lemma 7.

Up to a global phase, every Clifford operator which acts on the standard basis as a permutation has the form for some and some automorphism gate . Every diagonal Clifford operator is, up to a global phase, a quadratic phase gate.


The first statement was proved in [VDNest_12_QFTs]. We prove the second statement. Let be a diagonal unitary operator (so that for all ) in the Clifford group. Without loss of generality we may set , which can always be ensured by choosing a suitable (irrelevant) overall phase. Then for every , sends to a Pauli operator under conjugation. This implies that there exists a complex phase and group elements such that


Since is diagonal, it is easy to verify that we must have for every . Now consider an arbitrary . Then


Condition (30) implies that (31) is identical to (32) for every . Choosing and using that and for every it follows that . We thus find that


The function is manifestly linear in , since . Furthermore by definition is symmetric in and . Thus is also linear in . ∎

6 An Abelian-Group Stabilizer Formalism

In this section we develop further the stabilizer formalism for finite Abelian groups as started in [VDNest_12_QFTs]. We provide new analytic and algorithmic tools to describe them and analyze their properties. Throughout this section we consider an arbitrary Abelian group of the form .

6.1 Stabilizer states and codes

Let be a subgroup of the Pauli group . Then is said to be a stabilizer group (over ) if there exists a non-zero vector which is invariant under all elements in i.e.  for every . The linear subspace is called the stabilizer code associated with . If is one-dimensional, its unique element (up to a multiplicative constant) is called the stabilizer state associated with . In this work we will mainly be interested in stabilizer states. Occasionally, however, it will be useful to consider the general setting of stabilizer codes (cf. e.g. theorem 3).

Note that every stabilizer group is Abelian. To see this, consider a state which is invariant under the action of all elements in and consider two arbitrary . Then (29) implies that there exists a complex phase such that . It follows that , where we have used that . We thus find that so that (i.e.  and commute).

Conversely, not every Abelian subgroup of the Pauli group is a stabilizer group. A simple counterexample is the group where is the identity operator acting on .

The support of a stabilizer code is the set of all for which has a nonzero overlap with i.e. there exists such that . The support of a stabilizer state is simply the set of all for which .

6.2 Label groups

Let be a stabilizer group over . The diagonal subgroup is the subgroup of formed by its diagonal operators i.e. it consists of all operators in of the form . Second, we introduce two subgroups and of called the label groups of :


Using (29) it is straightforward to verify that is indeed a subgroup of . To prove that is a subgroup as well, one argues as follows. Let be a Pauli operator with label . We call the “-component” and the “-component” of . Denote the -component formally by . Then is the image of under the map . The commutation relations (29) yield


This implies that is a homomorphism from to . It follows that is a subgroup of .

Lemma 8 (Label groups).

Let be a stabilizer group and assume that the labels of polylog generators of are given as an input. Then the label groups of have the following properties:

  1. ;

  2. Generating sets of , can be efficiently computed classically;

  3. The labels of a generating set of can be efficiently computed classically.


Property (i) is a straightforward consequence of the commutation relations given in lemma 6 and the definition of orthogonal subgroup (20). To show property (ii), recall that the map defined above is a homomorphism from to with Im. Suppose that is generated by . Then is generated by : this yields an efficient method to compute generators of . To prove the second statement of (ii) as well as (iii) requires more work. The argument is a direct generalization of the proof of lemma 9 in [VDNest_12_QFTs] and the reader is referred to this work. ∎

6.3 Certificates

The main purpose of this section is to provide a criterion to verify when a stabilizer group gives rise to a one-dimensional stabilizer code i.e. a stabilizer state. This is accomplished in corollary 1. To arrive at this statement we first analyze how the the dimension of a general stabilizer code is related the structure of its stabilizer group.

Theorem 3 (Structure Test).

Let be a stabilizer group with stabilizer code . Then there exists such that


where , are the label subgroups of . Furthermore, there exist efficient classical algorithms to compute a representative of the support, a generating set of and the dimension .

Before proving theorem 3, we note that combining property (ii) together with lemma 8(i) immediately yield:

Corollary 1 (Uniqueness Test).

Let be a stabilizer group with stabilizer code . Then is one-dimensional if and only if and are dual orthogonal subgroups: .

Theorem 3(ii) also leads to an alternative formula for the dimension of a stabilizer code:

Corollary 2.

The dimension of equals .

The result in corollary 2 is well known for stabilizer codes over qubits [Gottesman_PhD_Thesis, nielsen_chuang] (i.e. where so that ) and qudits (where ) [Gottesman_PhD_Thesis, gheorghiu11Qudit_Stabilisers].


[of corollary 2] Consider the map , defined in section 6.2, which is a group homomorphism with image . Furthermore the kernel of is precisely the diagonal subgroup of . Since it follows that . Finally we claim that and are isomorphic groups so that . To prove this, consider the map that sends to . Using (29) it follows that this map is a homomorphism; furthermore, it is a surjective one by definition of , and thus . The kernel of is the set of all having the form . But the only operator in proportional to the identity is the identity itself, since otherwise cannot have a common eigenstate. This shows that the kernel of is trivial, so that and are isomorphic, as claimed. The resulting identity together with (recall lemma 1) and theorem 3(ii) proves the result. ∎

We now prove theorem 3 using techniques developed in [nest_MMS] where the properties of so-called M-spaces were studied. We briefly recall basic concepts and results.

A unitary operator acting on is said to be monomial if it can be written as a product where is diagonal and is a permutation matrix. A subspace of is called an M-space if there exists a group of monomial unitary operators such that iff for every . The group is called a stabilizer group of . If is one-dimensional, its unique (up to a multiplicative factor) element is called an M-state. The support of is defined analogously to the support of a stabilizer code i.e. it is the set of all such that has a nontrivial overlap with . With this terminology, every stabilizer code is an instance of an M-space and every stabilizer state is an M-state. To see this, note that every Pauli operator is a monomial unitary operator. Indeed, can be written as a product where is diagonal and is a permutation matrix.

We introduce some further terminology. Let be an arbitrary monomial stabilizer group. For every , let be the subset of consisting of all satisfying i.e.  acts trivially on , up to an overall phase. This subset is easily seen to be a subgroup of . Also, we define the orbit of as: