An introduction to Fault-tolerant Quantum Computing
aa r X i v : . [ qu a n t - ph ] A ug An introduction to Fault-tolerant Quantum Computing ∗ Alexandru Paler
University of PassauInnstr. 43Passau, Germany, 94032 [email protected] Simon J. Devitt
Ochanomizu University2-1-1, Otsuka, Bunkyo-kuTokyo, 112-8610, Japan [email protected]
ABSTRACT
In this paper we provide a basic introduction of the coreideas and theories surrounding fault-tolerant quantum com-putation. These concepts underly the theoretical frame-work of large-scale quantum computation and communica-tions and are the driving force for many recent experimentalefforts to construct small to medium sized arrays of con-trollable quantum bits. We examine the basic principalsof redundant quantum encoding, required to protect quan-tum bits from errors generated from both imprecise con-trol and environmental interactions and then examine theprincipals of fault-tolerance from largely a classical frame-work. As quantum fault-tolerance essentially is avoiding theuncontrollable cascade of errors caused by the interactionof quantum-bits, these concepts can be directly mapped toquantum information.
Categories and Subject Descriptors
H.4 [
Information Systems Applications ]: Miscellaneous;D.2.8 [
Software Engineering ]: Metrics— complexity mea-sures, performance measures
General Terms
Quantum Information, Quantum Error Correction
Keywords
ACM proceedings, L A TEX, text tagging
1. INTRODUCTION
Fault-tolerant, error corrected, digital quantum computingunderpins a significant worldwide effort to construct viable,commercial quantum computing systems [7]. The size ofsuch error corrected machines is somewhat daunting for afield that has only managed to experimentally fabricate ar-rays of up to about ten functional quantum-bits (qubits) ∗ (Does NOT produce the permission block, copyrightinformation nor page numbering). For use withACM PROC ARTICLE-SP.CLS. Supported by ACM. [4, 3]. However, the theoretical framework for fault-tolerantquantum computing has existed for nearly 20 years and isvery well understood and quantum computing is competingwith the vast classical computing power currently in exis-tence. It would be unreasonable to believe (even given theapparent computational power quantum information pro-cessing has over classical computing), that a small, errorprone array of qubits could computationally outperform aclassical system comprising of potentially millions of com-puting cores, each itself containing billions (or even trillions)of transistors.Fault-tolerant quantum computing refers to the frameworkof ideas that allow qubits to be protected from quantumerrors introduced by poor control or environmental interac-tions (Quantum Error Correction, QEC) and the appropri-ate design of quantum circuits to implement both QEC andencoded logic operations in a way to avoid these errors cas-cading through quantum circuits [8]. By avoiding a cascadeof errors, there becomes a point (when the fundamental ac-curacy of individual qubits is high enough), where QEC iscorrecting more errors than are being created. Once this t hreshold has been achieved, expanding the size of the pro-tective quantum will exponentially decrease the failure ofthe encoded information and allows us to achieve arbitrarilylong quantum algorithms implemented with noisy devices.In this paper we will provide a basic introduction to someof the key principals of QEC and then pivot into a discus-sion about fault-tolerance that have been investigated in theclassical computing world. As the goal of fault-tolerance isto prevent errors to cascade uncontrollably, a large amountof classical work can be easily transferred to the quantumworld.
2. QUANTUM COMPUTING
In this section we present the basic mathematical frameworkfor qubits, quantum gate operations and quantum circuits.Further details can be found in a number of papers [2] andbooks [8] both from the physics community and the com-puter science community.Quantum circuits represent and manipulate information in qubits . A single qubit has an associated quantum state | ψ i =( α , α ) T = α | i + α | i . Here, | i = (1 , T and | i =(0 , T are quantum analogons of classical logic values 0 and1, respectively. α and α are complex numbers called am-plitudes with | α | + | α | = 1. uantum measurement is defined with respect to a basisand yields one of the basis vectors with a probability re-lated to the amplitudes of the quantum state. Commonmeasurements are known as Z - and X -measurements. Z -measurement is defined with respect to basis ( | i , | i ). Ap-plying a Z -measurement to a qubit in state | ψ i = α | i + α | i yields | i with probability | α | and | i with prob-ability | α | . Moreover, the state | ψ i collapses into themeasured state (i.e. only the components of | ψ i consistentwith the measurement result remains). X -measurement isdefined with respect to the basis ( | + i , |−i ), where |±i = √ ( | i ± | i ).A state may be modified by applying single-qubit quantumgates . Each quantum gate corresponds to a complex unitarymatrix, and gate function is given by multiplying that ma-trix with the quantum state. The application of X gate to astate results in a bit flip : X ( α , α ) T = ( α , α ) T . The ap-plication of the Z gate results in a phase flip : Z ( α , α ) T =( α , − α ) T . A Y = iXZ gate can be thought of as botha bit-flip and a phase-flip together on an individual qubit.These three gates are important in the context of quantumerrors.The exponentiation of the Pauli matrices results in the ro-tational gates R x , R y , R z parameterised by the angle of therotation [8]. Hence the bit flip is a rotation by π aroundthe X -axis, implying that X = R x ( π ), and the phase-flip isa rotation by π around the Z -axis, such that Z = R z ( π ).The Hadamard gate is H = R z ( π/ R x ( π/ R z ( π/
2) andcan be used to take a computational state { ket , | i} intosuperposition states, {|±i = ( | i ± | i ) / √
2, a state with noclassical analogueIn the context of fault-tolerant quantum computation, onlyone interaction gate is needed; the controlled-not (CNOT)gate. The CNOT gate is the quantum analogue of a binaryXOR operation and is designed to bit-flip the state of atarget qubit, conditional on the state of a control qubit. Thisgate can be employed on certain quantum states to prepare entangled states . For example, CNOT( | i + | i ) | i / √ | i + | i ) / √
2. This state, known as a Bell state hasthe property that measuring one of the qubits produces arandom result ( | i or | i with a 50:50 probability), but oncethe state of one qubit is measured, the state of the otherqubit is also determined.It is well known that the ability to perform arbitrary rota-tions around two orthogonal axis (e.g. R z ( θ ) and R x ( θ )for arbitrary { θ , θ } ) and to couple arbitrary pairs of qubitswith a CNOT gate is sufficient to realise any N -qubit unitaryoperation. This gate set is therefore quantum universal.
3. ERRORS AND QUANTUM ERROR COR-RECTING CODES
There are two important differences between classical errorcorrection and quantum error correction. The first is theno-cloning theorem [11], which states that is is impossibleto perfectly copy an unknown quantum state. i.e. there is nooperation that satisfies U | ψ i | i = | ψ i | ψ i for an unknown | ψ i . Therefore, we are unable to protect arbitrary quan-tum states against errors by simply making multiple copies. Secondly, any measurement of an arbitrary quantum statewill collapse the wavefunction describing the state. Henceprotecting errors in an encoded piece of quantum informa-tion by measuring a certain subset of the encoded block willirrevocably destroy the information content of that state.Therefore we need a slightly new mechanism to protect en-coded quantum information.The foundation of quantum error correction is still based onclassical coding theory, however we need to design codes ina slightly different manner. This is due both to the restric-tions of what we can theoretically do with quantum infor-mation, but also due to the possible errors that can affectqubits. Unlike classical bits, which can only experience a flipbetween | i ↔ | i , qubits can also experience phase errors( | i + | i ) / √ ↔ ( | i − | i ) / √
2. Additionally, errors do notoccur in a discrete manner. They are most often continuouserrors, such as a rotation around the X axis by some an-gle ǫ or some incoherent (non-unitary) error caused by theinteraction with the outside environment.Due to expedience we will only present the formalism for coherent errors , those that can be represented by a uni-tary gate. In this case, an error operator, E , acting ona qubit, | ψ i can be decomposed into a linear superposi-tion of X gates, Z gates and both Y = iXZ , E | ψ i = a | ψ i + a X | ψ i + a Z | ψ i + ia XZ | ψ i . If we could magically measure if an X and/or Z error occurred on a qubits (viasome type of quantum measurement), the state would col-lapse to the state {| ψ i , X | ψ i , Z | ψ i , XZ | ψ i} with a prob-ability of {| a | , | a | , | a | , | a | } . This converts a possiblecontinuous quantum error into a discrete X and/or Z gate.While the errors themselves are continuous (for very smallerrors, | a | ≈ X -errors and one is designed to detect Z -errors without havingto, necessarily, decode the codespace. Detecting an errorindirectly for bit-flips is commonplace in classical computerscience and was usurped for the quantum regime. The sim-plest example is the bit-flip code, with basis states givenby | i L = | i ⊗ N and | i = | i ⊗ N , where the ⊗ N notationsimply meaning N copies of the qubit. The basic idea isthat given a given codified, N , the number of physical flipsneeded to turn | i L ↔ | i L scales linearly with N . Again,in the quantum regime, we are not allowed to directly mea-sure any subset of qubits in the code block. So we need adifferent method to identify errors. In the context of the bitflip code, we notice a certain property, namely that for bothbasis states, pairwise bit-parity in the code block is even (i.e.calculating the parity of any two bits via modulo additionfor the | i L and | i L state is even). If such a comparisonever results in an odd value, we know an error has occurredwithout actually knowing if we started with the | i L or | i L state. This is what we need. Therefore, we need a wayto calculate the parity of any two qubits in the code blockwithout directly measuring the qubits themselves. We cando this via the circuit in Fig. ?? . This circuit introducesn ancilla qubit that is initialised, interacted with a pair ofqubits in the code block and measured. The result of themeasurement on the ancilla (either | i or | i ) will determinethe parity of the two qubits (odd or even), and also force these two qubits to be in an even or odd parity state if theywere not beforehand.The principal of a codespace within quantum computationis to construct encoded codewords that are always in cer-tain, well defined parity states regardless of the state ofthe encoded information. Physical errors will then perturbencoded information away from these well defined paritieswhich can be detected without determining any informationregarding the encoding.Returning back to the example of a redundancy code, thetwo encoded states | i L and | i L are constructed to be evenparity states of any pairwise Z operators. i.e. applyingthe operator Z i Z j for any i , j ∈ N returns the same state, Z i Z j | , i L = | , i L . Bit flip errors result in states whichviolate this condition. For example, a bit-flip on qubit oneof the encoded block will result in Z Z j | , i L = − | , i L , ∀ j . Hence if we measure the parity of any of these operatorsand we find an odd result, we know that some type of errorhas occurred. Determining a location for the error and howmany unique errors we can identify depends on the size ofthe code block, N . The parity of pairwise checks of the Z i Z i +1 operator will allow us to uniquely locate individualerrors and the number of errors we can successfully correctscales linearly with the number of qubits in the code block.For N qubits, we are able to uniquely correct ( N − / |±i =( | i ± | i ) / √
2. i.e. a Z -error will take | + i ↔ |−i . Henceif we used a redundancy code of the form | i L = | + i ⊗ N and | i L = |−i ⊗ N and instead of checking the parity ofthe Z i Z i +1 operator, we check the parities of the X i X i +1 operator for i, ∈ ( N − | , i or | + , −i states will allow us to either protect encodedinformation against X -errors or Z -errors. A full quantumerror correction code therefore combines two classical codes,independently responsible for bit-errors and phase-errors.The Shor code is the simplest example of this [9]. In theShor code we essentially have one redundancy code embed-ded within another. The code encodes a single qubit ofinformation into nine physical qubits. The basis states aregiven by, | i L = 12 √ | i + | i )( | i + | i )( | i + | i ) | i L = 12 √ | i − | i )( | i − | i )( | i − | i )(1)We have three blocks of three qubits that effectively act as adistance three redundancy code to correct bit flips in the waythat we described above. This allows us to correct a single bit flip error in any one of the three blocks. In principal,this code can correct for three bit-flip errors (provided eacherror occurs in a separate block), however in general, astwo or more errors can occur in a single block the code isdescribed as only having the capacity for correcting a singlebit flip error. Phase errors are corrected via the three blocksand comparing the parity of pairwise blocks. Again, thecode, in principal, can correct for more than one phase error(provided errors occur in specific locations), but in generalonly a single arbitrary error is deterministically correctable.
4. FAULT-TOLERANCE
The effectiveness of QEC depends on how we implementquantum circuits to realise the correction code. As withclassical computing, interactions between qubits during theexecution of the circuit leads to the copying of errors. Ifthis happens in an uncontrolled manner, the QEC code isoverwhelmed and the computation will fail. Therefore, weneed to be very careful when designing circuits such that thisdoes not occur. While there is not often a direct compari-son between classical and quantum information processing,the principals of fault-tolerance in a classical framework iseasily transferable. We will therefore focus on some generalprincipals of fault-tolerance in the classical world which canbe mapped directly to quantum computing.
5. SHORT PARALLEL TO DISTRIBUTEDSYSTEMS
The need for fault-tolerance in quantum computing can beintroduced by drawing parallels with distributed systems.The following insights do not extend classical distributedsystems to quantum ones [10], but propose the problemof quantum fault-tolerance to be formulated without intro-ducing quantum information and quantum computing. Thediscussion will focus on processes and communication overpoint-to-point links.The distributed system is modelled as crash-stop [1], suchthat the processes can crash and never return to live, thereis at least one fault detector module in the system and thecommunication links are perfect (messages are not lost, du-plicated or inserted by fault). Additionally, the distributedsystem includes a fault corrector, which is informed by thefault detectors about faults requiring correction.The main target of fault-tolerance, as presented in thesesections, is to control the propagation of faults between pro-cesses. The presentation will focus on describing the dis-tributed system elements, and the way these interact, butwithout delving into details about the liveness and safetyproperties of the presented protocols.
A process holds an abstract object q and a black-box thatconsists of a coin, two Boolean values and a real value τ .The black-box is a model for the process faults. The Booleanvalues b and p are the results of tossing the coin twice. Thevalue true indicates heads, and false stands for tails.None of the processes is aware of the Boolean values in-side the box. Furthermore, the processes do not controlthe black-box and the coin toss. The coin toss is randomlyerformed (with a probability τ ), meaning that none, a sin-gle or both values are generated at undetermined executionpoints of the process. Therefore, there may be none or mul-tiple coin tosses during the lifetime of a process. In order tosimplify the modelling, the probability τ is equal for all theprocesses, and process failures are not correlated.The actual state of a process is computed by the function q a = q + b + p , where the + operation is the addition of thetwo possible random faults modelled as Boolean values A correct process is the one for which q a = q , while, if q a = q ,the process is called faulty . In the following, q will refer bothto the object and to its state, depending on the context it isused in. It should be noted that object q is noncopyable ,meaning that once constructed, it can be either transformedlocally or through distributed computations, but cannot becopied between processes.During process initialisation it possible to initialise the black-box values and to set the state of q to a state chosen from adiscrete set sq ∈ S . Once the black-box was set up, there isno guarantee that the values had not been changed by thecoin tosses.A terminating process returns a state so ∈ S . During ter-mination, the current q is classified against all the S -states,and the closest so is returned. The classification is proba-bilistic, meaning that if there is no state so for which so = q ,then it could happen that the returned state so is actually orthogonal to the state so ′ that was classified as next to q .Once a process is terminated, it cannot be brought back tolive and, if one would like to approximate the probability of q being in any of the states of S , the complete distributedcomputation has to be repeated. More flexible initialisationand termination procedures could benefit from a larger set S , but this will negatively impact the practicality of systemimplementation. The Boolean black-box values of a process can be eitherread and communicated to other processes, or updated bya second process. A single process is not able to read itsvalues and correct them. Value correction is performedonly through coordinated communication during a proce-dure similar to consensus [1].The processes are naive: if one of their Boolean values isconsidered heads, then the same happens to the other pro-cesses. The processes are also lazy, meaning that the com-munication of heads-values has an associated cost, such that cost(heads)=1 and cost(tails)=0 .Ideally, every process should have its Boolean values alwaysset to false (tails). For this reason, in general, the pro-cess avoids initialising their black-boxes with heads values.Processes are not byzantine, and each time one communi-cates, it will try, based on the process values, to convince itspartener to either flip or keep one of its values. More specif-ically, a communication step between two processes x and y Similarly, in C++ a private copy constructor and copy as-signment operator are required for such classes. is performed in two rounds: firstly, x sends its b value to y requesting it to update its b value to b x ⊕ b y . Afterwards,process y sends its p value to x asking an update of its v value to v x ⊕ v y . The ⊕ function models the behaviour of acoin flip: the coin returns to its initial value after two flips.During the third communication round the control processapplies the distributed abstract operation e : the update ofthe state q y (target) is a function of state q x (control). The e -operation will not be detailed in the context of the analogywith distributed systems, and its cost is considered zero.Besides communicating and performing the distributed op-eration e , the process can perform local (intra-process) op-erations that transform the state of the local object q . As previously introduced, inter-process comunication is bothan attempt to correct the black-box values and, at the sametime, a distributed computation. The simplest distributedsystem executing a single communication step consists oftwo processes, which we will call the control and the tar-get . The control initiates the communication, thus is therequester during the first communication round, and thetarget is the requester of the second communication round.Additionally, a process can be both control and target dur-ing separate communication steps.Generally, a distributed algorithm represens a series of inter-process communication steps and local operations. Thereare at least two types of algorithms: 1) distributed cor-rection, where processes communicate only to correct theirBoolean values; 2) distributed computation, in which pro-cesses try to solve a computational problem. Algorithmscompliant with the first option generally consist only of com-munication steps and no local operations. A well-definedcorrection protocol (see Section 5.5) is the execution of co-ordinated communication. Distributed computations (thesecond option) include intra-process operations but neglect(do not coordinate) the effect of the two correction rounds ineach communication step. The result is that uncoordinatedcorrection can lead to propagation of faults : the heads valuesare being transferred, without the processes having noticed,from a faulty process to a correct one (see Section 5.7).
In general, fault-tolerance is achieved by using an hierar-chic (layered) approach. Assuming the failure probability τ of a process, a set of two processes will fail simultaneouslywith probability τ . The introduction of redundancies is thekey of achieving fault-tolerance, and there are two types ofpossible redundancies: 1) computational redundancy, wherethe same computation is repeated sequentially for multipletimes; 2) resource redundancy, where multiple processes areabstracted as a single logical process and the componentprocesses are executed in parallel.Computational redundancy is the equivalent to executinga distributed algorithm in epochs, and to guaranteeing thatafter a certain number of epochs a property of the algorithmis achieved. Resource redundancies are generally used whenat least f faulty processes are needed to be tolerated. Forexample, the uniform epoch consensus algorithm from [1]requires N processes with N > f .ajorities (quorums [1]) are the most common option forchecking the introduced redundancies. The simple major-ity ( N/ N objects (processes, bits etc.) is used tointroduce the fault-tolerant quantum computing in the fol-lowing: a fault-tolerant logical process is constructed fromthree (or more) component processes (called components),and the logical process is able to tolerate at most one faultycomponent. The computation of quorums is detailed in Sec-tion 5.8.Due to the fact that the q objects of each process are non-copyable increases the difficulty of implementing fault-tolerancethrough redundancy. Copying the q state of an existingprocess to a newly initialised one is not possible. As a re-sult, separate components are initialised into the same state q ∈ S at the start of the distributed algorithm and exactlythe same operations are applied on their objects.This work presents, without loss of generality, how the con-struction of logical processes is performed using triple-modularredundancy (TMR) [6]. The logical state q l of a logical pro-cess is a sequence of n (in this work n = 3) componentprocess states: q l = Q ni =0 q i . Transforming q l represents thetransformation of each q i .The repetition code is the TMR counterpart in the field oferror-checking and -correction methods. As a consequence,the logical state q l should be interpreted as the encodingof one of the component process states (the states of thecomponents are equivalent). The repetition code can bereplaced with more powerful codes like the Hamming codeor surface codes [5], but this aspect is not further addressedin this work.After constructing a logical process from three freshly ini-tialised processes, it is possible to compute the simple ma-jority of the b -values from every component’s black-box.Additionaly, after grouping three separate logical processes(lower-level) into another logical process (higher-level), itis also possible to keep track of p -value majorities. Corre-spondingly, the highest-level logical process consists of ninecomponents (lowest-level) grouped into three logical pro-cesses. There will be three b -value majorities and one p -value majority. This hierarchic construction where logicalconstructs are embedded into one another is known as con-catenation , and has the advantage of polynomially loweringthe failure probability of the resulting logical processes [8]. The fault detectors used in the described distributed systemare detecting faulty component processes. For each logicalprocess there is a separate associated fault detector that in-teracts with the components. A fault detector consists ofa set of low-level processes (called ancillae) which are ini-tialised, used for communicating with the component pro-cesses and terminated. The output state of the ancillae isused to compute a syndrome: infer which component pro-cess is faulty. A fault detector contains also two variables:the Boolean faulty indicates if the associated logical processis faulty or not, and the integer pos points to the faultycomponent.Fault detectors can check either b -values (the components are controls and the ancillae targets) or p -values (the otherway around, the components are targets and the ancillaecontrols). Once more, without loss of generality, the follow-ing fault detectors will be responsible only for b -values.Ancillae are usual processes and can be affected by faults,which are required not to propagate to the components. Atthe same time, as process failures are probabilistic, a set ofancillae is used by the detector for reaching (with high prob-ability) a trustful decision about the logical process (see Sec-tion 5.8). A b -value detector responsible for a logical processprotected against b -value faults has the process componentsas controls and the ancilla as target during the communica-tion steps. If the ancilla holds a p -value set to heads, this willpropagate to the components, but it would not influence the b -value protection. Again, if the ancilla holds a b -value fault,this will not propagate given the communication protocol.A logical process could be faulty beyond correction whena majority of the components is faulty. Assuming that allthe communication between the logical processes is transver-sal (see Section 5.7), and because process faults are uncor-related, it would be improbable that such processes exist.Their existence would be a result of a high τ (called in thequantum computing literature the error threshold ), but canbe mitigated by using more powerful encodings (e.g. sur-face code). Therefore, it is further assumed that the rightencoding was chosen for the logical process states, and thatfaulty components form a minority.Computing a simple majority of correct processes from a setof components is equivalent to finding the faulty componentsforming a minority. For the distributed system example, aminority consists of at most one component. Two ancillaeare required, the first one compares the b -values between thefirst and the second components, and the second ancilla the b -values between the second and the third components.The two ancillae are initialised in the same known state q a .Let the component b -values be b , b , b ; the ancilla outputstates after termination will be q a = q a +( b a ⊕ b ⊕ b )+ p a , q a = q a + ( b a ⊕ b ⊕ b ) + p a . Considering that initiallythe ancillae are not faulty, the fault detector will extract twobits of information s = b ⊕ b and s = b ⊕ b , indicatinghow the b -values compare pairwise between the components.The extension to faulty ancillae is presented in Section 5.8.The syndrome bits s and s encode the index of the faultycomponent process. For s = s = 0 no faulty componentexists, and the fault detector sets its faulty flag to false . Forall the other syndrome values, the detector sets faulty=true ,and the faulty component index is computed by pos = s ∗ s − The fault corrector communicates with all the fault dectorsin the system, and has a global overview of all the faultsthat were detected during the execution of the distributedcomputation. The global perspective has the following ad-vantage: the corrector can observe if the modelled τ failurerates are valid or not; is the modelled failure rate to low?In the presence of faults (signalled by the detectors), theault corrector has two options: to either correct the faults,or to try and track their effect throught the distributed al-gorithm. The direct correction could introduce failures, andfor this reason fault-tracking is more advantageous. Fault-tracking is performed based on commutativity properties:it is known how faults are transformed by both local andglobal operations. Hence, corrections are required only afterthe distributed computation was terminated and the outputstates were read out from the distributed system. The transversal application of a logical operation (local ordistributed) is its decomposition into (local or distributed)operations applied on the component processes. For exam-ple, the logical local operation G l is the n -fold applicationof G on each of the n components.Faults are propagated by inter-process communication. Inthis section, propagation is illustrated by a distributed sys-tem with two logical processes, each constructed from threecomponent processes. Propagation will be mitigated bytransversal communication.Let q cl be the logical state of the logical control, and q tl thestate of the logical target. It is further assumed that in bothlogical processes (control and target) at most one componenthas its b -value set to heads. Once more, it should be notedthat the processes are not aware of their values. The logicalstates were transformed by transversal logical operations re-sulting in three equivalent component states in each logicalprocess: q c = q c = q c and q t = q t = q t .As the component states in both control and target areequivalent, transversal inter-process communication is im-plemented by forming pairs between control and target com-ponents. There are two possibilities: 1) the same controlcomponent is paired with each target component (see Fig-ure ?? ); 2) each control component is paired with a differenttarget component (see Figure ?? ). The second scenario cor-responds to transversal inter-process communication.For the first scenario, assuming that the component process0 c (the component indexed 0 in control) is used, pairs of thefollowing form ( control, target ) are built: (0 c , t ), (0 c , c )and (0 c , t ). The three communication steps result in the up-dated b -values of the target components ( b i t = b i t ⊕ b c ). As-suming b c is heads, the control fault was propagated to thetarget components. At this point it cannot be guaranteedthat the logical target is protected against a component’ssingle heads b -value. Furthermore, the total cost of commu-nication between the logical process is c = 3 × cost ( heads ).The second scenario, the transversal inter-process communi-cation, could result in the following three pairs being formed:(0 c , t ), (1 c , t ), (2 c , t ). Maintaining the assumption of thecomponent 0 c being faulty in the b -value, after the threecommunication rounds only the state of 0 t would be nega-tively affected ( b t = b t ⊕ b c ). As a result, after executingthis communication scenario, it can be guaranteed that thelogical target is further protected against a single heads valueof b . The total cost of communication between the logicalprocess is c ≤ × cost ( heads ). Transversality minimises thecommunication cost between the logical processes, because c ≥ c . Transversality is the key to constructing fault tolerant op-erations on logical processes, but is not applicable for main-taining a consistent set of component processes. A differenttechnique has to be devised. In the presentation of the pro-cess model it was mentioned that faults can occur any time:the black-box coin is tossed at random time points. Thetoss could happen before each local or distributed opera-tion. Faults are also allowed to occur before a process isterminated: after the last operation, but before returningits final state.The solution is to continously check and correct every logicalprocess in the system. Checking is performed by the faultdetectors and corrections are applied by the fault corrector.A detection round consists of multiple epochs, but a logicalprocess is continously checked (multiple rounds).Section 5.5 introduced the fault detector and its use of an-cillae, but ancillae were considered correct. In the presenceof faults, the syndrome bits could be incorrect and trig-ger an unnecessary correction that would introduce morefaults. The solution is to repeat during a detection roundthe syndrome extraction procedure multiple times, similarto a sequence of epochs (an example of computational re-dundancy). Every epoch requires a new pair of ancillae,and the fault detector will perform majority voting betweenthe three pairs of extracted syndrome bits.A freshly initialised process that was detected as being faultycould be either corrected or directly terminated and a newprocess instance would need to be initialised. During theexecution of a process (between local and distributed oper-ations), correction is the only option. Process operationscould be delayed by the complete detection and correctionprocedures, because the detectors requires multiple execu-tions in order to achieve a probabilistically consistent de-cision. Thus, fault-tolerance introduces significant resourceand computational overheads.
6. CONCLUSIONS7. ACKNOWLEDGEMENTS
SJD acknowledges support from the JSPS Grant-in-aid forChallenging Exploratory Research and JSPS KAKENHI KibanB 25280034
8. REFERENCES [1] Christian Cachin, Rachid Guerraoui, and Lu´ısRodrigues.
Introduction to reliable and securedistributed programming . Springer Science & BusinessMedia, 2011.[2] S.J. Devitt, W.J. Munro, and K. Nemoto. Quantumerror correction for beginners.
Rep. Prog. Phys. ,76:076001, 2013.[3] S.J. Devitt, A.M. Stephens, W.J. Munro, andK. Nemoto. Requirements for fault-tolerant factoringon an atom-optics quantum computer.
NatureCommunications , 4:2524, 2013.[4] J. Kelly et.al. State preservation by repetitive errordetection in a superconducting quantum circuit. ature (London) , 519:66–69, 2015.[5] Austin G Fowler, Matteo Mariantoni, John MMartinis, and Andrew N Cleland. Surface codes:Towards practical large-scale quantum computation.
Physical Review A , 86(3):032324, 2012.[6] Israel Koren and C Mani Krishna.
Fault-tolerantsystems . Morgan Kaufmann, 2010.[7] T. D. Ladd, F. Jelezko, R. Laflamme, Y. Nakamura,C. Monroe, and J.L. O’Brien. Quantum Computers.
Nature (London) , 464:45–53, 2010.[8] Michael A Nielsen and Isaac L Chuang.
Quantumcomputation and quantum information . Cambridgeuniversity press, 2010.[9] P.W. Shor. Scheme for reducing decoherence inquantum computer memory.
Phys. Rev. A. , 52:R2493,1995.[10] Rodney Van Meter.
Quantum Networking . John Wiley& Sons, 2014.[11] W.K. Wooters and W.H. Zurek. A Single QuantumCannot be Cloned.