Qompress: Efficient Compilation for Ququarts Exploiting Partial and Mixed Radix Operations for Communication Reduction

Andrew Litteken, Lennart Maximilian Seifert, Jason Chadwick, Natalia Nottingham, Frederic T. Chong and Jonathan M. Baker

Quantum computers are starved for qubits, yet many can quietly reach a third and fourth energy level in each physical unit — enough to pack two qubits into one and double the space — but people avoided it because those higher states are slower and noisier; this work from the University of Chicago builds Qompress, which synthesizes real control pulses so two qubits sharing a unit talk to each other almost for free, adds partial gates so a shared qubit can still reach the outside world without unpacking, and compiles ordinary circuits onto this mixed machine, cutting circuit error up to 50 percent and doubling qubit capacity.

The argument in one glance

Problem

Quantum computers are short on qubits, but each unit can hold more

The biggest limit on running useful quantum programs is simply not having enough qubits, and building bigger machines is slow. Yet the binary qubit picture undersells the hardware. A superconducting or trapped-ion unit stores a qubit in its lowest two energy levels, but can often be driven to a third and fourth level as well. Those four levels are enough to encode two full qubits in a single physical unit, called a ququart. Doing this everywhere would double the usable computing space on the machine, for any circuit.
What people did

Use the higher levels only briefly, and unpack for anything external

Prior work did tap these higher states, but cautiously. Some hand-optimized specific subcircuits, like a generalized Toffoli gate, to borrow a third level as scratch space. Others fully encoded two qubits into a ququart to exploit fast interactions between them — but the moment either qubit had to interact with something outside the ququart, they had to decode the pair back into two qubits, perform the operation, and re-encode. These schemes also assumed, in the abstract gate model, that a gate on a ququart costs the same as a gate on a qubit.
Why it fell short

The unpacking tax and the real gate costs make general encoding lose

Two things break this. First, every external operation forces a decode, an operation, and a re-encode — and the decode needs an empty ancilla to unpack into, so the space savings partly evaporate and communication balloons. Second, ququart gates are not free: higher levels have coherence times as short as a third of a qubit's, and their gates run longer. Put together, a full encode-and-decode scheme actually ends up worse than never using ququarts at all.
This paper's idea

Synthesize real fast gates, add partial operations, and compile for the mix

Qompress makes ququarts pay off by grounding everything in real pulses. Using quantum optimal control it finds the true gate durations on a realistic superconducting device, discovering that many ququart gates — especially between two qubits sharing one unit — are fast. It then synthesizes partial gates so an encoded qubit can interact with a bare qubit or with a qubit in another ququart without ever decoding. Finally it builds a compiler for this mixed-radix machine that chooses which qubit pairs to compress and routes around the uneven gate costs.

Why this problem is worth solving

To see why packing qubits is tempting yet treacherous, it helps to be precise about what a ququart is and what it costs.

A qubit uses the lowest two energy levels of a quantum system as its 0 and 1. But the same physical hardware — a superconducting transmon, a trapped ion — usually has more accessible levels; a qudit uses the lowest several, and a ququart uses the lowest four. Because four levels can represent the four combinations of two bits, one ququart can hold two qubits’ worth of information: encode the two-qubit state so that the first, second, third, and fourth ququart levels stand for the two-qubit patterns, and you have compressed two logical qubits into one physical unit without losing anything. Do that across the machine and you double its capacity. The catch is physical. Higher energy levels are harder to control and decay faster: a rough rule is that a d-level system holds its state only about one over d-minus-one as long as a plain qubit, so a ququart’s worst-case coherence time can be a third of a qubit’s. And gates that manipulate these larger state spaces have historically been assumed to run much longer, which both stretches the circuit and gives the shorter-lived state more time to decay. So the same trick that doubles space also invites more noise — which is exactly why it had been mostly avoided.

The reason the natural way to use ququarts backfires is a compilation problem, not just a physics one.

Suppose you encode two qubits into every ququart to enjoy the fast interactions between the pair. Real circuits do not confine their operations to within a pair; a qubit constantly has to interact with qubits elsewhere on the chip. In the prior model, any such external operation was impossible on the encoded state directly, so the compiler had to decode the ququart back into two separate qubits, which requires an empty ancilla qubit to unpack the second one into, then perform the operation, then re-encode. That decode-operate-re-encode cycle costs extra gates, extra time, and the very ancilla space the compression was supposed to save. On top of that, moving a whole ququart across a limited-connectivity chip uses full ququart-to-ququart swaps, which are the slowest operations of all. When the paper actually measures this, the full encode-and-decode strategy comes out consistently worse than plain qubit compilation: more gates, lower fidelity, no net win. The lesson is that the benefit of ququarts is real only if you can operate on encoded qubits in place, without unpacking, and if the compiler is smart about which pairs to compress and how to route them — which is what makes a dedicated compilation approach worth building.

