# Fault-tolerant quantum computation

with asymmetric Bacon-Shor codes

###### Abstract

We develop a scheme for fault-tolerant quantum computation based on asymmetric Bacon-Shor codes, which works effectively against highly biased noise dominated by dephasing. We find the optimal Bacon-Shor block size as a function of the noise strength and the noise bias, and estimate the logical error rate and overhead cost achieved by this optimal code. Our fault-tolerant gadgets, based on gate teleportation, are well suited for hardware platforms with geometrically local gates in two dimensions.

###### pacs:

03.67.Pp## I Introduction

The theory of fault-tolerant quantum computation shor1996fault (); gottesman2009introduction () has established that noisy quantum computers can operate reliably provided the noise is neither too strong nor too strongly correlated. In a fault-tolerant quantum circuit, carefully designed gadgets process logical qubits protected by quantum error-correcting codes.

Typical fault-tolerant gadgets are designed to work effectively against generic noise without any special structure. But in some physical settings, the noise is expected to be highly biased, with dephasing in the computational basis far more likely than bit flips. This paper addresses how noise bias can be exploited to improve the reliability of fault-tolerant quantum circuits.

Specifically, we have in mind a setting in which, to an excellent approximation, the computational basis states are the energy eigenstates for an unperturbed qubit, and single-qubit gates which are diagonal in this basis can be performed by adiabatically adjusting the energy splittings between these states. Similarly, diagonal two-qubit gates are performed by adjusting the energy splittings of the four (approximate) energy eigenstates . Various noise sources may induce fluctuations in these energy spacings, and pulse imperfections may cause gates to be over-rotated or under-rotated; in either case the noisy gate deviates from the ideal gate, but remains diagonal. Other physical processes may induce transitions between energy eigenstates, but we will assume that this non-diagonal noise is far weaker than the dominant diagonal noise.

Our scheme for fighting biased noise is based on asymmetric Bacon-Shor codes Shor95 (); Bacon06-2 (); napp2012optimal (). These quantum codes combine together a length- repetition code protecting against dephasing and a length- repetition code protecting against bit flips; by “asymmetric” we mean , so the code works more effectively against dephasing than against bit flips. A complete universal set of fault-tolerant gates can be constructed using only diagonal gates, plus single-qubit measurements in the eigenstate basis and preparation of single-qubit states.

In most previous studies of quantum fault-tolerance based on Bacon-Shor codes, these codes have been concatenated to build a hierarchy of codes within codes aliferis2007subsystem (); Cross07 (). Here we will mainly study the performance of a single large block code rather than a concatenated scheme. For the Bacon-Shor code family, used without concatenation, there is no accuracy threshold; rather, for a fixed value of the noise strength and noise bias, there is an optimal block size which achieves the best performance.

Our gadget constructions and analysis extend the results in Aliferis08 (); Aliferis09 (), where the case was regarded as the bottom layer of a concatenated code. In contrast to Aliferis08 (); Aliferis09 (), we consider the case where the gates are required to be geometrically local in a two-dimensional array. In the geometrically local case, logical blocks can be transported as needed via teleportation, with the fundamental operations still limited to diagonal gates, measurements, and preparations.

We have obtained upper bounds on the optimal performance and overhead cost of logical gates by deriving analytic formulas, and our estimates are far from tight. We expect that significantly better results could be obtained using numerical simulations assuming independent biased noise, which we have not attempted. In particular, our analysis includes quite conservative estimates of the probability of failure for preparations of cat states that are used for measurements of logical Pauli operators.

Another particularly attractive approach to achieving quantum fault tolerance with geometrically local gates is based on topological codes dennis2001topological (); raussendorf2007topological (); fowler2009high (), which unlike Bacon-Shor codes have an accuracy threshold and hence can reach arbitrarily low error rates per logical gate. Topological codes can be adapted for optimized protection against biased noise, and they perform well against biased noise even without any such adaptation. Our current results do not conclusively identify noise parameter regimes for which Bacon-Shor codes are clearly superior to topological codes. However, our scheme has several appealing features — for example, the optimal error rate per logical gate is achieved with a relatively modest number of physical qubits per code block, and is not too adversely affected when qubit measurements are noisier than quantum gates. Furthermore, only relatively modest classical computational resources are needed to interpret error syndromes.

We review Bacon-Shor codes in Sec. II, describe our biased noise model in Sec. III, and construct our fault-tolerant gadgets in Sec. IV. We obtain upper bounds on the performance of our fault-tolerant logical CNOT gate in Sec. V, repeat the analysis in Sec. VI for the case where two-qubit gates are required to be geometrically local, and report numerical values in Sec. VII. In Sec. VIII and IX we discuss the state injection and state distillation procedures needed to complete our fault-tolerant universal gate set.

Fault-tolerant gadgets protecting against biased noise have also been discussed previously in Gourlay00 (); Evans07 (); Stephens08 ().

## Ii Bacon-Shor codes

Bacon-Shor codes are quantum subsystem codes which are constructed by combining together two quantum repetition codes, one protecting against (phase) errors and the other protecting against (bit flip) errors. We will consider using Bacon-Shor codes to protect quantum information against biased noise, such that errors are much more common than errors; therefore, the length of the code protecting against errors will be longer than the length of the code protecting against errors. In this case we say that the code is asymmetric. The code protects one encoded qubit in a block of physical qubits.

It is convenient to arrange the physical qubits in a rectangular lattice with rows and columns. The code has -type stabilizer generators, or check operators, which can be measured to determined a syndrome for detecting errors, and -type stabilizer generators, which can be measured to determine the syndrome for errors. Each -type check operator is a weight- operator applying to each qubit in a pair of adjacent rows, and each -type check operator is a weight- operator applying to each qubit in a pair of adjacent columns. Because each -type check operator “collides” with each -type check operator at four lattice sites, the -type and -type check operators are mutually commuting and can be measured simultaneously. The logical Pauli operator acting on the encoded qubit is a tensor product acting on all the qubits in a (long) row; all rows are equivalent because a product of two such row operators is in the code stabilizer. The operator collides with each -type check operator at two sites; therefore it commutes with these check operators and hence preserves the code space. The logical Pauli operator is a tensor product acting on all qubits in a (short) column; again the columns are equivalent, and commutes with the -type check operators. The operators and collide at a single site and hence anticommute.

