Search

The behavior of real quantum hardware differs strongly from the simple error models typically used when simulating quantum error correction. Error processes are far more complex than simple depolarizing noise applied to single gates, and error rates can vary greatly between different qubits, and at different points in the circuit. Nevertheless, it would be useful to distill all this complicated behavior down to a single parameter: an effective error rate for a simple uniform error model. Here we show that this can be done by means of the average detector likelihood, which quantifies the rate at which error detection events occur. We show that this parameter is predictive of the overall code performance for two variants of the surface code: Floquet codes and the 3-CX surface code. This is then used to define an effective error rate at which simulations for a simple uniform noise model result in the same average detector likelihood, as well as a good prediction of the logical error rate.

Designs for quantum error correction depend strongly on the connectivity of the qubits. For solid state qubits, the most straightforward approach is to have connectivity constrained to a planar graph. Practical considerations may also further restrict the connectivity, resulting in a relatively sparse graph such as the heavy-hex architecture of current IBM Quantum devices. In such cases it is hard to use all qubits to their full potential. Instead, in order to emulate the denser connectivity required to implement well-known quantum error correcting codes, many qubits remain effectively unused. In this work we show how this bug can be turned into a feature. By using the unused qubits of one code to execute another, two codes can be implemented on top of each other, allowing easy application of fault-tolerant entangling gates and measurements. We demonstrate this by realizing a surface code and a Bacon-Shor code on a 133 qubit IBM Quantum device. Using transversal CX gates and lattice surgery we demonstrate entanglement between these logical qubits with code distance up to $d = 4$ and five rounds of stabilizer measurement cycles. The nonplanar coupling between the qubits allows us to simultaneously measure the logical $XX$, $YY$, and $ZZ$ observables. With this we verify the violation of Bell's inequality for both the $d=2$ case with post selection featuring a fidelity of $94\%$, and the $d=3$ instance using only quantum error correction.

Logical qubits encoded into a quantum code exhibit improved error rates when the physical error rates are sufficiently low, below the pseudothreshold. Logical error rates and pseudothresholds can be estimated for specific circuits and noise models, and these estimates provide approximate goals for qubit performance. However, estimates often assume uniform error rates, while real devices have static and/or dynamic distributions of non-identical error rates and may exhibit outliers. These distributions make it more challenging to evaluate, compare, and rank the expected performance of quantum processors. We numerically investigate how the logical error rate depends on parameters of the noise distribution for the subsystem surface code and the compass code on a subdivided hexagonal lattice. Three notable observations are found: (1) the average logical error rate depends on the average of the physical qubit infidelity distribution without sensitivity to higher moments (e.g., variance or outliers) for a wide parameter range; (2) the logical error rate saturates as errors increase at one or a few "bad" locations; and (3) a decoder that is aware of location specific error rates modestly improves the logical error rate. We discuss the implications of these results in the context of several different practical sources of outliers and non-uniform qubit error rates.

Achieving fault-tolerance will require a strong relationship between the hardware and the protocols used. Different approaches will therefore naturally have tailored proof-of-principle experiments to benchmark progress. Nevertheless, repetition codes have become a commonly used basis of experiments that allow cross-platform comparisons. Here we propose methods by which repetition code experiments can be expanded and improved, while retaining cross-platform compatibility. We also consider novel methods of analyzing the results, which offer more detailed insights than simple calculation of the logical error rate.

Spin qubits in semiconductor structures bring the promise of large-scale 2D integration, with the possibility to incorporate the control electronics on the same chip. In order to perform error correction on this platform, the characteristic features of spin qubits need to be accounted for. E.g., qubit readout involves an additional qubit which necessitates careful reconsideration of the qubit layout. The noise affecting spin qubits has further peculiarities such as the strong bias towards dephasing. In this work we consider state-of-the-art error correction codes that require only nearest-neighbour connectivity and are amenable to fast decoding via minimum-weight perfect matching. Compared to the surface code, the XZZX code, the reduced-connectivity surface code, the XYZ$^2$ matching code, and the Floquet code all bring different advantages in terms of error threshold, connectivity, or logical qubit encoding. We present the spin-qubit layout required for each of these error correction codes, accounting for reference qubits required for spin readout. The performance of these codes is studied under circuit-level noise accounting for distinct error rates for gates, readout and qubit decoherence during idling stages., Comment: 25 pages, 18 figures

