Quantum Logical Operations Per Second (QLOPS)

• QLOPS is a benchmark for fault-tolerant quantum computing that quantifies the rate of logical operations per second by accounting for syndrome extraction, decoding, and latency overheads.
• It is defined as the product of logical qubits, syndrome extraction frequency, and logical operations per cycle, serving as a unified measure analogous to classical FLOPS.
• Empirical studies and design improvements—such as constant-depth gate synthesis and batched logical processing—highlight pathways to diagnose and enhance logical throughput in quantum systems.

Searching arXiv for papers on QLOPS and related logical-operation throughput benchmarks. Quantum Logical Operations Per Second (QLOPS) is a proposed benchmark for fault-tolerant quantum computing (FTQC) that measures how many logical operations a fault-tolerant device can complete per second while accounting for the overheads that dominate practical execution, including syndrome extraction, decoding, and latency. Introduced explicitly as an analogue of classical FLOPS, QLOPS is intended to compare FTQC schemes and hardware platforms at the level of executable logical computation rather than raw physical-gate speed or memory-only performance (Kong et al., 16 Jul 2025). In the broader literature, closely related ideas appear as logical-cycle timing, constant-depth logical-gate constructions, batched logical processing, and space-time-normalized logical throughput; together these works define the technical landscape in which QLOPS is used, estimated, or indirectly optimized (Breuckmann et al., 2024).

1. Conceptual origin and benchmarking role

QLOPS was introduced to address a gap in FTQC benchmarking. Earlier benchmarks discussed alongside it include Quantum Volume (QV), CLOPS, rQOPS, and the standard quantum memory experiment. In the stated comparison, QV and CLOPS are based on direct execution of certain circuit types and do not reflect general fault-tolerant logical computation; rQOPS is fault tolerant but does not fully account for crucial classical-side costs such as decoder throughput and latency; and the quantum memory experiment evaluates logical error rates, decoder throughput, accuracy, and latency, but does not include logical operations themselves (Kong et al., 16 Jul 2025).

Within that framing, QLOPS is application-motivated rather than memory-motivated. Its purpose is to integrate physical hardware performance, code properties, and decoder performance into a single metric that reflects the practical requirements of quantum algorithm execution. The central shift is from asking whether encoded information can be stored reliably to asking how much logical computation can be sustained per unit time under fault tolerance. This suggests that QLOPS is best understood as a computational benchmark for the logical layer of FTQC rather than as a direct characterization of physical qubits alone (Kong et al., 16 Jul 2025).

A recurrent misconception in the surrounding literature is to equate logical performance with raw gate speed. That equation is explicitly rejected by the QLOPS framework and by related hardware studies: logical throughput is limited not only by physical-gate duration, but also by syndrome-extraction cadence, decoder reaction time, feedforward, post-selection or error-detection overhead, and the structure of the logical protocol itself (Kong et al., 16 Jul 2025).

2. Formal definition, normalization, and density

QLOPS is defined by analogy with FLOPS. FLOPS is described as a product of number of cores, clock frequency, and operations per cycle; correspondingly, QLOPS is defined as the product of the total number of logical qubits, the syndrome extraction cycle (SEC) frequency, and the number of logical operations per SEC (Kong et al., 16 Jul 2025).

Factor	Definition
$f_1$	total number of logical qubits
$f_2$	syndrome extraction cycle frequency
$f_3$	number of logical operations per SEC

In the simplified model used for a single $[[n,k,d]]$ code patch, $f_1=k$, $f_2=1/t_{\mathrm{SEC}}$, and $f_3$ is determined by how many SECs are needed before a logical operation can be safely performed. The paper gives the explicit formula

$$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$

where $k$ is the number of logical qubits, $t_{\mathrm{SEC}}$ is the SEC duration, $f_2$0 is the decoder reaction time, and $f_2$1 is the number of SECs consumed per logical operation (Kong et al., 16 Jul 2025).

QLOPS is defined at a target logical error level. For an $f_2$2 code, after a quantum memory experiment with total logical error probability $f_2$3, the normalized logical error per layer per logical qubit is