Assuming that and are both odd, the code can correct errors and errors. To perform a decoded measurement, we can measure all qubits in the basis, compute the parity of the outcomes for each of the columns, and then perform a majority vote on the column parities. The decoded measurement fails only if columns each have at least one errors. Similarly, we can perform a decoded measurement by measuring all qubits in the basis, computing the parity of the outcomes for each of the rows, and then performing a majority vote on the row parities. This decoded measurement fails only if rows each have at least one error.

The code also has a gauge algebra of Pauli operators that commute with the check operators and with the logical operators, though the gauge operators do not necessarily commute with one another. The -type gauge algebra is generated by weight-two operators with acting on a pair of neighboring qubits in the same column, and the -type gauge algebra is generated by weight-two operators with acting on a pair of neighboring qubits in the same row. Thus each -type check operator is a product of weight-two gauge operators, and each -type check operator is a product of weight-two gauge operators. Conveniently, then, the error syndrome can be determined by measuring only weight-two gauge operators, and furthermore each of these gauge operators is geometrically local, acting on a pair of neighboring qubits. Measuring an -type gauge operator disturbs the values of some -type gauge operators (and vice versa), but without inflicting any damage on the protected logical subsystem.

## Iii Noise model

We consider a local stochastic biased noise model, in which we distinguish between a rate for dephasing faults and a (perhaps much lower) rate for general faults in diagonal gates. The ratio will be called the noise bias. For simplicity we will assume that is also the error rate for single-qubit preparations and measurements in most of the formulas we display, though we will treat the case where preparations and measurements are noisier than diagonal gates in Sec. VII.3. A dephasing fault, which we will also call a diagonal fault, is a trace-preserving completely positive map such that all Kraus operators are diagonal in the computational basis; for a general fault, which we will also call a non-diagonal fault, the Kraus operators are unrestricted. We assume that the sum of the probabilities for all fault paths with dephasing faults and non-dephasing faults at specified circuit locations is no greater than .

## Iv Fault-tolerant gadgets

The construction of fault-tolerant gadgets for universal quantum computation follows Ref. Aliferis08 (). We implement the logical gate set

(1) |

using the physical gate set

(2) |

here , denote measurements of the Pauli operators and , , denote preparations of the and eigenstates with eigenvalue , and CZ denotes the two-qubit controlled phase gate

(3) |

which is diagonal in the computational (-eigenstate) basis with eigenvalues . A diagonal gate like this one can be realized by adiabatically perturbing the energy splittings of the computational basis states, and hence could plausibly have highly biased noise. Note that we have not included in the physical gate set Eq. (2), because it will not be needed in our fault-tolerant gadget constructions.

The CZ gate acts symmetrically on the two qubits, and, like any Clifford gate, it can be usefully characterized by how it propagates Pauli errors:

(4) |

Of course, CZ commutes with acting on either qubit, and propagates an acting on either qubit to a error acting on the other. These properties are nice if errors dominate over errors and we use a code that corrects errors more effectively than errors. The gates do not propagate the relatively common errors, and though errors do propagate they are transformed to errors, which the code handles more readily.

To achieve universal quantum computation, we supplement the logical gate set with high-fidelity encoded states and , which can be prepared using state injection and distilled using the operations Bravyi08 (). Gates that complete a universal set can then be constructed using these states and the gates Knill05 ().

### iv.1 gadget

To perform a destructive measurement we first perform independent measurements on all qubits in the code block, and then compute the parity of the measurement outcomes in each column. Finally a majority vote of the column parities yields the logical measurement outcome. The result agrees with an ideal measurement if the sum of the number of errors in the block and the number of faulty measurements is no larger than .

### iv.2 gadget

If were included in our repertoire of physical gates, then we could perform a destructive using the dual of the procedure described above for the destructive . That is, we could perform independent measurements on all qubits in the code block, compute the parity of the measurement outcomes in each row, and perform a majority vote of the row parities to obtain the logical measurement outcome. The result agrees with an ideal measurement if the sum of the number of errors in the block and the number of faulty measurements is no larger than .

However, for our fault-tolerant gadget constructions we will require instead a non-destructive measurement, such that the ideal measurement procedure leaves encoded eigenstates intact. In principle a non-destructive measurement of the row parity could be done by preparing a single ancilla qubit in the state , performing CZ gates in succession acting on the ancilla qubit and the qubits in the row, and finally measuring the ancilla qubit in the basis. However, this procedure is not fault-tolerant for two reasons. First, a single error acting on the ancilla qubit can flip the measurement outcome. Second, a single error acting on the ancilla can propagate multiple times, producing a high-weight error acting on the qubits in the row.

This second problem can be addressed by replacing the single-qubit ancilla by an -qubit cat state , so that each ancilla qubit interacts via a CZ gate with only one data qubit, limiting the error propagation. The fault-tolerant preparation of the cat state is discussed below. After the CZ gates, the cat state is read out in the basis to determine the row parity. This measurement of is performed destructively by measuring each of the ancilla qubits in the basis and computing the parity of the outcomes.

To address the first problem (that a single fault can flip the measured parity), the parity measurement is repeated times for each row, each time with a fresh cat state, and the majority of the results is computed. The repetition provides protection against errors in the ancilla, but of course there may also be (relatively rare) errors acting on the data qubits due to faults during the measurement circuit. These faults cause a logical error only if errors occur in a majority of the rows.

Actually, we find that, depending on the rates for diagonal and non-diagonal faults, it may be advantageous to use a shorter ancilla prepared in a cat state of length , where . In that case some ancilla qubits interact with more than one data qubit, increasing the danger of error propagation, but on the other hand errors are less likely to occur during the preparation of the (shorter) cat state. However, using a length- cat state has the significant advantage that the measurement can be conveniently executed using geometrically local gates on the two-dimensional lattice, as we will discuss in Sec. VI.

This procedure for measuring can easily be extended to build gadgets that perform the parity measurements , on multiple logical qubits.

### iv.3 Cat state preparation

The length- cat state may be characterized as the simultaneous eigenstate with eigenvalue 1 of and of operators, each one acting on a pair of neighboring qubits. To prepare the cat state, we start by preparing the product state (an eigenstate of ), and proceed to measure the operators (each of these measurements is executed using yet another ancilla qubit). If every measurement has the outcome , then the cat state has been prepared successfully, assuming the measurements are flawless. Otherwise, the measurement outcomes provide a syndrome pointing to errors in the cat state (each outcome identifies the endpoint of a chain of errors). These errors in the cat state need not be corrected; instead we can keep track of their propagation as the computation proceeds. Specifically, the errors in the cat state propagate to become errors acting on the measured row of the data block, which should be taken into account when we decode a later measurement of that block. Following Knill Knill05 (), we say that the measured syndrome is used to update the “Pauli frame” of the computation.

