Implementing fault-tolerant quantum computing necessitates the realization of logical non-Clifford gates, which requires the preparation of specific quantum states known as magic states. However, IBM’s heavy-hexagon structure, which has limited qubit connectivity, presents challenges in adapting quantum error correction codes such as the surface code. Several methods have been proposed to address these challenges by adapting the surface code to the heavy-hexagon architecture. In this study, we implement the magic state injection process within two distinct implementations of surface codes (standard and rotated methods) suitable for the heavy-hexagon structure and compare their logical error rates. Furthermore, we propose initialization methods to enhance the performance of magic state injection in the heavy-hexagon structure, thereby efficiently achieving logical non-Clifford gates with reduced error rates.
The surface code family is a promising approach to implementing fault-tolerant quantum computations. Universal fault-tolerance requires error-corrected non-Clifford operations, in addition to Clifford gates, and for the former, it is imperative to experimentally demonstrate additional resources known as magic states. Another challenge is to efficiently embed surface codes into quantum hardware with connectivity constraints. This work simultaneously addresses both challenges by employing a qubit-efficient rotated heavy-hexagonal surface code for IBM quantum processors (ibm_fez) and implementing the magic state injection protocol. Our work reports error thresholds for both logical bit- and phase-flip errors, of [Formula: see text] and [Formula: see text], respectively, which are higher than the threshold values previously reported with traditional embedding. The post-selection-based preparation of logical magic states [Formula: see text] and [Formula: see text] achieve fidelities of [Formula: see text] and [Formula: see text], respectively, which are both above the magic state distillation threshold. The post-selection process yields an average success rate of [Formula: see text]. Additionally, we report the minimum fidelity among injected arbitrary single logical qubit states as [Formula: see text]. Our work demonstrates the potential for realising non-Clifford logical gates by producing high-fidelity logical magic states on IBM quantum devices.
The surface code family is a promising approach to implementing fault-tolerant quantum computations. Universal fault-tolerance quantum computing requires error-corrected nonClifford operations, in addition to Clifford gates, and for the former, it is important to experimentally demonstrate additional resources known as magic states. Another challenge is to efficiently embed surface codes into quantum hardware with connectivity constraints. This work simultaneously addresses both challenges by employing a qubit-efficient rotated heavyhexagonal surface code for IBM quantum processors (ibm_fez) and implementing the magic state injection protocol. Our work reports error thresholds for both logical bit- and phase-flip errors, of
≈0.37%and
≈0.31%, respectively, which are higher than the threshold values previously reported with traditional embedding. The post-selection-based preparation of logical magic states
∣HL⟩and
∣TL⟩achieves fidelities of
0.8806±0.0002and
0.8665±0.0003, respectively, which are both above the magic state distillation threshold. Our work demonstrates the potential for realising nonClifford logical gates by producing high-fidelity logical magic states on IBM quantum devices.
Fault-tolerant quantum computing based on the surface code requires magic states to achieve universality. The initially prepared magic states have low fidelity and need to be purified by a costly procedure called magic state distillation. The high spatial-temporal cost for distillation can be reduced by improving the fidelity of initial magic states. Prior works have investigated state injection approaches on the regular surface code. In this work, we propose a magic state injection method for the rotated surface code that requires fewer physical qubits to encode one logical qubit. Analytical results show that our method could achieve lower logical error rates than the state-of-the-art approach for the regular surface code in [1]. When both the two-qubit gate and single-qubit operation error rates are p, the new method results in a logical error rate to 34p/15 compared to 46p/15 in [1]. This fidelity improvement and fewer qubit encoding requirement would help reduce the overhead of fault-tolerant quantum computation, which is crucial for practical implementation in the near term.
Topological quantum error correction is a milestone in the scaling roadmap of quantum computers, which targets circuits with trillions of gates that would allow running quantum algorithms for real-world problems. The square-lattice surface code has become the workhorse to address this challenge, as it poses milder requirements on current devices both in terms of required error rates and small local connectivities. In some platforms, however, the connectivities are kept even lower in order to minimise gate errors at the hardware level, which limits the error correcting codes that can be directly implemented on them. In this work, we make a comparative study of possible strategies to overcome this limitation for the heavy-hexagonal lattice, the architecture of current IBM superconducting quantum computers. We explore two complementary strategies: the search for an efficient embedding of the surface code into the heavy-hexagonal lattice, as well as the use of codes whose connectivity requirements are naturally tailored to this architecture, such as subsystem-type and Floquet codes. Using noise models of increased complexity, we assess the performance of these strategies for IBM devices in terms of their error thresholds and qubit footprints. An optimized SWAP-based embedding of the surface code is found to be the most promising strategy towards a near-term demonstration of quantum error correction advantage.
Quantum error correction represents a significant advancement in large-scale quantum computing. However, achieving fault-tolerant implementations of non-Clifford logical gates with reduced overhead remains a challenge in the popular surface code strategy. Recent advances have underscored the need for a substantial code distance to attain complete fault tolerance. Here, we introduce a continuous fault-tolerant scheme for non-Clifford logical gates via multiple injections. Unlike existing protocols that focus on a single logical chain, our approach utilizes multiple logical chains, each of which can employ the same or different logical rotation angles to initialize a non-Clifford state. Compared to previous efforts, our protocol significantly alleviates the challenges associated with the requirement for a large code distance and reduces the corresponding resource overheads, making it more feasible to be implemented in current midscale chips via the surface code strategy.
Fault tolerance is widely regarded as indispensable for achieving scalable and reliable quantum computing. However, the spacetime overhead required for fault-tolerant quantum computating remains prohibitively large. A critical challenge arises in many quantum algorithms with Clifford +
φ compiling, where logical rotation gates
RZL(φ) serve as essential components. The Eastin-Knill theorem prevents their transversal implementation in quantum error correction codes and necessitating resource-intensive workarounds through T-gate compilation combined with magic state distillation and injection. In this work, we consider error-structure-tailored fault tolerance, where fault-tolerance conditions are analyzed by combining perturbative analysis of realistic dissipative noise processes with the structural properties of stabilizer codes. Based on this framework, we design 1-fault-tolerant continuous-angle rotation gates in stabilizer codes, implemented via dispersive-coupling Hamiltonians. Our approach could circumvent the need for T-gate compilation and distillation, offering a hardware-efficient solution that maintains simplicity, minimizes physical footprint, and requires only nearest-neighbor interactions. Integrating with recent small-angle-state preparation techniques, we can suppress the gate error to
91∣φ∣p2 for small rotation angle (where p denotes the physical error rate). For current achievable hardware parameters (
p=10−3), this enables reliable execution of over
107 small-angle rotations when
∣φ∣≈10−3, meeting the requirements of many near-term quantum applications. Compared to the 15-to-1 magic state distillation and magic state cultivation approaches, our method reduces spacetime resource costs by factors of 1337.5 and 43.6, respectively, for a Heisenberg Hamiltonian simulation task under realistic hardware assumptions.