What people did before, and where it broke

Hand-optimize a specific subcircuit to borrow a higher level. Use the third state as a temporary carry or scratch bit inside a known circuit like a generalized Toffoli. Where it broke. It is bespoke, one circuit at a time, and gives no general way to compile an arbitrary program onto higher levels.
Fully encode two qubits per ququart, decoding for external operations. Pack every pair to get fast internal gates, and unpack whenever a qubit must interact outside its ququart. Where it broke. Each external operation forces a decode, an operation, and a re-encode, needs an empty ancilla to decode into, and relies on slow full-ququart swaps — so the scheme ends up worse than never encoding at all.
Assume qudit gates cost the same as qubit gates. Reason in the abstract gate model, treating a ququart gate as no more expensive than a qubit gate and ignoring connectivity. Where it broke. On real hardware qudit gates run longer and higher levels decay faster, so a plan that looks good in the gate model can lose badly once true durations and coherence are counted.
Translate the whole program to a higher radix. Rewrite every qubit as a qudit and use a generalized gate set throughout. Where it broke. Full radix translation gives only constant-factor advantages asymptotically and pays the higher-level noise cost everywhere, all the time, whether or not a given qubit benefits.
The gap. Every approach either was too specialized to generalize, paid an unpacking tax that erased the savings, or ignored the real, uneven costs of ququart gates and communication. What was missing was a realistic gate set that lets encoded qubits operate in place, plus a compiler that selectively compresses only where it helps — which is exactly what practical ququart computing needs.

How Qompress works

Making ququarts pay off with real gates and a mixed-radix compiler

↓ →
new
↓ →
new
↓ →
new
↓ →
new
↓ →
new

The idea

Compress two logical qubits into one physical unit, so scarce hardware holds twice as much. The whole premise is a denser mapping from logical qubits to physical quantum degrees of freedom: instead of one qubit per unit using two energy levels, use four levels to carry two qubits, doubling capacity on a machine that has too few units. The engineering is in making that denser packing survive the extra noise it invites. Mapping logical quantum information onto a carefully structured physical arrangement, and then fighting to keep the noise that richer arrangement invites from overwhelming the benefit, is the same balancing act the quantum-error-correction synthesis work covered elsewhere on this site performs, encoding logical qubits across many physical ones and living or dying by whether the structure it chooses controls the resulting error.

Ground the design in real measured gate costs, not the idealized gate model. The reason prior reasoning went wrong is that it treated a ququart gate as costing the same as a qubit gate. Qompress instead runs quantum optimal control to synthesize the actual shortest control pulse for each gate on a realistic device, and discovers a landscape the gate model hides: internal gates between two qubits in one ququart are strikingly fast, while cross-ququart swaps are the slowest, and the whole compiler is built to exploit that real structure. Refusing the convenient abstraction and designing instead against the hardware’s true, measured costs is precisely the discipline the deep-learning-on-GPUs retrospective covered elsewhere on this site argues for, insisting that what the silicon actually does, not the tidy model of it, is what a system must be planned around.

Spend effort only where compression actually helps, and let the router absorb the rest. Finding the optimal set of compressions is exponential, and exhaustively recompiling for every pair is impractical, so Qompress does not try. Its cheap strategy folds compression into mapping, prioritizing the pairs whose fast internal gates or diameter reduction will most help — often the ones on the critical path — and leaves the router to adapt to whatever communication remains. Concentrating limited effort on the few decisions that actually move the outcome, rather than optimizing everything uniformly, is the same instinct behind the GPU-kernel study work covered elsewhere on this site, which invests only in the code paths that actually matter and trusts the rest to ordinary handling.

Following a structured circuit through Qompress

Compiling an adder onto a mixed qubit-ququart machine

Tracing a structured circuit shows how compression turns communication into fast local gates.

Step 1 of 5

Start from a circuit with tight clusters of interaction

A ripple-carry adder or a generalized Toffoli has a regular structure: small groups of qubits interact heavily with each other, forming triangles and cycles in the interaction graph. On a limited-connectivity chip, laying these out naively would demand many swaps to bring interacting qubits together.

Communication, not computation, is what usually dominates error on such circuits.

Why it works