To improve robustness, we add one more (redundant) measurement acting on the first and last qubit in the cat state. Then an even number among the measurements should have the outcome if all measurements are correct; if in fact we find an odd number of outcomes than we reject the syndrome. (Adding further redundant checks would further improve the reliability of the syndrome extraction, though we will not include these.) We conduct rounds of syndrome measurement, including rejected rounds, so that the number of accepted rounds may be fewer than .

In principle, the cat state Pauli frame could be determined by performing a perfect matching on a two-dimensional graph representing the space-time history of the cat state syndrome measurement dennis2001topological (). Instead, we will consider a much simpler and less effective method for decoding the syndrome history. Though far from optimal, our procedure has two advantages over the perfect matching algorithm — it requires only very modest (classical) computational resources compared to perfect matching, and it is also much easier to study analytically.

In our unsophisticated scheme, we determine the Pauli frame using whichever syndrome occurs most frequently among the accepted rounds, which we call the “winning” syndrome. (Our analysis does not depend on what rule is used when two or more syndromes tie for the distinction of being most frequent, since we pessimistically assume that the preparation gadget fails catastrophically in the event of such a tie.) The state preparation protocol is deterministic in the sense that ancillas are never discarded, and the number of rounds of syndrome measurement is always irrespective of the measurement outcomes.

The complete circuit for measuring the row parity, including repeated measurement of the cat state syndrome, is shown in Fig. 3. In the circuit shown, the cat state is prepared first, and then used to measure the parity of a row. Since the CZ gates commute with each other, we could alternatively perform the measurements on the cat state after the ancilla interacts with the data.

Even if the cat state is “prepared” after its “use,” errors in the ancilla during the preparation can still cause trouble. The errors cause the cat state syndrome to evolve as it is measured repeatedly, and therefore the syndrome that occurs most often, even if valid when measured, may differ from the syndrome that is applicable when the cat state interacts with the data. The effect of this syndrome “drift” needs to be included in our error analysis.

### iv.4 gadget

The logical state , for a particular “choice of gauge,” is a product of length- cat states, one for each column of the block. This state is an eigenstate with eigenvalue of acting on any column, and of the gauge operator acting on a pair of neighboring qubits in any column (and hence also a +1 eigenstate of all the -type check operators). We prepare these length- cat states in parallel, using the same procedure for preparing length- cat states described above. In this case we repeat the syndrome measurement for each column times.

### iv.5 Error correction gadget

Error correction can be performed on a logical block using the “one-bit teleportation” gadget shown in Fig. 4. This circuit transfers the single-qubit state from qubit 2 to qubit 1. We prepare qubit 1 in the state , perform the joint measurement on the two qubits, then perform the single-qubit measurement . After applying Pauli operators conditioned on the two measurement outcomes, the result is that the input state of qubit 2 is moved to qubit 1. The conditional and gates in this teleportation gadget need not actually be executed; instead the Pauli frame is updated to reflect the measurement outcomes. One-bit teleportation can be performed at the logical level using the fault-tolerant measurement gadgets and that we have already described.

### iv.6 Cnot gadget

The gadget shown in Fig. 5 applies a fault-tolerant “teleported” CNOT logical operation, up to a known Pauli error determined by the measurement outcomes Aliferis08 (). Aside from executing the logical gate, the gadget also achieves error correction by measuring both incoming blocks and preparing fresh outgoing blocks.

To better understand how the gadget works, it is helpful to divide it into two parts. One part is the “one-bit teleportation” gadget described in Sec. IV.5, which performs error correction on a single block. The other component of the CNOT gadget is shown in Fig. 6, where again the Pauli frame updates are explicitly indicated. We may verify that this circuit realizes a CNOT gate by checking that it propagates Pauli operators according to the rule

(5) |

We denote the measurement outcomes of and as and respectively. Since is an eigenstate of with eigenvalue , acting on the input qubits is equivalent to acting on the three qubits in the circuit, which commutes with and hence becomes acting on the output qubits. Likewise, acting on the input qubits is equivalent to , which commutes with and becomes acting on the output qubits using the measurement outcome . acting on the input qubits commutes with and trivially maps to acting on the output qubits, while acting on the input qubits becomes , which maps to using the measurement outcome . Hence we have found

which is corrected to Eq.(IV.6) by applying to both output qubits and to the second qubit. When we combine the CNOT gate with one-bit teleportation of the first qubit, the measurements and commute and hence can be done in either order.

Four different versions of the CNOT gadget are shown in Fig. 5 Let us denote the blocks appearing in the figure as blocks 1, 2, 3, 4, counting from the top down. Version of the CNOT gadget contains the preparations and measurements , , , , , . This gadget has some arbitrary features which are exploited to construct the other versions. Since , we extract the same parity information if is replaced by ; also, since acts symmetrically on its two measured blocks, we may permute the blocks, in effect replacing and by and , thus obtaining version . Similarly, since acts symmetrically, we may replace and by and , thus obtaining versions and . In all these realizations of the gadget, the upper incoming block is the control block and the lower incoming block is the target block; by replacing and by and we can reverse the order of the CNOT.

This freedom to choose the incoming control block to be either block 1 or block 2, and to choose the incoming target block to be either block 3 or block 4, will be useful when we consider in Sec. VI how to realize the CNOT gadget using geometrically local gates. No matter how we configure the gadget, one block participates in both and . However, for versions and in Fig. 5, the twice measured block is an incoming (control) data block, while for versions and the twice measured block is an outgoing (control) data block.

The CNOT gadget is characterized by four parameters: the length of the cat states used in the -type measurements and the number of times measurements are repeated ( for the preparation, for the cat state preparation, and for and measurements). In principle we could choose different values of these parameters in the measurements and , but in practice we have found it optimal or near optimal to use the same parameters for both.

### iv.7 Scheduling

