Managing Performance Trade-Offs in Quantum Code Design

Quantum error correction is facing a critical dilemma: do we choose the low-overhead efficiency of Quantum LDPC codes or the robust fault tolerance of surface codes? A groundbreaking new paper from the IBM Quantum team solves this trade-off by introducing a powerful new architecture: Concatenating Algebraic Codes over High-Rate Quantum LDPC Codes. The core challenge with high-rate qLDPC codes is that a single error block can cause correlated faults across multiple logical qubits. This paper introduces a brilliant workaround. Instead of treating logical qubits individually, they bundle them into a large logical Galois qudit. Then, they wrap this structure in a Quantum Reed-Solomon outer code using advanced list decoding techniques. The results are a game-changer for fault-tolerant quantum computing. Under a 10^-3 physical noise floor, this concatenated approach successfully pushes performance into the ultra-reliable teraquop regime, all while maintaining a remarkably low physical qubit overhead. It bridges the gap between theoretical efficiency and practical scalability. What are your thoughts on using concatenated algebraic codes to scale fault-tolerant hardware? Let's discuss in the comments. #QuantumComputing #QuantumErrorCorrection #QEC #QuantumLDPC #IBMQuantum #Physics #DeepTech

New preprint out today with my PhD student Marvin Richter, together with Ingrid Strandberg and Simone Gasparinetti of the 202Q-lab, all at WACQT - Wallenberg Centre for Quantum Technology at Chalmers tekniska högskola: ”Overhead in quantum circuits with time-multiplexed qubit control” https://lnkd.in/d8tVVxjA We analyse an important scaling challenge for quantum computers. It would be good to reduce the number of control lines going into the fridge hosting superconducting qubits, to reduce cooling requirements and the amount of electronics. But doing so risks quantum algorithms taking longer to execute and thus becoming more affected by noise, since fewer qubits can be controlled in parallel with fewer control lines. We quantify this trade-off and find it to be surprisingly benign. We show that couplers for two-qubit gates can be grouped on common drive lines without any overhead up to a limit set by the connectivity of the qubits. For single-qubit gates, we find that the serialization overhead generally scales only logarithmically in the number of qubits sharing a drive line. We are able to explain this finding using queueing theory. These results are promising for the continued progress towards large-scale quantum computers. The number of control lines in a quantum computer can be significantly reduced without introducing much overhead in execution time for quantum algorithms.

New work from a Harvard team highlights a major bottleneck in fault-tolerant quantum computing: the classical decoder used in quantum error correction. Quick primer on QEC: 1. Encode: A logical qubit is spread across many physical qubits, so no single error destroys the information. 2. Detect: Stabilizer measurements run repeatedly. They do not reveal the quantum state, but they do flag when something has gone wrong. The pattern of those flags is called the syndrome. 3. Decode: A classical computer reads the syndrome and infers which error most likely occurred. 4. Correct: The correction is applied, and the logical qubit survives. Step 3 is where things get hard. For quantum LDPC codes, one of the most promising routes to efficient fault tolerance, practical decoders have usually forced a tradeoff between speed and accuracy: the fast ones are too weak, and the accurate ones are too slow for real-time use. This paper introduces Cascade, a geometry-aware convolutional neural decoder. The key idea is not just “use a neural network,” but to build the structure of the code directly into the model: locality, translation equivariance, and anisotropy. That makes this feel less like generic ML and more like architecture co-design. Some of the headline results: - On the [[144, 12, 12]] Gross code, Cascade achieves logical error rates up to 17x lower than prior practical decoders, with 3–5 orders of magnitude higher throughput - It reveals a “waterfall” regime in which logical errors fall much faster than standard distance-based formulas would suggest, largely because earlier decoders were not strong enough to expose it - In one surface code example, that translates to roughly 40% fewer physical qubits to reach a target logical error rate of 10^-9 - Its confidence estimates are well calibrated, which enables post-selection. In one setting on the [[72, 12, 6]] code, that implies roughly 20x fewer retries for repeat-until-success protocols such as magic state distillation - Current GPU latencies already fit the timing budgets for trapped-ion and neutral-atom platforms. Superconducting qubits still require a tighter ~1 microsecond budget, with FPGA and ASIC paths supported by the hardware estimates in the supplement The broader takeaway: decoder quality is not just an implementation detail. It directly shapes how many qubits and how much time fault-tolerant quantum computing actually requires, and those costs may be meaningfully lower than standard estimates assume. Paper: https://lnkd.in/g9D82Ry8

Computational regimes in matrix-product-state-based quantum trajectory simulations. We explore the subtle regimes for classically simulating and hence “dequantizing” noisy quantum hardware and many-body dynamics. https://lnkd.in/dqa2Z-db In detail, the efficient simulation of open quantum systems is central to modeling noisy quantum hardware and many-body dynamics. In trajectory-based tensor network methods, cost is often associated with trajectory-level quantities such as entanglement growth or bond dimension. However, the total cost of a fixed-accuracy simulation also depends on statistical sampling, and the interplay between per-trajectory complexity and sampling effort remains poorly understood. Here we introduce a cost-resolved framework for #matrixproductstate (MPS)-based quantum trajectory simulations that decomposes total cost into memory per trajectory, runtime per trajectory, and sampling effort. We show that physically equivalent stochastic unravelings of the same Lindblad dynamics do not necessarily reduce total cost, but instead redistribute cost between trajectory complexity and statistical convergence. This trade-off is quantified by two dimensionless inflation factors: a bond dimension inflation α and a sampling inflation κ, which together determine the preferred unraveling under hardware-dependent memory and parallelism constraints. We provide a practical protocol for extracting (α,κ) from modest pilot simulations and demonstrate it using benchmarks across multiple noise channels. The resulting decision maps show that the computationally favorable unraveling can change with noise strength, time-step resolution, system size, and available parallelism. These results establish unraveling choice as a hardware-aware simulation design problem rather than an intrinsic optimization of trajectory entanglement alone. Warm thanks to Aaron Sander, Simon Cichy, Martin Eigel, Maximilian Fröhlich, Tom Peham, and Robert Wille for the once again wonderful collaboration.