An Introduction into Fault-tolerant Quantum Computing

1. An Introduction into Fault-tolerant Quantum Computing Alexandru Paler, University of Passau, Germany Simon J. Devitt, Ochanomizu University ,Tokyo 2015 DAC (Design Automation Conference) PRESENTED BY: Mahita Nagabhiru DATE: Nov 26th 2018

2. Motivation • Quantum circuits are error-prone. • Provides a Fault Tolerance Computing framework that helps build commercial and viable Quantum Computers. • It provides a framework of ideas that allow qubits to be protected from quantum errors introduced by poor control or environmental interactions (i.e. Quantum Error Correction, QEC) • Deals with appropriate design of quantum circuits to implement both QEC and “encoded logic operations” in a way to avoid errors cascading through quantum circuits.

3. Refresher on QEC • Quantum error correction is different from classical error correction as: • We can’t safe guard errors simply by replicating data (no-cloning theorem limitation) • We can’t detect errors by intermediate measurement as waveform will collapse entangled information. • Quantum errors are continuous unlike discretized classical errors.

4. Refresher on QEC • QEC: • Encoding: Have multiple physical qubits encode logical qubits (encoded “codeword”) • |0>+|1>  |00…0>+|11…1> • Use CNOT for this encoding: eg: encoding circuit • Detection: • Provide bit-flip detection using X-rotations • Provide phase-flip detection using Z-rotations. • Correction: • Shor code: hierarchical encoding using 9 physical qubits for a single logical qubit. • Provides multi-bit error correction as long as errors are part of separate hierarchy. • measurement on ancilla bits reveals the error but not the data information.

5. Refresher on QEC • First ancilla checks whether first two qubitsare equal. • Second ancilla checks whether first andthird qubits are equal. • Result uniquely identifies the flip. • Apply X to error bit to correct. From Greg Byrd’s Quantum error correction lecture CSC 591-050 / ECE 592-050

6. Scalability • S = Q/P • Q is the number of physical qubits of a physical quantum computer (used to represent say the entire data needed for your program analogous to something like the register state or so) • P is the number of physical qubits required by a fault tolerant computer (FTC) for subset of Q qubits to have error-free quantum computation. • Ideally, Q >> P and S → ∞. • threshold theorem states that P is bounded by O(poly(log Q/Ɛ)Q) for an Ɛ < τ. • Basically P is bound in polynomial-scale instead of exponentially for a logical qubit C.

7. Scalability • Increasing S is possible by optimizing some of the parameters {τ, Q, P}: • because the values of τ and Q are influenced by technological factors, decreasing τ and increasing Q is one of the goals of quantum computing experimentalists (similar to increasing transistor reliability and increasing their density on chip); • allowing high τ and strongly increasing Q such that Q > P (similar to constructing computing clusters from unreliable components) is the case in surface-code-based quantum architectures. • without optimizing τ and Q, lower values for P are obtained by optimizing QECs or compaction of fault-tolerant quantum circuits; this direction is followed in quantum computer engineering. All this math is just to highlight that having 1 logical qubit map to multiple physical qubits is convergent and the overheads will be justified in the future quantum computers; given this- how do we address fault tolerance in viable, large-scale manner.

8. Scalable fault-tolerance • Builds on two basic principles: • resource redundancy- where multiple physical resources are abstracted into logical resources. • computational redundancy- where the same computation is repeated sequentially for multiple times. • FT framework Premise: • A distributed system modelled as crash-stop will be used. • The processes can crash and never return to life. • There are multiple fault detector modules in the system and the point-to-point links are perfect (messages are not lost, duplicated or inserted by fault). • The distributed system includes a single fault corrector, which is informed by the fault detectors about process faults requiring correction.