If geometrically nonlocal gates are allowed, and fresh ancilla qubits are always available on demand, then we can schedule the CZ gates so that no data qubit or ancilla qubit is idle during any time step. We assume that a preparation, measurement, or CZ gate can be performed in a single time step. Suppose, for example, that we use the gadget design in Fig. 5b, where the outgoing control data block participates in both and , and let us also assume that the [12] cat states have length while the [234] cat states have length , matching the weight of the measured operators. We label the ancilla registers used to measure a row operator times by for the measurement and by for the measurement. Suppose that is completed in time step -1 and that is completed in time step 0. Then the CZ gates are scheduled as follows: The ancilla interacts with block 2 in time step and with block 1 in time step , while the ancilla interacts with blocks 2, 3, and 4 in time state . Hence processing of the incoming blocks (1 and 4) begins in time step , and processing of the outgoing blocks (2 and 3) ends in time step .

The “preparation” of the [234] ancilla begins in time step , but the “preparation” of the [12] ancilla is “staggered.” The syndrome measurement for the first qubits in ancilla (those that interact with block 1) begins in time step , while the syndrome measurement for the last qubits (those that interact with block 2) begins one step earlier (step ). Despite this one time step delay, no qubits are ever idle — the ancilla qubit used to measure syndrome bit in cat state interacts with cat state qubit in time step and interacts with cat state qubit in time step . Meanwhile, the ancilla qubit used to measure the syndrome bit in cat state interacts with cat state qubit in time step and with cat state qubit 1 in time step , etc.

If instead we use the CNOT gadget design in Fig. 5a, where the incoming control data block participates in both and , the processing of the data blocks is not perfectly synchronized. If is performed first, then the incoming and outgoing control blocks are one time step ahead of the incoming and outgoing target blocks, while if is performed first it is the other way around. Thus if the incoming control block is either one step ahead or one step behind the incoming target block, we can perform the CNOT without leaving any qubits idle, while maintaining the one-step lag between the blocks. But if the two incoming blocks are synchronized, then using the gadget in Fig. 5a one block or the other would have to wait for one time step before the processing of the block begins.

### iv.8 Injection by teleportation

To complete a universal set of protected gates, we will use the magic state distillation procedure introduced by Bravyi and Kitaev Bravyi08 (). First we inject non-Clifford states into the code block using teleportation, then we improve the fidelity of these encoded states via distillation. The distillation protocol is discussed further in Sec. IX; here we briefly describe the state injection procedure, with further details postponed until Sec. VIII.

The state injection makes use of the “one-bit teleportation” circuit depicted in Fig. 4. To inject a state into the Bacon-Shor block, first the state is prepared using a single physical qubit, while a logical block is prepared in the state . Then the weight- operator is measured on the single qubit and a single row of the block, and finally the single qubit is measured in the basis. This procedure prepares the block in the state , up to a logical Pauli operator known from the measurement outcomes.

There are other possible injection procedures, but this one is particularly simple. A single fault in the circuit can cause failure.

## V Effective error strength

The CNOT gadget may produce a logical error if any one of its four measurements deviates from the ideal case. To estimate the failure probability for the CNOT gadget, we must enumerate the ways in which these measurements might fail.

One potential source of trouble is the preparation of cat states and the logical states. Recall that in these preparation gadgets a syndrome is measured repeatedly, and that the “winning” (i.e., most frequently occurring) syndrome measurement result is used to update the Pauli frame. This winning syndrome might differ from the syndrome that would have been inferred in an ideal gadget because of repeated errors that induce errors in the syndrome measurement, because of errors that cause the syndrome to evolve between rounds, or because of some combination of the two. We say that the preparation gadget “succeeds” if the winning syndrome matches the syndrome that could have been obtained by an ideal measurement at some stage during the multiple rounds of syndrome measurement, and if furthermore fewer than half of the cat state qubits are afflicted by errors during the preparation process. Otherwise the preparation gadget “fails.”

Failure of a preparation gadget can be catastrophic, because the inferred Pauli frame may differ from the actual Pauli frame by a high-weight -type error. If it occurs in a cat state, this high-weight error could propagate to the data, causing a logical error. If it occurs in the preparation of a logical block, the error could flip the value of a subsequent -type logical measurement.

On the other hand, even if a cat state preparation succeeds, the winning syndrome might not coincide perfectly with the ideal syndrome that applies to the cat state at the time it interacts with the data. The syndrome may drift due to errors that accumulate during the many rounds of syndrome measurement. However, the inferred Pauli frame differs from the ideal Pauli frame by a number of errors that is no larger than the number of non-diagonal faults that occur inside the preparation gadget. Though the inferred Pauli frame may not be exactly right, it is not catastrophically wrong unless there are many errors in the circuit.

Aside from errors in the measured cat state syndrome, a or could be faulty because of errors acting on the cat state qubits, which flip the outcomes of row measurements. Because each row measurement is repeated times, multiple errors are required for a row measurement to fail. Alternatively, an error acting on a data qubit could flip the outcome of a row measurement. Because a majority vote is performed on row measurement outcome, again multiple errors are required for the logical -type measurement to fail. An could be faulty because of errors on data qubits, which flip outcomes of subsequent measurements on those qubits. Because a majority vote is performed on the column parities, multiple errors are required for the to fail.

In estimating the failure probability for , , or , we need to take into account possible faults in circuit locations preceding the CNOT gadget, which might cause these measurements to deviate from their ideal outcomes. In our fault-tolerant scheme, a logical CNOT gate is either preceded by teleportation into the code block or by another CNOT gate; in the worst case, each input block to the CNOT gadget is an output block from an immediately preceding CNOT gadget. Thus, in the preceding gadget, each block is prepared in the state , and then subjected to either and (if it is the control block of the CNOT gadget) or just (if it is the target block of the CNOT gadget).

### v.1 Measurement failure

We will assume that failure of any of its preparation gadgets will cause the CNOT to fail, and we denote by the failure probability for a logical measurement due to a cause other than failure of a preparation gadget. Thus, the failure probability for the CNOT can be bounded as

(7) |

The last term accounts for preparation errors that may have occurred in a or immediately preceding the current CNOT gadget, acting on either one of the two input blocks to the current gadget. In the worst case, both incoming blocks were control blocks in the preceding CNOT gadgets, and were therefore subjected to both and . The coefficient of is 4 rather than 2 for a similar reason — the logical measurement outcomes in the current CNOT gadget may differ from ideal outcomes due to errors in the preparation of logical blocks either in the current gadget or in one of the two preceding gadgets.