To run large-scale algorithms on a quantum computer, error-correcting codes must be able to perform a fundamental set of operations, called logic gates, while isolating the encoded information from noise~\cite{Harper2019,Ryan-Anderson2021,Egan2021fault, Chen2022calibrated, Sundaresan2022matching, ryananderson2022implementing, Postler2022demonstration, GoogleAI2023}. We can complete a universal set of logic gates by producing special resources called magic states~\cite{Bravyi2005universal,Maier2013magic, Chamberland2022building}. It is therefore important to produce high-fidelity magic states to conduct algorithms while introducing a minimal amount of noise to the computation. Here, we propose and implement a scheme to prepare a magic state on a superconducting qubit array using error correction. We find that our scheme produces better magic states than those we can prepare using the individual qubits of the device. This demonstrates a fundamental principle of fault-tolerant quantum computing~\cite{Shor96}, namely, that we can use error correction to improve the quality of logic gates with noisy qubits. Additionally, we show we can increase the yield of magic states using adaptive circuits, where circuit elements are changed depending on the outcome of mid-circuit measurements. This demonstrates an essential capability we will need for many error-correction subroutines. Our prototype will be invaluable in the future as it can reduce the number of physical qubits needed to produce high-fidelity magic states in large-scale quantum-computing architectures., Comment: 19 pages, 13 figures, 3 tables, comments welcome; v2 - Updated draft including new appendices following peer review. Includes a section on injecting the encoded magic state into larger codes (explicitly studying the surface code, the heavy-hex code and the color code) and a numerical section interrogating the fault-tolerant properties of the circuit

The recently introduced Floquet codes have already inspired several follow up works in terms of theory and simulation. Here we report the first preliminary results on their experimental implementation, using IBM Quantum hardware. Specifically, we implement the stabilizer measurements of the original Floquet code based on the honeycomb lattice model, as well as the more recently introduced Floquet Color code. The stabilizers of these are measured on a variety of systems, with the rate of syndrome changes used as a proxy for the noise of the device., Comment: This manuscript is not intended for submission to a journal

Quantum error correcting codes are designed to pinpoint exactly when and where errors occur in quantum circuits. This feature is the foundation of their primary task: to support fault-tolerant quantum computation. However, this feature could used as the basis of benchmarking: By analyzing the outputs of even small-scale quantum error correction circuits, a detailed picture can be constructed of error processes across a quantum device. Here we perform an example of such an analysis, using the results of small repetition codes to determine the error rate of each qubit while idle during a syndrome measurement. This provides an idea of the errors experienced by the qubits across a device while they are part of the kind of circuit that we expect to be typical in fault-tolerant quantum computers.

Though some years remain before quantum computation can fully outperform conventional computation, it already provides resources that can be used for exploratory purposes in various fields. This includes certain tasks for procedural generation in computer games, music and art. The so-called `Quantum Blur' method represents the first step on this journey, providing a simple proof-of-principle example of how quantum software can be useful in these areas today. Here we analyse the `Quantum Blur' method and compare it to conventional blur effects. This investigation was guided by discussions with the most prominent user of the method, to determine which features were found most useful. In particular we determine how these features depend on the quantum phenomena of superposition and entanglement.

Matching codes are stabilizer codes based on Kitaev's honeycomb lattice model. The hexagonal form of these codes are particularly well-suited to the heavy-hexagon device layouts currently pursued in the hardware of IBM Quantum. Here we show how the stabilizers of the code can be measured solely through the 2-body measurements that are native to the architecture. The process is then run on 27 and 65 qubit devices, to compare results with simulations for a standard error model. It is found that the results correspond well to simulations where the noise strength is similar to that found in the benchmarking of the devices. The best devices show results consistent with a noise model with an error probability of around $1.5\%-2\%$.

Near term quantum computers suffer from the presence of different noise sources. In order to mitigate for this effect and acquire results with significantly better accuracy, there is the urge of designing efficient error correction or error mitigation schemes. The cost of such techniques is usually high in terms of resource requirements, either in hardware or at the algorithmic level. In this work, we follow a pragmatic approach and we use repetition codes as scalable schemes with the potential to provide more accurate solutions to problems of interest in quantum chemistry and physics. We investigate different repetition code layouts and we propose a circular repetition scheme with connectivity requirements that are native on IBM Quantum hardware. We showcase our approach in multiple IBM Quantum devices and validate our results using a simplified theoretical noise model. We highlight the effect of using the proposed scheme in an electronic structure VQE calculation and in the simulation of time evolution for a quantum Ising model.