Two qubits sharing a ququart interact as one fast single-ququart gate. A controlled-NOT or swap between two separate qubits is a full two-qubit gate on the hardware → but when those qubits are encoded in the same ququart, that interaction becomes a single-ququart operation → so the circuit’s most frequent internal gates get dramatically cheaper, a swap dropping from about 500 nanoseconds to under 80.
Partial gates let an encoded qubit reach outside without unpacking. The prior model could only operate on an encoded qubit by decoding it, acting, and re-encoding, needing a spare ancilla → but Qompress synthesizes partial gates that act on the encoded state in place → so the decode-operate-re-encode tax and its ancilla simply disappear, and external interactions stay affordable.
Compression raises connectivity and shrinks the circuit’s diameter. Bringing distant, interacting qubits together on a sparse chip normally costs a chain of swaps → but fusing the right pairs both wires an encoded qubit to more neighbors and pulls interacting qubits closer → so even pairs that rarely interact directly can be worth compressing purely to cut communication.
Prioritizing fast internal gates beats chasing communication reduction. Communication cost is hard to predict before recompiling, and strategies that optimize it directly shuffle qubits into positions with little locality → but picking the compressions that create fast internal gates early and letting the router adapt is more reliable → so the cheap greedy strategy matches the exhaustive optimum on structured circuits while communication-first strategies stay inconsistent.
Scoring by both fidelity and decoherence keeps the compiler honest. A ququart gate can raise fidelity yet run longer, giving the shorter-lived state more time to decay → but the success metric multiplies gate fidelity by the coherence survival probability → so the compiler compresses only where the net expected success actually rises, rather than chasing fidelity into a coherence loss.

What it costs (trade-offs and scope)

At today’s coherence times, the decoherence penalty can outweigh the gate-fidelity gain. Ququart gates run longer and higher levels decay faster, so with the worst-case one-to-three coherence ratio the total success rate can fall below qubit-only even when gate fidelity improves; the overall win depends on better ququart coherence, and the paper shows a crossover appears before the coherence times fully equalize.
It is a proof-of-concept, not a run on a characterized device. The control pulses come from optimal control on a realistic model, not a fully calibrated ququart machine; accurately controlling higher energy levels is the real technical barrier and remains experimentally limited, so the synthesized durations may not transfer exactly.
The results are simulated upper bounds. The expected probability of success multiplies gate fidelities and coherence survival, an optimistic bound that assumes worst-case coherence and ignores complex errors like crosstalk.
The best heuristic is circuit-structure dependent. The cheap greedy and ring-based strategies shine on structured circuits (over 50 percent gains) but yield only around 20 percent on graph-based circuits, while communication-first strategies are inconsistent and the exhaustive search is too expensive to use.
Encoded qubits cannot be measured independently. Reading out one qubit of a compressed pair requires the other, unless the pair is first decoded, which constrains how mid-circuit measurement can be used.
The specific speedups are hardware-specific. The fast-internal-gate advantage comes from this transmon Hamiltonian; another device could have different tradeoffs, and although the compiler is built to adapt to any gate-duration table, the reported numbers are not universal.

The evaluation

Three ways to compile qubits onto a ququart-capable machine

Property	Qubit-only	Full encode/decode (prior)
Encoding of qubit pairs	Never encode; use two levels only	Encode all pairs, decode on demand
Operating outside a ququart	Ordinary qubit gates
Internal two-qubit gate speed	Not applicable	Fast, but rarely usable without decoding
Qubit capacity	Baseline	Up to twice, minus decode space
Expected gate success vs qubit-only	Reference point

Three compilation approaches for a machine whose units can be qubits or ququarts, evaluated in simulation with gate durations from quantum optimal control on a realistic transmon Hamiltonian, across grid, IBM heavy-hex, and ring topologies. The prior full encode-and-decode model loses to plain qubits because of its unpacking tax; Qompress's partial gates and selective compression instead lift expected gate success by up to 50 percent on structured circuits and roughly 20 percent on graph circuits while doubling qubit capacity — though at present coherence times the longer ququart gates can still erode the net total-success win.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

Qompress is an elegant systems answer to a scarce-hardware problem: it takes the idea of packing two qubits into one four-level ququart — long avoided as too slow and noisy — and makes it practical by synthesizing real fast gates with quantum optimal control, adding partial gates so encoded qubits operate in place without unpacking, and building a compiler that selectively compresses only where it helps. On structured circuits its cheap greedy strategy lifts expected gate success by more than 50 percent, matching an intractable exhaustive search, and it doubles the effective qubit capacity across grid, heavy-hex, and ring topologies. Read it with its scope. It is a proof-of-concept: the pulses come from a realistic model, not a fully calibrated ququart device, and controlling higher energy levels accurately is the real, still-limited barrier. Its numbers are simulated upper bounds that ignore crosstalk, its best heuristic is structure-dependent (only about 20 percent on graph circuits), and encoded qubits cannot be measured independently. Most important, at today’s coherence times the longer ququart gates can make total success fall below qubit-only even when gate fidelity rises — the overall win depends on better ququart coherence, which the paper is candid the technique needs and is meant to motivate. The durable contribution is the reframing: higher energy levels are usable capacity if you design real gates and a real compiler for them.

Background

Why the NISQ era keeps squeezing more from imperfect hardware

