{'fraction_non_alphanumeric': 0.032571833190474415, 'fraction_numerical': 0.009410054783289233, 'mean_word_length': 4.439590512872491, 'pattern_counts': {'":': 0, '<': 2, '<?xml version=': 0, '>': 4, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Fault tolerance for holonomic quantum computation

We review an approach to fault-tolerant holonomic quantum computation on stabilizer codes. We explain its workings as based on adiabatic dragging of the subsystem containing the logical information around suitable loops along which the information remains protected.


I. INTRODUCTION
In Chapter 16 it was shown how holonomic quantum computation (HQC) can be combined with the method of decoherence-free subspaces (DFSs), leading to passive protection against certain types of correlated errors. However, this is not enough for fault tolerance since other types of errors can accumulate detrimentally unless corrected. Scalability of HQC therefore requires going beyond that scheme, e.g., by combining the holonomic approach with active error correction. One way of combining HQC with active quantum error-correcting codes, which is similar to the way HQC is combined with DFSs, was also mentioned in Chapter 16. This approach, however, is not scalable since it requires Hamiltonians that commute with the stabilizer elements, and when the code increases in size, this necessitates couplings that become increasingly nonlocal.
In this chapter, we will show how HQC can be made fault tolerant by combining it with the techniques for faulttolerant quantum error correction (FTQEC) on stabilizer codes using Hamiltonians of finite locality. The fact that the holonomic method can be mapped directly to the circuit model allows us to construct procedures which resort almost entirely to these techniques. We will discuss an approach which makes use of the encoding already present in a stabilizer code and does not require additional qubits [28,30]. An alternative approach which requires ancillary qubits for implementing transversal operations between qubits in the code can be found in Ref. [29].
Since protected information is contained in subsystems [9,20] (see Chapter 6), the problem of implementing faulttolerant HQC can be understood as that of manipulating fault-tolerantly the subsystem containing the protected information by holonomic means. We therefore begin by first introducing a generalization of the standard HQC method, which is applicable to encoding in subsystems.

II. HOLONOMIC QUANTUM COMPUTATION ON SUBSYSTEMS
As pointed out in Chapter 6, protected quantum information is most generally contained in the subsystems H A i in a decomposition of the Hilbert space of the system of the form Here the dimensions of the subsystems are related by dimH S = m i=1 dimH A i × dimH B i + dimK. In the formalism of operator quantum error correction [22,23,32,33], the subsystems H A i contain the logical information, and H B i contain the syndrome and gauge degrees of freedom. In the most general case, all subsystems H A i can be used for encoding and computation [8]. By using adiabatic holonomies it is possible to apply arbitrary computations in the subsystems H A i , a result which is summarized in the following theorem [29]: Theorem 1. Consider a non-trivial decomposition into subsystems of the form (1). Choose an initial Hamiltonian in the form where H B i are operators on H B i such that all eigenvalues of H B i are different from the eigenvalues of H K and the eigenvalues of H B j for i = j. In the case when dimK = 0 and m = 1, we impose the additional requirement that H B 1 has at least two different eigenvalues. By varying this Hamiltonian adiabatically along suitable loops in a sufficiently large control manifold, it is possible to generate a unitary of the form where {W A i } is any desired set of geometric unitary transformations on {H A i }. The proof of the theorem is based on the following lemma.
Lemma 1. By varying a Hamiltonian adiabatically along suitable loops in a sufficiently large control manifold, it is possible to implement holonomically any combination of unitary transformations in its eigenspaces.
Comment. As discussed in Chapter 16, if we have sufficient control over the parameters of a Hamiltonian, we can generate holonomically any unitary operation in a given eigenspace. This lemma concerns the question of whether it is possible to generate any combination of holonomies in the different eigenspaces. Although intuitively expected based on considerations concerning the generic irreducibility of the adiabatic connection, the property may not be obvious. For example, in the case of a two-level Hamiltonian, the evolution of one of the eigenspaces completely determines the evolution of the other one, which raises the question of whether it is possible to obtain independent holonomies in the two eigenspaces. We now show that this is possible. Note that even though the proof is constructive and can serve as a general prescription for simultaneous HQC in different eigenspaces, it is primarily meant as a proof of principle.
Proof of Lemma 1. It is sufficient to show that it is possible to generate an arbitrary operation in any given eigenspace while at the same time generating the identity operation in the rest of the eigenspaces. Without loss of generality, we will assume that there are only two eigenspaces; if there are more, we can operate within the subspace spanned by two of them at a time, by varying only the restriction of the Hamiltonian on that subspace. Then the initial Hamiltonian can be written as where Π 1,2 are the projectors on the ground and excited eigenspaces, and ε 1 < ε 2 are their corresponding eigenvalues. Notice that this Hamiltonian is invariant under unitary transformations of the form where V 1,2 are unitaries on the subspaces with projectors Π 1,2 , respectively. Let the Hamiltonian vary along a loop H(t), H(0) = H(T ), which satisfies the adiabatic requirement to some satisfactory precision. To this precision, the resulting unitary transformation can be written as where U 1 and U 2 are the holonomies resulting in the two eigenspaces, and ω 1,2 = T 0 dtε 1,2 (t) are dynamical phases. Observe that the Hamiltonian V H(t)V † , where V = V 1 ⊕ V 2 , is a valid loop based on H(0) with the same spectrum as that of H(t), which gives rise to the holonomies V 1 U 1 V † 1 and V 2 U 2 V † 2 , respectively. This follows from the fact that the overall unitary transformation generated by V H(t)V † is equal to V U (t)V † where U (t) is the unitary generated by H(t). Imagine that we want to generate holonomically the unitary transformation W 1 in the ground space of the Hamiltonian while at the same time obtaining the identity holonomy I 2 in the excited space. Choose any loop H(t) which gives rise to the holonomy W in the ground space, where d 2 is the dimension of the excited space (we know that such a loop can be found). Let this loop result in the holonomy W 2 in the excited space. The latter can be written as W 2 = d2 j=1 e iαj |j j|, where {|j } is an eigenbasis of W 2 and e iαj , α j ∈ R, are the corresponding eigenvalues.
Consider the unitary transformation C 2 which cyclicly permutes the eigenvectors {|j }: C 2 |j = |j + 1 , where we define |d 2 + 1 ≡ |1 . We can implement the desired combination of holonomies in the two eigenspaces as follows.
First apply H(t). This results in the holonomies W and W 2 in the ground and excited spaces, respectively. Next, . The combined effect of these two operations is W e i(αj +αj−1) |j j|. We next apply where e iφα i are dynamical phases resulting in the eigenspaces H A i ⊗ H B αi . To summarize, HQC on a subsystem can be realized by adiabatically varying a Hamiltonian that acts locally on the corresponding co-subsystem. During the evolution, the information initially encoded in the subsystem transforms to a different subsystem which is related to the initial one via a geometric unitary operation. The dynamical part of the unitary factors out as a transformation on the correspondingly transformed co-subsystem. The problem of FTHQC can be understood as that of finding a fault-tolerant realization of this approach.

A. The main idea
The developed techniques for FTQEC on stabilizer codes provide a prescription for how to encode information and how to transform the subsystem containing the information (hereafter referred to as the code subsystem) so that the class of errors for which the code is designed remains correctable. We will try to find realizations of the same transformations that the code subsystem follows in a standard fault-tolerant scheme using the generalized method of HQC on subsystems. There are two difficulties in this respect that have to be considered. First, not every unitary evolution of a subsystem can be realized by holonomic means. For example, a general evolution inside a fixed subsystem cannot be implemented holonomically because the HQC method requires that the encoded states leave the original code in order to undergo non-trivial geometric transformations. Second, the holonomic approach unavoidably gives rise to dynamical transformations on the co-subsystem (see below), and these could jeopardize the fault tolerance of the scheme. We will see that neither of these features is a fundamental obstacle to the realization of fault-tolerant HQC.
The standard fault-tolerant techniques are primarily based on the use of transversal operations. In addition, there are non-transversal operations for preparing and verifying a special ancillary state such as Shor's "cat" state (|00...0 + |11...1 )/ √ 2. Since single-qubit unitaries together with the CNOT gate form a universal set of gates, faulttolerant computation can be realized entirely in terms of single-qubit gates and transversal CNOT gates, assuming that the ancillary state can be prepared reliably. Thus we can aim at constructing holonomic gates on the code subsystem via transformations that in the original basis of the full Hilbert space are equivalent to transversal oneand two-qubit gates or to operations for the preparation of the "cat" state.
It turns out, however, that holonomic transformations on the code subsystem cannot be realized using purely transversal operations without the use of extra qubits, even if the encoded gate has a purely transversal implementation in the dynamical case. This is because the Hamiltonians that leave the code subsystem invariant are linear combinations of elements of the stabilizer or, more generally (in the case of operator codes), the gauge group of the code, and they unavoidably couple qubits in the same block. But transversal operations are not the most general class of operations that do not lead to propagation of errors. A transformation which at every moment is equal to a transversal operation followed by a syndrome-preserving transformation on the co-factor of the subsystem that contains the protected information is also fault-tolerant. In fact, any transversal operation in a given fault-tolerant protocol can be safely replaced by an operation of the latter type. It is this latter type of transformations by means of which we can realize fault-tolerant HQC without the use of extra qubits.
We will show that by choosing as a starting Hamiltonian a suitable element of the stabilizer or the gauge group of the code and varying this Hamiltonian along appropriately chosen paths in parameter space, we can generate operations that -from the perspective of the full Hilbert space -transform both the ground and the excited spaces via the same transversal operation. This means, in particular, that the transformation of the code subsystem is the same as the one that would result from the application of the transversal operation, up to a transformation on the co-subsystem. The relative dynamical phase that accumulates between the ground and excited spaces is equal to a phase on the co-subsystem which is irrelevant for the fault-tolerance of the scheme since it is either projected out when a measurement of the syndrome is performed, or is equivalent to a gauge transformation. Thus by an appropriate sequence of such transformations we can take the code subsystem adiabatically along a loop such that the resultant holonomy at the end is by construction equal to a given encoded gate. This is the main idea behind our scheme. We note, however, that our scheme does not use an isodegenerate Hamiltonian along a given loop. This is because for simplicity we use Hamiltonians that are equal to a single element of the stabilizer or the gauge group at a given time, and we change the Hamiltonians along different portions of a loop. In this respect, the scheme we will present is slightly more general than the one described in Sec. II, but the main idea behind its workings is the same-the full Hilbert space splits into different subspaces, each of which is adiabatically transported around a loop such that all subspaces undergo the same holonomy which factors out as an operation on the code subsystem. In the case of standard stabilizer codes, the subspaces in question are the syndrome subspaces. In the case of subsystem codes, each syndrome subspace further splits into subspaces containing redundant information. In the latter case, if along the loop we change between Hamiltonians that are non-commuting elements of the gauge group, these redundant subspaces may seem to undergo dynamical transformations in addition to the geometric ones. However, these dynamical effects are equivalent to gauge transformations and do not affect the holonomy taking place inside the code subsystem.
For concreteness, we will consider an [[n, 1, r, 3]] stabilizer code. This is a code that encodes 1 qubit into n, has r gauge qubits, and can correct arbitrary single-qubit errors. As we saw in the previous section, in order to apply holonomic transformations on the subsystem that contains the logical information, we need a nontrivial starting Hamiltonian that leaves this subsystem invariant. It is easy to verify that the only Hamiltonians that satisfy this property are linear combinations of the elements of the stabilizer or the gauge group.
Note that the stabilizer and the gauge group transform during the course of the computation under the operations being applied. At any stage when we complete an encoded operation, they return to their initial forms modulo a gauge transformation. Our scheme will follow the same transversal operations as those used in a standard dynamical fault-tolerant scheme, but as explained above, in addition we will have extra dynamical phases that multiply each syndrome subspace or are equivalent to more general gauge transformations. It is easy to see that these phases leave the stabilizer invariant and transorm the gauge group via a gauge transformation, so without loss of generality we can omit them from our analysis of the transformation of these groups. During the implementation of a standard encoded gate, the Pauli group G n on a given codeword may spread over other codewords, but it can be verified that this spreading can be limited to at most 4 other codewords including the "cat" state. This is because the encoded CNOT gate can be implemented fault-tolerantly on any stabilizer code by a transversal operation on 4 encoded qubits [15], and any encoded Clifford gate can be realized using only the encoded CNOT, provided that we are able to do fault-tolerant measurements (the encoded Clifford group is generated by the encoded Hadamard, Phase and CNOT gates). Encoded gates outside of the Clifford group, such as the encoded π/8 or Toffoli gates, can be implemented fault-tolerantly using encoded CNOT gates conditioned on the qubits in a "cat" state, so they may require transversal operations on a total of 5 blocks. For CSS codes, however, the spreading of the Pauli group of one block during the implementation of a basic encoded operation can be limited to a total of 3 blocks, since the encoded CNOT gate has a transversal implementation [15].
It also should be noted that fault-tolerant encoded Clifford operations can be implemented using only Clifford gates on the physical qubits [15]. These operations transform the stabilizer and the gauge group into subgroups of the Pauli group, and their elements remain in the form of tensor products of Pauli matrices. The fault-tolerant implementation of encoded gates outside of the Clifford group, however, involves operations that take these groups outside of the Pauli group. We will, therefore, consider separately two cases: encoded operations in the Clifford group, and encoded operations outside of the Clifford group.
B. Encoded operations in the Clifford group

Single-qubit unitary operations
For applying transformations on a given qubit, say, the first one, we will use as a starting Hamiltonian an element of the stabilizer (with a minus sign) or the gauge group of the code, that acts non-trivially on that qubit. Since we are considering codes that can correct arbitrary single-qubit errors, one can always find an element of the initial stabilizer or the initial gauge group that has a factor σ 0 = I, σ 1 = X, σ 2 = Y or σ 3 = Z acting on the first qubit, i.e., where G is a tensor product of Pauli matrices and the identity on the remaining n − 1 qubits. It can be verified that under Clifford gates the stabilizer and the gauge group transform in such a way that this is always the case except that the factor G may spread to qubits in other blocks. We can assume that the stabilizer spreads on at most 5 blocks including the "cat" state, since this is sufficient to implement any encoded operation. Henceforth, we will use "hat" to denote operators on all qubits on which the stabilizer spreads, and "tilde" to denote operators on all of these qubits except the first one. Without loss of generality we will assume that the chosen stabilizer or gauge-group element for that qubit has the form As initial Hamiltonian, we will take the operator Proposition 1. If the initial Hamiltonian (10) is varied adiabatically so that only the factor acting on the first qubit changes, where the transformation that each of the eigenspaces of this Hamiltonian undergoes will be equivalent to that driven by a local unitary on the first qubit, Proof. Observe that (11) can be written as where are orthogonal complementary projectors. The evolution driven by H(t) is therefore where Let |φ 0 (t) and |φ 1 (t) be the instantaneous ground and excited states of H(t) with eigenvalues E 0,1 (t) = ∓E(t) (E(t) > 0). Then in the adiabatic limit we have where The projectors on the ground and excited eigenspaces of H(0) are and respectively. Using Eq. (17) and Eq. (18), one can see that the effect of the unitary (15) on each of these projectors is i.e, up to an overall dynamical phase its effect on each of the eigenspaces is the same as that of the unitary where We next show how by suitably choosing H(t) we can implement all necessary single-qubit gates. We will identify a set of points in parameter space, such that by interpolating between these points we can draw various paths resulting in the desired transformations.
Consider the single-qubit unitary operator where θ is a real parameter. Note that V θ∓ = (V θ± ) † . Define the following single-qubit Hamiltonian: Let H(t) in Eq. (11) be a Hamiltonian that interpolates between H(0) = Z and H(T ) = H θ± (up to a factor) as follows: where f (0), g(T ) > 0, f (T ) = g(0) = 0. To simplify our notation, we will drop the indices f and g of the Hamiltonian, since the exact form of these functions is not important for our analysis as long as they are sufficiently smooth (see discussion in Sec. III B 2). This Hamiltonian has eigenvalues ± f (t) 2 + g(t) 2 and its energy gap is non-zero unless the entire Hamiltonian vanishes. It can be shown that in the adiabatic limit, the Hamiltonian (11) with H(t) = H θ± (t) gives rise to the effective transformation on each eigenspace. Details of the proof can be found in Ref. [31].
We will use this result to construct a set of standard gates by sequences of operations of the form V θ± , which can be generated by interpolations of the type (27) run forward or backward. For single-qubit gates in the Clifford group, we will only need three values of θ: 0, π/2 and π/4. For completeness, however, we will also demonstrate how to implement the π/8 gate, which together with the Hadamard gate is sufficient to generate any single-qubit unitary transformation [10]. For this we will need θ = π/8. Note that so for these values of θ we have H 0± = ±X, . Consider the adiabatic interpolations between the following Hamiltonians: According to the above result, the first interpolation yields the transformation V π/2+ . The second interpolation can be regarded as the inverse of We see that up to a global phase the above sequence results in an implementation of the X gate in each eigenspace. Similarly, one can verify that the Z gate can be realized via the loop The Phase gate P can be realized by applying followed by the X gate. The Hadamard gate W can be realized by first applying Z, followed by Finally, the π/8 gate T can be implemented by first applying Y = iXZ, followed by

A note on the adiabatic condition
Before we show how to implement the CNOT gate, let us comment on the conditions under which the adiabatic approximation assumed in the above operations is satisfied. Because of the form (15) of the overall unitary, the adiabatic approximation depends on the extent to which each of the unitaries (16) approximate the expressions (17). The latter depends only on the adiabatic properties of the non-degenerate two-level Hamiltonian H(t). For such a Hamiltonian, the simple version of the adiabatic condition [26] reads where and ∆ = min is the minimum energy gap of H(t).
Along the segments of the parameter paths we described, the Hamiltonian is of the form (27) and its derivative is This derivative is well defined as long as df (t) dt and dg(t) dt are well defined. The curves we described, however, may not be differentiable at the points connecting two segments. In order for the Hamiltonians (27) that interpolate between these points to be differentiable, the functions f (t) and g(t) have to satisfy df (T ) dt = 0 and dg(0) dt = 0. This means that the change of the Hamiltonian slows down to zero at the end of each segment (except for a possible change in its strength), and increases again from zero along the next segment. We point out that when the Hamiltonian stops changing, we can turn it off completely by decreasing its strength. This can be done arbitrarily fast and it would not affect a state which belongs to an eigenspace of the Hamiltonian. Similarly, we can turn on another Hamiltonian for the implementation of a different operation.
The above condition guarantees that the adiabatic approximation is satisfied with precision 1 − O(( ε ∆ 2 ) 2 ). It is known, however, that under certain conditions on the Hamiltonian, we can obtain better results [17]. Let us write the Schrödinger equation as where ǫ > 0 is small. Assume thatH(t) is smooth and all its derivatives vanish at the end points t = 0 and t = T (note thatH(t) is non-analytic at these points, unless it is constant). Then if we keepH(t) fixed and vary ǫ, the adiabatic error would scale super-polynomially with ǫ, i.e., the error will decrease with ǫ faster than O(ǫ N ) for any N . (Notice that ε ∆ 2 ∝ ǫ, i.e., the standard adiabatic condition guarantees error O(ǫ 2 ).) In our case, the smoothness condition translates directly to the functions f (t) and g(t). For any smooth f (t) and g(t) we can further ensure that the condition at the end points is satisfied by the reparameterization f (t) → f (y(t)), g(t) → g(y(t)) where y(t) is a smooth function of t which satisfies y(0) = 0, y(T ) = T , and has vanishing derivatives at t = 0 and t = T . Then by slowing down the change of the Hamiltonian by a constant factor ǫ, which amounts to an increase of the total time T by a factor 1/ǫ, we can decrease the error super-polynomially in ǫ. We will use this result to obtain a low-error interpolation in Sec. III E where we estimate the time needed to implement a holonomic gate with a given precision.

The CNOT gate
The stabilizer (or gauge group) on multiple blocks of the code is a direct product of the stabilizers (or gauge groups) of the individual blocks. Therefore, from Eq. (8) it follows that one can always find an element of the initial stabilizer or gauge group on multiple blocks that has any desired combination of factors σ i , i = 0, 1, 2, 3 on the first qubits in these blocks. It can be verified that applying transversal Clifford operations on the blocks does not change this property. Therefore, we can find an element of the stabilizer or the gauge group that has the form (9) where the factor Z acts on the target qubit and G acts trivially on the control qubit. We now explain how to implement the CNOT gate adiabatically starting from such a Hamiltonian.
Notice that a Hamiltonian of the form where the superscript c denotes the control qubit, gives rise to the unitary transformation where If H 0 (t) and H 1 (t) have the same non-degenerate instantaneous spectra, and Tr{H 0,1 (t)} = 0, then it follows that in the adiabatic limit each of the eigenspaces of H(t) will undergo the transformation where V 0,1 (t) ⊗ I are the effective transformations generated by H 0,1 (t) ⊗ G according to Proposition 1. Our goal is to find H 0 (t) and H 1 (t), H 0 (0) = H 1 (0) = Z, such that at the end of the transformation the unitary (43) will be equal to the CNOT gate. In other words, we want V 0 (2T ) = I and V 1 (2T ) = X (we choose the total time of evolution to be 2T for convenience).
We already saw how to generate adiabatically the X gate up to a phase-Eq. (30). We can use the same Hamiltonian in place of H 1 (t): Now we want to find a Hamiltonian H 0 (t) with the same spectrum as H 1 (t), which gives rise to a trivial geometric transformation, V 0 (2T ) = I (possibly up to a phase, which can be undone later). Since all Hamiltonians of the type H θ± (t) have the same instantaneous spectrum (for fixed f (t) and g(t)), we can simply choose which corresponds to applying a given transformation from t = 0 to t = T and then undoing it (running it backwards) from t = T to t = 2T . This results exactly in V 0 (2T ) = I. Since, as we saw in Sec. III B 1, the Hamiltonian H 1 (t) ⊗ G gives rise to the transformation iX ⊗ I in each of its eigenspaces, the above choice for the Hamiltonians (45) and (44) in Eq. (40) will result in the transformation which is the desired CNOT gate up to a Phase gate on the control qubit. We can correct the phase by applying the inverse of the Phase gate to the control qubit, either before or after the described transformation. Notice that from t = 0 to t = T the Hamiltonians (45) and (44) are identical, i.e., during this period the Hamiltonian (40) has the form so we are simply applying the single-qubit operation V π/2+ to the target qubit according to the method for singlequbit gates described before. It is easy to verify that during the second period, from t = T to t = 2T , the Hamiltonian (40) realizes the interpolation which is understood as in Eq. (27). To summarize, the CNOT gate can be implemented by first applying the inverse of the Phase gate (P † ) on the control qubit, as well as the transformation V π/2+ on the target qubit, followed by the transformation (48). Due to the form (40) of H(t), the extent to which the adiabatic approximation is satisfied during this transformation depends only on the adiabatic properties of the single-qubit Hamiltonians H π/2± (t) which we discussed in the previous subsection.

C. Encoded operations outside of the Clifford group
For universal fault-tolerant computation we also need at least one encoded gate outside of the Clifford group. The fault-tolerant implementation of such gates is based on the preparation of a special encoded state [10,15,21,34,37] which involves a measurement of an encoded operator in the Clifford group. For example, the π/8 gate requires the preparation of the encoded state |0 +exp(iπ/4)|1 √ 2 , which can be realized by measuring the encoded operator e −iπ/4 P X [10]. Equivalently, the state can be obtained by applying the encoded operation W P † on the encoded state cos(π/8)|0 +sin(π/8)|1 √ 2 which can be prepared by measuring the encoded Hadamard gate [21]. The Toffoli gate requires the preparation of the three-qubit encoded state |000 +|010 +|100 +|111 2 and involves a similar procedure [37]. In all these instances, the measurement of the encoded Clifford operator is realized by applying transversally the operator conditioned on the qubits in a "cat" state.
We now describe a general method that can be used to implement adiabatically any conditional transversal Clifford operation with conditioning on the "cat" state. Let O be a Clifford gate acting on the first qubits from some set of blocks. As we discussed in the previous section, under this unitary the stabilizer and the gauge group transform in such a way that we can always find an element with an arbitrary combination of Pauli matrices on the first qubits. If we write this element in the form where G 1 is a tensor product of Pauli matrices acting on the first qubits from the blocks, and G 2,...,n is an operator on the rest of the qubits, then applying O conditioned on the first qubit in a "cat" state transforms this stabilizer or gauge-group element as follows: where the superscript c denotes the control qubit from the "cat" state. We can implement this operation by choosing the factor G 1 to be the same as the one we would use if we wanted to implement the operation O according to the previously described procedure. Then we can apply the following Hamiltonian: where H O (t) ⊗ G 2,...,n is the Hamiltonian that we would use for the implementation of the operation O and α(t) is a real parameter chosen such that at every moment the operator α(t)|1 1| c ⊗H O (t)⊗G 2,...,n has the same instantaneous spectrum as the operator |0 0| c ⊗ G 1 ⊗ G 2,...,n . This guarantees that the overall Hamiltonian is degenerate and the transformation on each of its eigenspaces is where U O (t) is the transformation on the first qubits generated by H O (t)⊗G 2,...,n . Since we presented the constructions of the basic Clifford operations up to an overall phase, the operation U O (t) may differ from the desired operation by a phase. This phase can be corrected by applying a suitable gate on the control qubit from the "cat" state (we explain how this can be done in the next section). We remark that a Hamiltonian of the type (51) requires fine tuning of the parameter α(t) and generally can be complicated. In Sec. III F we will show that depending on the code one can find more natural implementations of these operations. If we want to apply a second conditional Clifford operation Q on the first qubits in the blocks, we can do this as follows. Imagine that if we had to apply the operation Q following the operation O, we would use the Hamiltonian ..,n is a suitable element of the stabilizer or the gauge group after the application of O. Before the application of O, that element would have had the form G ′ 1 ⊗ G ′ 2,...,n . Under the application of a conditional O, the element which can be used (with a minus sign) as a starting Hamiltonian for a subsequent operation. In particular, we can implement the conditional Q following the conditional O using the Hamiltonian where the factor β(t) guarantees that there is no splitting of the energy levels. Subsequent operations can be applied analogously. Using this general method, we can implement a unitary whose geometric part is equal to any transversal Clifford operation conditioned on the "cat" state.

D. Preparing and using the "cat" state
In addition to transversal operations, a complete fault-tolerant scheme requires the ability to prepare, verify and use a special ancillary state such as the "cat" state (|00...0 + |11...1 )/ √ 2. This can also be done in the spirit of the described holonomic scheme. Since the "cat" state is known and its construction is non-fault-tolerant, we can prepare it by simply treating each initially prepared qubit as a simple code (with G in Eq. (9) being trivial), and updating the stabilizer of the code via the applied transformation as the operation progresses. The stabilizer of the prepared "cat" state is generated by Z i Z j , i < j. Transversal unitary operations between the "cat" state and other codewords are applied as described in the previous sections.
We also have to be able to measure the parity of the state, which requires the ability to apply successive CNOT operations from two different qubits in the "cat" state to the same ancillary qubit initially prepared in the state |0 . We can regard a qubit in state |0 as a simple code with stabilizer Z , and we can apply the first CNOT as described before. Even though after this operation the state of the target qubit is unknown, the second CNOT gate can be applied via the same interaction, since the transformation in each eigenspace of the Hamiltonian is the same and at the end when we measure the qubit we project onto one of the eigenspaces.

E. Fault tolerance of the scheme
We saw how we can transform the code subsystem by any transversal operation adiabatically, which allows us, by a sequence of such operations, to generate a holonomy in the subsystem which is equivalent to any encoded gate. This was based on the assumption that the state has not undergone an error. But what if an error occurs on one of the qubits?
At any moment, we can distinguish two types of errors-those that result in transitions between the ground and the excited spaces of the current Hamiltonian, and those that result in transformations inside the eigenspaces. Due to the discretization of errors in quantum error correction, it suffices to prove correctability for each type separately.
The key property of the construction we described is that each of the eigenspaces undergoes the same transversal transformation. Because of this, if we are applying a unitary on the first qubit, an error on that qubit will remain localized regardless of whether it causes an excitation or not. If the error occurs on one of the other qubits, at the end of the transformation the result would be the desired single-qubit unitary gate plus the error on the other qubit, which is correctable.
We see that even though the Hamiltonian couples qubits in the same block, single-qubit errors do not propagate. This is because the coupling between the qubits amounts to a change in the relative phase between the ground and excited spaces, but the latter is irrelevant since either it is equivalent to a gauge transformation, or when we apply a correcting operation we project on one of the eigenspaces. In the case of the CNOT gate, an error can propagate between the control and the target qubits, but it never results in two errors within the same codeword.

F. FTHQC with the Bacon-Shor code using 3-local Hamiltonians
The weight of the Hamiltonians needed for the scheme we described depends on the weight of the stabilizer or gauge-group elements. Remarkably, certain codes possess stabilizer or gauge-group elements of low weight covering all qubits in the code, which allows us to perform holonomic computation using low-weight Hamiltonians. Here we will consider as an example a subsystem generalization of the 9-qubit Shor code [35]-the Bacon-Shor code [6,7]-which has particularly favorable properties for fault-tolerant computation [3,4]. In the 9-qubit Bacon-Shor code, the gauge group is generated by the weight-two operators Z k,j Z k,j+1 and X j,k X j+1,k , where the subscripts label the qubits by row and column when they are arranged in a 3 × 3 square lattice. Since the Bacon-Shor code is a CSS code, the CNOT gate has a direct transversal implementation. We now show that the CNOT gate can be realized using at most weight-three Hamiltonians.
If we want to apply a CNOT gate between two qubits each of which is, say, in the first row and column of its block, we can use as a starting Hamiltonian −Z t 1,1 ⊗ Z t 1,2 , where the superscript t signifies that these are operators in the target block. We can then apply the CNOT gate as described in the previous section. After the operation, however, this gauge-group element will transform to −Z t 1,1 ⊗ Z c 1,1 ⊗ Z t 1,2 . If we now want to implement a CNOT gate between the qubits with index {1, 2} using as a starting Hamiltonian the operator −Z t 1,1 ⊗ Z c 1,1 ⊗ Z t 1,2 according to the same procedure, we will have to use a four-qubit Hamiltonian. Of course, at this point we can use the starting Hamiltonian −Z t 1,2 ⊗ Z t 1,3 , but if we had also applied a CNOT between the qubits labelled {1, 3}, this operator would not be available-it would have transformed to −Z t 1,2 ⊗ Z t 1,3 ⊗ Z c 1,3 . What we can do instead, is to use as a starting Hamiltonian the operator −Z t 1,1 ⊗ Z t 1,2 ⊗ Z c 1,2 which is obtained from the gauge-group element Z t 1,1 ⊗ Z c 1,1 ⊗ Z t 1,2 ⊗ Z c 1,2 after the application of the CNOT between the qubits with index {1, 1}. Since the CNOT gate is its own inverse, we can regard the factor Z t 1,1 as G in Eq. (48) and use this starting Hamiltonian to apply the procedure backwards. Thus we can implement any transversal CNOT gate using at most weight-three Hamiltonians.
Since the encoded X, Y and Z operations have a bitwise implementation, we can always apply them according to the described procedure using Hamiltonians of weight 2. For the Bacon-Shor code, the encoded Hadamard gate can be applied via bitwise Hadamard transformations followed by a rotation of the grid by a 90 degree angle [4]. The encoded P gate can be implemented by using the encoded CNOT and an ancilla.
The preparation and measurement of the "cat" state can also be done using Hamiltonians of weight 2. To prepare the "cat" state, we prepare first all qubits in the state (|0 + |1 )/ √ 2, which can be done by measuring each of them in the {|0 , |1 } basis (this ability is assumed for any type of computation) and applying the transformation −Z → −X or Z → −X depending on the outcome. To complete the preparation of the "cat" state, apply a two-qubit transformation between the first qubit and each of the other qubits (j > 1) via the transformation Single-qubit transformations on qubits from the "cat" state can be applied according to the method described in the previous section using at most weight-two Hamiltonians.
To measure the parity of the state, we need to apply successively CNOT operations from two different qubits in the "cat" state to the same ancillary qubit initially prepared in the state |0 . This can also be done according to the method described in Sec. III D and requires Hamiltonians of weight 2.
For universal computation with the Bacon-Shor code, we also need to be able to apply one encoded transformation outside of the Clifford group. As we mentioned earlier, in order to implement the Toffoli gate or the π/8 gate, it is sufficient to be able to implement a CNOT gate conditioned on a "cat" state. For the Bacon-Shor code, the CNOT gate has a transversal implementation, so the conditioned CNOT gate can be realized by a series of transversal Toffoli operations between the "cat" state and the two encoded states. We will now show that this gate can be implemented using at most three-qubit Hamiltonians.
Ref. [27] provides a circuit for implementing the Toffoli gate as a sequence of one-and two-qubit gates. We will use the same circuit, except that we flip the control and target qubits in every CNOT gate using the identity where W i denotes a Hadamard gate on the qubit labelled by i and CX i,j denotes a CNOT gate between qubits i and j with i being the control and j being the target. Let Toffoli i,j,k denote the Toffoli gate on qubits i, j and k with i and j being the two control qubits and k being the target qubit, and let P i and T i denote the Phase and π/8 gates on qubit i, respectively. Then the Toffoli gate on three qubits (the first one of which we will assume to belong to the "cat" state), can be written as: To show that each of the above gates can be implemented adiabatically using Hamiltonians of weight at most 3, we will need an implementation of the CNOT gate which is suitable for the case when we have a stabilizer or gauge-group element of the form where the factor X acts on the target qubit and G acts trivially on the control qubit. By a similar argument to the one in Sec. III B 3, one can verify that in this case the CNOT gate can be implemented as follows: apply the operation P † on the control qubit (we describe how to do this for our particular case below) together with the transformation on the target qubit, followed by the transformation Since the second and the third qubits belong to blocks encoded with the Bacon-Shor code, there are weight-two elements of the initial gauge group of the form Z ⊗ Z covering all qubits. The stabilizer generators on the "cat" state are also of this type. Following the transformation of these operators according to the sequence of operations (56), one can see that before every CNOT gate in this sequence, there is an element of the form (57) with G = Z that can be used to implement the CNOT gate as described, provided that we can implement the gate P † on the control qubit. We also point out that all single-qubit operations on qubit 1 in this sequence can be implemented according to the procedure describes in Sec. III B 1, since at every step we have a weight-two stabilizer element on that qubit with a suitable form. Therefore, all we need to show is how to implement the necessary single-qubit operations on qubits 2 and 3. Due to the complicated transformation of the gauge-group elements during the sequence of operations (56), we will introduce a method of applying a single-qubit operation with a starting Hamiltonian that acts trivially on the qubit. For implementing single-qubit operations on qubits 2 and 3 we will use as a starting Hamiltonian the operator where the first factor (I i ) acts on the qubit on which we want to apply the operation (2 or 3), and X 1 ⊗ Z is the transformed (after the Hadamard gate R 1 ) stabilizer element of the "cat" state that acts non-trivially on qubit 1 (the factor Z acts on some other qubit in the "cat" state).
To implement a single-qubit gate on qubit 3 for example, we first apply the interpolation This results in a two-qubit transformation U 1,3 on qubits 1 and 3 in each eigenspace. We do not have to calculate this transformation exactly since we will undo it later, but the fact that each eigenspace undergoes the same two-qubit transformation can be verified similarly to the CNOT gate we described in Sec. III B 3. At this point, the Hamiltonian is of the form (10) with respect to qubit 3, and we can apply any single-qubit unitary gate V 3 according to the method described in Sec. III B 1. This transforms the Hamiltonian to −V 3 Z 3 V † 3 ⊗ Z 1 ⊗ Z. We can now "undo" the transformation U 1,3 by the interpolation The latter transformation is the inverse of Eq. (61) up to the single-qubit unitary transformation V 3 , i.e., it results in the transformation V 3 U † 1,3 V † 3 . Thus, the net result is which is the desired single-qubit unitary transformation on qubit 3. Note that during this transformation, a singlequbit error can propagate between qubits 1 and 3, but this is not a problem since we are implementing a transversal Toffoli operation and such an error would not result in more that one error per block of the code. We see that with the Bacon-Shor code the above scheme for fault-tolerant HQC can be implemented with at most 3-local Hamiltonians. This is optimal for this approach, because there are no non-trivial codes with stabilizer or gauge-group elements of weight smaller than 2 covering all qubits.

G. Effects on the accuracy threshold
Since the method we described conforms completely to a given fault-tolerant scheme, it would not affect the error threshold per qubit per operation for that scheme. However, the allowed errors per qubit per operation include both errors due to imperfectly applied transformations and errors due to interaction with the environment. It turns out that certain features of the method we described have an effect on the allowed distribution of these errors within the accuracy threshold.
First, observe that when applying the Hamiltonian (11), we cannot at the same time apply operations on the other qubits on which the factor G acts non-trivially. Thus, some operations at the lowest level of concatenation that would otherwise be implemented simultaneously might have to be implemented serially. The effect of this is equivalent to slowing down the circuit by a constant factor. (Note that we could also vary the factor G simultaneously with H(t), but in order to obtain the same precision as that we would achieve by a serial implementation, we would have to slow down the change of the Hamiltonian by the same factor.) The slowdown factor resulting from this loss of parallelism is usually small since this problem occurs only at the lowest level of concatenation. It can be verified that for the Bacon-Shor code, we can apply operations on up to 6 out of the 9 qubits in a block simultaneously. For example, when applying encoded single-qubit operations, we can address simultaneously any two qubits in a row or column by taking G to be a single-qubit operator Z or X on the third qubit in the same row or column. The Hamiltonians used to apply operations on the two qubits commute with each other at all times and do not interfere. A similar phenomenon holds for the implementation of the encoded CNOT gate or the operations involving the "cat" state. Thus, for the Bacon-Shor code we have a slowdown due to parallelism by a factor of 1.5.
A more significant slowdown results from the fact that the evolution is adiabatic. In order to obtain a rough estimate of the slowdown due specifically to the adiabatic requirement, we will compare the time T h needed for the implementation of a gate according to our method with precision 1 − δ to the time T d needed for a dynamical realization of the same gate with the same strength of the Hamiltonian. We will consider a realization of the X gate via the unitary interpolation where τ (0) = 0, τ (T h ) = T h . The energy gap of this Hamiltonian is constant. The optimal dynamical implementation of the same gate is via the Hamiltonian −X for time T d = π 2 . As we argued in Sec. III B 2, the accuracy with which the adiabatic approximation holds for the Hamiltonian (64) is the same as that for the Hamiltonian We now present estimates for two different choices of the function τ (t). The first one is In this case the Schrödinger equation can be easily solved in the instantaneous eigenbasis of the Hamiltonian (65). For the probability that the initial ground state remains a ground state at the end of the evolution, we obtain where Expanding in powers of ε and averaging the square of the cosine whose period is much smaller than T h , we obtain the condition Assuming, for example, that δ ≈ 10 −4 (approximately the threshold for the 9-qubit Bacon-Shor code [4]), we obtain that the time of evolution for the adiabatic case must be about 70 times longer than that in the dynamical case. It is known, however, that if H(t) is smooth and its derivatives vanish at t = 0 and t = T h , the adiabatic error decreases super-polynomially with T h [17]. To achieve this, we will choose For this interpolation, by a numerical solution we obtain that when T h /T d ≈ 17 the error is already of the order of 10 −6 , which is well below the threshold values obtained for the Bacon-Shor codes [4]. This is a remarkable improvement in comparison to the previous interpolation which shows that the smoothness of the Hamiltonian plays an important role in the performance of the scheme. An additional slowdown in comparison to a perfect dynamical scheme may result from the fact that the constructions for some of the standard gates we presented involve long sequences of loops. With more efficient parameter paths, however, it should be possible to reduce this slowdown to minimum.
In comparison to a dynamical implementation, the allowed rate of environmental noise for the holonomic case would decrease by a factor similar to the slowdown factor. In practice, however, dynamical gates are not perfect and the holonomic approach may be advantageous if it allows for a better precision.
We finally point out that an error in the factor H(t) in the Hamiltonian (11) would result in an error on the first qubit according to Eq. (24). Such an error clearly has to be below the accuracy threshold. More dangerous errors, however, are also possible. For example, if the degeneracy of the Hamiltonian is broken, this can result in an unwanted dynamical transformation affecting all qubits on which the Hamiltonian acts non-trivially. Such multi-qubit errors have to be of higher order in the threshold, which imposes more severe restrictions.

IV. CONCLUSION AND OUTLOOK
In this chapter we saw that HQC can be made fault tolerant by combining it with the techniques for fault-tolerant quantum error correction on stabilizer codes. This means that HQC is, at least in principle, a scalable method of computation. However, further research is needed in order to bring the presented ideas closer to experimental realization.
We presented a scheme which uses Hamiltonians that are elements of the stabilizer or the gauge group of the code. We saw that with the Bacon-Shor code, this scheme can be implemented with 2-and 3-qubit Hamiltonians. Since the scheme conforms completely to a given dynamical fault-tolerant scheme and does not require the use of extra qubits, it has the same error threshold as the dynamical scheme on which it is based. However, due to the fact that adiabatic gates are slower than dynamical gates and that at the lowest concatenation level this scheme requires certain gates to be implemented serially or more slowly, the allowed error threshold for environmental noise is lower in comparison to a dynamical scheme. The factor by which this threshold decreases depends on how smooth the adiabatic interpolations are, but it seems to be at most ∼ 10 2 . Therefore, if the robustness provided by the geometric nature of the gates is sufficiently higher than that achievable by dynamical means, this approach could be advantageous in comparison to dynamical schemes. The main challenge in the implementation of this is approach, however, is that it requires the engineering of 3-local Hamiltonians. An alternative scheme for fault-tolerant HQC that uses Hamiltonians independent of the code at the expense of additional qubits [29] has been proven to allow reducing the locality of the Hamiltonian with perturbative gadget techniques, showing that 2-local Hamiltonians are universal for fault-tolerant HQC. The disadvantage of using the gadgets is that they decrease the gap of the Hamiltonian by a very large factor, which requires a significant slowdown of the computation and decreases the allowed rate of environment noise.
Applying the strategies we have described to actual physical systems will undoubtedly require modifications in accordance with the available interactions in those systems. A possible way of avoiding the use of multi-local Hamiltonians without the use of perturbative gadgets could be to use higher-dimensional systems (e.g., qutrits) between which two-local interactions are naturally available. It may be possible to encode qubits in subspaces or subsystems of these higher-dimensional systems and use fault-tolerant techniques designed for stabilizer codes based on qudits [16]. Given that simple quantum error-correcting codes and two-qubit geometric transformations have been realized using NMR [13,18] and ion-trap [12,24] techniques, these systems seem particularly suitable for hybrid HQC-QEC implementations.
Finally, it is interesting to point out that the adiabatic regime in which the holonomic schemes operate is consistent with the Markovian model of decoherence. In Ref. [2] it was argued that the standard dynamical paradigm of fault tolerance is based on assumptions that are in conflict with the rigorous derivation of the Markovian limit. Although the threshold theorem has been extended to non-Markovian models [1, 5,36], the Markovian assumption is an accurate approximation for a wide range of physical scenarios [11] and allows for a much simpler description of the evolution in comparison to non-Markovian models (see Chapter 8). In Ref. [2] it was shown that the weak-coupling-limit derivation of the Markovian approximation is consistent with computational methods that employ slow transformations, such as adiabatic quantum computation [14] or HQC. A theory of fault-tolerance for the adiabatic model of computation at present is not known, although steps in this direction have been undertaken (see Refs. [19,25]). The hybrid HQC-QEC schemes presented here provide solutions for the case of HQC. However, we point out that it is an open problem whether the Markovian approximation makes sense for a fixed value of the adiabatic slowness parameter when the circuit increases in size. Giving a definitive answer to this question requires a rigorous analysis of the accumulation of non-Markovian errors due to deviation from perfect adiabaticity.
The techniques described in this chapter may prove useful in other areas as well. It is possible that some combination of transversal adiabatic transformations and active correction could provide a solution to the problem of fault tolerance in the adiabatic model of computation.