Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

Cambridge University Press eBooks

Quantum Computing

Juan José García‐Ripoll

Published Jul 31, 2022• 0 citations
Publisher

Abstract

We discuss the building blocks of a universal quantum computer within the circuit model of computation and how this is implemented using superconducting quantum circuits. In particular, we discuss, one by one, the creation of quantum registers, resetting of quantum bits, qubit measurements, single-qubit operations, and universal two-qubit gates, and how these are all implemented using the tools from earlier chapters. We discuss how to calibrate the errors in the qubits and in the operations, assigning them complete descriptions via positive maps. We explain how these errors can be corrected and how to implement a fault-tolerant quantum computer, focusing on the paradigm of stabilizer codes and the surface code in particular. We close with a discussion on the outlook for quantum computers in the near term and the NISQ paradigm of computation.

DOI
10.1017/9781316779460.008

Related papers

Quantum computing with superconducting qubits

Manish Yadav

Few technological ideas in recent memory have stirred as much excitement—or skepticism—as quantum computing. The promise is genuine: for certain computational tasks, a quantum machine can do in seconds what would take a classical supercomputer longer than the age of the universe. At the heart of realising that promise is the qubit, the quantum analogue of a classical bit, and among the many physical systems that can host a qubit, superconducting circuits have quietly become the frontrunner. They can be fabricated in the same cleanrooms used to make conventional chips, controlled with ordinary microwave electronics, and scaled up in ways that other approaches cannot yet match. This thesis traces the full arc from first principles to working code. We start with the quantum mechanics a reader needs—superposition, entanglement, measurement—and build from therethrough the physics of superconductivity to the engineering of real qubit circuits. A key character in that story is the Josephson junction: a thin sandwich of metal and insulator whose quirky nonlinear behaviour is what makes the whole enterprise of superconducting qubits possible. A major focus of this work is the surface code, a topological quantum error-correcting code widely regarded as the most promising approach for achieving fault-tolerant quantum computation. We provide a rigorous analysis of the surface code’s lattice structure, stabilizer formalism, syndrome extraction, and decoding algorithms—in particular the minimum-weight perfect matching (MWPM) algorithm. A full Python/Qiskit implementation of a distance-3 surface code is presented, including qubit initialization, syndrome measurement circuits, error simulation, and decoding logic. We close by looking ahead. Modular processors, 3D circuit integration, and the long road to fault-tolerant machines are all on the horizon, and we try to give an honest assessment of where things stand and what the real obstacles are. Throughout, the goal has been to bridge theory and practice—to be precise enough to be useful, but grounded enough to stay connected to what is actually happening in laboratories today.

•Jan 1, 2026•0 citations

Quantum error correction

Anirban Pathak

In Chapter 4 we introduced different quantum gates and quantum circuits and in Chapter 5 we described several quantum algorithms. So far the analysis of the algorithms and the circuits has been made with the assumption that the required unitary operations can be implemented exactly without any error. This is an abstraction. In an actual physical system that implements a quantum algorithm or a quantum circuit there are several sources of errors. The situation is similar in classical computation and to circumvent this problem error correcting codes are used in classical digital computing. Since qubits are more delicate and more susceptible to errors we need to introduce quantum error correcting codes. It is very important, as without such codes it will not be possible to build a scalable quantum computer. Such quantum error correcting codes are introduced in this chapter. However, we will not limit ourselves to the discussion of error correcting codes alone. We will also discuss more general aspects of errors and error correction, like decoherence, decoherence free subspace and fault-tolerance.

CRC Press eBooks•Jun 20, 2013•33 citations

Quantum Computation with Topological Codes: from qubit to topological fault-tolerance

Keisuke Fujii

This is a comprehensive review on fault-tolerant topological quantum computation with the surface codes. The basic concepts and useful tools underlying fault-tolerant quantum computation, such as universal quantum computation, stabilizer formalism, and measurement-based quantum computation, are also provided in a pedagogical way. Topological quantum computation by brading the defects on the surface code is explained in both circuit-based and measurement-based models in such a way that their relation is clear. The interdisciplinary connections between quantum error correction codes and subjects in other fields such as topological order in condensed matter physics and spin glass models in statistical physics are also discussed. This manuscript will be appeared in SpringerBriefs.

arXiv:1504.01444•Apr 7, 2015•23 citations

Surface codes: Towards practical large-scale quantum computation

Austin G. Fowler, M. Mariantoni, John M. Martinis +1 more