Quantum computing is a technology that promises to offer significant advantages during the coming decades. Though the technology is still in a prototype stage, the last few years have seen many of these prototype devices become accessible to the public. This has been accompanied by the open-source development of the software required to use and test quantum hardware in increasingly sophisticated ways. Such tools provide new education opportunities, not just for quantum computing specifically, but also more broadly for quantum information science and even quantum physics as a whole. In this paper we present a case study of one education resource which aims to take advantage of the opportunities: the open-source online textbook `Learn Quantum Computation using Qiskit'. An overview of the topics covered is given, as well as an explanation of the approach taken for each.

Quantum computation is an emerging technology that promises to be a powerful tool in many areas. Though some years likely still remain until significant quantum advantage is demonstrated, the development of the technology has led to a range of valuable resources. These include publicly available prototype quantum hardware, advanced simulators for small quantum programs and programming frameworks to test and develop quantum software. In this provocation paper we seek to demonstrate that these resources are sufficient to provide the first useful results in the field of procedural generation. This is done by introducing a proof-of-principle method: a quantum generalization of a blurring process, in which quantum interference is used to provide a unique effect. Through this we hope to show that further developments in the technology are not required before it becomes useful for procedural generation. Rather, fruitful experimentation with this new technology can begin now., Comment: To be published in the proceedings of FDG 2020

Quantum computation is an emerging technology that promises a wide range of possible use cases. This promise is primarily based on algorithms that are unlikely to be viable over the coming decade. For near-term applications, quantum software needs to be carefully tailored to the hardware available. In this paper, we begin to explore whether near-term quantum computers could provide tools that are useful in the creation and implementation of computer games. The procedural generation of geopolitical maps and their associated history is considered as a motivating example. This is performed by encoding a rudimentary decision making process for the nations within a quantum procedure that is well-suited to near-term devices. Given the novelty of quantum computing within the field of procedural generation, we also provide an introduction to the basic concepts involved., Comment: To be published in the proceedings of the IEEE Conference on Games

Now that ever more sophisticated devices for quantum computing are being developed, we require ever more sophisticated benchmarks. This includes a need to determine how well these devices support the techniques required for quantum error correction. In this paper we introduce the \texttt{topological\_codes} module of Qiskit-Ignis, which is designed to provide the tools necessary to perform such tests. Specifically, we use the \texttt{RepetitionCode} and \texttt{GraphDecoder} classes to run tests based on the repetition code and process the results. As an example, data from a 43 qubit code running on IBM's \emph{Rochester} device is presented., Comment: Source files include data from 'ibmq_melbourne' and 'ibmq_rochester' devices

The surface code is currently the primary proposed method for performing quantum error correction. However, despite its many advantages, it has no native method to fault-tolerantly apply non-Clifford gates. Additional techniques are therefore required to achieve universal quantum computation. Here we propose a hybrid scheme which uses small islands of a qudit variant of the surface code to enhance the computational power of the standard surface code. This allows the non-trivial action of the non-Abelian anyons in the former to process information stored in the latter. Specifically, we show that a non-stabilizer state can be prepared, which allows universality to be achieved.

Scalable and fault-tolerant quantum computation will require error correction. This will demand constant measurement of many-qubit observables, implemented using a vast number of CNOT gates. Indeed, practically all operations performed by a fault-tolerant device will be these CNOTs, or equivalent two-qubit controlled operations. It is therefore important to devise benchmarks for these gates that explicitly quantify their effectiveness at this task. Here we develop such benchmarks, and demonstrate their use by applying them to a range of differently implemented controlled gates and a particular quantum error correcting code. Specifically, we consider spin qubits confined to quantum dots that are coupled either directly or via floating gates to implement the minimal 17-qubit instance of the surface code. Our results show that small differences in the gate fidelity can lead to large differences in the performance of the surface code. This shows that gate fidelity is not, in general, a good predictor of code performance.

Quantum processors with sizes in the 10-100 qubit range are now increasingly common. However, with increased size comes increased complexity for benchmarking. The effectiveness of a given device may vary greatly between different tasks, and will not always be easy to predict from single and two qubit gate fidelities. For this reason, it is important to assess processor quality for a range of important tasks. In this work we propose and implement tests based on random quantum circuits. These are used to evaluate multiple different superconducting qubit devices, with sizes from 5 to 19 qubits, from two hardware manufacturers: IBM Research and Rigetti. The data is analyzed to give a quantitive description of how the devices perform. We also describe how it can be used for a qualititive description accessible to the layperson, by being played as a game.

The Decodoku project seeks to let users get hands-on with cutting-edge quantum research through a set of simple puzzle games. The design of these games is explicitly based on the problem of decoding qudit variants of surface codes. This problem is presented such that it can be tackled by players with no prior knowledge of quantum information theory, or any other high-level physics or mathematics. Methods devised by the players to solve the puzzles can then directly be incorporated into decoding algorithms for quantum computation. In this paper we give a brief overview of the novel decoding methods devised by players, and provide short postmortem for Decodoku v1.0-v4.1., Comment: Extended version of article in the proceedings of the GSGS'17 conference (see https://gsgs.ch/gsgs17/)

The repetition code is an important primitive for the techniques of quantum error correction. Here we implement repetition codes of at most $15$ qubits on the $16$ qubit \emph{ibmqx3} device. Each experiment is run for a single round of syndrome measurements, achieved using the standard quantum technique of using ancilla qubits and controlled operations. The size of the final syndrome is small enough to allow for lookup table decoding using experimentally obtained data. The results show strong evidence that the logical error rate decays exponentially with code distance, as is expected and required for the development of fault-tolerant quantum computers. The results also give insight into the nature of noise in the device., Comment: 7 pages

Currently, the mainstream approach to quantum computing is through surface codes. One way to store and manipulate quantum information with these to create defects in the codes which can be moved and used as if they were particles. Specifically, they simulate the behaviour of exotic particles known as Majoranas, which are a kind of non-Abelian anyon. By exchanging these particles, important gates for quantum computation can be implemented. Here we investigate the simplest possible exchange operation for two surface code Majoranas. This is found to act non-trivially on only five qubits. The system is then truncated to these five qubits, so that the exchange process can be run on the IBM 5Q processor. The results demonstrate the expected effect of the exchange. This paper has been written in a style that should hopefully be accessible to both professional and amateur scientists.

The surface code is currently the leading proposal to achieve fault-tolerant quantum computation. Among its strengths are the plethora of known ways in which fault-tolerant Clifford operations can be performed, namely, by deforming the topology of the surface, by the fusion and splitting of codes and even by braiding engineered Majorana modes using twist defects. Here we present a unified framework to describe these methods, which can be used to better compare different schemes, and to facilitate the design of hybrid schemes. Our unification includes the identification of twist defects with the corners of the planar code. This identification enables us to perform single-qubit Clifford gates by exchanging the corners of the planar code via code deformation. We analyse ways in which different schemes can be combined, and propose a new logical encoding. We also show how all of the Clifford gates can be implemented with the planar code without loss of distance using code deformations, thus offering an attractive alternative to ancilla-mediated schemes to complete the Clifford group with lattice surgery., Comment: 18 pages, 15 figures, comments welcome; v2 - improvements and clarifications given in the manuscript. No significant changes in the main conclusions; v3 - same as v2 with corrected fig. 2 and ; v4 - minor changes following peer review. One new figure; v5 - version to be published, final author copy, minor typos and mistakes corrected

Current quantum technology is approaching the system sizes and fidelities required for quantum error correction. It is therefore important to determine exactly what is needed for proof-of-principle experiments, which will be the first major step towards fault-tolerant quantum computation. Here we propose a surface code based experiment that is the smallest, both in terms of code size and circuit depth, that would allow errors to be detected and corrected for both the $X$ and $Z$ basis of a qubit. This requires $17$ physical qubits initially prepared in a product state, on which $16$ two-qubit entangling gates are applied before a final measurement of all qubits. A platform agnostic error model is applied to give some idea of the noise levels required for success. It is found that a true demonstration of quantum error correction will require fidelities for the preparation and measurement of qubits and the entangling gates to be above $99\%$., Comment: Additional author and numerics for v3

The boundary of a 2D topological superconductor can be modeled by a conformal field theory. Here we demonstrate the behaviors of this high level description emerging from a microscopic model at finite temperatures. To achieve that, we analyze the low energy sector of Kitaev's honeycomb lattice model and probe its energy current. We observe that the scaling of the energy current with temperature reveals the central charge of the conformal field theory, which is in agreement with the Chern number of the bulk. Importantly, these currents can discriminate between distinct topological phases at finite temperatures. We assess the resilience of this measurement of the central charge under coupling disorder, bulk dimerisation and defects at the boundary, thus establishing it as a favorable means of experimentally probing topological superconductors., Comment: updated -- minor tweaks to text and figures

Quantum gates in topological quantum computation are performed by braiding non-Abelian anyons. These braiding processes can presumably be performed with very low error rates. However, to make a topological quantum computation architecture truly scalable, even rare errors need to be corrected. Error correction for non-Abelian anyons is complicated by the fact that it needs to be performed on a continuous basis and further errors may occur while we are correcting existing ones. Here, we provide the first study of this problem and prove its feasibility, establishing non-Abelian anyons as a viable platform for scalable quantum computation. We thereby focus on Ising anyons as the most prominent example of non-Abelian anyons and show that for these a finite error rate can indeed be corrected continuously. There is a threshold error rate $p_c>0$ such that for all error rates $p

We consider a class of decoding algorithms that are applicable to error correction for both Abelian and non-Abelian anyons. This class includes multiple algorithms that have recently attracted attention, including the Bravyi-Haah RG decoder. They are applied to both the problem of single shot error correction (with perfect syndrome measurements) and that of active error correction (with noisy syndrome measurements). For Abelian models we provide a threshold proof in both cases, showing that there is a finite noise threshold under which errors can be arbitrarily suppressed when any decoder in this class is used. For non-Abelian models such a proof is found for the single shot case. The means by which decoding may be performed for active error correction of non-Abelian anyons is studied in detail. Differences with the Abelian case are discussed.

Engineering complex non-Abelian anyon models with simple physical systems is crucial for topological quantum computation. Unfortunately, the simplest systems are typically restricted to Majorana zero modes (Ising anyons). Here we go beyond this barrier, showing that the $\mathbb{Z}_4$ parafermion model of non-Abelian anyons can be realized on a qubit lattice. Our system additionally contains the Abelian $D(\mathbb{Z}_4)$ anyons as low-energetic excitations. We show that braiding of these parafermions with each other and with the $D(\mathbb{Z}_4)$ anyons allows the entire $d=4$ Clifford group to be generated. The error correction problem for our model is also studied in detail, guaranteeing fault-tolerance of the topological operations. Crucially, since the non-Abelian anyons are engineered through defect lines rather than as excitations, non-Abelian error correction is not required. Instead the error correction problem is performed on the underlying Abelian model, allowing high noise thresholds to be realized., Comment: 11+10 pages, 14 figures; v2: accepted for publication in Phys. Rev. X; 4 new figures, performance of phase-gate explained in more detail

We study and generalize the class of qubit topological stabilizer codes that arise in the Abelian phase of the honeycomb lattice model. The resulting family of codes, which we call `matching codes' realize the same anyon model as the surface codes, and so may be similarly used in proposals for quantum computation. We show that these codes are particularly well suited to engineering twist defects that behave as Majorana modes. A proof of principle system that demonstrates the braiding properties of the Majoranas is discussed that requires only three qubits., Comment: Published version

