New construction of quantum error-avoiding codes via group representation of quantum stabilizer codes

In quantum computing, nice error bases as generalization of the Pauli basis were introduced by Knill. These bases are known to be projective representations of finite groups. In this paper, we propose a group representation approach to the study of quantum stabilizer codes. We utilize this approach to define decoherence-free subspaces (DFSs). Unlike previous studies of DFSs, this type of DFSs does not involve any spatial symmetry assumptions on the system-environment interaction. Thus, it can be used to construct quantum error-avoiding codes (QEACs) that are fault tolerant automatically. We also propose a new simple construction of QEACs and subsequently develop several classes of QEACs. Finally, we present numerical simulation results encoding the logical error rate over physical error rate on the fidelity performance of these QEACs. Our study demonstrates that DFSs-based QEACs are capable of providing a generalized and unified framework for error-avoiding methods.


Introduction
In quantum computation/communication systems, it is critical to maintain the coherence of a quantum system [1]. In practice, however, decoherence coming from the unwanted interaction between the system and the environment will collapse the state of the quantum communication/computation, thus making the information harder to correct [2]. Decoherence has been recognized as a major and un-ignorable proba e-mail: xhl_xiaohailin@163.com b e-mail: zhangzs@ustb.edu.cn c e-mail: antony.tc@gmail.com lem in practical applications [3]. Quantum error-correcting codes (QECCs) have become the most efficient way to combat decoherence [4]. However, QECCs are rather costly in quantum computing resources [5]. To protect a single quantum bit (qubit) of information from suffering general singlequbit errors, at least five qubits are needed [6]. An alternate quantum code exists, called "quantum error-preventing or error-avoiding code (QEAC)", which is capable of combating decoherence and has exhibited the advantage of being easyto-use [7][8][9]. It must be noted that quantum error-avoiding codes (QEACs) are mainly designed based on collective decoherence [10]. Furthermore, collective decoherence is possible for adjacent qubits due to the qubits coupling to the same environment. For collective decoherence, on the other hand, there exist coherence-preserving states. Therefore, in QEACs, arbitrary input states can be encoded into superpositions of the coherence-preserving states.
From quantum coding theory, it is well known that a code is capable of correcting the linear span of these error operators if it can correct a set of error operators. Therefore, it is sufficient to confine our attention to errors that form a unitary basis of vector space of linear operators. A special type of basis of unitary operators called a "nice error basis" has been investigated [11]. In this basis, the number of known index groups for nice error bases are extended by exploiting the connections between groups of central type and their Sylow subgroups. In general, nice error bases are parameterized by a group. Furthermore, the conjecture that every nice error basis is equivalent to a shift-and-multiply basis has been proved to be false [12]. In this paper, we will show that nice error bases have more structures. We also prove that nice error bases are faithful irreducible projective representations that are induced from finite groups. Thus, the knowledge of these groups is sufficient to construct the corresponding error bases. Without loss of generality, we may assume that the associated abstract error group is finite if we consider nice error bases up to equivalence [4].
The group structure associated with nice error bases is helpful in constructing QECCs. Currently, the stabilizer formalism is regarded as the most striking development in QECCs, whereby codewords are specified by Abelian subgroups and the stabilizers [13][14][15][16]. A stabilizer code is usually given by a selforthogonal(with respect to the trace inner product) additive code over G F (4). It can also be given by a self-orthogonal (with respect to the symplectic inner product) linear code over G F (2), where information is encoded in linear subspaces of the entire Hilbert space. In this manner, "errors" induced by the interaction with the environment can be detected and corrected. The essential point resides in the fact that detected errors belonging to the class of errors correctable by the given code, must be found without gaining any information as regards the actual state of the computing system prior to corruption. Otherwise, this would lead to a further decoherence [17].
Nice error bases are also of interest in the theories of noiseless subsystems (NS) and decoherence-free subspaces (DFSs) [18][19][20]. For instance, NS and DFSs are two standard coding methods used to implement collective decoherence. The idea is described as follows: in the presence of such a "coherence" environmental noise, one can design states that are hard to corrupt rather than states that can easily be corrected. In other words, the present approach consists of an intrinsic stabilization of quantum information and it is complementary to error correcting. We are interested in simple implementation of DFSs for the quantum channels with a common error on each qubit. From the above-mentioned discussion, an error group is a finite group of unitary operators generated by nice error bases, and a stabilizer construction can also be derived from nice error bases. We next propose a group representation approach to the construction of quantum stabilizer codes. Meanwhile, the group representation of quantum stabilizer codes is kept unchanged so as to preserve coherence states. All the coherence-preserving states constitute DFSs, which can be used to construct QEACs that are fault tolerant automatically.
The remainder of the paper is organized as follows. Section 2 describes the group representation of quantum stabilizer codes. Section 3 defines DFSs. In Sect. 4, a new simple construction of QEACs is proposed, followed by developing several classes of QEACs from this construction. Finally, Sect. 5 concludes this paper. Notation Lowercase bold letters are used to denote operators or vectors and uppercase bold letters denote matrices. Superscript †, T , and * denote Hermitian transpose, transpose, and conjugate, respectively.w complex conjugate of w. Furthermore, we use Tr(·), |· , ·|, ·|· to denote the matrix trace, the bra, the ket, and the Dirac inner product, respectively. We use I to denote an identity matrix, use U to denote an unitary operator. Finally symbol "≡" stands for "defined as".