This article provides an introduction to surface code quantum computing. We first estimate the size and speed of a surface code quantum computer. We then introduce the concept of the stabilizer, using two qubits, and extend this concept to stabilizers acting on a two-dimensional array of physical qubits, on which we implement the surface code. We next describe how logical qubits are formed in the surface code array and give numerical estimates of their fault tolerance. We outline how logical qubits are physically moved on the array, how qubit braid transformations are constructed, and how a braid between two logical qubits is equivalent to a controlled-not. We then describe the single-qubit Hadamard, $\stackrel{\ifmmode \hat{}\else \^{}\fi{}}{S}$ and $\stackrel{\ifmmode \hat{}\else \^{}\fi{}}{T}$ operators, completing the set of required gates for a universal quantum computer. We conclude by briefly discussing physical implementations of the surface code. We include a number of Appendices in which we provide supplementary information to the main text.

arXiv:1208.0928•Physical Review A•Sep 18, 2012•3,060 citations

Optimizing Superconducting Three-Qubit Gates for Surface-Code Error Correction

Stephan Tasler, Josias Old, Lukas Heunisch +4 more

Quantum error correction (QEC) is one of the crucial building blocks for developing quantum computers that have significant potential for reaching a quantum advantage in applications. Prominent candidates for QEC are stabilizer codes for which periodic readout of stabilizer operators is typically implemented via successive two-qubit entangling gates, and is repeated many times during a computation. To improve QEC performance, it is thus beneficial to make the stabilizer readout faster and less prone to fault-tolerance-breaking errors. Here we design a 3-qubit CZZ gate for superconducting transmon qubits that maps the parity of two data qubits onto one measurement qubit in a single step. We find that the gate can be executed in a duration of $35\,$ns with a fidelity of F$=99.96 \, \%$. To optimize the gate, we use an error model obtained from the microscopic gate simulation to systematically suppress Pauli errors that are particularly harmful to the QEC protocol. Using this error model, we investigate the implementation of this 3-qubit gate in a surface code syndrome readout schedule. We find that for the rotated surface code, the implementation of CZZ gates increases the error threshold by nearly 50\% to $\approx 1.2\,\%$ and decreases the logical error rate, in the experimental relevant regime, by up to one order of magnitude, compared to the standard CZ readout protocol. We also show that for the unrotated surface code, strictly fault-tolerant readout schedules can be found. This opens a new perspective for below-threshold surface-code error correction, where it can be advantageous to use multi-qubit gates instead of two-qubit gates to obtain a better QEC performance.

arXiv:2506.09028•Jan 1, 2025•0 citations

Computation

Jochen Rau

This chapter introduces the basic building blocks of quantum computing and a variety of specific algorithms. It begins with a brief review of classical computing and discusses how its key elements – bits, gates, circuits – carry over to the quantum realm. It highlights crucial differences to the classical case, such as the impossibility of copying a qubit. The quantum circuit model is shown to be universal, and a peculiar variant of quantum computing, based on measurements only, is illustrated. That a quantum computer can perform some calculations more efficiently than a classical computer, at least in principle, is exemplified with the Deutsch-Jozsa algorithm. Other examples covered in this chapter are the variational quantum eigensolver, which can be applied to the study of molecules and classical optimization problems; quantum simulation; and entanglement-assisted metrology.