$f_2$4

This $f_2$5 is used as an average quantity for benchmarking and as the normalization that allows different FTQC schemes to be compared at the same logical error rate (Kong et al., 16 Jul 2025).

Because duplicating hardware scales QLOPS linearly, the framework also defines QLOPS density

$f_2$6

where $f_2$7 is the total number of physical qubits in the error-correcting code hardware. In that sense, QLOPS density measures how efficiently a physical platform and FTQC scheme convert physical qubits into logical computation rate. The same paper also states a rough lower bound on runtime,

$f_2$8

where $f_2$9 is the Toffoli count or another gate-count proxy, while emphasizing that the bound can be loose if only a subset of logical qubits are active per cycle or if Clifford-gate overhead is not counted (Kong et al., 16 Jul 2025).

3. Determinants of QLOPS: latency, decoding, code rate, and parallelism

The QLOPS framework makes decoder reaction time a first-class systems parameter. The SEC duration $f_3$0 sets the logical clock; the reaction time $f_3$1 measures the delay between completing the relevant syndrome extraction and obtaining a decoder output; and the quantity $f_3$2 determines how many SECs are consumed per logical operation. In that model, longer decoder latency directly lowers QLOPS (Kong et al., 16 Jul 2025).

Decoder throughput and decoder accuracy enter in opposite directions. Faster decoding reduces $f_3$3 and raises QLOPS, whereas more accurate decoding may require more computation and therefore increase $f_3$4. The neutral-atom example in the benchmark paper makes this tradeoff explicit: decoding with both $f_3$5 and $f_3$6 syndromes improves accuracy, but significantly increases decoding time, and the increased decoder cost can outweigh the gain in logical fidelity when judged by QLOPS (Kong et al., 16 Jul 2025).

Code rate enters through $f_3$7, the number of logical qubits per code patch. A code with more logical qubits per patch increases QLOPS if latency remains controlled. The same discussion notes that a more realistic formula might replace “number of logical qubits” by the maximum number of parallel logical operations, because parallelism can be limited by code structure and by magic-state supply. This suggests that QLOPS is fundamentally a joint property of coding, architecture, and control, not a property of the decoder or the hardware in isolation (Kong et al., 16 Jul 2025).

The framework also identifies explicit bottlenecks. If $f_3$8, then a parallel window decoder is needed to avoid exponential delay in the logical pipeline. If the decoder is too slow, logical operations become decoder-limited rather than hardware-limited. If magic-state production is slower than the logical-cycle rate, magic-state supply becomes the bottleneck. In this sense, QLOPS is designed not only to compare systems but to diagnose which subsystem limits usable logical throughput (Kong et al., 16 Jul 2025).

4. Empirical proxies and experimental estimators

Several experimental papers do not define QLOPS explicitly but provide timing and operation-count data from which a QLOPS-like quantity can be estimated. In a distance-two superconducting surface-code experiment, the reported stabilization-cycle durations are $f_3$9 for a pipelined scheme and $[[n,k,d]]$0 for a parallel scheme, corresponding to about $[[n,k,d]]$1 and $[[n,k,d]]$2 cycles/s. The same work models post-selected survival under repeated detection cycles as

$[[n,k,d]]$3

with $[[n,k,d]]$4 the error-detection rate per cycle. The paper does not define QLOPS, but it provides the ingredients for a logical-cycle-rate proxy that is tempered by survival probability, logical fidelity, and post-selection overhead (Marques et al., 2021).

A reconfigurable neutral-atom logical processor similarly provides timing and gate-count data rather than a formal QLOPS definition. The paper reports a 270 ns two-qubit Rydberg gate duration, global single-qubit rotations of about $[[n,k,d]]$5, atom movement between gates of roughly $[[n,k,d]]$6, mid-circuit readout imaging time of $[[n,k,d]]$7, and a full mid-circuit readout plus feedforward cycle of slightly less than $[[n,k,d]]$8. For a 48-logical-qubit $[[n,k,d]]$9 circuit with 228 logical two-qubit gates and 48 logical CCZ gates executed in 1.44 s, the paper gives a defensible estimate of about $f_1=k$0 logical operations/s if each logical gate is counted once. It also emphasizes that clock speed is not the dominant limit; throughput is set by transport, readout, feedforward, and postselection or error-detection overheads (Bluvstein et al., 2023).