Before considering the probability of a preparation failure, let us estimate for each of the three types of logical measurements. For an measurement to fail, more than half of the length- columns must each have at least one error. In the worst case, each qubit in the block participates in circuit locations: a preparation, a measurement, CZ gates contained in the preparation of the logical state, CZ gates in the logical measurement in the current gadget, and CZ gates in two logical measurements in the preceding gadget. Each of these locations could be faulty with probability , since either a diagonal of non-diagonal fault could produce a phase error.

For the moment, let us assume for simplicity that the cat state has length for the measurement and length for the measurement, so that no ancilla qubit interacts with more than one data qubit. (We will consider the case where the cat state is shorter in Sec. V.3.) Because the preparation of the cat state actually occurs after the ancilla interacts with the data, we do not need to worry about errors arising in the cat state preparation propagating directly to the data. We do need to worry that the Pauli frame inferred from the “winning” syndrome after rounds of syndrome measurement actually differs from the ideal Pauli frame. However, assuming that the syndrome is decoded correctly (as it will be if the preparation succeeds), a Pauli frame error afflicts a qubit only if at least one error acted on that qubit during the multi-round syndrome measurement. The probability of such a Pauli-frame error on any qubit in the cat state is therefore bounded above by , since two CZ gates act on each qubit in each round of syndrome measurement, and the syndrome measurement is repeated times in the cat state preparation. Because each row measurement is repeated times, the total probability that a row measurement fails due to a Pauli-frame error in a cat state is bounded above by . Furthermore, in the worst case there are three logical measurements between the preparation and measurement of the block, in each of which a cat state interacts with the data.

Combining together the probability per qubit of a error caused directly by a fault with the probability of a error that propagates from the cat state, we conclude that the error probabilities for the measurements can be bounded as

(8) |

As explained in Sec. IV.7, there are no time steps in which “resting” qubits are subject to “storage errors.”

For the to fail, more than half of the weight- row parity measurements must have errors. An error acting on any one of the qubits in the same row of the two blocks, either before or during the measurement, could flip the parity of the row. Before the is completed, each qubit participates in CZ gates during the operation, CZ gates during the , and in the worst case another CZ gates during the and in the preceding CNOT gadget. Thus the probability per qubit of a non-diagonal error is . There might also be an -type Pauli frame error in the preparation, but we do not have to count that separately; if the preparation “succeeds,” then a Pauli-frame error afflicts a qubit in the block only if a non-diagonal fault damaged that same qubit during the preparation circuit.

In the absence of non-diagonal faults, the row parity measurement might still fail because at least one error acts on the cat state in each of of the repeated measurements. If the cat state has length , then in each repetition of the measurement there are circuit locations ( CZ gates coupling the ancilla to the data, plus qubit preparations, qubit measurements and CZ gates for the cat state preparation). We conclude that the failure probability can be bounded as

(9) |

Similarly,

(10) |

(The is preceded by a acting on one of its input blocks inside the current CNOT gadget, plus additional -type logical measurements in the preceding CNOT gadgets acting on another one of its input blocks.)

### v.2 Cat state preparation failure

Now it remains to estimate the probability of failure for the cat state and the logical state . Recall that the preparation fails if the syndrome measurement is faulty in every round that yields the “winning” syndrome outcome. The faults can be either non-diagonal or diagonal, but there must be at least two faults; otherwise only one syndrome bit would be wrong, the result would fail the parity test, and the syndrome would be rejected. (A round with a single non-diagonal fault might be accepted if the fault flips a syndrome bit while also simultaneously applying an error to one of the cat state qubits, which flips a second syndrome bit measured in the following step. However, in this case the measured syndrome matches the actual cat state syndrome at the end of the round, and therefore is not counted as a failure.)

Suppose that the winning syndrome occurs times, and that there are additional rounds that each contain at least one fault (some of these rounds might be rejected). Suppose that non-diagonal faults occur in of the rounds of syndrome measurement; these faults can alter the syndrome. There are rounds without any faults, and the number of distinct syndromes detected in these rounds is at most .

Now we can use the pigeonhole principle to obtain a lower bound on , expressed in terms of , , and . There are at most valid syndromes that can occur in syndrome measurement rounds that have no faults. Combining these with the winning syndrome, there are at most possible syndromes that can occur in the accepted rounds which either have no faults or produce the winning outcome. Of these syndromes, the winning syndrome must occur at least as many times as any other syndrome; hence

(11) |

where denotes the smallest integer greater than or equal to .

To bound , we sum over and in each cat state preparation step, estimating the number of possible fault histories using the upper bound Eq. (11) on . In the first of the winning rounds, a particular winning syndrome is found, which differs in at least two bits from the actual syndrome in the beginning of that round. Then this same syndrome is found again in each of the remaining winning rounds. The sum over all possible winning syndromes, weighted by their probabilities, is bounded above by the probability that at least two measured syndrome bits are faulty in the first of the winning rounds. Each measurement is performed using one preparation, two gates, and one measurement; therefore the probability of error in the measurement of a single syndrome bit is bounded above by , and the probability that at least two syndrome bits are in error is bounded above by .

In each of the rounds that contain errors, we must sum over all the possible -error patterns that can occur in that round. The sum over all -error patterns, weighted by the probabilities, is bounded above by the probability that at least one nondiagonal fault occurs in that round. Since the round contains gates, this probability is in turn bounded above by .

Once the -error pattern has been chosen in each round that contains errors, we know the actual syndrome at the beginning of each round. And once the winning syndrome is chosen in the first winning round, we know which syndrome bits must have errors in each of the remaining winning rounds. If the cat state preparation fails, then by definition at least two syndrome bits have errors in each of these rounds; hence each winning round after the first has a probability weight bounded above by .

Taking into account that the rounds with non-diagonal faults can be chosen in at most ways, and enumerating the ways to choose which rounds produce the winning syndrome and which additional rounds have faults, we obtain

(12) |

and similarly

(13) |

where denotes . The prefactor in Eq. (12) arises because we use length- cat states in each measurement, and each measurement is repeated times. The prefactor in Eq. (13) arises because the encoded state is a product of length- cat states.

We should add another contribution to the failure probability, because if half of the qubits (or more) have errors, we might decode the cat-state syndrome incorrectly. A syndrome of the repetition code points to two possible error patterns, one low weight and one high weight. We always assume the low-weight interpretation is correct, so if the high-weight interpretation is actually correct, then a Pauli-frame error is applied to the cat state (or worse if the cat state qubits are used multiple times). The additional contribution, then, is bounded by the probability that each of qubits in the cat state are each hit by errors at least once in at least one of the cat state preparations. This upper bound is