To use quantum systems for technological applications we first need to preserve their coherence for macroscopic timescales, even at finite temperature. Quantum error correction has made it possible to actively correct errors that affect a quantum memory. An attractive scenario is the construction of passive storage of quantum information with minimal active support. Indeed, passive protection is the basis of robust and scalable classical technology, physically realized in the form of the transistor and the ferromagnetic hard disk. The discovery of an analogous quantum system is a challenging open problem, plagued with a variety of no-go theorems. Several approaches have been devised to overcome these theorems by taking advantage of their loopholes. Here we review the state-of-the-art developments in this field in an informative and pedagogical way. We give the main principles of self-correcting quantum memories and we analyze several milestone examples from the literature of two-, three- and higher-dimensional quantum memories., Comment: v2,3,4 - Final author copy; to appear in Rev. Mod. Phys.; 55 pages, 29 figures, 254 references; improvements include new sections on the Curie-Weiss model, open questions on interacting anyon models, and a discussion on SPT phases. Criteria for self correction is simplified, and the discussion on the 4D toric code is extended. Other changes are made following new work since submission of v1

Hard-decision renormalization group (HDRG) decoders are an important class of decoding algorithms for topological quantum error correction. Due to their versatility, they have been used to decode systems with fractal logical operators, color codes, qudit topological codes, and non-Abelian systems. In this work, we develop a method of performing HDRG decoding which combines strenghts of existing decoders and further improves upon them. In particular, we increase the minimal number of errors necessary for a logical error in a system of linear size $L$ from $\Theta(L^{2/3})$ to $\Omega(L^{1-\epsilon})$ for any $\epsilon>0$. We apply our algorithm to decoding $D(\mathbb{Z}_d)$ quantum double models and a non-Abelian anyon model with Fibonacci-like fusion rules, and show that it indeed significantly outperforms previous HDRG decoders. Furthermore, we provide the first study of continuous error correction with imperfect syndrome measurements for the $D(\mathbb{Z}_d)$ quantum double models. The parallelized runtime of our algorithm is $\text{poly}(\log L)$ for the perfect measurement case. In the continuous case with imperfect syndrome measurements, the averaged runtime is $O(1)$ for Abelian systems, while continuous error correction for non-Abelian anyons stays an open problem., Comment: 14 pages, 11 figures; v2: to appear in New J. Phys