It helps to see Qompress as one move in the defining struggle of today’s quantum machines, the noisy intermediate-scale quantum era: too few qubits, too much noise, and no error correction yet to hide behind. In that regime the whole game is to extract more useful computation from hardware that is smaller and shakier than the algorithms want, and every gain has to be weighed against the noise it stirs up. Qompress squeezes capacity out of energy levels the machine already has but rarely uses; the price is the extra decoherence those levels bring, which is why its honesty about the coherence tradeoff matters as much as its speedups. The photonic-quantum-classifier work covered elsewhere on this site fights the same fight from a different corner, co-designing a machine-learning classifier around the specific photon loss and noise of a real photonic device rather than assuming an ideal machine — both are refusals to wait for perfect hardware, insisting instead on getting real value from the imperfect hardware that exists. The broad lesson is that until quantum machines are large and clean, progress comes from compilers and co-designs that treat the hardware’s quirks and limits as the primary design constraint, not an afterthought.

If you remember only three things

1. Quantum computers are qubit-starved, but many physical units can reach higher energy levels: four levels can encode two qubits in one unit (a ququart), doubling capacity. The field mostly avoided this because higher levels have coherence times as short as a third of a qubit's and their gates run longer, and prior schemes either hand-optimized single subcircuits or fully encoded pairs but had to decode-operate-re-encode (needing a spare ancilla) for any operation reaching outside a ququart — so a full encode-and-decode approach actually loses to plain qubit compilation.
2. Qompress makes ququarts pay off three ways: it runs quantum optimal control on a realistic transmon Hamiltonian to find true gate durations, discovering that a two-qubit gate between qubits sharing one ququart becomes a fast single-ququart gate (a swap in 78 nanoseconds versus 504); it synthesizes partial mixed-radix gates so an encoded qubit interacts with a bare qubit or a different ququart directly, with no decoding; and it builds a compiler that models the mixed machine as an expanded interaction graph, scores choices by both gate fidelity and decoherence, and selectively compresses the pairs that either interact often (gaining fast internal gates) or shrink the circuit diameter (cutting swaps).
3. In simulation across grid, IBM heavy-hex, and ring topologies, Qompress lifts expected gate success by up to 50 percent on structured circuits (matching an intractable exhaustive search with a cheap greedy strategy) and about 20 percent on graph circuits, while doubling qubit capacity, and the old full encode-decode baseline loses to qubit-only. Its limits: it is a proof-of-concept with pulses from a model rather than a calibrated ququart device, the numbers are simulated upper bounds ignoring crosstalk, encoded qubits cannot be measured independently, and crucially at present coherence times the longer ququart gates can drag total success below qubit-only even when gate fidelity improves — so the overall win depends on better ququart coherence, which the work is designed to motivate.

Check yourself

Check your understanding

1. What is a ququart, and why would packing two qubits into one be attractive?
2. Why did the prior full encode-and-decode approach to ququarts end up worse than not using them at all?
3. How does Qompress avoid the assumption, made by earlier work, that a ququart gate costs the same as a qubit gate?
4. Which statement best reflects the honest limits of Qompress's results?

Sources

The paper is “Qompress: Efficient Compilation for Ququarts Exploiting Partial and Mixed Radix Operations for Communication Reduction” by Andrew Litteken, Lennart Maximilian Seifert, Jason Chadwick, Natalia Nottingham, Frederic T. Chong, and Jonathan M. Baker, published at ASPLOS 2023, DOI 10.1145/3575693.3575726 (arXiv 2303.00658). The authors are at the University of Chicago.

This explainer is written from the full 14-page text. Everything above comes from the paper’s own sections: the introduction and background motivating ququart compression against the qubit-count limit, and the physics of higher energy levels (shorter coherence, roughly one over d-minus-one of the qubit time, and historically longer gates); the qudit pulse generation using the Juqbox quantum optimal control software on a two-transmon Hamiltonian to synthesize the gate set (the encoding gate, internal single-ququart gates, and partial mixed-radix and cross-ququart gates) and Table 1’s measured durations (internal swap 78 nanoseconds versus qubit-qubit swap 504, internal controlled-NOT around 83 versus 251, encode 608, full ququart swap 1184); the Qompress compiler representing the mixed-radix machine as an expanded interaction graph and extending mapping, routing, and scheduling with a success metric combining gate fidelity and coherence; the five compression strategies (exhaustive, extended qubit mapping, ring-based, average weight per edge, and progressive pairing) and the two kinds of beneficial compression (high interactivity and communication reduction); and the evaluation on grid, IBM Ithaca heavy-hex, and ring topologies over adder, generalized Toffoli, quantum RAM, Bernstein-Vazirani, and graph-based QAOA circuits, reporting the full encode-decode baseline losing to qubit-only, up to 50 percent gate-success gains on structured circuits and about 20 percent on graph circuits, doubled capacity, and the honest coherence-time analysis showing the net total-success win depends on improved ququart coherence.