Group representation of quantum stabilizer codes
In this section, we firstly parameterize the nice error bases, which make it easy to connect the quantum mechanics. In quantum error-correcting codes, the coding structure to store quantum information is a subspace of the total Hilbert space of the physical qubits, thereafter referred to as the code space C. After that, we will construct quantum stabilizer codes from a finite error group E. The main properties of such a stabilizer code are determined by applying results from error group of nice error bases. Finally, we obtain the group representation of quantum stabilizer codes.

Error group of nice error bases
A nice error basis in a n-dimensional Hilbert space H is defined as a set ε ≡ {E g } g∈G , where E g is unitary on H , G denotes a group of order n 2 with identity element 1, Tr(E g ) = nδ g,1 and E g E h = w gh E g+h , where w gh is a nonzero complex number depending on (g, h) ∈ G ×G. Furthermore, the function w: G × G → G × is called the factor system of E. We call G the index group of the error basis ε [21]. In addition, error bases with Abelian index groups are called nice error bases that generate a finite group of unitary operators U, which comprise scalar multiples of the identity [4]. Meanwhile, an error group is a finite group of unitary operators generated by both a nice unitary error basis and multiples of the identity. Theorem 1 If a nice error basis ε has an Abelian index group G [22], then for any nonzero h ∈ G we have g∈G w ghwhg = 0. (1) Proof As the property of error bases, ∀g, h ∈ G, E g E h = ω gh E g+h , we have the following equalities: Combining (2) with (3), we obtain If G h is defined as G h ≡ w ghwhg , from (4) we can observe that G h is a subgroup of cyclic group, because w gh generates a cyclic group [4]. We can define an operation • on the set It turns out that L is a finite group with respect to this multiplication, which is called the w-covering group of G. Without loss of generality, we assume that the factor system w is of finite order, which ensures that the abstract error group is finite. For instance, if we take the n-fold tensor product of matrices [23] where m 0 ∈ (0, 1, 2, 3) and σ i ∈ {I, X, Y , Z}∀i, from (6), we may obtain a nice error basis for a system of n qubits. The abstract error group L generated by these matrices is isomorphic to a so-called extraspecial 2-group. Proof We denote L the commutator subgroup by using Recall that a quotient group L/S of L is Abelian if and only if the stabilizer subgroup S of L contains the commutator subgroup L , for a subgroup S < L, let us define stabilizer code as where C(S) is non-trivial and has dimension 2 k if only if −I / ∈ S is satisfied and at the same time S is generated by a set of n − k independent generators M.
We use a z-polynomial to describe the tensor product of error operators E g , i.e. E g = E g 1 ⊗ E g 2 ⊗· · ·⊗ E g n . In order to simplify the description, z g 1 1 z g 2 2 · · · z g n n is denoted by z g . All z g 's are constituted product group Z , where Z ⊂ E. For any g ∈ S, h ∈ L, we can obtain a mapping χ h on complex number field as By substituting (2) and (3) into (9), we obtain In code space C, we redefine (8) as where c g is the weight of code satisfying c g = χ h (z g ), and f C (g) is polynomial of code. The detailed construction method will be addressed later.