Current approaches for building quantum computing devices focus on two-level quantum systems which nicely mimic the concept of a classical bit, albeit enhanced with additional quantum properties. However, rather than artificially limiting the number of states to two, the use of d-level quantum systems (qudits) could provide advantages for quantum information processing. Among other merits, it has recently been shown that multi-level quantum systems can offer increased stability to external disturbances - a key problem in current technologies. In this study we demonstrate that topological quantum memories built from qudits, also known as abelian quantum double models, exhibit a substantially increased resilience to noise. That is, even when taking into account the multitude of errors possible for multi-level quantum systems, topological quantum error correction codes employing qudits can sustain a larger error rate than their two-level counterparts. In particular, we find strong numerical evidence that the thresholds of these error-correction codes are given by the hashing bound. Considering the significantly increased error thresholds attained, this might well outweigh the added complexity of engineering and controlling higher dimensional quantum systems., Comment: 7 pages, 3 figures

The possibility of quantum computation using non-Abelian anyons has been considered for over a decade. However the question of how to obtain and process information about what errors have occurred in order to negate their effects has not yet been considered. This is in stark contrast with quantum computation proposals for Abelian anyons, for which decoding algorithms have been tailor-made for many topological error-correcting codes and error models. Here we address this issue by considering the properties of non-Abelian error correction in general. We also choose a specific anyon model and error model to probe the problem in more detail. The anyon model is the charge submodel of $D(S_3)$. This shares many properties with important models such as the Fibonacci anyons, making our method applicable in general. The error model is a straightforward generalization of those used in the case of Abelian anyons for initial benchmarking of error correction methods. It is found that error correction is possible under a threshold value of $7 \%$ for the total probability of an error on each physical spin. This is remarkably comparable with the thresholds for Abelian models.