A later superconducting surface-code experiment on a 107-qubit processor reports compiled logical depths in syndrome-extraction cycles rather than seconds. The demonstrated schedules use 5 cycles for routing, 6 for logical CNOT, 6 for logical Hadamard, and 4 or 5 for logical $f_1=k$1, depending on readout basis. Because the cycle time is not given in the extracted text, the operational rate is left in symbolic form,

$f_1=k$2

which is precisely the sort of quantity that a QLOPS benchmark would convert into an absolute throughput once $f_1=k$3 is specified (Lin et al., 1 Jul 2026).

These examples show that QLOPS often appears first as an inferred logical-throughput quantity rather than as a directly reported number. A plausible implication is that the benchmark is most mature when cycle timing, decoder latency, active logical parallelism, and operation counts are all reported together.

5. Architectural routes to higher QLOPS

A substantial body of work is directed not at defining QLOPS but at increasing it through lower logical depth, higher parallelism, or reduced space-time overhead. One route is algebraic gate synthesis in CSS codes. “Cups and Gates I” constructs logical gates from cohomology invariants and cup products on CSS codes, with physical implementations by constant-depth unitary circuits composed of $f_1=k$4-type gates. For fixed $f_1=k$5, the copy-cup gate has depth depending only on $f_1=k$6, not on code size $f_1=k$7, and the framework provides gates at arbitrary levels of the Clifford hierarchy on $f_1=k$8 copies of the same code. The paper is explicit that it does not define QLOPS, but it is directly relevant to logical-operation throughput because it ties fast logical gates to code algebra rather than to ad hoc constructions (Breuckmann et al., 2024).

A second route is constant-time addressable computation on qLDPC codes. In “Addressable gate-based logical computation with quantum LDPC codes,” the main throughput claim is the replacement of $f_1=k$9-time lattice-surgery style logical operations by $f_2=1/t_{\mathrm{SEC}}$0-time logical Clifford operations using an auxiliary $f_2=1/t_{\mathrm{SEC}}$1 Bacon–Shor code and teleportation. The paper states explicit qubit overhead $f_2=1/t_{\mathrm{SEC}}$2 and time overhead $f_2=1/t_{\mathrm{SEC}}$3, with gate duration depending only on the number of nontrivial Pauli factors in the implemented string $f_2=1/t_{\mathrm{SEC}}$4, not on code distance $f_2=1/t_{\mathrm{SEC}}$5. This makes logical-gate latency distance-independent at the circuit level, while leaving realized QLOPS dependent on hardware speed and decoder latency (Pecorari et al., 8 Nov 2025).

A third route is simultaneous measurement of commuting logical operators. “Time-Efficient Logical Operations on Quantum Low-Density Parity Check Codes” proposes measurement stickers and branch stickers, showing that an arbitrary set of commuting logical Pauli operators can be measured in a time independent of the number of operators. The time cost is instead controlled by the repetition parameter $f_2=1/t_{\mathrm{SEC}}$6, so the total time is $f_2=1/t_{\mathrm{SEC}}$7, independent of how many commuting operators are in the batch. In QLOPS terms, this removes a serialization bottleneck in qLDPC logical measurements and lets throughput scale with hardware parallelism rather than operator count (Zhang et al., 2024).

A fourth route is high-rate surgery. “High-Rate Surgery” formalizes the measurable logical space $f_2=1/t_{\mathrm{SEC}}$8, defines the information extraction rate

$f_2=1/t_{\mathrm{SEC}}$9

and derives surgery overhead

$f_3$0

When $f_3$1, the normalized overhead is $f_3$2, comparable to the memory baseline. The paper reports that up to hundreds of randomly sampled logical measurements can be executed simultaneously with a total space-time overhead around a factor of two of memory experiments, including about 200 simultaneous logical measurements for a $f_3$3 code with roughly twice the memory overhead (Zheng et al., 9 Oct 2025).