Oxford University Press eBooks•May 27, 2021•0 citations
We discuss the building blocks of a universal quantum computer within the circuit model of computation and how this is implemented using superconducting quantum circuits. In particular, we discuss, one by one, the creation of quantum registers, resetting of quantum bits, qubit measurements, single-qubit operations, and universal two-qubit gates, and how these are all implemented using the tools from earlier chapters. We discuss how to calibrate the errors in the qubits and in the operations, assigning them complete descriptions via positive maps. We explain how these errors can be corrected and how to implement a fault-tolerant quantum computer, focusing on the paradigm of stabilizer codes and the surface code in particular. We close with a discussion on the outlook for quantum computers in the near term and the NISQ paradigm of computation.
Few technological ideas in recent memory have stirred as much excitement—or skepticism—as quantum computing. The promise is genuine: for certain computational tasks, a quantum machine can do in seconds what would take a classical supercomputer longer than the age of the universe. At the heart of realising that promise is the qubit, the quantum analogue of a classical bit, and among the many physical systems that can host a qubit, superconducting circuits have quietly become the frontrunner. They can be fabricated in the same cleanrooms used to make conventional chips, controlled with ordinary microwave electronics, and scaled up in ways that other approaches cannot yet match. This thesis traces the full arc from first principles to working code. We start with the quantum mechanics a reader needs—superposition, entanglement, measurement—and build from therethrough the physics of superconductivity to the engineering of real qubit circuits. A key character in that story is the Josephson junction: a thin sandwich of metal and insulator whose quirky nonlinear behaviour is what makes the whole enterprise of superconducting qubits possible. A major focus of this work is the surface code, a topological quantum error-correcting code widely regarded as the most promising approach for achieving fault-tolerant quantum computation. We provide a rigorous analysis of the surface code’s lattice structure, stabilizer formalism, syndrome extraction, and decoding algorithms—in particular the minimum-weight perfect matching (MWPM) algorithm. A full Python/Qiskit implementation of a distance-3 surface code is presented, including qubit initialization, syndrome measurement circuits, error simulation, and decoding logic. We close by looking ahead. Modular processors, 3D circuit integration, and the long road to fault-tolerant machines are all on the horizon, and we try to give an honest assessment of where things stand and what the real obstacles are. Throughout, the goal has been to bridge theory and practice—to be precise enough to be useful, but grounded enough to stay connected to what is actually happening in laboratories today.
In Chapter 4 we introduced different quantum gates and quantum circuits and in Chapter 5 we described several quantum algorithms. So far the analysis of the algorithms and the circuits has been made with the assumption that the required unitary operations can be implemented exactly without any error. This is an abstraction. In an actual physical system that implements a quantum algorithm or a quantum circuit there are several sources of errors. The situation is similar in classical computation and to circumvent this problem error correcting codes are used in classical digital computing. Since qubits are more delicate and more susceptible to errors we need to introduce quantum error correcting codes. It is very important, as without such codes it will not be possible to build a scalable quantum computer. Such quantum error correcting codes are introduced in this chapter. However, we will not limit ourselves to the discussion of error correcting codes alone. We will also discuss more general aspects of errors and error correction, like decoherence, decoherence free subspace and fault-tolerance.
This is a comprehensive review on fault-tolerant topological quantum computation with the surface codes. The basic concepts and useful tools underlying fault-tolerant quantum computation, such as universal quantum computation, stabilizer formalism, and measurement-based quantum computation, are also provided in a pedagogical way. Topological quantum computation by brading the defects on the surface code is explained in both circuit-based and measurement-based models in such a way that their relation is clear. The interdisciplinary connections between quantum error correction codes and subjects in other fields such as topological order in condensed matter physics and spin glass models in statistical physics are also discussed. This manuscript will be appeared in SpringerBriefs.
This article provides an introduction to surface code quantum computing. We first estimate the size and speed of a surface code quantum computer. We then introduce the concept of the stabilizer, using two qubits, and extend this concept to stabilizers acting on a two-dimensional array of physical qubits, on which we implement the surface code. We next describe how logical qubits are formed in the surface code array and give numerical estimates of their fault tolerance. We outline how logical qubits are physically moved on the array, how qubit braid transformations are constructed, and how a braid between two logical qubits is equivalent to a controlled-not. We then describe the single-qubit Hadamard, $\stackrel{\ifmmode \hat{}\else \^{}\fi{}}{S}$ and $\stackrel{\ifmmode \hat{}\else \^{}\fi{}}{T}$ operators, completing the set of required gates for a universal quantum computer. We conclude by briefly discussing physical implementations of the surface code. We include a number of Appendices in which we provide supplementary information to the main text.
Quantum error correction (QEC) is one of the crucial building blocks for developing quantum computers that have significant potential for reaching a quantum advantage in applications. Prominent candidates for QEC are stabilizer codes for which periodic readout of stabilizer operators is typically implemented via successive two-qubit entangling gates, and is repeated many times during a computation. To improve QEC performance, it is thus beneficial to make the stabilizer readout faster and less prone to fault-tolerance-breaking errors. Here we design a 3-qubit CZZ gate for superconducting transmon qubits that maps the parity of two data qubits onto one measurement qubit in a single step. We find that the gate can be executed in a duration of 35 35\,35ns with a fidelity of F=99.96 %=99.96 \, \%=99.96%. To optimize the gate, we use an error model obtained from the microscopic gate simulation to systematically suppress Pauli errors that are particularly harmful to the QEC protocol. Using this error model, we investigate the implementation of this 3-qubit gate in a surface code syndrome readout schedule. We find that for the rotated surface code, the implementation of CZZ gates increases the error threshold by nearly 50\% to ≈1.2 %\approx 1.2\,\%≈1.2% and decreases the logical error rate, in the experimental relevant regime, by up to one order of magnitude, compared to the standard CZ readout protocol. We also show that for the unrotated surface code, strictly fault-tolerant readout schedules can be found. This opens a new perspective for below-threshold surface-code error correction, where it can be advantageous to use multi-qubit gates instead of two-qubit gates to obtain a better QEC performance.
This chapter introduces the basic building blocks of quantum computing and a variety of specific algorithms. It begins with a brief review of classical computing and discusses how its key elements – bits, gates, circuits – carry over to the quantum realm. It highlights crucial differences to the classical case, such as the impossibility of copying a qubit. The quantum circuit model is shown to be universal, and a peculiar variant of quantum computing, based on measurements only, is illustrated. That a quantum computer can perform some calculations more efficiently than a classical computer, at least in principle, is exemplified with the Deutsch-Jozsa algorithm. Other examples covered in this chapter are the variational quantum eigensolver, which can be applied to the study of molecules and classical optimization problems; quantum simulation; and entanglement-assisted metrology.