(14) |

The Kraus operator arising from a general non-diagonal fault could be a coherent linear combination of Pauli operators; therefore the pattern of errors acting on the cat state may be a coherent superposition of many possibility. For convenience and clarity, we assumed in the above discussion that non-diagonal errors are actually Pauli errors, so that -error patterns can be assigned probabilities rather than amplitudes. But the argument also applies to more general non-diagonal faults. — by expanding each Kraus operator in terms of Pauli operators, and noting that all syndrome bits are measured in the basis, we can bound the probability for each syndrome measurement outcome in terms of and as above.

### v.3 Shorter ancillas

Cat states are used in measurements of the weight- logical operator and the weight- logical operator . In the derivation of Eq. (8) we assumed that the cat states have length and respectively, so that each of the cat state’s qubits participates in just one CZ gate during the measurement. But we have found that the CNOT gadget may be more reliable if a shorter cat state is used instead.

If the length of the cat state is at least , then each cat-state qubit interacts with only one qubit in each encoded block. But if the length is , then a single cat-state qubit may interact with as many as

(15) |

data qubits in a single block, and hence an error on that cat-state qubit may propagate to produce errors in distinct columns of one block. If of the cat state’s qubits have errors, these could generate errors in columns of the block; thus an measurement on the block could fail if there are

(16) |

additional columns that each contain at least one error.

In each measurement, each data block interacts with the ancilla for consecutive time steps, where in each step at most CZ gates act on the data block. The repeated measurements can be staggered as described in Aliferis08 (), to avoid time steps in which data qubits are idle.

We use the index to label the positions of the qubits in the cat state, and design the measurement circuits so that the cat-state qubit interacts with the same set of data qubits in each one of the measured code blocks. Since the measurement is performed on all rows of each block, and also repeated times, inside a there are at most CZ gates that act on a cat-state qubit at position (not counting CZ gates in the cat state preparation step), any of which could have a non-diagonal fault. Similarly, inside a there are at most CZ gates that act on a cat-state qubit at position .

The inside a CNOT gadget is preceded by or within the CNOT, and in the worst case by both and in the preceding gadget, so at most there are CZ gates in these measurements where a non-diagonal fault could disturb cat-state qubit . An error acting on cat-state qubit might also occur because of an error in the winning syndrome in one of the cat-state preparation steps, which can occur only if a faulty gate acts on qubit at least once during the repeated syndrome measurements. Noting that a damaged cat-state qubit in position could cause errors in columns of the encoded block, and that damaged qubits in the length- cat state can be chosen in ways, we conclude that if length- cat states are used then Eq. (8) should be replaced by

(17) |

where

(18) |

## Vi Geometrically local circuits

In our analysis so far, we have assumed that the two-qubit CZ gates can be performed on any pair of qubits, with an error rate independent of the distance between the qubits. Now we will consider how the analysis is modified if CZ gates can be performed only on neighboring pairs of qubits.

There are a variety of possible architectures for fault-tolerant quantum computing using Bacon-Shor codes. To be concrete, we will consider an effectively one-dimensional arrangement, in which logical qubits are encoded in a ribbon of physical qubits with constant width in the vertical direction and length in the horizontal direction proportional to the total number of logical qubits. Each logical qubit lives in a “bi-block” — a pair of Bacon-Shor code blocks, one storing the data processed by the computation, and the other used as an auxiliary block for teleporting gates. If desired, the data block can be shuffled back and forth between the left and right sides of the bi-block via a “one-bit-teleportation” circuit consisting of a preparation, a measurement, and an measurement, as in Fig. 4.

Each logical block is interlaced with an array of ancilla qubits, as in Fig. 7. Of the ancilla qubits in a row, are used to read out the outcome of a measurement performed on the qubit’s two horizontal neighbors, preparing an -qubit cat state in the row. In addition, there is a column of ancilla qubits at the boundary between two adjacent blocks, allowing the cat states to be extended to length or as needed for the measurements and in the CNOT gadget. In the preparation gadget, ancilla qubits in a column are used to read out the outcome of a measurement on the qubit’s two vertical neighbors, preparing an -qubit cat state in a column.

A CNOT gate is performed on a neighboring pair of logical bi-blocks using one of the variants of the CNOT gadget depicted in Fig. 5. Let us denote the bi-block on the left as bi-block 1 and the bi-block on the right as bi-block 2. If the data in bi-block 1 is on the right side of the bi-block and the data in bi-block 2 is on the left side, then we may use the CNOT gadget design in Fig. 5 to perform a CNOT gate in either direction (i.e. with either logical qubit as the control and the other as the target) using cat states of length and , with the output data from the gate appearing on the left side of bi-block 1 and the right side of bi-block 2. Otherwise, we may use one of the alternative gadget designs discussed in Fig. 5 to deal with the cases where the data in bi-block 1 is on the left side and/or the data in bi-block 2 is on the right side. Whichever design we choose, the CNOT gadget flips the data from one side to the other in both bi-blocks, and only the measurement reaches across the boundary between the two bi-blocks.

Note that with this method for performing a logical CNOT gate using geometrically local gates there is no need to swap the positions of pairs of physical qubits. The CZ gate is the only two-qubit gate used at the physical level, so that the assumption of highly biased noise remains physically plausible. Bacon-Shor blocks can be swapped using circuits of logical CNOT gates.

To complete a universal gate set we also need to be able to inject noisy non-Clifford states into code blocks which can then be purified by state distillation. This state injection can be performed using one-bit teleportation — the state is prepared using a single physical qubit, while a logical block is prepared in the state , then the weight- operator is measured on the single qubit and a single row of the block, and finally the single qubit is measured in the basis. This procedure prepares the block in the state , up to a logical Pauli operator known from the measurement outcomes. To perform this task in a bi-block, we prepare on (say) the left side of the bi-block, and build a length- cat state using of the ancilla qubits that accompany a row of the block on the left side, and one additional ancilla qubit on the right side. The single-qubit state is prepared using one physical qubit on the right side of the bi-block which is adjacent to the st qubit of the cat state, allowing the measurement of to be complete using local CZ gates.

If we wish to build a two-dimensional architecture, we may stack horizontal ribbons of logical qubits on top of one another. To perform CNOT gates on pairs of logical bi-blocks that are stacked vertically, we need to be able to perform using cat states shared by vertically stacked blocks. For this purpose we can use ancilla qubits in neighboring bi-blocks to establish a “channel” linking the cat states neighboring corresponding rows of the vertically stacked blocks.

