Hybrid Coherent Measure-and-Reprogramming

• Hybrid coherent measure-and-reprogramming is a technique that adaptively updates quantum gate parameters using mid-circuit measurements while maintaining essential quantum coherence.
• It interleaves quantum measurements with embedded classical computation to dynamically adjust operations, thereby reducing latency and avoiding exponential lookup tables in execution.
• In the QROM setting, the technique leverages coherent control registers and controlled oracle access to tighten security proofs by deferring measurement and minimizing cumulative proof losses.

“Hybrid coherent measure-and-reprogramming” (Editor's term) denotes a family of techniques in which intermediate information is extracted and used to modify future computation without fully destroying the state that must persist. In hybrid quantum-classical execution, a quantum program interleaves mid-circuit measurements and resets with embedded classical computation so that gate parameters, evolution times, and control flow are updated in real time while an unmeasured quantum register remains coherent (Lubinski et al., 2022). In the quantum random oracle model (QROM), coherent measure-and-reprogram replaces destructive measurement of oracle queries by a coherent control register and controlled reprogrammed oracle queries, so that reprogramming information is accumulated coherently and only measured at the end (Cojocaru et al., 11 Sep 2025). The common structural theme is adaptive reparameterization under a coherence constraint, but the immediate objectives differ: one line targets low-latency execution on physical quantum hardware, whereas the other targets tighter lifting theorems and average-case hardness bounds in cryptographic security games.

1. Dual technical lineage

Across these two literatures, “measure-and-reprogram” refers to updating later computation from information obtained during an ongoing process, while “coherent” refers to preserving the part of the state that still matters. In the hardware-execution setting, the preserved object is an unmeasured quantum register, often the target register in phase estimation. In the QROM setting, the preserved object is the simulator’s coherent superposition over oracle-query behavior, maintained by a control register $\mathcal{R}$ and controlled oracle access rather than mid-computation query measurement. The word “hybrid” also has two technical roles: hybrid quantum-classical execution in the first setting, and hybrid state decomposition in the second (Lubinski et al., 2022, Cojocaru et al., 11 Sep 2025).

Setting	What is measured	What is reprogrammed while coherence persists
Real-time hybrid execution	Mid-circuit ancilla or a small subset of qubits	Subsequent gate angles, evolution times, and branches
QROM coherent reprogramming	Only $\mathcal{R}$ at the end	Oracle behavior at selected points recorded in $\mathcal{R}$

The first setting explicitly goes beyond simple dynamic circuits that branch on measurement outcomes by lookup table. Instead of enumerating all possible branches ahead of time, the program uses variables that are updated iteratively by embedded arithmetic, enabling adaptive algorithms whose parameters change run by run within a single execution while the quantum state persists. The second setting generalizes the older measure-and-reprogram paradigm used in the QROM, where the simulator chooses query indices at random, measures those queries to learn $x$, reprograms the random oracle at $x$ to a chosen value $y$, and continues the adversary’s computation. The classical paradigm typically incurs losses such as $(2q+1)^{2k}$ when reprogramming $k$ points for a $q$-query adversary, because repeated measurement disturbs the computation (Cojocaru et al., 11 Sep 2025).

2. Real-time execution with mid-circuit measurement and feedforward

In the hardware-oriented formulation, hybrid coherent measure-and-reprogramming is a programming and execution pattern in which a quantum program interleaves mid-circuit measurement and reset with embedded classical computation to adapt the circuit on the fly while keeping part of the quantum register coherent. A single cycle consists of mid-circuit measurement of one ancilla or a small subset of qubits, embedded classical processing to compute new parameter values for subsequent quantum gates, active reset of the measured ancilla when needed, and feedforward application of the updated parameters to the next quantum operations (Lubinski et al., 2022).

The timing model is expressed through

$$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$

where $\mathcal{R}$0 is the readout latency, $\mathcal{R}$1 is the embedded classical computation time, $\mathcal{R}$2 is the active reset time, and $\mathcal{R}$3 is the feedforward-apply latency. To preserve coherence in the unmeasured register, the constraint is

$\mathcal{R}$4

with $\mathcal{R}$5 the relevant coherence time of the subset of qubits that must remain coherent. In the reported implementation, this constraint is handled at the application level by choosing how often to refresh the target eigenstate, and at the system level by co-locating classical control with the quantum controller and choosing gates that support fast reparameterization.

The hardware assumptions are correspondingly concrete. The native single-qubit gate set includes $\mathcal{R}$6, $\mathcal{R}$7, $\mathcal{R}$8, and $\mathcal{R}$9, with $\mathcal{R}$0 implemented “virtually” as a frame update that incurs effectively zero pulse time at run time and near-perfect fidelity, thereby minimizing $\mathcal{R}$1 for phase updates. The native entangling gate $\mathcal{R}$2 accepts a run-time angle parameter. The control system uses specialized electronics close to the QPU, specifically AWGs/FPGAs, capable of fixed-point arithmetic, branching, and low-level goto semantics at nanosecond-scale scheduling. Arithmetic is represented in fixed-point $\mathcal{R}$3 for “double”-like values and 18-bit signed integers for integer/boolean types; addition, subtraction, and multiplication are native, while division is implemented by table-based interpolation. Scheduling semantics are block-oriented: quantum gate sequences are interspersed with blocks of classical instructions, and measurement results are routed to classical registers and then to locally computed conditional branches. The paper does not report explicit numeric values for $\mathcal{R}$4, $\mathcal{R}$5, $\mathcal{R}$6, $\mathcal{R}$7, or $\mathcal{R}$8, but it demonstrates feasibility by exploiting virtual $\mathcal{R}$9, refreshing the target eigenstate frequently, and limiting the number of iterations to $x$0.

3. QIR integration and the random walk phase estimation demonstration

The execution model is expressed in a full-featured Quantum Intermediate Representation (QIR) based on LLVM IR, which integrates quantum operations with classical control flow, loops, SSA variables, branches, and goto-like constructs. In the reported workflow, a program is authored in Q# with classical loops and arithmetic embedded, compiled to QIR, adapted to a hardware-specific profile using QAT, then parsed with PyQIR and lowered into QCI’s native IR with fixed-point data types, approximate division, and hardware-level branches. In the RWPE control-flow graph, the blocks body__1, then0__1, and else__1 encode the iterative computation of $x$1 and $x$2, the two branches of the random walk, and the loop backedge. Variables such as $x$3 and $x$4 become SSA values that feed both arithmetic and later gate calls (Lubinski et al., 2022).

The algorithmic demonstration is random walk phase estimation (RWPE), a Bayesian-inspired adaptive variant of iterative phase estimation designed to require very few arithmetic operations per iteration. The objective is to recover an eigenphase $x$5 of a unitary $x$6 from an eigenstate $x$7 using iterative, low-qubit-depth experiments. Standard iterative phase estimation has $x$8 time scaling to estimate $x$9 with accuracy $x$0, substantially better than VQE’s $x$1 sampling. Exact Bayesian updates are noted as infeasible in qubit lifetimes, which motivates RWPE’s low-cost arithmetic.

At iteration $x$2, the online estimate is represented by a mean $x$3 and standard deviation $x$4. The inversion angle and evolution time are

$x$5

For $x$6, the measurement likelihoods are

$x$7

$x$8

The random-walk update rule is

$x$9

with final estimate $y$0. These updates reduce $y$1 geometrically by $y$2 per iteration while $y$3 performs a guided random walk.

The reported experiment uses a QCI superconducting system with 3-D resonator technology. The target register is prepared as $y$4 for the oracle $y$5, giving target eigenphases $y$6 in units of $y$7. The prior $y$8 is chosen so that the algorithm converges preferentially to $y$9, and the final reported value is $(2q+1)^{2k}$0 multiplied by $(2q+1)^{2k}$1 in post-processing. The demonstration uses exactly one mid-circuit measurement and variable update per iteration, with $(2q+1)^{2k}$2, and resets/re-prepares the target eigenstate every other iteration to stay within coherence bounds. In the ideal simulator with no noise and full precision, 10,000 shots yield a distinct peak at $(2q+1)^{2k}$3 with secondary shoulders reflecting the random walk. On hardware, 5,000 shots produce a peak at $(2q+1)^{2k}$4 that is lower than ideal due to noise and resets, with secondary shoulders still visible. A noisy simulator using the QCI noise model and fixed-point arithmetic shows close qualitative agreement with hardware. The location of the highest histogram peak indicates correct convergence, while the reduced peak height captures noise, finite precision, and frequent resets.

4. Coherent measure-and-reprogram in the QROM

In the QROM, coherent measure-and-reprogram is a simulator framework that replaces destructive measurement of oracle-query registers with coherent bookkeeping. The simulator introduces a control register $(2q+1)^{2k}$5 that stores pairs $(2q+1)^{2k}$6 in superposition, where $(2q+1)^{2k}$7 is an auxiliary random oracle used to generate target outputs. Oracle access is then given through a controlled reprogrammed oracle $(2q+1)^{2k}$8: the data register experiences queries to $(2q+1)^{2k}$9 reprogrammed at the points currently recorded in $k$0, while $k$1 itself is untouched. The register is updated via an isometry $k$2 that coherently appends $k$3 whenever needed, with a check that avoids duplicates; if a duplicate would occur, the simulator aborts. Only $k$4 is measured at the end (Cojocaru et al., 11 Sep 2025).

This construction avoids the repeated measurement-and-disturbance losses that characterize older measure-and-reprogram techniques. The proof proceeds by decomposing the adversary’s final state into subnormalized components indexed by a choice of $k$5 query positions $k$6 from $k$7, a bit pattern $k$8 indicating whether reprogramming is done before or after each chosen query, and an ordering $k$9 of the $q$0 reprogram points. The global state is written as a sum of hybrid components $q$1. Coherence enables a Cauchy–Schwarz argument over these amplitudes, producing a factor $q$2 at the amplitude level rather than multiplicative losses per measured query.

The framework includes a uniformity lemma: when $q$3 is uniform, measuring $q$4 at the end yields images uniformly distributed over $q$5. The underlying reason is that updates to $q$6 always add $q$7 with $q$8 uniform, while the controlled oracle never disturbs $q$9. This is one of the points at which the coherent construction differs qualitatively from older destructive-query simulations.

5. Lifting theorems, image relations, and security applications

The central quantitative statement is the Quantum Lifting Theorem. If $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$0 is a search game with a classical challenger that makes at most $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$1 classical queries to a random oracle $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$2, and $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$3 is a $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$4-query quantum adversary against $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$5, then there exists a $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$6-query quantum adversary $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$7 such that

$$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$8

The associated coherent measure-and-reprogram theorem is formulated in terms of a simulator $$t_{\mathrm{cycle}} = t_{\mathrm{meas}} + t_{\mathrm{proc}} + t_{\mathrm{reset}} + t_{\mathrm{ff}},$$9 that makes exactly $\mathcal{R}$00 quantum queries to $\mathcal{R}$01 and runs in time polynomial in the parameters and the runtime of $\mathcal{R}$02. Relative to the previous Yamakawa–Zhandry lifting bound $\mathcal{R}$03, the new loss is

$\mathcal{R}$04

which for $\mathcal{R}$05 is approximately $\mathcal{R}$06 and thus saves a factor of roughly $\mathcal{R}$07 (Cojocaru et al., 11 Sep 2025).

A stronger form applies to image relations. For a winning relation $\mathcal{R}$08 that depends only on images, define

$\mathcal{R}$09

Then any $\mathcal{R}$10-query adversary satisfies

$\mathcal{R}$11

This yields an average-case direct product theorem:

$\mathcal{R}$12

A notable feature is that, once coherent lifting is established, the remaining hardness analysis is reduced to the classical quantity $\mathcal{R}$13.

The applications stated in the paper include non-uniform hardness of salted games, multiple-instance one-wayness, multi-collision resistance, and multi-search. For salted games, a non-uniform adversary with $\mathcal{R}$14 queries and $\mathcal{R}$15 bits of classical advice satisfies

$\mathcal{R}$16

For inversion of $\mathcal{R}$17 distinct outputs,

$\mathcal{R}$18

For finding $\mathcal{R}$19 inputs mapping to the same output,

$\mathcal{R}$20

The salted multi-collision variant satisfies

$\mathcal{R}$21

and the multi-search bound is

$\mathcal{R}$22

The paper explicitly situates these results against prior work by Zhandry, Yamakawa–Zhandry, Don–Fehr–Majenz, Liu–Zhandry, and DFMS22, emphasizing that the new framework is tight for richer multi-instance settings even though the $\mathcal{R}$23 case was already essentially sharp.

6. Comparative significance, trade-offs, and limitations

In the hardware-execution literature, the principal benefits are latency reduction, avoidance of exponential branch tables, and reduced data traffic. Computing $\mathcal{R}$24, $\mathcal{R}$25, $\mathcal{R}$26, and $\mathcal{R}$27 inside the quantum program eliminates host round-trips for each iteration; the paper emphasizes orders-of-magnitude reductions relative to cloud-mediated driver loops by co-locating computation with the controller and using virtual $\mathcal{R}$28 for instantaneous phase updates. Non-adaptive dynamic circuits often require precomputed lookup tables for every measurement history, which grow exponentially with the number of iterations, whereas RWPE stores only $\mathcal{R}$29 state, updated iteratively. The trade-offs are equally explicit: embedded computation requires hardware-level arithmetic units, instruction scheduling, and careful IR/compiler mapping; measurement-induced decoherence and cross-talk must be suppressed; active reset may be imperfect; and fixed-point rounding or interpolation errors produce feedforward angle errors. The paper summarizes a one-iteration error model as

$\mathcal{R}$30

with first-order accumulation

$\mathcal{R}$31

Later iterations are attenuated because $\mathcal{R}$32 shrinks geometrically by $\mathcal{R}$33 (Lubinski et al., 2022).

In the QROM literature, the principal benefit is a tighter lifting theorem that reduces quantum security analyses to classical calculations of $\mathcal{R}$34 once coherence has been managed correctly. The framework avoids per-query gentle-measurement losses by deferring measurement to the end and using controlled reprogramming during the computation. The stated limitations are also specific: the results are in the QROM only; they treat the case where the challenge is independent of the oracle; reprogramming is defined on $\mathcal{R}$35 distinct inputs with coherent duplicate checking and abort; and the lifted adversary still makes $\mathcal{R}$36 quantum queries rather than $\mathcal{R}$37 classical queries. Oracle-dependent challenges are noted as an open question (Cojocaru et al., 11 Sep 2025).

A common misconception is that these techniques are merely standard dynamic circuits or standard measure-and-reprogram with different notation. The cited works argue otherwise. In real-time execution, the essential novelty is embedded arithmetic and iterative variable updates under qubit-lifetime constraints, rather than simple branching on lookup-table outcomes. In the QROM, the essential novelty is coherent reprogramming via $\mathcal{R}$38 and controlled oracle access, rather than repeated destructive measurement of query registers. A plausible implication is that both literatures recast measurement from a terminal observation into a controlled resource: in one case, disturbance is budgeted against physical coherence time; in the other, against proof losses in a lifting argument.

Taken together, these works show that “measure-and-reprogram” can describe either a physical execution primitive or a proof-theoretic simulation primitive, and that “coherence” is the mechanism that makes both scalable in their respective senses. In one domain, coherence permits real-time adaptation of gate parameters while an eigenstate survives long enough for useful feedforward. In the other, coherence permits reprogramming of oracle behavior with a tighter combinatorial accounting of amplitudes. The resulting connection is methodological rather than application-identical, but it is structurally precise: both settings use controlled intermediate information to alter future computation while preserving the part of the system whose continued coherence is indispensable.