Basic circuits · QAOA / MaxCut
QAOA ring layer benchmark · 16 qubits
A fixed-angle p=1 MaxCut-style QAOA layer on a cycle graph, including cost and mixer blocks.
Strong empiricalUpdated
A small worked example, computed in your browser. It is not a result from this record's papers.
QAOA, p=1, MaxCut on a 4-cycle
4 qubits on a 4-cycle (edges 0-1, 1-2, 2-3, 3-0), one QAOA layer with gamma=pi/8, beta=3*pi/8.
Step 1 of 2 · Hadamard layer(4)
Probability of each outcome after this step
- 00006%
- 00016%
- 00106%
- 00116%
- 01006%
- 01016%
- 01106%
- 01116%
- 8 more outcomes50%
Starts from the uniform superposition over all 16 possible cuts.
Probability spreads from 1 outcome to 16. All 16 are equally likely.
The cost layer (RZZ(2*gamma) on each of the 4 edges) rewards cuts that separate connected qubits, then the mixer (RX(2*beta) on every qubit) lets amplitude move between cuts.
Probability moves between the same 16 outcomes. Up: 0101 6.3% → 26.6%, 1010 6.3% → 26.6%. Down: 0001 6.3% → 1.6%. This is the step that entangles the qubits: from here on no single qubit has a state of its own, only the register as a whole does.
Readout 0101 and 1010 are the two optimal cuts of a 4-cycle (alternating around the ring); at these angles measuring the register returns one of them clearly more often than any other cut.
Open in Studio- Steps80
- Wires16
- Qubits16
- Operations80
- Framework exports7
- Papers1
A fixed-angle p=1 MaxCut-style QAOA layer on a cycle graph, including cost and mixer blocks. This 16-qubit record gives the repository a concrete, inspectable circuit at a known width rather than only a family-level description.
Takes16 qubitsassumed |0…0⟩What joins here
Takes a 16-qubit register, and this entry's published behaviour was measured from |0…0⟩. Putting another stage in front is a defined circuit and is no longer the thing this entry measured — the results on this page were not produced that way.
Nothing in the Atlas meets this end.
Returns16 classical bitsWhat joins here
Returns 16 classical bits. Nothing in this catalogue takes classical bits, so this end closes a pipeline rather than continuing one — what is worth having here is the measurement, not a register to pass on.
Nothing in the Atlas meets this end.
A whole program rather than a stage: it begins on |0…0⟩ and ends by measuring every qubit, so what it returns is classical bits. Nothing in this catalogue takes classical bits, so nothing follows it. See all 30 →
The circuit is stored once as a framework-neutral ordered gate graph and converted lazily when a framework is selected. The converter preserves gate order, numeric angle expressions, qubit indices, and terminal all-qubit measurement for its bounded gate set. It intentionally does not claim that downstream compiler decompositions or device behavior are identical. The cited MQT Bench work motivates scalable, cross-level benchmark families; this particular circuit is a Leona Quantum-authored scaffold and should be compared by width, operation count, transpiled depth, two-qubit count, and measured output behavior.
Takes16 qubitsassumed |0…0⟩What joins here
Takes a 16-qubit register, and this entry's published behaviour was measured from |0…0⟩. Putting another stage in front is a defined circuit and is no longer the thing this entry measured — the results on this page were not produced that way.
Nothing in the Atlas meets this end.
Returns16 classical bitsWhat joins here
Returns 16 classical bits. Nothing in this catalogue takes classical bits, so this end closes a pipeline rather than continuing one — what is worth having here is the measurement, not a register to pass on.
Nothing in the Atlas meets this end.
A whole program rather than a stage: it begins on |0…0⟩ and ends by measuring every qubit, so what it returns is classical bits. Nothing in this catalogue takes classical bits, so nothing follows it. See all 30 →
- Qubits
- 16
- Operations
- 80
- Framework exports
- 7
- Circuit model
- Ordered portable gate graph
- Measurement
- Terminal all-qubit
Hon q0Hon q1Hon q2Hon q3Hon q4Hon q5Hon q6Hon q7Hon q8Hon q9Hon q10Hon q11Hon q12Hon q13Hon q14Hon q15CXon q0, q1RZon q1CXon q0, q1CXon q1, q2RZon q2CXon q1, q2CXon q2, q3RZon q3CXon q2, q3CXon q3, q4RZon q4CXon q3, q4CXon q4, q5RZon q5CXon q4, q5CXon q5, q6RZon q6CXon q5, q6CXon q6, q7RZon q7CXon q6, q7CXon q7, q8RZon q8CXon q7, q8CXon q8, q9RZon q9CXon q8, q9CXon q9, q10RZon q10CXon q9, q10CXon q10, q11RZon q11CXon q10, q11CXon q11, q12RZon q12CXon q11, q12CXon q12, q13RZon q13CXon q12, q13CXon q13, q14RZon q14CXon q13, q14CXon q14, q15RZon q15CXon q14, q15CXon q15, q0RZon q0CXon q15, q0RXon q0RXon q1RXon q2RXon q3RXon q4RXon q5RXon q6RXon q7RXon q8RXon q9RXon q10RXon q11RXon q12RXon q13RXon q14RXon q15
Circuit structure
Derived from this entry's published gate sequence on every read, not authored alongside it. Depth is the longest serial run through the circuit, not the gate count: operations on disjoint qubits share a layer, and the terminal measurement is one layer of its own.
Fault-tolerant cost
Estimated under a stated precision
This circuit's cost is dominated by arbitrary-angle rotations, which have no T-count until a synthesis precision is named. The figures below hold under the precision stated at the bottom of this panel and move with it.
Two machines, not one number
This circuit does not have a cost; it has a cost per machine, and almost all of the difference is magic-state factories — hardware bought for speed, not asked for by the circuit. Neither end below was chosen by anyone: one factory is the fewest the estimator will cost a magic-state circuit on, and the other is the crossover, derived. Only the footprint and the wall-clock move between them; everything else on this page is a property of the circuit and reads the same on both.
Smallest machine
- Factories
- 1
- Physical qubits
- 8,800
- Runtime
- 6.19 ms
The fewest factories this circuit can run on at all.
Fastest useful machine
- Factories
- 310
- Physical qubits
- 750,400
- Runtime
- 20.0 µs
Past this count, the reaction time binds and more factories change nothing.
- Magic statesSame on both machines.
- 976
What the algorithm needs
Architecture-independent. Nothing here mentions hardware.
- Logical qubits
- 16
- T gates
- 976 (960 of which from rotation synthesis)
- Toffoli gates
- 0
- Serial non-Clifford depthThe one number no amount of hardware improves.
- 2
- Clifford operations
- 48
Error correction
- Code distanceThe smallest distance whose logical error rate clears the target across every operation in the circuit.
- d = 9
- Logical operations protected
- 1,296
- Error per operation
- 1.00e-6 achieved · 7.72e-6 needed
Physical footprint
The layers below cost the fastest useful machine — the right-hand column above. Factories are hardware bought for speed, not for the circuit. Cost them separately from the circuit's own patches — for a small circuit they are nearly the whole figure.
- Circuit qubits
- 6,400
- Factory qubits
- 744,000 (310 × magic-state factories)
- Total
- 750,400
Wall-clock
- Distillation throughput
- 20.0 µs
- Reaction-limited floor
- 20.0 µs — binds
- Useful factory ceilingPast this count the control system's feed-forward latency binds instead, and more factories change nothing.
- 310
Qubits vs runtime, across hardware
Each row is one hardware set with a number of magic-state factories, and none of them is a recommendation. A combination that isn't listed was checked: it needed at least as many qubits and at least as long a runtime as a row that is.
| Hardware | Factories | Physical qubits | Runtime |
|---|---|---|---|
gidney-2025@v2+eps=1e-06 | 1 | 8,800 | 6.19 ms |
gidney-2025@v2+eps=1e-06 | 2 | 11,200 | 3.09 ms |
gidney-2025@v2+eps=1e-06 | 3 | 13,600 | 2.06 ms |
gidney-2025@v2+eps=1e-06 | 5 | 18,400 | 1.24 ms |
gidney-2025@v2+eps=1e-06 | 8 | 25,600 | 773 µs |
gidney-2025@v2+eps=1e-06 | 14 | 40,000 | 442 µs |
gidney-2025@v2+eps=1e-06 | 23 | 61,600 | 269 µs |
gidney-2025@v2+eps=1e-06 | 38 | 97,600 | 163 µs |
gidney-2025@v2+eps=1e-06 | 65 | 162,400 | 95.2 µs |
gidney-2025@v2+eps=1e-06 | 109 | 268,000 | 56.7 µs |
gidney-2025@v2+eps=1e-06 | 184 | 448,000 | 33.6 µs |
gidney-2025@v2+eps=1e-06 | 310 | 750,400 | 20.0 µs |
24 combinations checked
gidney-2025@v2+eps=1e-06: Gidney, How to factor 2048 bit RSA integers with less than a million noisy qubits (arXiv:2505.15917), which states its hardware assumptions in one place: square nearest-neighbour grid, uniform 0.1% gate error, 1 us surface-code cycle, 10 us reaction time. It also states, in its Physical Costs section, the three values this model used to invent: 2(d+1)^2 physical qubits per logical patch, magic state factories covering a 3x4 area of patches, and 8T-to-CCZ distillation, so eight T states per Toffoli. threshold and logical_error_prefactor: the logical-error form this model uses, p_L = 0.1(100p)^((d+1)/2) with a 1% threshold, is Fowler and Gidney, Low overhead quantum computation using lattice surgery (arXiv:1808.06709) — quoted as equation (10) of Litinski's A Game of Surface Codes and equation (2) of Webber et al. (arXiv:2108.12371). The paper this set is named for does not use it: it picks a distance by reading a target error rate of 1e-15 per logical qubit round off simulated suppression curves (its figure 6), which is a shape this model has no field for. routing_factor: the leading term of Litinski's data blocks in A Game of Surface Codes (Quantum 3, 128, arXiv:1808.02892) — 2n+4 tiles for the intermediate block, 2n+sqrt(8n)+1 for the fast one, both 2n to leading order. arXiv:2505.15917 lays out a fixed 7x18 compute region with three columns of workspace rather than a multiplier on the data block, which is not a shape this field can hold. The constant term is dropped, so this is optimistic by a few patches. factory_cycles_per_state: the paper's own derivation — 14.7 rounds of magic state cultivation plus six lattice-surgery layers at 2d/3 rounds each, which is 14.7 + 4d rounds per CCZ state and reproduces its stated 114.7 at its own d = 25 — divided by the eight T states a CCZ costs here. The paper then rounds 114.7 up to 150 for slack and carries 150 forward, so this model is about 24% faster at distillation than the figure the paper reports. The derivation is taken rather than the rounded figure because it is the one that states how the cost moves with the code distance, which is the whole reason this field is not a constant. One distortion follows from spreading it over eight states and is worth knowing: the paper's factory delivers a CCZ state, not a bare T state, and its two terms are not alike — the 14.7 is cultivating the eight input T states (independently confirmed here: the paper's 30000 physical qubit-rounds per cultivated T state over a 12-patch factory at d = 25 is 1.85 rounds, which is 14.7/8), while the 4d is the 8T-to-CCZ distillation on top. This model has one magic-state currency, so a circuit whose states are plain T gates — every synthesised rotation in this catalogue — is charged a share of a distillation it never performs, and is pessimistic on factory time by roughly 3.4x at d = 9. A circuit of Toffolis is charged exactly the paper's 114.7. Pessimistic is the safe direction for a machine size, and splitting the two terms needs a factory model this record does not have. rotation_t_coefficient: Ross and Selinger, Optimal ancilla-free Clifford+T approximation of z-rotations (arXiv:1403.2975) — the leading term of 3*log2(1/eps) + O(log log 1/eps) for the T-count of an ancilla-free single-qubit z-rotation synthesis, which this field carries as the coefficient in t_per_rotation. Not from arXiv:2505.15917: that paper's circuit is Toffoli-only and states no rotation synthesis convention.
Stated caveats
- factory_count defaulted to the crossover (310); past it the control-system reaction time binds and more factories change nothing.
Computed under
gidney-2025@v2+eps=1e-06
- Rotation synthesis precision
- ε = 1e-6
- T gates per rotation
- 60
- Magic states per Toffoli
- 8
- Physical error rate
- 1e-3
- Target failure probability
- 1e-2
Gidney, How to factor 2048 bit RSA integers with less than a million noisy qubits (arXiv:2505.15917), which states its hardware assumptions in one place: square nearest-neighbour grid, uniform 0.1% gate error, 1 us surface-code cycle, 10 us reaction time. It also states, in its Physical Costs section, the three values this model used to invent: 2(d+1)^2 physical qubits per logical patch, magic state factories covering a 3x4 area of patches, and 8T-to-CCZ distillation, so eight T states per Toffoli. threshold and logical_error_prefactor: the logical-error form this model uses, p_L = 0.1(100p)^((d+1)/2) with a 1% threshold, is Fowler and Gidney, Low overhead quantum computation using lattice surgery (arXiv:1808.06709) — quoted as equation (10) of Litinski's A Game of Surface Codes and equation (2) of Webber et al. (arXiv:2108.12371). The paper this set is named for does not use it: it picks a distance by reading a target error rate of 1e-15 per logical qubit round off simulated suppression curves (its figure 6), which is a shape this model has no field for. routing_factor: the leading term of Litinski's data blocks in A Game of Surface Codes (Quantum 3, 128, arXiv:1808.02892) — 2n+4 tiles for the intermediate block, 2n+sqrt(8n)+1 for the fast one, both 2n to leading order. arXiv:2505.15917 lays out a fixed 7x18 compute region with three columns of workspace rather than a multiplier on the data block, which is not a shape this field can hold. The constant term is dropped, so this is optimistic by a few patches. factory_cycles_per_state: the paper's own derivation — 14.7 rounds of magic state cultivation plus six lattice-surgery layers at 2d/3 rounds each, which is 14.7 + 4d rounds per CCZ state and reproduces its stated 114.7 at its own d = 25 — divided by the eight T states a CCZ costs here. The paper then rounds 114.7 up to 150 for slack and carries 150 forward, so this model is about 24% faster at distillation than the figure the paper reports. The derivation is taken rather than the rounded figure because it is the one that states how the cost moves with the code distance, which is the whole reason this field is not a constant. One distortion follows from spreading it over eight states and is worth knowing: the paper's factory delivers a CCZ state, not a bare T state, and its two terms are not alike — the 14.7 is cultivating the eight input T states (independently confirmed here: the paper's 30000 physical qubit-rounds per cultivated T state over a 12-patch factory at d = 25 is 1.85 rounds, which is 14.7/8), while the 4d is the 8T-to-CCZ distillation on top. This model has one magic-state currency, so a circuit whose states are plain T gates — every synthesised rotation in this catalogue — is charged a share of a distillation it never performs, and is pessimistic on factory time by roughly 3.4x at d = 9. A circuit of Toffolis is charged exactly the paper's 114.7. Pessimistic is the safe direction for a machine size, and splitting the two terms needs a factory model this record does not have. rotation_t_coefficient: Ross and Selinger, Optimal ancilla-free Clifford+T approximation of z-rotations (arXiv:1403.2975) — the leading term of 3*log2(1/eps) + O(log log 1/eps) for the T-count of an ancilla-free single-qubit z-rotation synthesis, which this field carries as the coefficient in t_per_rotation. Not from arXiv:2505.15917: that paper's circuit is Toffoli-only and states no rotation synthesis convention.
Two estimates may be compared only when this identity matches. Change the precision or the hardware set and every number above is a different claim.
Import resource data
Inspect QREF v1 JSON and keep the original file. This leaves your physical estimate unchanged.
Quantum vs classical
Classical baseline
Use a classical state-vector or matrix simulation at the same width, precision, and measurement objective.
Quantum claim
The quantum record demonstrates a state or operator behavior; it does not make classical simulation or communication costs disappear.
How to compare
Compare fidelity, samples, gate depth, noise, memory, and the cost of preparing and reading the state.
Nobody has reviewed this record for gaps yet.
from qiskit import QuantumCircuit
from numpy import pi
qc = QuantumCircuit(16)
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
qc.h(4)
qc.h(5)
qc.h(6)
qc.h(7)
qc.h(8)
qc.h(9)
qc.h(10)
qc.h(11)
qc.h(12)
qc.h(13)
qc.h(14)
qc.h(15)
qc.cx(0, 1)
qc.rz(pi/4, 1)
qc.cx(0, 1)
qc.cx(1, 2)
qc.rz(pi/4, 2)
qc.cx(1, 2)
qc.cx(2, 3)
qc.rz(pi/4, 3)
qc.cx(2, 3)
qc.cx(3, 4)
qc.rz(pi/4, 4)
qc.cx(3, 4)
qc.cx(4, 5)
qc.rz(pi/4, 5)
qc.cx(4, 5)
qc.cx(5, 6)
qc.rz(pi/4, 6)
qc.cx(5, 6)
qc.cx(6, 7)
qc.rz(pi/4, 7)
qc.cx(6, 7)
qc.cx(7, 8)
qc.rz(pi/4, 8)
qc.cx(7, 8)
qc.cx(8, 9)
qc.rz(pi/4, 9)
qc.cx(8, 9)
qc.cx(9, 10)
qc.rz(pi/4, 10)
qc.cx(9, 10)
qc.cx(10, 11)
qc.rz(pi/4, 11)
qc.cx(10, 11)
qc.cx(11, 12)
qc.rz(pi/4, 12)
qc.cx(11, 12)
qc.cx(12, 13)
qc.rz(pi/4, 13)
qc.cx(12, 13)
qc.cx(13, 14)
qc.rz(pi/4, 14)
qc.cx(13, 14)
qc.cx(14, 15)
qc.rz(pi/4, 15)
qc.cx(14, 15)
qc.cx(15, 0)
qc.rz(pi/4, 0)
qc.cx(15, 0)
qc.rx(pi/8, 0)
qc.rx(pi/8, 1)
qc.rx(pi/8, 2)
qc.rx(pi/8, 3)
qc.rx(pi/8, 4)
qc.rx(pi/8, 5)
qc.rx(pi/8, 6)
qc.rx(pi/8, 7)
qc.rx(pi/8, 8)
qc.rx(pi/8, 9)
qc.rx(pi/8, 10)
qc.rx(pi/8, 11)
qc.rx(pi/8, 12)
qc.rx(pi/8, 13)
qc.rx(pi/8, 14)
qc.rx(pi/8, 15)
qc.measure_all()
FINAL_CIRCUIT = qcRelated entries
- Variational quantum eigensolver for ground-state energy
Algorithms
- Bell state measurement
Basic circuits
References
- MQT Bench: Benchmarking Software and Design Automation Tools for Quantum Computing
Nils Quetschlich, Lukas Burgholzer, Robert Wille · 2022
Defines a cross-level, scalable benchmark methodology; this entry is a Leona Quantum-authored portable scaffold, not a byte-for-byte upstream circuit.