We note that in the case of unbiased noise, a two-dimensional architecture might be realized more simply, using symmetric Bacon-Shor codes. In that case we can build a CNOT gate using either the gadget in Fig. 5 or its Hadamard dual, with and interchanged. The primal gadget uses horizontal cat states to execute CNOT gates on horizontally neighboring blocks, while the dual gadget uses vertical (dual) cat states to execute CNOT gates on vertically neighboring blocks.

For the geometrically local case, our analysis needs to be modified in several ways. As already indicated, we will not be able to choose the length of the cat state to optimize the gadget. Rather, the locality constraint requires that the length of the cat state match the weight of the measured operator ( for and for ). Another change is that we must now consider the consequences of storage errors acting on idle qubits. Previously, we assumed that the off-line preparation of cat states can be scheduled so that the cat states are always available immediately when needed. But now there is only one set of ancilla qubits to accompany each row of a data block. Each time a cat state is measured we must prepare a new one, and the preparation involves a syndrome measurement repeated times. In each round of syndrome measurement, all qubits except the ones at the ends of the cat state participate in two measurements, and because the same ancilla qubits are used for two different measurements, four time steps are required for each one (a preparation, two CZ gates, and an measurement). Therefore, the data waits for time steps before the cat state is ready to interact with the data. While the data qubits wait for the cat state to be ready, they may be subject to storage errors. We must estimate how these storage errors contribute to the failure probability of the logical measurements in the CNOT gadget.

We will denote by the probability per time step of a diagonal storage error and by the probability per time step of a non-diagonal storage error. How many storage steps are included depends on the gadget design, which in turn depends on whether the data is on the left or right side of the incoming bi-blocks. In the worst case, the measurement is performed on a block that undergoes four logical -type measurements between its preparation and measurement, two in the current gadget plus another two in the immediately preceding gadget, and for each of these measurements the data waits for steps as the cat state is prepared. If each -type logical measurement is repeated times, then the total contribution to the error probability per qubit due to the identity gates in the circuit is . Therefore, Eq. (8) is modified to become

(19) |

Furthermore, a non-diagonal storage fault on any of the data qubits can flip the outcome of . This fault can occur in any of the time steps while a cat state is prepared in either the or one of the preceding measurement. Similarly, a non-diagonal storage fault on any of the data qubits can flip the outcome of , where his fault can occur in any of the time steps while the cat state is prepared in either the or one of the preceding measurements. Thus Eq. (9,10) are replaced by

(20) |

Note that the number of storage locations in the circuit might be reduced by adding additional ancilla sites, so that more measurements can be performed in parallel, and/or by combining together measurement locations with immediately following preparation locations.

Geometric locality also requires that we remove the redundant cat state measurements that “wrap around” the code block; Thus there is no syndrome parity check; any syndrome outcome is accepted, and a single diagonal fault can generate a syndrome error. There are also storage locations where the cat state qubits wait while ancilla qubits are prepared and measured. Because of these changes, Eq. (12,13) are replaced by

(21) |

and

(22) |

## Vii Results for logical CSS gates

### vii.1 Unrestricted gates

With our analytic upper bound on the effective error strength of the CNOT gadget, we can find the optimum choice of the code block size as well as the four CNOT parameters , , and , for any choice of the error strengths and . We did this by brute force search over the parameter space. Fig. 8 plots the results of this optimization for five choices of the bias .

These results were obtained by optimizing the size of a Bacon-Shor code block which is used by itself, rather than as part of a more complex concatenated code. Alternatively, we may consider using our Bacon-Shor gadgets at the bottom level of a concatenated coding scheme. In particular, we may estimate the accuracy threshold for biased noise achieved by such concatenated codes, as was done in Ref. Aliferis08 () for the special case of the Bacon-Shor code (i.e., the repetition code). We have extended the analysis of the accuracy threshold performed in Aliferis08 () to more general Bacon-Shor codes. However, for bias above we found no improvement over the threshold estimate in Aliferis08 (), because the code turns out to provide the best threshold value. For values of the bias between 1 and , the optimal value of turns out to be greater than 1, and for that range of the bias we found modest improvements in the accuracy threshold estimate compared to Aliferis08 ().

Using asymmetric Bacon-Shor codes, we can exploit the noise bias to improve the number of physical gates needed to construct a fault-tolerant CNOT gate with a specified logical error rate. Fig. 9 shows this overhead factor and also indicates the dimensions of the optimal code block. This plot includes a comparison with the performance of concatenated codes surveyed in Cross07 () for the case of unbiased noise. For highly biased noise, asymmetric Bacon-Shor codes achieve a much lower logical error rate with a smaller number of physical two-qubit gates, compared to the performance of these previous constructions for unbiased noise.

### vii.2 Geometrically local gates

Optimizing the parameters for the case of geometrically local gates, assuming the storage error rate is negligible, we obtain the results displayed in Fig. 10 and Fig. 11. Enforcing locality significantly weakens the performance of our constructions — at a bias of and dephasing error strength of , the optimal effective error strength we can achieve increases from to , while requiring roughly 8 times as many gates. Therefore, in the geometrically local case our estimated logical error rate for asymmetric Bacon-Shor codes and highly biased noise is roughly similar to what can be achieved using surface codes with a similar number of logical gates, while disregarding the bias raussendorf2007topological (); fowler2009high (). The most important reason that nonlocal gates prove to be advantageous is that if geometry is ignored then the cat state used in (for example) the measurement can be chosen to be much shorter than the length- cat state used in our geometrically local construction. The number of physical qubits per block required to achieve the optimal logical error rate stays relatively small, as indicated in Fig. 12.

Our upper bound on the logical error rate is likely to be far from optimal, and we also expect that the performance could be substantially improved by using a more sophisticated (but harder to analyze) method like perfect matching for decoding the cat state syndrome history. Suitable lattice deformations may also make it more feasible to reduce the length of cat states substantially, yielding further enhancements in performance for the case of geometrically local gates. Such improvements might make asymmetric Bacon-Shor codes more competitive relative to surface codes.

### vii.3 Geometrically local gates and measurement bias