Here we study an efficient algorithm for decoding the topological codes. It is based on a simple principle, which should allow straightforward generalization to complex decoding problems. It is benchmarked with the planar code for both i.i.d. and spatially correlated errors and is found to compare well with existing methods., Comment: v3: Corrected error and added data for correlated errors. v4: Added data for improved version of decoder. This is the published version

We propose and study a model of a quantum memory that features self-correcting properties and a lifetime growing arbitrarily with system size at non-zero temperature. This is achieved by locally coupling a 2D L x L toric code to a 3D bath of bosons hopping on a cubic lattice. When the stabilizer operators of the toric code are coupled to the displacement operator of the bosons, we solve the model exactly via a polaron transformation and show that the energy penalty to create anyons grows linearly with L. When the stabilizer operators of the toric code are coupled to the bosonic density operator, we use perturbation theory to show that the energy penalty for anyons scales with ln(L). For a given error model, these energy penalties lead to a lifetime of the stored quantum information growing respectively exponentially and polynomially with L. Furthermore, we show how to choose an appropriate coupling scheme in order to hinder the hopping of anyons (and not only their creation) with energy barriers that are of the same order as the anyon creation gaps. We argue that a toric code coupled to a 3D Heisenberg ferromagnet realizes our model in its low-energy sector. Finally, we discuss the delicate issue of the stability of topological order in the presence of perturbations. While we do not derive a rigorous proof of topological order, we present heuristic arguments suggesting that topological order remains intact when perturbative operators acting on the toric code spins are coupled to the bosonic environment., Comment: This manuscript has some overlap with arXiv:1209.5289. However, a different model is the focus of the current work. Since this model is exactly solvable, it allows a clearer demonstration of the principle behind our quantum memory proposal. v2: minor changes and additional reference

Recent studies have shown that topological models with interacting anyonic quasiparticles can be used as self-correcting quantum memories. Here we study the behaviour of these models at thermal equilibrium. It is found that the interactions allow topological order to exist at finite temperature, not only in an extension of the ground state phase but also in a novel form of topologically ordered phase. Both phases are found to support self-correction in all models considered, and the transition between them corresponds to a change in the scaling of memory lifetime with system size., Comment: 5 pages, only references on fifth