9. Fault–tolerance framework • Processes are modelled by: • We will have a state set S such that all initial and final values of all our qubits are subset of S. • “q” is the initial set for data. • We will have a black-box that will do a coin flip randomly with a probability τ and based on this, we will randomly introduce bit-flips and phase-flips to our “q” initial state. • For simplicity, τ is same across processes. • Bit flips introduced in the life-time of a process are represented by b and phase-flips by p. • We can do coin toss zero times or more during the life-time. A heads is true and tails is false- heads means we introduced a bit flip of |0> -> |1>. • The more well defined and inclusive the state set S is, more accurate models we can build.

10. Fault–tolerance framework |> |>=a|0>+b|1> |0> |0> • We have a distributed pool of qubits and they will be running a process with QEC encoding. We use inter-process communication for achieving QEC: • They term interaction between data qubits and ancillas through a cnot as communication. • 3-step communication at the end of which we will have fault detection. • bit flips detected by having data qubits as controls and ancillas as targets and errors are commutative. • Eg: During the first round, data sends bc to target updating the old bt’ value to bt = bt’ ⊕ bc M |0> |0> Encoding Decode X Error Channel M Diagnose and Correct

11. Fault–tolerance framework • Lprocess • Fault detector • Fault-corrector • Transversality

12. Fault–tolerance framework • Lprocess: • We define lprocess as a collection of protected physical process i.e. 1 quantum operation on protected physical qubits. (collection of fig- (c)) • Protected physical process can be further decomposed into physical processes on unprotected qubits. (collection of figure (a) into (c) )

13. Fault–tolerance framework • Fault detector • Each process has its own fault detector. • A fault detector consists of a set of low-level processes (called ancillae)- operations on ancillas. • The two ancillae are initialized in the same known state qa. • Let the component b-values be b0, b1, b2; the ancilla output states • qa1 = qa+(ba1⊕b0⊕b1)+pa1 • qa2 = qa + (ba2 ⊕ b1 ⊕ b2) + pa2. • Ancillae used to calculate fault syndromes: • s1 = b0 ⊕ b1 • s2 = b1 ⊕ b2 • For s1 = s2 = 0 no faulty component exists, and for all the other syndrome values, fault exists. • Syndromes used to get the integer pos which points to the faulty component- pos = s2 ∗ 2 + s1 − 1 a|000>+b|111>|00> a|100>+b|011>|10> a|010>+b|101>|01> a|001>+b|110>|11> a|110>+b|001>|01> a|101>+b|010>|10> a|011>+b|100>|11> a|111>+b|000>|00>

14. Fault–tolerance framework • Fault-corrector • The fault corrector communicates with all the fault detectors in the system, and has a global overview of all the faults that were detected during the execution of the distributed computation. • The global perspective has the advantage that the corrector can observe if the modelled τ failure rates are valid or not. • The fault corrector then has two options: to either correct the faults, or to try and track their effect through the distributed computation • The direct correction could introduce failures, and for 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 and global operations. Hence, corrections are required only after the distributed computation was terminated and the output states were read from the system.

15. Fault–tolerance framework • Transversality and computational redundancy • Fig (d) demonstrates each initialized copy of data bit acts on its own ancilla- so we have resource redundancy as well as process but this helps isolate errors from propagation and detect/correct easily. • This also minimized communication cost as communicating a |1> is expensive and if we had an error on the data qubit, in (c) this would be communicated to all three ancillas but not in (d).

16. Conclusion • Provided an introduction to QEC, then pivoted the discussion to its scalability and fault-tolerance. • Provided mathematical bounds for scalability and realization of fault-tolerance computers. • Relation between Q and τ • Framework that self-checks the τ assumptions and validates itself. • Transversality helps prevent cascading of errors.

17. Discussion points • This paper talks about a framework for fault-tolerance- so what could be improved? • How to improve the state set S and what would be an optimal size. • Can we have distributed corrector just like detector and self correct individually- what is the trade off between global vs local. • Can we come up with a completely different model? • Non-crash-stop model- have a provision to resurrect processes from a know safe state by copying/checkpointing intermediate results into classical registers? • Audience suggestions?