In some experimental settings measurements are noisier than gates, in which case we say the noise has “measurement bias.” We may consider a noise model in which the dephasing error rate in diagonal gates exceeds the rate for nondiagonal faults, while in addition the error rate for single-qubit measurements exceeds . (We also continue to assume that is the error rate for single-qubit preparations.) As shown in Fig. 13, our geometrically local asymmetric Bacon-Shor code gadgets are somewhat robust against increasing measurement bias, because our gadgets contain considerably more gates than measurements (or preparations). Relative to the case , the performance of the logical CNOT gate is not much affected as the measurement bias rises to about 5. In contrast, surface-code gadgets, which contain a higher number of measurements relative to the number of gates, are more sensitive to measurement bias.

## Viii State injection

Having analyzed the performance of our fault-tolerant CSS gates, we now turn to the state injection and distillation protocols needed to complete a universal set of fault-tolerant gates. An arbitrary single-qubit state can be injected into the Bacon-Shor block using the “one-bit teleportation” circuit depicted in Fig. 4. Here a logical qubit is prepared in the state , the two-qubit measurement is performed jointly on an unprotected qubit and the Bacon-Shor block using a length- cat state, and finally the -basis measurement is performed on the unprotected qubit. To estimate the error in the state injection step, we should consider all the ways in which the outcomes of the measurements and might deviate from their ideal values.

In the state distillation circuit, this injection step is directly followed by a CNOT gate. Hence some sources of error in the teleportation circuit need not be attributed to the state injection step, as they are already included in our error estimate for the CNOT gate that follows. In particular, the possibility of failure in the preparation of or a cat state is included in Eq.(V.1), and conservatively at that, since we assumed there that the cat states had length or rather than . Here we assume that the number of repetitions of the cat state syndrome measurement, and the number of syndrome measurement repetitions in the state preparation, match the number of repetitions in the following CNOT gate. If so, we may bound the injection error probability by

(23) |

where bounds the probability of an error in the preparation of the unprotected state (we presume that this error is not necessarily diagonal in the basis).

We assume that is repeated times to improve its reliability. In the first measurement we can time the preparation of the unprotected qubit and the cat state so that there are no storage errors prior to step in which the cat state interacts with the data. But in subsequent measurements storage errors on the data may accumulate during the time steps while the cat state is prepared for the next round. To estimate , we note that each of the cat-state qubits is acted upon by two CZ gates during each of rounds of cat-state syndrome measurement, where a nondiagonal fault in any of these gates could result in a Pauli-frame error. Furthermore, a storage fault acting on the unprotected qubit, a fault in final measurement of the unprotected qubit, or a fault in the gate that couples the unprotected qubit to the cat state could cause to fail. Therefore we find

(24) |

A nondiagonal error acting on any data qubit can flip the outcome of . Otherwise, a diagonal fault in each of at least measurement rounds could cause the to fail. Since in each round there are gates coupling the qubits to the data, CZ gates in the cat state preparation, as well as single-qubit preparations and measurements, we find

(25) |

Fig. 14 bounds the injection error probability assuming the values of , and chosen to optimize the geometrically local CNOT gadget. For large biases the injection error probability is around 1%, well below the thresholds for successful distillation, as will be seen in Sec. IX.

By choosing (no repetition of the measurement), we can avoid storage locations, and the leading contribution to linear in (assuming ) is

(26) |

Increasing to entails increasing the sensitivity to storage errors, while providing better protection against diagonal errors in CZ gates:

(27) |

which might be a significant improvement if .

The probability of error in state injection depends on and also on , the number of times the cat-state syndrome measurement is repeated, which we assume matches the value of in the CNOT gate that follows the state injection step. We note, though, that the value of might increase gradually as state injection proceeds. If there are multiple rounds of state distillation, we might be willing to accept a larger CNOT error rate in early rounds where the error in the distilled state is higher, with declining in later rounds as the state’s purity improves. Adjustment of the Bacon-Shor block size, and hence of , is easy to incorporate in our circuit constructions, as there is no need for the control and target blocks in the CNOT circuit to be of equal size. Using a smaller code in early rounds may save on overhead, but more importantly reducing the value of and used in the first round improves the error of the initially injected state. However, for simplicity, we did not invoke this strategy of gradually increasing the block size in the analysis of state distillation reported in Sec. IX.

## Ix State distillation

So far we have seen how, using asymmetric Bacon-Shor codes, to perform fault-tolerant encoded versions of the operations in the “CSS set” : the CNOT gate, preparations of the encoded states and , and the measurements , . To perform fault-tolerant universal quantum computation, we will need in addition to prepare high-fidelity encoded versions of the states

(28) |

Using a ancilla state and CSS operations, we can teleport the Clifford group gates and , which suffice for generating the full Clifford group. Using a ancilla, the gate, and CSS operations, we can teleport , completing a universal gate set.

To prepare these encoded ancilla states, we first prepare noisy versions of the encoded states, and then use a distillation protocol to generate the needed high-fidelity versions of these states Bravyi08 (). To distill the ancillas we need only CSS operations, and can use a circuit based on the [[7,1,3]] Steane code; it takes 7 noisy () ancillas and produces one clean () ancilla. The distillation protocol uses both CSS operations and ancillas and is based on Reed-Muller codes Bravyi08 (); it produces one clean ancilla from 15 noisy ones. Other, more efficient, distillation protocols have been proposed recently Meier12 (); Bravyi12 (); Jones12 ().

In the original analysis Bravyi08 () of the performance of these state distillation protocols, it was assumed that the CSS operations were perfect. Here we want to consider the case in which the CSS operations, protected by an optimally chosen Bacon-Shor code, are themselves noisy. We provide more details about our analysis in Brooks12 (); state distillation using noisy CSS operations has also been discussed previously in, for example, Refs. raussendorf2007topological (); fowler2009high (); jochym2012robustness ().

When the CSS operations are perfect, we can attain ancilla states with arbitrarily low error by performing a sufficient number of rounds of distillation, assuming that the fidelity of the initial ancilla with the desired ideal state exceeds a threshold value. However, when the CSS operations are noisy, the error rate for the CSS operations sets a nonzero floor on the error in the output ancilla states — once this floor is reached, further rounds of distillation produce no further improvement, because the error in the output is dominated by the errors in the distillation circuit rather than the errors in the input ancilla states. We have designed fault-tolerant distillation circuits that minimize this noise floor, and have found the corresponding lower bounds on the output error for distillation of both and states Brooks12 (). For distillation, the best achievable error rate for our procedure is

(29) |

and for