Minimum-weight perfect matching (MWPM) has been been the primary classical algorithm for error correction in the surface code, since it is of low runtime complexity and achieves relatively low logical error rates [Phys. Rev. Lett. 108, 180501 (2012)]. A Markov chain Monte Carlo (MCMC) algorithm [Phys. Rev. Lett. 109, 160503 (2012)] is able to achieve lower logical error rates and higher thresholds than MWPM, but requires a classical runtime complexity which is super-polynomial in L, the linear size of the code. In this work we present an MCMC algorithm that achieves significantly lower logical error rates than MWPM at the cost of a polynomially increased classical runtime complexity. For error rates p close to the threshold, our algorithm needs a runtime complexity which is increased by O(L^2) relative to MWPM in order to achieve a lower logical error rate. If p is below an L-dependent critical value, no increase in the runtime complexity is necessary any longer. For p->0, the logical error rate achieved by our algorithm is exponentially smaller (in L) than that of MWPM, without requiring an increased runtime complexity. Our algorithm allows for trade-offs between runtime and achieved logical error rates as well as for parallelization, and can be also used to correct in the case of imperfect stabilizer measurements., Comment: 10 pages, 10 figures; v2: includes community feedback

Quantum states are inherently fragile, making their storage a major concern for many practical applications and experimental tests of quantum mechanics. The field of quantum memories is concerned with how this storage may be achieved, covering everything from the physical systems best suited to the task to the abstract methods that may be used to increase performance. This review concerns itself with the latter, giving an overview of error correction and self-correction, and how they may be used to achieve fault-tolerant quantum computation. The planar code is presented as a concrete example, both as a quantum memory and as a framework for quantum computation., Comment: Review article for Journal of Modern Optics

In [Phys. Rev. A 88, 062313 (2013)] we proposed and studied a model for a self-correcting quantum memory in which the energetic cost for introducing a defect in the memory grows without bounds as a function of system size. This positive behavior is due to attractive long-range interactions mediated by a bosonic field to which the memory is coupled. The crucial ingredients for the implementation of such a memory are the physical realization of the bosonic field as well as local five-body interactions between the stabilizer operators of the memory and the bosonic field. Here, we show that both of these ingredients appear in a low-energy effective theory of a Hamiltonian that involves only two-body interactions between neighboring spins. In particular, we consider the low-energy, long-wavelength excitations of an ordered Heisenberg ferromagnet (magnons) as a realization of the bosonic field. Furthermore, we present perturbative gadgets for generating the required five-spin operators. Our Hamiltonian involving only local two-body interactions is thus expected to exhibit self-correcting properties as long as the noise affecting it is in the regime where the effective low-energy description remains valid., Comment: 14 pages, 3 figures

Here we investigate the effect lattice geometry has on the lifetime of two-dimensional topological quantum memories. Initially, we introduce various lattice patterns and show how the error-tolerance against bit-flips and phase-flips depends on the structure of the underlying lattice. Subsequently, we investigate the dependence of the lifetime of the quantum memory on the structure of the underlying lattice when it is subject to a finite temperature. Importantly, we provide a simple effective formula for the lifetime of the memory in terms of the average degree of the lattice. Finally, we propose optimal geometries for the Josephson junction implementation of topological quantum memories., Comment: 12 pages, 6 figures

We study the two-dimensional toric code Hamiltonian with effective long-range interactions between its anyonic excitations induced by coupling the toric code to external fields. It has been shown that such interactions allow to increase the lifetime of the stored quantum information arbitrarily by making $L$, the linear size of the memory, larger [Phys. Rev. A 82 022305 (2010)]. We show that for these systems the choice of boundary conditions (open boundaries as opposed to periodic boundary conditions) is not a mere technicality; the influence of anyons produced at the boundaries becomes in fact dominant for large enough $L$. This influence can be both beneficial or detrimental. In particular, we study an effective Hamiltonian proposed in [Phys. Rev. B 83 115415 (2011)] that describes repulsion between anyons and anyon holes. For this system, we find a lifetime of the stored quantum information that grows exponentially in $L^2$ for both periodic and open boundary conditions, though the exponent in the latter case is found to be less favourable. However, $L$ is upper-bounded through the breakdown of the perturbative treatment of the underlying Hamiltonian., Comment: 14+2 pages, 10 figures, revtex; v2: author added; v3: minor improvements, to appear in Phys. Rev. A

An algorithm is presented for error correction in the surface code quantum memory. This is shown to correct depolarizing noise up to a threshold error rate of 18.5%, exceeding previous results and coming close to the upper bound of 18.9%. The time complexity of the algorithm is found to be polynomial with error suppression, allowing efficient error correction for codes of realistic sizes., Comment: 5 pages, 3 figures. Published version + extra material; Phys. Rev. Lett. (2012)