A fifth route is batched high-rate logical processing. “Batched high-rate logical operations for quantum LDPC codes” constructs batched gadgets with constant space-time overhead, assuming fast classical computation, for single-shot error correction, state preparation, code surgeries, code switching, and addressable Clifford gates on arbitrary CSS qLDPC codes. The guiding principle is to implement many logical operations in lockstep so that physical resources are shared across a batch. For near-term self-dual bivariate bicycle codes, the paper reports a high-rate protocol with approximate space-time overhead per logical qubit of $f_3$4, compared with $f_3$5 for a surface-code protocol and $f_3$6 for a low-rate BB protocol, together with code-cycle counts $f_3$7, $f_3$8, and $f_3$9, respectively, for the Hamiltonian-simulation example (Xu et al., 7 Oct 2025).

Taken together, these works imply that QLOPS is shaped as much by logical protocol design as by physical-qubit performance. Constant-depth gate synthesis, distance-independent logical depth, simultaneous logical measurement, high-rate ancillas, and batched resource sharing all act directly on the denominator of logical operations per second.

6. Comparative use, limitations, and broader physical significance

As a comparative benchmark, QLOPS is explicitly presented as useful but simplified. The benchmark paper states that it does not yet fully include all practical constraints, such as syndrome transmission bandwidth, parallel-window-decoder overhead, or auxiliary routing space. It is therefore a starting point for a more complete FTQC performance framework rather than a final application-specific predictor (Kong et al., 16 Jul 2025).

That caveat is visible in the benchmark’s own platform comparisons. For superconducting qubits with surface codes and neutral atoms with generalized bicycle codes, representative matched-error-rate results include QLOPS values of $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$0 for $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$1 future neutral atoms versus $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$2 and $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$3 for matched superconducting cases under current and future assumptions, and $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$4 for $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$5 future neutral atoms versus $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$6 and $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$7 for the matched superconducting settings. The same paper explicitly warns that larger superconducting QLOPS values do not necessarily mean the platform is “better” overall, because neutral-atom systems may be easier to scale to much larger qubit counts and may therefore be better suited to larger logical workloads despite lower QLOPS at equal qubit count (Kong et al., 16 Jul 2025).

The paper further tests QLOPS against RSA2048 resource estimates. It gives $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$8 and QLOPS per data qubit $$Q = k \times \frac{1}{(\lceil t_r/t_{\mathrm{SEC}} \rceil + d)t_{\mathrm{SEC}}},$$9 for a superconducting proposal, and $k$0 and QLOPS per data qubit $k$1 for a neutral-atom proposal, together with the ratios

$k$2

The authors interpret these comparisons as evidence that QLOPS is not an exact application-specific predictor, but still a useful comparative indicator across platforms (Kong et al., 16 Jul 2025).

A distinct but related use of logical-operation throughput appears in the proposal to probe the Planck scale with quantum computation. That work does not define QLOPS, but it uses computational rate density and the Number of Equivalent classical Operations (NEO) to ask whether a verified quantum computation exceeds the classical bound of one logical operation per Planck volume per Planck time. The paper states the Planck-scale operational limit as

$k$3

with $k$4 for $k$5 logical qubits in the basic NEO conversion, and estimates threshold scales of about 525 logical qubits for a large laboratory/year model, about 806 for a whole-past-light-cone model, about 1050 for a fully connected laboratory, and about 1609 for a fully connected universe. This suggests that logical-operation-rate concepts can function not only as engineering benchmarks but also as physical diagnostics for whether a computation challenges classical spacetime-based explanations at the Planck scale (Katz et al., 7 Apr 2026).

In that broader perspective, QLOPS names a specific FTQC benchmark, but the surrounding literature treats logical-operation rate more generally as a unifying quantity connecting code design, decoder architecture, scheduling, hardware control, and even foundational questions about the physical meaning of large-scale verified quantum computation.