Fault-tolerant quantum computing protects fragile qubits with quantum error-correcting codes, and quantum low-density parity-check (qLDPC) codes are exciting because they need roughly ten times fewer physical qubits than the widely used surface code — but qLDPC codes natively support only a limited set of operations, so a real program must be broken down into a huge number of those operations, blowing execution time out to tens of days; this paper (Seoul National University — Jungmin Cho, Jangwoo Kim, and colleagues) presents ACQC, a software-hardware co-design that accelerates computation on qLDPC codes so their large qubit savings can finally be used without the crippling time cost.
The argument in one glance
-
Problem
A qubit-saving error-correcting code that is agonizingly slow to compute with
Real quantum computers are noisy: their qubits lose their state and their operations make errors. To run a large program reliably, fault-tolerant quantum computing (FTQC) uses quantum error correction (QEC), which encodes one protected logical qubit into many physical qubits so errors can be caught and fixed. The most widely used code, the surface code, is robust but extremely expensive, needing a huge number of physical qubits per logical qubit. Quantum low-density parity-check (qLDPC) codes are a newer class that fixes this: they protect the same information using about an order of magnitude — roughly ten times — fewer physical qubits, which could make large quantum computers far more attainable. But there is a catch. A qLDPC code natively supports only a limited set of operations, so a general quantum program cannot run directly; it must be decomposed into a very large number of the operations qLDPC does support. That decomposition explodes the amount of work, pushing the execution time of real FTQC applications to tens of days. So qLDPC codes save qubits but make computation impractically slow, which has kept them from real use.
-
What people did
Use surface codes, or run qLDPC codes with naive operation decomposition
One path is to stay with surface codes, which support the needed operations more directly, and simply pay for the enormous number of physical qubits they require. The other is to adopt qLDPC codes for their qubit savings and decompose every program into the limited operations qLDPC supports, accepting whatever running time that yields.
-
Why it fell short
One path needs too many qubits; the other takes tens of days
Neither choice is practical. Surface codes are operation-friendly but their qubit overhead is so large that building a machine with enough physical qubits for a useful program is a formidable barrier — the very problem qLDPC codes were meant to relieve. Switching to qLDPC codes recovers the qubits, but because they support only a limited operation set, a real program decomposes into so many qLDPC-supported operations that execution stretches to tens of days, which is far too slow to be useful. So the field faces a bind: the qubit-efficient code is computationally crippled, and the computationally convenient code is qubit-crippled. Making qLDPC codes viable requires attacking their computation cost directly — dramatically speeding up how a decomposed program actually runs — so their order-of-magnitude qubit savings can be kept without paying tens of days per application.
-
This paper's idea
Co-design software and hardware to accelerate qLDPC computation
This paper proposes ACQC, a software-hardware co-design approach that accelerates computation in qLDPC codes, with the goal of making qLDPC codes practical for fault-tolerant quantum computing. The premise is that the tens-of-days execution time is not a fundamental limit but a consequence of how qLDPC-supported operations are generated and carried out, and that this cost can be cut by designing the software (how a program is decomposed and scheduled into qLDPC operations) together with the hardware (the control and execution machinery that runs those operations), rather than treating either in isolation. By co-designing the two so the enormous number of qLDPC operations a program requires is produced and executed far more efficiently, ACQC aims to shrink the crippling execution time while preserving the order-of-magnitude qubit savings that make qLDPC codes attractive in the first place. (This page is a draft: the paper's full text was not available when it was written, so the specific software techniques, the hardware design, and the measured speedups are not detailed here and should be read from the paper.)
Why this problem is worth solving
The number of physical qubits a useful quantum computer needs is one of the biggest obstacles between today’s machines and practical quantum computing, and error-correction overhead is the main reason that number is so large. Quantum bits are extraordinarily fragile. They lose their quantum state through interaction with their environment, and the operations that manipulate them are themselves imperfect, so any long computation accumulates errors that would ruin the result. Fault-tolerant quantum computing is the plan for running large programs reliably anyway, and its foundation is quantum error correction: instead of trusting a single physical qubit, you encode one logical (protected) qubit across many physical qubits, arranged so that errors on individual physical qubits can be detected and corrected without disturbing the encoded information. The cost is that every logical qubit now consumes many physical qubits, and useful programs need many logical qubits, so the physical-qubit count balloons. The surface code, the most widely used scheme, is popular because it is robust and tolerant of relatively high error rates, but it has a poor encoding rate: it needs a large number of physical qubits for each logical qubit. Since real machines have limited qubits, this overhead is a central barrier to scaling. Anything that meaningfully reduces the physical qubits per logical qubit therefore moves practical quantum computing closer, which is exactly why qLDPC codes have drawn so much attention.
The trouble is that saving qubits with qLDPC codes trades one scarce resource for another — time. Quantum low-density parity-check codes achieve a much better encoding rate than the surface code, protecting the same information with roughly an order of magnitude fewer physical qubits. That is a dramatic saving, and it is why qLDPC codes are seen as a promising route to large fault-tolerant machines. But an error-correcting code is not just storage; you must also compute on the encoded logical qubits, and here qLDPC codes are far less convenient. A given qLDPC code natively supports only a limited set of logical operations. To run a general quantum program, whose operations may not be among that set, the program must be decomposed into long sequences of the operations the code does support. Because the supported set is limited, this decomposition can expand a modest program into an enormous number of qLDPC-supported operations, and executing all of them takes a very long time — the paper reports tens of days for real FTQC applications. So the qubit savings come with a computational tax so heavy that it cancels the practical benefit. The resource you save in space you lose in time, and unless that time cost is brought down, qLDPC codes cannot be used in practice even though they solve the qubit problem.
What people did before, and where it broke
- Surface codes with direct operation support. Use the well-understood surface code, which supports the needed logical operations more directly. Where it broke. Its encoding rate is poor, so it needs a very large number of physical qubits per logical qubit, and building a machine with enough qubits for a useful program is a severe barrier.
- Adopt qLDPC codes for their qubit efficiency. Switch to qLDPC codes to cut the physical-qubit count by about an order of magnitude. Where it broke. qLDPC codes support only a limited set of operations, so programs must be decomposed into many supported operations, which is where the time cost appears.
- Run the decomposed program naively. Execute the large number of qLDPC-supported operations that decomposition produces. Where it broke. The sheer count of operations pushes execution time to tens of days for real applications, which is far too slow to be practical.
- The gap. No approach made qLDPC codes both qubit-efficient and fast enough to use, by directly attacking the computation cost of running the many operations a decomposed program requires.
How ACQC approaches it
Where the time goes, and where ACQC intervenes
-
-
-
-
-
new
-
new
The idea
Treat the execution-time explosion, not the qubit count, as the thing to fix. ACQC starts from the observation that qLDPC codes already solve the qubit-overhead problem; what remains is that computing on them is too slow because of the operation-decomposition blow-up. So its target is the computation cost itself. Recognizing that making a promising quantum error-correcting scheme practical is fundamentally an engineering-acceleration problem, not only a coding-theory one, is the same stance the work on extending the reach of real-time quantum error correction covered elsewhere on this site takes, attacking the speed at which error correction can actually be carried out. ACQC applies that stance to qLDPC computation, aiming to turn a tens-of-days cost into something usable.
Design the software and the hardware together. The defining choice in ACQC is co-design: how a program is decomposed and scheduled into qLDPC-supported operations (software) is designed jointly with the control and execution hardware that runs them, so that the two fit and reinforce each other instead of each being optimized alone. Co-designing the quantum error-correction layer together with the hardware that implements it, rather than fixing one and adapting the other, is the same principle the work on the co-design of quantum error-correcting codes and modular chiplets covered elsewhere on this site is built on, matching the code to the machine. ACQC extends that joint-design philosophy specifically to accelerating computation in qLDPC codes.
Keep the qubit savings that motivated qLDPC in the first place. The whole point of qLDPC codes is to shrink the physical-qubit count that makes large fault-tolerant machines so hard to build, so any fix for their speed must not give those savings back. ACQC aims to accelerate computation while preserving the order-of-magnitude qubit reduction, keeping the code’s original advantage intact. Pursuing fault-tolerant quantum computing at large scale by driving down the resource cost of error correction rather than accepting it as fixed is the same ambition the work on a fault-tolerant million-qubit-scale distributed quantum computer covered elsewhere on this site pursues, chasing scalable FTQC by confronting its overheads. ACQC contributes on the computation-time side of that same overall goal.
Following a program onto a qLDPC code
Why a modest program becomes tens of days of work
An illustrative walk-through, based on the paper's abstract and public description, of where the qLDPC time cost arises and where ACQC intervenes. Exact mechanisms and numbers should be read from the full paper.
Step 1 of 5
Start with a program that needs error correction
A fault-tolerant application consists of many logical operations that must run on noisy hardware. To be reliable, its logical qubits must be encoded in a quantum error-correcting code.
Without error correction, accumulated noise would ruin any large computation.
Why it works
- The qubit barrier is already solved, so time is the right target. qLDPC codes cut physical qubits by about an order of magnitude → but their limited operation set makes computation the new bottleneck → so attacking execution time, not qubit count, is where the remaining gain is.
- The slowdown comes from operation count, which is addressable. A limited native operation set forces long decompositions → but decomposition and execution are engineering steps, not fundamental limits → so how operations are generated and run can be made far more efficient.
- Co-design fits software and hardware to each other. Optimizing decomposition or hardware alone leaves gaps between them → but designing both together lets each be shaped for the other → so the many qLDPC operations run more efficiently than either could achieve in isolation.
- Preserving the qubit savings keeps the whole point intact. A speed fix that inflated qubit count would defeat qLDPC codes → but ACQC targets computation while keeping the encoding → so the order-of-magnitude qubit advantage survives.
- Making qLDPC practical unlocks smaller fault-tolerant machines. Tens of days per application blocks real use → but cutting that time keeps qLDPC’s low qubit count usable → so fault-tolerant computers could need far fewer physical qubits to be practical.
What it costs (trade-offs and scope)
- This explainer is from the abstract and public description only. The paper’s full text was not available when this page was written, so the specific software techniques, the hardware design, and the measured speedups of ACQC are not reproduced here and should be read from the paper. The problem, the qubit-versus-time trade-off, and the co-design approach are described at the level the public sources support.
- Co-design ties the solution to specific choices. A software-hardware co-design gains efficiency by specializing to a particular code and execution model; that specialization can make it less general across different qLDPC codes or hardware than a more generic approach, a trade-off inherent to co-design.
- qLDPC codes remain harder to compute with than surface codes. Even accelerated, computing on a code with a limited operation set is more involved than on one with more direct operation support; ACQC aims to make the qubit-efficient option practical, not to make it as operationally simple as the surface code.
- The benefit depends on the decomposition being the true bottleneck. The approach assumes the tens-of-days cost is dominated by producing and executing the decomposed operations; workloads or codes where the cost lies elsewhere would benefit differently.
- It advances one part of the FTQC stack. Accelerating qLDPC computation is one piece of making fault-tolerant quantum computing real; it does not by itself resolve the many other challenges of building and operating a large quantum computer.
The evaluation
Choosing an error-correcting code for fault-tolerant quantum computing
| Property | Surface code | qLDPC, naive execution | qLDPC with ACQC |
|---|---|---|---|
| Physical qubits per logical qubit | |||
| Native operation support | |||
| Execution time of applications | |||
| Practical viability | |||
| Detail available here |
Check yourself
Check your understanding
1. Why are qLDPC codes attractive for fault-tolerant quantum computing?
2. What is the drawback of qLDPC codes that this paper attacks?
3. What approach does ACQC take?
4. Predict: suppose a future scheme sped up qLDPC computation but doubled the physical qubits needed. Why would that miss the point, and how does ACQC differ?
Sources
The paper is “Accelerating Computation in Quantum LDPC Code” by Jungmin Cho, Hyeonseong Jeong, Junpyo Kim, Junhyuk Choi, Juwon Hong, and Jangwoo Kim (Seoul National University), published at ASPLOS 2026, DOI 10.1145/3779212.3790122. It is licensed CC BY.
This explainer is written from the paper’s abstract and its public description; the full text was not available at the time of writing, so this page is marked as a draft. According to the abstract, fault-tolerant quantum computing (FTQC) uses quantum error correction (QEC) codes to execute large-scale quantum programs on noisy quantum computers; quantum low-density parity-check (qLDPC) codes are promising because they use an order of magnitude fewer qubits than widely used surface codes; however, because qLDPC codes support only a limited set of operations, they require programs to be decomposed into many qLDPC-supported operations, which prohibitively increases the execution time of FTQC applications to tens of days, hindering the practical viability of qLDPC codes. Public descriptions of the paper state that it proposes ACQC, a software-hardware co-design approach to accelerate computation in qLDPC codes and realize their practical use for FTQC. The specific software techniques, the hardware design, the exact qLDPC code and supported operations, the workloads, and the measured speedups are not available in these sources and have not been invented here; they should be confirmed in the full paper.