Group representation of quantum stabilizer codes
When an error operator varies the original state of a qubit, the corrupted state may fall either inside or outside the code space. The former case occurs in the classic coding literature as undetectable errors, a type of errors which exceed the errorcorrection capability of any code. This should occur very rarely in well-designed codes. However, this can be achieved by measuring the eigenvalue array, as known as the syndrome of a given state. Furthermore, a syndrome identifies the error operator that can counteract the specific error, which can be further used to the corrupted state in order to recover the original state. Motivated by this, we start with the basic notions of classical and quantum coding theory. We may denote the Galois field of q m elements by F q m , where q is a prime number and m is an integer [24]. Let a 1 , a 2 , . . . a n denote the elements of a basis of F q m over F q , where a i ∈ F q . By fixing a nonzero F q -linear function Tr : F q m → F q (called a trace function), Tr(·) thus satisfies Tr(a i a) = a i Tr(a), for ∀a, b ∈ F q m . Note that, for x ∈ F q m , another trace function can be defined by Tr x (a) = Tr(xa). For any a, b from C and any g, h ∈ F q m , ag + bh is also obtained from C (If C is q m -linear, we just call it linear). We may simply say that C is an [n, k] q m code, and then use R C = R = 1 n log q m |C|, d(C) = d, and δ(C) = δ = d/n to denote its transmission rate, minimum distance, and relative minimum distance, respectively. Hence, the weight distribution of a linear code C of length n is defined by where wt (·) is the weight function.
A q m -dimensional Hilbert space H can be identified with the n-fold tensor product of Hilbert spaces [25]. The q mdimensional spaces are thought of as the state spaces of q mary systems, and in the same way the value 0 and 1 can be thought of as the possible states of a bit in a bit string. We now define an explicit error basis for q m -ary quantum codes. Let T and R be the linear operators acting on the space C that are defined by the matrices with entries where ξ = e √ −12π/n , and the indices range from 0 to n − 1 [25].
As discussed in the previous section, it is enough to consider the error operators The set of operators is then given by Quantum stabilizer codes are defined as joint eigenspaces of the operators of a commutative subgroup L in (7) of ε. Without loss of generality, we assume that Z ∈ L . Otherwise, we should extend L by Z . Recall that the characters of L with pointwise multiplication form a group, i.e. L, which is isomorphic to L . Let Z be the group of linear characters of Z . The map, i.e. |ψ , will restrict a character of L to a character of Z is a group homomorphism L → Z . The corresponding code space is then denoted by C .
To connect and compare quantum error-correcting codes with classic error-correcting codes, we thenceforth denote a classic code that encodes k binary bits to n binary bits as an [n, k] code. Furthermore, we denote a quantum code that encodes k qubits to n qubits as an [[n, k]] code [26,27]. If a code has minimum distance d, it is capable of detecting any d − 1 and correcting any d−1 2 errors. In [28], Gottesman has proposed a class of stabilizer codes, which are one-qubit error correcting, saturate the quantum Hamming bound, and assign distinct "error syndrome" to each correctable error operator according to a certain rule.
The encoding of a stabilizer code C(S) through a standard generator matrix is summarized as follows. Considering a stabilizer group S whose elements, when represented as in (6), have m 0 = 0. Let |0 ≡ |0 ⊗n , referred to as "seed" state. Define The set of 2 k vectors will be where |ψ c 1 c 2 ···c g ≡ χ h (z |ψ , is a basis of the stabilizer code C(S). The encoding process will be accomplished by a linear transformation from the state space Z to the stabilizer code C(S) given by |c 1 c 2 · · · c g → |ψ c 1 c 2 ···c g , c g ∈ {0, 1}. When encoding in this way, c g = χ h (z g ) is called "seed generators". Noted that the encoding process can involve only primary generators and seed generators since g|0 = |0 , where g is generated by secondary generators.
From (16), we observe that if any two error operators E a and E b are in G h , with each item having weight less than or for a certain stabilizer group S, with C(S) being at least t *qubit error correcting. As in (14), for any g ∈ S, h ∈ L, we may define f g : Furthermore, for a given generating set of a stabilizer group S with n independent generators g 1 , g 2 , . . . , g n , we may define where is an error syndrome matrix of a qubit, and H is the check of S corresponding to the generators g 1 , g 2 , . . . , g n . It can be inferred that f S is a group homomorphism [22]. In (22) . . , f S (β n ) as its columns and to verify this matrix to be commutative.
is a sum of no more than 4t * terms and can be represented as In (22), H is linearly independent if the elements of S can be viewed as the realization of an (i.i.d.) Bernoulli process [29]. We can model the elements of S as outcomes of a Bernoulli process with parameter p. The weight-d parity-check matrix H leads to where ρ denotes the probability of error of a qubit, and O is the set of positive odd integers not larger than d.
In (23), we assume that α u and β v are two concatenated 2n-dimensional vectors of a Pauli block matrix. Let α u and β u be two concatenated 2n -dimensional vectors of a Pauli block matrix. In order to link α u and α u together, we define a 2(n + n )-dimensional vector α u = α u ⊕ α u . In the same way, we also obtain another 2(n + n )-dimensional vector β u = β u ⊕ β u . After that, we have the following lemma for constructing the stabilizers with large block length.
Lemma 1 According to the above-mentioned vectors α u and β u , we have [30] Next, we will construct the stabilizers by designing an Abelian group from Pauli block matrices with size 2 n by 2 n . When n = 1 is satisfied, an arbitrary symmetrical Pauli block matrix J 2 with size 2 by 2 can easily be constructed as where α u and β v are two concatenated 4-dimensional vectors of two row operators α u = σ i ⊗ σ j and β v = σ j ⊗ σ i , respectively. It implies that α u and β v commute. As an example, for i = 1 and j = 2, we obtain two concatenated vectors α 1 = (10|01) and α 2 = (01|10), where two operations are α 1 = σ 1 ⊗ σ 2 and α 2 = σ 2 ⊗ σ 1 , respectively. In order to construct Pauli block matrix with a higher size, we introduce the concept of Kronecker product of matrices The key properties of the Kronecker product will be used throughout the rest of the paper. Now let us go back to (22), Λ n×(n−k) is error syndrome matrix of a qubit. We define error syndrome for any error operators E g as In ( A quantum state is vulnerable to external noise. Thus, the code of quantum state must be protected from it in quantum information. One may apply a decoding operation to quantum state in order to extract the error syndrome and determine the presence of any errors. We assume that the xth qubit generates bit-flip error, the corresponding error operator is defined as and the error syndrome of X x is thus given by The error syndrome matrix of a bit-flip error is given by More generally, if multiple qubits generate bit-flip errors simultaneously, then the error operator is denoted by where a v ∈ F 2 , c X ∈ {0, 1}. Define a = [a 1 , a 2 , . . . , a n ], we can obtain the following relation: Using a similar method, we can obtain the error operator of a bit phase-flip error as The corresponding error syndrome of Z z and the error syndrome matrix are, respectively, given by If a qubit generates bit-flip error and bit phase-flip error simultaneously, the corresponding error operator and error syndrome are, respectively, given by where Therefore, the linear relation among s Y m , s X m and s Z m can be expressed as If multiple qubits generate bit-flip error and bit phase-flip errors simultaneously, the corresponding error operator E g can be denoted by where a v , b l ∈ F 2 . Define a = [a 1 , a 2 , . . . , a n ], b = [b 1 , b 2 , . . . , b n ], we can obtain the relation as follows: From (43), we have The error syndrome matrix of E g is then given by where s E g , s X , s X ∈ Λ n×(n−k) are defined in (22). From (45), there exist n − k possible ways in which error syndromes, ε( j), occur in each transmitted n-bit vector. These error patterns occur with probability where α is the crossover probability [30], and wt (ε( j)) is the weight of ε( j). Basically, each error pattern results in one of the 2 m syndromes, which is produced as follows: Any error pattern, which is a codeword, has a syndrome equal to zero. Since the code is linear, for each particular syndrome, s E g , there exist n − k different error patterns, ε( j), that produce the same syndrome, and the probability of each syndrome is given by where δ(·) denotes the Dirac function.

Group projective representation of quantum stabilizer codes
Recall that the group E has a faithful irreducible ordinary representation χ : E → U of large degree deg = (E; Z (E)) 1/2 . The errors are expressed as linear combinations of the unitary n × n matrices χ(g) representing elements g of the abstract error group E.

Lemma 2 Let N be a finite group N ⊂ E, and let χ (χ ⊂ S) be an irreducible character of N that is faithful on Z
If z ∈ Z , z = 1, and n ∈ N , then χ(zn) = tχ(n) for t = 1.
Proof The restriction of φ to N can be expressed as a sum of characters χ g (x) = χ(gx g −1 ) conjugated to χ where χ ↓ N denotes the restriction of χ to N . The conjugated characters satisfy for all central elements z ∈ Z . Hence, for all z ∈ Z , which proves the lemma. (21). It is assumed that χ is an irreducible projective representation of S consisting of unitary matrices, implying that {χ(g) : g ∈ G} is a nice error basis and χ is an irreducible projective representation of S.

Lemma 3 Let S be a certain quantum stabilizer group in
Proof Equations (20) and (51) have the same meaning: that {χ(g) ∈ U : g ∈ G} form a projective representation χ of S. It is assumed that χ is an irreducible projective representation of S consisting of unitary matrices. Let τ be the projective character of χ . Since χ is irreducible and τ (1) 2 = n 2 = |S|, we obtain τ (g) = 0 for all g = 1. Conversely, suppose that χ is the projective representation formed by a nice error basis. In this case, its projective character τ is invariant under projective equivalence. When τ (g) = 0 for all g = 1, τ (1) 2 = n 2 = |S|, we conclude that χ is irreducible. The above-mentioned proof showed that χ is an irreducible projective representation of S, leading to where ε χ is an orthogonal projector onto Q. The available code Q is used to correct a set of errors ⊂ E, and the dimension of Q is denoted nχ (1).
Once a quantum stabilizer code on H ⊗n has been constructed in the previous sections, the inertia subgroup can be applied to find operations that can be implemented transversally. This ensures that these operations can be implemented with fault tolerance. Suppose that C = C(χ ) for an irreducible character of the normal subgroup N of ε ⊗n . Let In (18), |ψ is an initial state in C(S). Let |ψ denote the state after an interaction with the environment. For error detection, it suffices to measure whether |ψ is in C(S). If the projection operator (also called the density operator) ρ is detectable and the measurement outcome is to project |ψ into C(S), the resultant state is |ψ . What we have known is that the other measurement outcome is an error occurred.
To correct errors, it requires that we restore |ψ according to a syndrome representation of the Hilbert space, H ≡ S ⊗ C(S) + R. A suitable syndrome representation can be gained from ε/T (χ ) (where T (χ ) is inertia subgroup, E / ∈ T (χ ) ∈ Z ) as follows: let {g 0 , g 1 , . . .} be a set be Hilbert space spanned by orthonormal states labeled |g i , and let | j i denote an orthonormal basis of C(S). An isomorphism Ω: S ⊗ C(S) → H is given by The choice of g i implies that the subspaces g i C(S) partition H into equal dimensional orthogonal subspaces (the invariant subspaces of N associated with the distinct induced irreducible characters). In order to recover |ψ from |ψ , one first measures the syndrome by projecting |ψ into one of the g i C(S). If the measurement outcome is in g i C(S), then we can apply g −1 i to the state. Note that the g i C(S) are independent of the choice of representation g i ∈ g i T (χ ), and only the restoration of the state to C(S) will depend on this choice.
H is used to denote the Hilbert space for some quantum system and it can be decomposed as We assume that H A and H B are spanned by the orthonormal sets {|g i }, {| j i }, respectively. We define the projection operator Hereafter, we will discuss the case when dim(K ) = 0. Every such channel admits an operator sum representation as where E i denotes the error operator.

Definition of decoherence-free subspaces
Noted that quantum system is fragile for external noise. Therefore, the quantum system must be protected in both quantum information processing and quantum computation [31]. In practice, the majority of quantum systems employed for these purposes are microscopic in size (typically a few micrometers). In contrast, environmental noise, such as electromagnetic waves, has a wavelength about a few centimeters or more. Therefore, it is natural to assume that all the qubits suffer from the same error operator. The DFSs and NS are two standard coding methods used to correct collective errors [32][33][34]. The scheme has been explained using the operator sum representation of the quantum channel (55). In (55), the error operators E i in E can be expressed as multiples of an operator of the form ε ⊗n ∈ H ⊗n . Let C(S) be the 2 n -dimensional space spanned by the singlets |ψ . If |ψ (Z ) ∈ C(S) is satisfied, then |ψ ∈ C(S), and one may obtain H l |ψ (Z ) ⊗ |ψ = 0. It leads to the following result:

Theorem 3 Let E N be the manifold of states built over the singlet space C(S). If
and taking the trace over the bath one gets Theorem 3 can be rephrased in the following way, which emphasizes its strength: In the manifold of the states over H S , there must exist a submanifold E N of stationary states of the Liouvillian evolution. Therefore, the dynamics over E N is a fortiori unitary. Note that it holds for arbitrary strength of the system-bath coupling. This evokes the possibility of encoding in E N decoherence-free information, namely, the states of E N realize a DFS [17,35]. If we begin deriving the master equation for collective error, a collective error of qubits is caused by the interaction with noise environment. The system Hamiltonian H l (t) over singlet space C(S) is then given by where a j is the annihilation operator of the bath mode, and f i and f 0 denote frequencies of the bath mode and of the qubits, respectively. The corresponding Lindblad master equation is expressed as Substituting (58) into (59), we obtain the following Lindblad master equation: where γ i j is the coefficient 2 n -dimensional space spanned by the singlets |ψ . As described previously, quantum stabilizer codes are defined as joint eigenspaces of the operators of a commutative subgroup in (7), and | j i denote an orthonormal basis of C(S) in (53). Hence, both j i and j † i satisfy the commutation relations, i.e., [ j † i , j ] = 0. Substituting (56) into (60), the Lindblad master equation can be rewritten as d dt where j † i and ρ(t) jointly satisfy the commutation relations = 0 (ϒ is the decay rate of the transmission line resonator) is satisfied. If ρ satisfies L D (ρ) = 0, the space becomes DFS [35,36].

Theorem 4 For quantum stabilizer code C(S) in (22) is nonempty linear subspace of S, if and only if C(S) is eigenspace of all Kraus operators
Proof We first of all prove the necessity. For |ψ ∈ C(S), Furthermore, K i |ψ can be decomposed as [17] where ψ|ψ ⊥ = 0, g i g ⊥ i is constant coefficient. Note that K i satisfies the normalizing condition and is denoted Substituting (63) into (64), we can obtain Suppose that |ψ 1 , |ψ 2 ∈ C(S) and K i |ψ i = g i |ψ i (i = 1, 2) can be satisfied, the coherence superposition state satisfies |ψ c = γ 1 |ψ 1 + γ 1 |ψ 1 ∈ C(S), where Hence, for any ψ ∈ C(S), we have K i |ψ = g i |ψ , thus C(S) is eigenspace of all Kraus operators K i . We secondly prove the sufficiency. We have Therefore, we use three methods to prove the statement of "C(S) space is a DFS". In fact, the definitions for DFSs are equivalent over C(S) space. Since |ψ , H l (t) and ρ(t) can describe DFSs from different views.

Quantum error-avoiding codes
In this section, we propose a new but simple construction of QEACs and develop several classes of QEACs from this construction.

Quantum stabilizer codes of QEACs
Quantum stabilizer codes C(S) are defined in the previous section. The code construction method for obtaining codes is based on the syndrome probability mass function of a code, where a code extended in length is a function of the probability mass function of the original code. For syndrome coding, it implies that the syndrome probability mass function (48) considers only error events with weight less than d−1

2
. The probability generating function of code can be given by for a given syndrome segment s t , an unencoded logical segment L t , and memory states M t−1 and M t . Defining the set {Ω(M t−1 , M t , L t , s t )} to be the solutions of (68), the corresponding weight is thus given by d−1

2
. If the probability generating function of code is given by Given the seed transformation of (30), there exist n − k different ways that make (46) fulfill with M t−1 → X and M t → Z, corresponding to the four transformation rules that are, respectively, given by X IY → Y ZZ; X ZX → Y I Z; where all of these four rules involve the logical operator X. To find a quantum stabilizer code C(S) with minimal possible d, we consider a class of "equivalent transformations" on stabilizer codes. Note that stabilizer operators must satisfy stringent commutativity constraints in order to form a valid quantum code [37,38]. In the case, a binary (n − k) × 2n check matrix H = [H X |H Z ] of a stabilizer code C(S) will be described as an (n −k)×n matrix H 4 over G F (4) according to the following mapping [39]: We can multiply each column of H 4 by ω or perform conjugation on it. Furthermore, we can also perform any combination of conjugation and multiply by or do nothing. Therefore, for C(S), there exist 6 n equivalent transformations. Equivalently, we have the following six transforma-tions on every element of a column of H 4 , respectively: From (72), there exist 3 n equivalent transformations on H 4 to be considered, corresponding to 3 n transformations on the check matrix H = [H X |H Z ] over G F (2). We can always transform a check matrix with r 1 = n − k to a check matrix with r 1 ≤ n − k − 1. Hence, we can reconstruct an error syndrome group in DFSs from (30) and (45). For example, when k = 4, we have |ψ 1 = |0000 + |1111 , |ψ 2 = |0011 + |1100 , which denote the decoherence-free states, thus span [|ψ 1 , |ψ 2 , |ψ 3 , |ψ 4 ] forms a DFS of C(S) space, due to the fact that leading to Using the same method, we can obtain When k = 3, we also have |ψ 1 = |000 + |111 , |ψ 2 = |011 > +|110 , where |ψ 1 , |ψ 2 , |ψ 3 , |ψ 1 are decoherence-free states. Relying on the above-mentioned methods, we can also construct a DFS of the C(S) space. From (76), we can prove that linear superposition states of any decoherence-free states can be constructed DFSs of the C(S) space. If the C(S) space has dimensional 2 d , i.e. dim(C(S)) = 2 d , then the corresponding DFSs can encode k − d qubits. If dim(C(S)) = 2 d−1 , then DFSs will encode k −d +1 qubits. For example, when k = 5 and dim(C(S)) = 2, E 5 = [I I I I I, X X I I I, X I X I I, . . . , I X X X X], where even qubits generate a bit-flip error, the corresponding decoherence-free states are, respectively, denoted by |ψ 0 = |00000 + |11000 + |10100 + |10010 + |10001 + |01100 + |01010 + |01001 + |00110 + |00101 + |00011 + |11110 + |11101 + |11011 + |10111 + |01111 , (78) |ψ 1 = |00001 + |11001 + |10101 + |10011 + |10000 + |01101 + |01011 + |01000 + |00111 + |00100 + |00010 + |11111 The above-mentioned examples show that we can derive QEACs from DFSs of C(S). We can construct other DFSs of C(S) using similar methods. Furthermore, QEACs provide the generalized and unified framework for error-avoiding methods.

Stabilizer groups of QEACs
The most prominent open problem concerning operator QEACs is stabilizer groups that are more interesting than the stabilizer codes [40,41]. Therefore, we shall consider a subgroup operator of QEACs. There now exist two ways to construct subgroup operator of QEACs: in parallel or in series. In the following, our primary interest resides in parallel construction. The parallel implementation has the advantage that it requires only three basic steps and thus is very efficient. Its disadvantage is that it may be hard to implement in practice because it requires simultaneous control over many qubits.
Let us introduce a simple example illustrating the notation of DFSs using normalizer elements which are two-body Hamiltonians, e.g. the stabilizer group Q 4 = {I ⊗4 , X ⊗4 , Y ⊗4 , Z ⊗4 }. As Hamiltonians,X k andZ k are valid two-body interactions and hence can be used directly to generate the encoded SU(2) group on each encoded qubit: whereX 1 andZ 1 act as a bit flip and a phase flip on the first encoded qubit, respectively.
Recall the multiplicity formula for unitary irreducible representation as [42] where m k denotes the number of times Γ k appears in the given irreducible representation, χ [Γ k (G n )] is the character of the Γ k irreducible representation on the group element G n , and χ [Γ (G n )] is the character of G n in the given irreducible representation Γ . The normalizer in (80) contains twoX k andZ k operations, since X k (Z k ) all commute, the corresponding gates can be implemented in parallel. In other words, can be used as parallel gates in our circuit (see Fig. 1 for an example). In fact, we can observe that this circuit really does implement the normalizer gate exp(iθZ) (or exp(iθX). Therefore, the encoded qubits can be written as By substituting (84) and (85) into (82) and (83), we can generate k − d = 2 elements for subgroup Q 4 . These elements encode d = 2 qubits, with states given by Let the encoding space be of dimension N (d), the optimal d-bit quantum code has efficiency [10] If d is large, η(d) can be approximated by 1 − (1/2d) log 2 (π d/2), which approaches 1 very rapidly [10].
As the above-mentioned decrepitation, in the case of four qubits, the encoding space is of six dimensions. The subgroup codewords are given by respectively. The effectiveness of this code is 1/4(1+log 2 3).
At least two qubits of information can be encoded. Figure 2 illustrates logical error rate vs. physical error rate for QEAC with Q 4 . The results show an advantage for the encoding technique over the whole range of errors considered. As expected, a slightly higher error rate in the DFS is obtained due to the additional operations required for increasing qubits.
As another example with a many-body normalizer element, we consider the subgroup Q 2X , which describes a physically interesting error model, where bit-flip errors act on all pairs of nearest-neighbor qubits. To find the DFS under Q 2X , we expect to find just on oneX and oneZ. Fault-tolerant circuit implementing exp(iθZ) for the subgroup Q 2X is shown in Fig. 3. In the case of Q 2X , it is easily verified that the normalizer is generated bȳ X = XXII,Z = ZZZZ (94) In the case of two qubits, the encoding space is of two dimensions. The two codewords are given by which are sufficient to encode one qubit of information. The efficiency is 1/2. We find a two-dimensional DFS, i.e. Q 2X , spanned by these two states. This DFS thus encodes a single qubit. To simulate random errors in values of the couplings between physical qubits when implementing gates, we can add random Gaussian noise to the exp(iθZ) parameters, where the Gaussian distribution has mean 0 and standard deviation Δ ∈ [0, 0.05]. Charge fluctuations for QEAC can be regarded as an example of such errors. Furthermore, we calculate the process fidelity over 200 iterations taken from a normal standard derivation Δ and mean 0. The results are shown in Fig. 4, with one set of results being shown, since one-and three-qubit encoding give very similar results. The process fidelity falls off slowly and stays above 0.9 for Δ ≤ 0.05. Since a reasonable estimate of these fluctuations in gate couplings would have fidelity about 0.99, we can verify that these gates have high fidelity even at high-noise regime.  Fig. 4 The average process fidelity when performing the gate with random fluctuations in gate times, subgroups Q 4 and Q 2X encoding of QEAC are, respectively, shown, where Q 4 has three-qubit encoding and Q 2X has one-qubit encoding

Conclusions
The proposed QEACs are shown to be immune to both the environmental decoherence and the channel noise in comparison with existing results. The most critical point is that multiqubit quantum states can be efficiently transferred via QEACs, which has the ability to predict intrinsically so as to construct the DFSs by means of multiple qubits. We can readily use the direct sum of the one-dimensional representation of the C(S). In principle, this elegant result allows us to design DFSs (or noiseless) quantum codes. However, in practical applications, encounter some difficulties, e.g. the preparation of codewords and the large coherence length required. Hence, One open question is if the code stability can be addressed in the framework of the Liouville-von Neumann equation formalism. Another open question is whether the proposed approach may possibly be extended to the case when H is infinite dimensional. Furthermore, every single common eigenvector of the Lindblad operators with any eigenvalue can be chosen the basic vector of the DFSs. This provides various selections to implement the DFSs scheme and can be used to find the best scheme in implementation of the DFSs program.