We propose a novel parameter, the anyonic topological entropy, designed to detect the error correcting phase of a topological memory. Unlike similar quantities such as the topological entropy, the anyonic topological entropy is defined using the states of the anyon occupations. As such, though the parameter deals with phases and phase transitions that are quantum in nature, it can be calculated solely from classical probability distributions. In many cases, these calculations will be tractable using efficient classical algorithms. The parameter therefore provides a new avenue for efficient studies of anyonic systems., Comment: 8 pages, 3 figures; J. Phys. A: Math. Theor. (2012)

We numerically study the effects of two forms of quenched disorder on the anyons of the toric code. Firstly, a new class of codes based on random lattices of stabilizer operators is presented, and shown to be superior to the standard square lattice toric code for certain forms of biased noise. It is further argued that these codes are close to optimal, in that they tightly reach the upper bound of error thresholds beyond which no correctable CSS codes can exist. Additionally, we study the classical motion of anyons in toric codes with randomly distributed onsite potentials. In the presence of repulsive long-range interaction between the anyons, a surprising increase with disorder strength of the lifetime of encoded states is reported and explained by an entirely incoherent mechanism. Finally, the coherent transport of the anyons in the presence of both forms of disorder is investigated, and a significant suppression of the anyon motion is found., Comment: 13 pages, 12 figures

The electron spin is a natural two level system that allows a qubit to be encoded. When localized in a gate defined quantum dot, the electron spin provides a promising platform for a future functional quantum computer. The essential ingredient of any quantum computer is entanglement---between electron spin qubits---commonly achieved via the exchange interaction. Nevertheless, there is an immense challenge as to how to scale the system up to include many qubits. Here we propose a novel architecture of a large scale quantum computer based on a realization of long-distance quantum gates between electron spins localized in quantum dots. The crucial ingredients of such a long-distance coupling are floating metallic gates that mediate electrostatic coupling over large distances. We show, both analytically and numerically, that distant electron spins in an array of quantum dots can be coupled selectively, with coupling strengths that are larger than the electron spin decay and with switching times on the order of nanoseconds., Comment: 11 pages, 8 figures

Calculation of topological order parameters, such as the topological entropy and topological mutual information, are used to determine whether states possess topological order. Their calculation is expected to give reliable results when the ground states of gapped Hamiltonians are considered, since non-topological correlations are suppressed by a finite correlation length. However, studies of thermal states and the effects of incoherent errors require calculations involving mixed states. Here we show that such mixed states can effectively lead to a diverging correlation length, and hence may give misleading results when these order parameters are calculated. To solve this problem, we propose a novel method to calculate the quantity, allowing topologically ordered states to be identified with greater confidence., Comment: 6 pages, 2 figures

Anderson localization emerges in quantum systems when randomised parameters cause the exponential suppression of motion. Here we consider this phenomenon in topological models and establish its usefulness for protecting topologically encoded quantum information. For concreteness we employ the toric code. It is known that in the absence of a magnetic field this can tolerate a finite initial density of anyonic errors, but in the presence of a field anyonic quantum walks are induced and the tolerable density becomes zero. However, if the disorder inherent in the code is taken into account, we demonstrate that the induced localization allows the topological quantum memory to regain a finite critical anyon density, and the memory to remain stable for arbitrarily long times. We anticipate that disorder inherent in any physical realisation of topological systems will help to strengthen the fault-tolerance of quantum memories., Comment: 5 pages, 2 figures. To appear in PRL. Presented as a contributed talk at QIP 2011

In three spatial dimensions, particles are limited to either bosonic or fermionic statistics. Two-dimensional systems, on the other hand, can support anyonic quasiparticles exhibiting richer statistical behaviours. An exciting proposal for quantum computation is to employ anyonic statistics to manipulate information. Since such statistical evolutions depend only on topological characteristics, the resulting computation is intrinsically resilient to errors. So-called non-Abelian anyons are most promising for quantum computation, but their physical realization may prove to be complex. Abelian anyons, however, are easier to understand theoretically and realize experimentally. Here we show that complex topological memories inspired by non-Abelian anyons can be engineered in Abelian models. We explicitly demonstrate the control procedures for the encoding and manipulation of quantum information in specific lattice models that can be implemented in the laboratory. This bridges the gap between requirements for anyonic quantum computation and the potential of state-of-the-art technology., Comment: 15 pages, 3 figures. To appear in Annals of Physics