Solving k–SAT problems with generalized quantum measurement

Abstract

We generalize the projection–based quantum measurement–driven k–SAT algorithm of Benjamin, Zhao, and Fitzsimons¹ to arbitrary strength quantum measurements, including the limit of continuous monitoring. In doing so, we clarify that this algorithm is a particular case of the measurement–driven quantum control strategy elsewhere referred to as “Zeno dragging”. We argue that the algorithm is most efficient with finite time and measurement resources in the continuum limit, where measurements have an infinitesimal strength and duration. Moreover, for solvable k-SAT problems, the dynamics generated by the algorithm converge deterministically towards target dynamics in the long–time (Zeno) limit, implying that the algorithm can successfully operate autonomously via Lindblad dissipation, without detection. We subsequently study both the conditional and unconditional dynamics of the algorithm implemented via generalized measurements, quantifying the advantages of detection for heralding errors. These strategies are investigated first in a computationally–trivial 2-qubit 2-SAT problem to build intuition, and then we consider the scaling of the algorithm on 3-SAT problems encoded with 4–10 qubits. We numerically investigate the scaling of 3-SAT with respect to algorithmic runtime and find that the optimized time to solution scales with qubit number n as λⁿ, where λ is slightly larger than $\sqrt{2}$ for unconditional dynamics and less than $\sqrt{2}$ for conditional dynamics. We assess the implications for using this analog measurement–driven approach to quantum computing in practice.

Introduction

Since the remarks by Feynman², and algorithms by Shor³ and Grover⁴, quantum computation^5,6 has drawn increasing research interest, spurring the rapid development of quantum technologies across a variety of experimental platforms. Even independent of any particular hardware implementation, a variety of approaches have been developed, including circuit–based quantum computers⁶, adiabatic–^7,8 or annealing–based^9,10 quantum computing, and measurement–based quantum computing¹¹, in addition to many flavors of quantum simulators. Below we will explore an instance of a different approach: In contrast with “measurement–based” computation, where a highly entangled state is prepared and then measured, we will study here an example of what may instead be called “measurement–driven”^{1,12,13,14,15,16,17} computation. Measurement–driven computation here refers to an approach in which the fundamental invasiveness of quantum measurements or dissipators are used to create the quantum dynamics that solve a computational problem. Related approaches to computation involving or simulating open quantum systems have also been explored^18,19,20,21.

Our point of departure in this manuscript is the quantum measurement–driven approach to solving k–SAT problems proposed by Benjamin, Zhao, and Fitzsimons¹ (henceforth BZF). k–SAT problems involve n Boolean variables and require satisfaction of m clauses each containing k Boolean variables. The complexity of k-SAT is well understood, and Boolean satisfiability problems were among the first to be classified as NP-complete^22,23,24. Many rigorous and heuristic classical algorithms have been proposed to solve k-SAT, particularly 3-SAT. While not the best classical algorithm, the celebrated Schöning’s algorithm²⁵, which repeatedly checks and randomly corrects the clauses, is probably the most well-known. This has a provable runtime upper bound that scales as (4/3)ⁿ for 3-SAT²⁵.

BZF proposed a method by which a k–SAT problem may be solved through repeated cycles of k–qubit projective measurements, with a measurement representing each clause of the logical proposition. Through gradual adjustment of the measurement axes defining true or false on a given qubit, the clause measurements are able to negotiate a solution. This may be regarded as a form of analog quantum computation (most similar to adiabatic computation), where open system dynamics (here, the invasiveness of measurement) are used to create the solution dynamics, instead of the closed system (unitary) dynamics that are more often considered for such purposes. Our aim in this manuscript is to generalize the BZF scheme to the cases of sequential general–strength measurements, and weak measurements or dissipators.

This approach rests on the enormous progress made in continuous quantum monitoring over the past few decades. Generalized quantum measurements are well understood theoretically²⁶ in the language of Positive Operator–Valued Measures. Generalized measurements include not only projectors, but also minimally invasive (and minimally informative) weak quantum measurements. Continuous quantum monitoring arises in the limit of continuous infinitesimal–strength quantum measurements^{27,28,29,30,31}, and has been extensively explored in experiments, primarily on superconducting qubit platforms^32,33,34,35. The “quantum trajectories” conditioned on sequences of measurement readouts are accessible in real-time in such experiments, and the ensemble average of such trajectories reduces to Lindbladian dissipation of the monitored channel(s). Continuous monitoring enables such features as simultaneous monitoring of non-commuting qubit observables^{36,37,38,39,40,41,42,43}, and measurement–dependent feedback control^{28,30,44,45,46,47,48,49} that enables such diverse capabilities as e.g., measurement–driven entanglement generation^{50,51,52,53,54,55}, quantum state or subspace stabilization^{46,56,57,58,59,60,61,62,63,64,65,66}, dissipative control via continuously–modified measurements (i.e., “Zeno Dragging”)^67,68,69,70, or real–time error detection and correction^{71,72,73,74,75,76,77,78,79,80,81,82,83}. The quantum Zeno effect⁸⁴ describes the inhibition of quantum dynamics that occur on a timescale which is slow compared to measurement or dissipation. This too has been examined for weak measurements and/or continuous dissipation^{56,85,86,87,88,89,90,91,92}, and has moreover found a number of applications as a form of dissipation engineering^93,94, for quantum control of logical operations on qubits^95,96,97, and for error correction^{57,58,59,60,61,62,63,64,65,66,69,97,98,99,100,101,102,103,104,105}.

We highlight two main motivations for generalizing the BZF algorithm with such tools:

• 1. Projective measurements imply idealized and discrete quantum operations that exist at the limit of infinite resource consumption¹⁰⁶, in contrast with laboratory situations which typically involve continuous dissipation of a system via imperfectly–monitored channels,

• 2. We will be able to formally connect the BZF k–SAT algorithm to “Zeno Dragging”^67,68,70, which is a method for measurement–driven quantum control based on the quantum Zeno effect. Importantly, while Zeno dragging is improved by true measurement (dissipation leading to detection), it is a protocol that is able to function autonomously (with dissipation alone).

As we formally develop these ideas, we will be able to quantify some of the algorithm’s convergence properties as a function of the quantum measurement resources it requires. The extensive literature concerning quantum measurement contributes to the understanding of the generalized BZF algorithm that we develop below because (i) the algorithm of interest requires monitoring non-commuting observables corresponding to different clauses of a k–SAT problem, and (ii) the observables are changed over time as in the Zeno dragging approach to control, such that a solution state or subspace is dissipatively stabilized by the set of clause measurements. In particular, whenever a solution exists, the measurement–driven algorithm generates dynamics following a pure–state kernel of the Liouvillian in the adiabatic regime, similar to refs. ^86,88.

The plan and aims of this paper are as follows: In section “Towards formulating the BZF scheme via continuous measurement” we review the construction of k–SAT problems, and the construction of quantum measurements used in the BZF projective algorithm. In section “Generalizing the measurement strength”, we describe how the projectors in the BZF algorithm may be generalized to finite strength and/or continuous monitoring. Specifically, we write down Kraus operators and state update rules for generalized clause measurements in section “Conditional and un-conditional dynamics under generalized measurement and dissipation”, and then write the corresponding time–continuous version of the dynamics in section “Weak continuous limit”. In section “Convergence in the Zeno limit” we then formalize the parallel between these continuous dynamics and Zeno dragging, and describe the convergence properties of the time–continuous algorithm in the Zeno limit (analogous to the adiabatic limit). These convergence properties imply that the algorithm is capable of functioning autonomously. We are then in a position to begin putting forward several generalized BZF algorithms: In section “Un-conditional BZF algorithm with finite measurement strength” we describe a dissipative (autonomous) algorithm, and in section “Heralding BZF algorithm with finite measurement strength via filtering” we describe a heralded algorithm that explicitly uses the clause measurement records. Finally, in section “Readout scheme and time-to-solution”, we describe the final (local) qubit readout, used to turn a state in the qubit register into a candidate solution bitstring to a k-SAT proposition, and describe how we quantify the time-to-solution (TTS). The methods of section “Generalizing the measurement strength” are applied first for the simple case of a two–qubit 2-SAT problem in section “Two–qubit 2-SAT: from discrete to continuous measurement”, with the aim of building intuition, and then applied to larger–scale 3-SAT problems in section “Scaling the problem up”. As we investigate larger 3-SAT problems, we comment increasingly on the TTS and its scaling with regard to qubit number. Concluding remarks are offered in section “Discussion and outlook”.

Reformulating the BZF scheme with continuous measurement

SAT problems

In this subsection, we briefly introduce the Boolean satisfiability (SAT) problem. A SAT problem involves n Boolean variables ${\{{b}_{j}\}}_{j = 1}^{n}$, where each variable b_j takes values from either true (denoted by 0 or +) or false (denoted by 1 or −). A literal x_j can take values from $\{{b}_{j},{\bar{b}}_{j}\}$, where ${\bar{b}}_{j}$ is the negation of b_j. In k-SAT, a clause C_i contains k literals connected by logical OR (∨). A k-SAT instance is then defined by a Boolean formula F in the conjunctive normal form (CNF), which involves m clauses connected by logical AND (∧)

$$F={C}_{1}\wedge {C}_{2}\wedge \cdots \wedge {C}_{m}$$

(1)

where C_i can be, for example, ${C}_{1}={b}_{2}\vee {b}_{3}\vee {\bar{b}}_{5}$ for k = 3. A clause is satisfied when at least one of the literals is true, and we say a given SAT instance is satisfiable iff there exists an assignment of the n Boolean variables b_soln ∈ {0, 1}ⁿ such that all m clauses are satisfied simultaneously. A SAT problem is then a decision problem, where the goal is to decide whether a given SAT instance is satisfiable or not (A summary of index variables is provided in Table 1).

Table 1 Index variables used throughout the manuscript

Note that, while 2-SAT can be solved by classical algorithms such as that of ref. ¹⁰⁷ in polynomial time, k-SAT for k ≥ 3 is NP-complete. However, the classical complexity arguments are based on the worst case analysis. In practice, the difficulties of solving random SAT are not uniformly distributed for the clause density α, which is defined as α = m/n. It has been shown that, when α is increasing from 0, there is a phase transition exhibiting easy-hard-easy behavior for SAT¹⁰⁸.

The BZF algorithm

We now describe the way we encode the classical Boolean variables into qubits, following the scheme due to Benjamin, Zhao, and Fitzsimons (BZF)¹. We will then briefly review the BZF algorithm for 3-SAT based on projective measurements before proceeding to section “Generalizing the measurement strength” where we present the extended algorithm based on generalized measurement schemes that constitute the focus of this work.

For a classical Boolean variable b_j, the two possible values (true and false) are represented by two θ-dependent pure states of a qubit j as per

$$\begin{array}{rr}{\mathtt{true}}\to {\left\vert \theta \right\rangle }_{(j)}\,=\,{\hat{R}}_{Y}(+\theta ){\left\vert +\right\rangle }_{(j)},\\ {\mathtt{false}}\to {\left\vert \bar{\theta }\right\rangle }_{(j)}\,=\,{\hat{R}}_{Y}(-\theta ){\left\vert +\right\rangle }_{(j)},\end{array}$$

(2)

where θ is a control parameter taking its value from [0, π/2]. Here $\left\vert +\right\rangle$ is the equal superposition state $\left\vert +\right\rangle =\frac{1}{\sqrt{2}}(\left\vert 0\right\rangle +\left\vert 1\right\rangle )$ that lies on the equator in the xz-plane of each qubit’s Bloch sphere. The θ-dependence is obtained by rotating $\left\vert +\right\rangle$ around the y-axis of the Bloch sphere by an angle ± θ, with the sign corresponding to true or false. The rotation operator is given by

$${\hat{R}}_{Y}(\theta )={e}^{-i{\hat{\sigma }}_{y}\theta /2}=\left(\begin{array}{cc}\cos \theta /2&-\sin \theta /2\\ \sin \theta /2&\cos \theta /2\end{array}\right).$$

(3)

See Fig. 1 for an illustration.

Fig. 1: A visual representation of the two qubit states Eq. (2) in the xz Bloch plane contributing to the reduced density matrix of a single qubit following rotation from the initial state $\left\vert +\right\rangle$ according to ${\hat{R}}_{Y}(\theta )$, Eq. (3).

The true and false states are initialized in parallel along $\left\vert +\right\rangle$ for θ = 0, and are then gradually rotated so as to become orthogonal for θ = π/2.

A θ-dependent projection operator ${\hat{P}}_{i}(\theta )$ is assigned to each clause C_i. Specifically, for k-SAT, the projector is given by

$${\hat{P}}_{i}(\theta )=\mathop{\bigotimes}\limits_{q=1}^{k}{\vert {l}_{{i}_{q}}{\theta }^{\perp }\rangle }_{({i}_{q})}\langle {l}_{{i}_{q}}{\theta }^{\perp }\vert ,$$

(4)

where the integer ${l}_{{i}_{q}}$ is + 1 if the q^th literal in the i^th clause ${x}_{{i}_{q}}$ is equal to the Boolean variable ${b}_{{i}_{q}}$ itself, and ${l}_{{i}_{q}}$ is − 1 if ${x}_{{i}_{q}}$ is equal to the negated corresponding Boolean variable ${\bar{b}}_{{i}_{q}}$. The states $\vert {\theta }^{\perp }\rangle$ and $\vert -{\theta }^{\perp }\rangle$ are defined by

$$\begin{array}{l}|{\theta }^{\perp }\rangle ={\hat{R}}_{Y}(\pi +\theta )\vert +\rangle ,\\ \vert {\bar{\theta }}^{\perp }\rangle =\vert -{\theta }^{\perp }\rangle ={\hat{R}}_{Y}(\pi -\theta )\vert +\rangle ,\end{array}$$

(5)

which are orthogonal to $\left\vert \theta \right\rangle$ and $\left\vert \bar{\theta }\right\rangle$ defined in Eq. (2) respectively, i.e., $\langle {\theta }^{\perp }| \theta \rangle =0=\langle {\bar{\theta }}^{\perp }| \bar{\theta }\rangle$. As an example, the projector of the clause ${C}_{1}={b}_{2}\vee {b}_{3}\vee {\bar{b}}_{5}$ is given by

$${\hat{P}}_{1}(\theta )={\vert {\theta }^{\perp }\rangle }_{(2)}{\langle {\theta }^{\perp }| \otimes | {\theta }^{\perp }\rangle }_{(3)}{\langle {\theta }^{\perp }| \otimes | {(-\theta )}^{\perp }\rangle }_{(5)}\langle {(-\theta )}^{\perp }\vert .$$

(6)

Essentially, the projector ${\hat{P}}_{i}(\theta )$ checks whether the clause C_i is violated: ${\hat{P}}_{i}(\theta )$ defines a measurement of a Hermitian observable

$${\hat{X}}_{i}(\theta )=\hat{{\mathbb{1}}}-2{\hat{P}}_{i}(\theta ),$$

(7)

where $\hat{{\mathbb{1}}}$ is the identity operator and ${\hat{X}}_{i}(\theta )$ has two eigenvalues ± 1. If the measurement gives +1 (Success), then C_i is not violated, while if the measurement gives −1 (Fail), then C_i is violated and the k-qubit subsystem of the quantum state is projected into the state ${\bigotimes }_{q = 1}^{k}{\vert {l}_{{i}_{q}}{\theta }^{\perp }\rangle }_{({i}_{q})}\langle {l}_{{i}_{q}}{\theta }^{\perp }\vert$, that corresponds to the only assignment of the relevant k Boolean variables violating the clause C_i.

The BZF algorithm¹ can be summarized as follows. The input quantum state is the equal superposition of all computational basis states ${\left\vert +\right\rangle }^{\otimes n}$. In the c^th cycle of clause measurements, one sequentially checks all the clauses ${\{{C}_{i}\}}_{i = 1}^{m}$ via projectors ${\{{\hat{P}}_{i}({\theta }_{c})\}}_{i = 1}^{m}$ in a pre-determined order. At the end of each cycle of clause measurements, θ_c is updated according to some schedule moving from θ = 0 to θ = π/2 over the course of the algorithm. The result is that after many clause measurement cycles, with the true/false measurement angles getting further apart, the qubits’ states “fan out”, and eventually arrive at z = ±1 in the computational basis when θ reaches π/2. All of the qubits are then individually measured in the computational basis to give the assignment of Boolean variables as the output, at which point the algorithm has terminated. During the entire process, if any clause measurement has failed, then one restarts the algorithm from the very beginning.

Intuitively speaking, when one fixes θ = 0, the quantum state cannot distinguish true and false of the Boolean variable, i.e., $\vert \theta \rangle =\vert \bar{\theta }\rangle$ and $\vert {\theta }^{\perp }\rangle =\vert {\bar{\theta }}^{\perp }\rangle$, but the clause checks will never fail. On the other hand, when θ = π/2, the quantum states corresponding to true and false are orthogonal $\langle \bar{\theta }| \theta \rangle =\langle {\bar{\theta }}^{\perp }| {\theta }^{\perp }\rangle =0$ and thus can be perfectly distinguished. However, implementing the algorithm at fixed θ = π/2 is equivalent to a randomized classical brute force search. This is the advantage of the BZF algorithm, where θ is varied from θ_i to π/2 so that the success probability throughout the algorithm is higher than classical brute force searching, while the value θ = π/2 at the end of the algorithm ensures the complete information of the solution assignment can be obtained. In particular, BZF showed that for θ ∈ (0, π/2), the number of quantum states that can satisfy all clause checks is equal to the number of solution assignments of the Boolean variables in the SAT problem. Furthermore, if there is a solution assignment (s₁, …, s_n) with s_j ∈ {±1} satisfying the CNF Boolean formula, then there is a corresponding quantum solution given by.

$$| {\phi }_{soln}(\theta )\rangle =\mathop{\bigotimes }\limits_{j=1}^{n}\vert {s}_{j}\cdot {\theta }_{j}\rangle .$$

(8)

We note that this solution state is both pure and separable, and necessarily also a +1 simultaneous eigenstate of all of the clause observables ${\hat{X}}_{j}(\theta )$ defined in Eq. (7). BZF also showed that the fidelity of the instantaneous quantum state to the solution is monotonically increasing as one continues to implement clause check cycles that herald success. BZF’s numerical results indicated that the running time of their projection–based quantum algorithm measured in terms of the number of projective measurements scales as (1.19)ⁿ, outperforming the classical Schöning algorithm which is well known for its provable upper bound of (1.334)^{n 25}.

Generalizing the measurement strength

In this section, we introduce a measurement model that will allow us to scale between the limits of projective measurement and weak continuous measurement, in the context of the BZF algorithm for solving k-SAT. As we generalize the measurement strength below, we will be moving the discrete and projective scheme of BZF towards a different scheme of generalized measurement, including the limit of weak continuous measurement, in which the measurement or dissipation is composed of a sequence of infinitesimal–strength open–system processes occurring on infinitesimal timesteps. With finite measurement strength, perfect projectors exist only in the limit of operations that take an infinitely long time to complete; such ideal operations do not really exist in any laboratory. Explicitly considering tradeoffs between measurement quality and the time expended to carry them out will later prove to be important in quantifying the performance and speed of the measurement–driven algorithm. As part of this exploration, we will show that the continuous version of the BZF algorithm is a version of what we have elsewhere called Zeno Dragging (see ref. ⁷⁰ and references therein). Zeno dragging involves monitoring or dissipating observable(s) so as to induce the quantum dynamics to follow and eigenspace of the observable(s) over time. Here, we define clause measurements such that the k-SAT solution is the mutual + 1 eigenspace of many observables, that we Zeno drag as θ is varied. This allows for high–probability/high–fidelity control as long as the observable is moved slowly compared to the strength with which it is measured^14,88. Moreover, such Zeno dragging schemes work autonomously (via dissipation without detection). We will ultimately define two main variants of the generalized algorithm, involving (i) the average (dissipative) dynamics, or (ii) the true measurement dynamics in which errors can be heralded. These two approaches are presented in four algorithmic subroutines below.

Conditional and un-conditional dynamics under generalized measurement and dissipation

In general, a measurement process can be described by a set of Kraus operators $\{{\hat{M}}_{r}\}$ satisfying ${\sum }_{r}{\hat{M}}_{r}^{\dagger }{\hat{M}}_{r}=\hat{{\mathbb{1}}}$, where r is the label for the measurement record^30,31. Given the prior-measurement state described by a density matrix ρ₀, the probability of obtaining measurement result r is given by Born’s rule ${\mathbb{P}}(r)={\rm{Tr}}({\hat{M}}_{r}{\rho }_{0}{\hat{M}}_{r}^{\dagger })$, and the post-measurement state ρ_r conditioned on the readout r is

$${\rho }_{r}=\frac{{\hat{M}}_{r}{\rho }_{0}{\hat{M}}_{r}^{\dagger }}{{\rm{Tr}}({\hat{M}}_{r}{\rho }_{0}{\hat{M}}_{r}^{\dagger })}.$$

(9)

We will consider here Kraus operators for generalized clause checks of the form

$$\begin{array}{rcl}{\hat{M}}_{r}(\theta )&=&{\left(\displaystyle\frac{\Delta t}{2\pi }\right)}^{\frac{1}{4}}\left\{\exp \left[-\frac{\Delta t}{4}{\left(r+\frac{1}{\sqrt{\tau }}\right)}^{2}\right]\frac{\hat{{\mathbb{1}}}-\hat{X}(\theta )}{2}\right.\\ &&\left.+\exp \left[-\frac{\Delta t}{4}{\left(r-\frac{1}{\sqrt{\tau }}\right)}^{2}\right]\frac{\hat{{\mathbb{1}}}+\hat{X}(\theta )}{2}\right\},\end{array}$$

(10)

where $\hat{X}(\theta )$ is defined in Eq. (7). Here, τ is the “characteristic measurement time” representing the measurement strength and Δt is the duration of the measurement. Short τ denotes the fast “collapse” or strong measurement, while large τ denotes the slow “collapse” or weak measurement. The particular form of these Kraus operators assumes a measurement apparatus generating a continuous–valued readout r, and is based on, e.g., the Kraus operators derived in quantum optical contexts^109,110. In particular, in the limit Δt/τ ≫ 1 the above–defined generalized measurement is effectively projective, while Δt/τ ≪ 1 is the limit of weak measurement. The latter leads to diffusive quantum trajectories when infinitesimal–strength measurements are continuously made over time (i.e., in the limit of continuous monitoring)^28,29,30,31. When Δt/τ is between the two limits, the Kraus operators describe a generalized discrete measurement with finite strength.

When one considers the measurement process without measurement records, the dynamics are described by the average over all the possible trajectories, weighted by their probabilities. In this case, given the density operator ρ(t) at t, the average post-measurement density operator $\bar{\rho }(t+\Delta t)$ is given by

$$\begin{array}{l}\bar{\rho }(t+\Delta t)\,=\,\mathop{\int}\nolimits_{-\infty }^{+\infty }dr{\hat{M}}_{r}\rho (t){\hat{M}}_{r}^{\dagger }\\\qquad\qquad\quad =\,\displaystyle\frac{1+\beta }{2}\rho (t)+\frac{1-\beta }{2}\hat{X}(\theta )\rho (t)\hat{X}(\theta ),\end{array}$$

(11)

where β = e^−Δt/2τ.

Weak continuous limit

In this work, we will pay particular attention to the limit where Δt/τ ≪ 1, which is the limit of weak continuous measurement. In this case, the measurement strength in infinitesimal time interval Δt approaches 0. By expanding Eq. (11) to first order in Δt, we can derive the Lindblad master equation (LME) for the average dynamics

$$\dot{\bar{\rho }}=\frac{1}{4\tau }{\mathcal{L}}[\hat{X}(\theta )]\bar{\rho },$$

(12)

where ${\mathcal{L}}[\hat{X}]$ is the Lindbladian generator ${\mathcal{L}}[\hat{X}]\rho =\hat{X}\rho {\hat{X}}^{\dagger }-\frac{1}{2}({\hat{X}}^{\dagger }\hat{X}\rho +\rho {\hat{X}}^{\dagger }\hat{X})$, and $\bar{\rho }$ denotes the average state. This is an expected and general property of Markovian quantum trajectories^{28,29,30,31,111,112}. Note that we will be able to assume $\hat{X}{(\theta )}^{\dagger }=\hat{X}(\theta )$ and $\hat{X}{(\theta )}^{2}=\hat{{\mathbb{1}}}$ throughout this work, which is guaranteed for $\hat{X}$ of the form $\hat{{\mathbb{1}}}-2\,\hat{P}$ (7).

The individual trajectories conditioned on the measurement record, which can be expressed as $r\,dt=\langle \hat{X}\rangle dt/\sqrt{\tau }+dW$, are also of interest. From Eq. (9) we can derive an Itô stochastic master equation (SME) describing such dynamics under the weak continuous limit^28,29,30

$$d\rho =\frac{1}{4\tau }{\mathcal{L}}[\hat{X}(\theta )]\rho \,dt+\frac{1}{2\sqrt{\tau }}{\mathcal{H}}[\hat{X}(\theta )]\rho \,dW,$$

(13)

where ${\mathcal{H}}[\hat{X}]\rho =\rho \hat{X}+\hat{X}\rho -2\langle \hat{X}\rangle \rho$ is the measurement backaction with $\langle \hat{X}\rangle ={\rm{Tr}}(\hat{X}\rho )$ the expectation value of $\hat{X}$. Here dW is the Wiener increment satisfying dW² = dt by Itô’s lemma. Notice that the dynamics satisfying Eq. (12) are recovered by averaging over all possible trajectories in Eq. (13), consistent with the fact that dW has zero mean.

A striking difference between the algorithm dynamics for SAT under continuous measurement and under projective measurement is the effect of measurement ordering. To see this, we first notice that the observables corresponding to different clauses do not necessarily commute. This happens for θ ∈ (0, π/2), due to common Boolean variables involved in the two clauses being of complementary form. For example, the observables for C₁ = x₁ ∨ x₂ and ${C}_{2}={x}_{1}\vee {\bar{x}}_{2}$ do not commute because both x₂ and ${\bar{x}}_{2}$ appear in different clauses. Therefore, in the dynamics under projective measurement, the order of measurements will be important. However, for weak continuous measurement, non-commutativity plays no role in the time–continuous master equations Eq. (12) and Eq. (13), because non-commutative effects in the dynamics only appear to O(Δt²) and higher^{36,37,38,39,40,42,113}. In other words, one can simultaneously measure all the clause observables under weak continuous measurement, and any effects due to clause ordering must vanish in the limit Δt/τ → 0. Importantly, the weak continuous measurement enabled simultaneous clause check immediately reduces the algorithmic running time by a factor of m compared to strong measurement, where clauses must be measured sequentially. The average dynamics under such m simultaneous clause measurements are described by the master equation

$$\dot{\rho }=\mathop{\sum }\limits_{i=1}^{m}\frac{1}{4\tau }{\mathcal{L}}[{\hat{X}}_{i}(\theta )]\rho ,,$$

(14)

and the individual trajectory conditioned on ${\{d{W}_{i}\}}_{i = 1}^{m}$ is described by the SME

$$d\rho =\mathop{\sum }\limits_{i=1}^{m}\frac{1}{4\tau }{\mathcal{L}}[{\hat{X}}_{i}(\theta )]\rho \,dt+\mathop{\sum }\limits_{i=1}^{m}\frac{1}{\sqrt{4\tau }}{\mathcal{H}}[{\hat{X}}_{i}(\theta )]\rho \,d{W}_{i},$$

(15)

where each observable ${\hat{X}}_{i}(\theta )$ corresponds to a clause C_i. Each of the readouts on which these dynamics are conditioned is a sum of signal and noise contributions, namely,

$${r}_{i}\,dt=\frac{1}{\sqrt{\tau }}\,{\rm{Tr}}\left(\rho (t)\,{\hat{X}}_{i}(\theta )\right)\,dt+d{W}_{i}(t),$$

(16)

where the first term is the expected signal content of the measurement outcome, and the Wiener process dW_i is pure noise.

Convergence in the Zeno limit

We now elaborate on the convergence properties of Zeno dragging necessary for an understanding of our algorithms. Let us consider the case where there is a unique solution to our k–SAT problem, i.e., we assume there exists a unique solution of the form of Eq. (8). We may then define a frame change by the rotation

$$\hat{Q}=\mathop{\bigotimes }\limits_{j=1}^{n}{\hat{R}}_{Y}^{(j)}\left(\mp\left(\frac{\pi }{2}-\theta\right)\right),$$

(17)

where ± rotations are assigned to each qubit according to the unknown solution bitstring s, such that the ideal solution dynamics become static in the $\hat{Q}$–frame. In this frame all of the ${\hat{X}}_{i}(\theta )$ are partially diagonalized, in the sense that the row/column of each ${\hat{{\mathcal{X}}}}_{i}={\hat{Q}}^{\dagger }\,{\hat{X}}_{i}(\theta )\,\hat{Q}$ which corresponds to the solution state at θ = π/2 (or t = T_f, where T_f is the total time) in the computational basis will now be occupied only by its θ–independent diagonal element. The schedule θ(t) is here assumed to vary in a continuous and differentiable way.

Let $\varrho ={\hat{Q}}^{\dagger }\,\rho \,\hat{Q}$, such that the Itô $\hat{Q}$–frame dynamics read

$$d\varrho =i[{\hat{H}}_{Q},\varrho ]\,dt+\frac{1}{4\tau }\mathop{\sum }\limits_{i}^{m}{\mathcal{L}}[{\hat{{\mathcal{X}}}}_{i}]\varrho \,dt+\frac{1}{2\sqrt{\tau }}\mathop{\sum }\limits_{i}^{m}{\mathcal{H}}[{\hat{{\mathcal{X}}}}_{i}]\varrho \,d{W}_{i}$$

(18a)

with

$${\hat{H}}_{Q}=\frac{1}{2}\,\dot{\theta }\mathop{\sum }\limits_{j}^{n}{s}_{j}\,{\hat{\sigma }}_{y}^{(j)}.$$

(18b)

The additional Hamiltonian term ${\hat{H}}_{Q}$ encodes diabatic motion due to movement of the $\hat{Q}$–frame as the observables are rotated, with s ∈ {±1}ⁿ representing the solution bitstring corresponding to Eq. (17). The solution state Eq. (8) is a simultaneous + 1 eigenstate of the clause observables ${\hat{X}}_{i}$, which we now notate as $\tilde{\rho }=\left\vert {\phi }_{soln}(\theta )\right\rangle \left\langle {\phi }_{soln}(\theta )\right\vert$. In the new frame, this eigenstate is θ–independent and therefore time–independent, i.e., we have ${\hat{{\mathcal{X}}}}_{i}\,\tilde{\varrho }\,{\hat{{\mathcal{X}}}}_{i}=\tilde{\varrho }$ for all i.

We can now consider the algorithm dynamics in the $\hat{Q}$–frame, in the Zeno limit T_f /τ → ∞ (which is an adiabatic limit). We initialize our system in $\tilde{\varrho }$, corresponding to $\rho ={(\left\vert +\right\rangle \left\langle +\right\vert )}^{\otimes n}$ at θ = 0. Notice that because $\tilde{\varrho }$ is an eigenstate of all the ${\hat{{\mathcal{X}}}}_{i}$, we have ${\mathcal{L}}[{\hat{{\mathcal{X}}}}_{i}]\tilde{\varrho }=0$ and ${\mathcal{H}}[{\hat{{\mathcal{X}}}}_{i}]\tilde{\varrho }=0$ for all i. Then in the limit T_f /τ → ∞, we have $\dot{\theta }\to 0$, and $\tilde{\varrho }$ is therefore a fixed point of both the conditional and unconditional dynamics. This means that in the Zeno limit, our algorithm converges in probability to the desired solution dynamics via perfect Zeno pinning in the $\hat{Q}$–frame, thereby achieving deterministic (diffusion–free) evolution. In other words, when the $\hat{Q}$–frame can be constructed, namely, when a unique solution exists, one may think of the rotation of the clause observables as generating a diabatic perturbation about the solution Eq. (8) when T_f /τ ≫ 1. We point out that these limiting–case solution dynamics are both pure and separable in the case of a unique solution. Furthermore, the arguments above imply that the scaling of the Lindbladian algorithm with qubit number goes to 1ⁿ in the Zeno limit T_f/τ → ∞, since any solution that exists is found deterministically, independent of the number of qubits. See Supplementary Information Section I and refs. ^{57,58,59,60,61,62,63,64,65,66,70} for further comments and context. We will revisit questions related to algorithmic scaling in later sections.

We now proceed by clarifying the connection between such continuous BZF algorithms and the measurement–driven approach to quantum control known as “Zeno Dragging”. In ref. ⁷⁰ we defined “Zeno Dragging” in terms of a quantity

$$\begin{array}{ll}{\mathsf{g}}(\rho ,\theta )\,=\,\sum\limits_{i}{{\mathsf{g}}}_{i}(\rho ,\theta )=\displaystyle\frac{1}{2\tau }\sum\limits_{i}\left(\left\langle {\hat{X}}_{i}^{2}(\theta )\right\rangle -{\left\langle {\hat{X}}_{i}(\theta )\right\rangle }^{2}\right)\\\qquad\quad\;=\,\displaystyle\frac{1}{2\tau }\sum\limits_{i}{\rm{var}}\left({\hat{X}}_{i}(\theta )\right)\ge 0,\end{array}$$

(19)

claiming that “Zeno dragging is a viable approach to driving a quantum system from some initial $\vert {\psi }_{i}\rangle$ to a final $\vert {\psi }_{f}\rangle$, if and only if there exists a parameter(s) θ controlling the choice of measurement such that (i) a continuous sweep in θ is possible, and (ii) that this generates a continuous deformation of a local minimum of ${\mathsf{g}}(\rho ,\theta )$ which traces a path from $\vert {\psi }_{i}\rangle$ to $\vert {\psi }_{f}\rangle$”. It is easy to verify that each ${{\mathsf{g}}}_{j}$ vanishes at an eigenstate of ${\hat{X}}_{j}(\theta )$, and hence that ${\mathsf{g}}(\rho ,\theta )$ vanishes at a common eigenstate of all the ${\hat{X}}_{j}(\theta )$, if such an eigenstate exists. One can readily see the connection between this definition with definitions employing the Liouvillian kernel^86,88. We conclude that the time–continuum version of the finite–time generalized–measurement BZF algorithm is a Zeno Dragging operation by the definition of ref. ⁷⁰, where Zeno dragging here means that we continuously and quasi-adiabatically deform the initial state ${\left\vert +\right\rangle }^{\otimes n}$ to the distinguishable solution state $\left\vert {\phi }_{soln}(\theta =\frac{\pi }{2})\right\rangle$ by rotating θ from 0 to π/2.

Finally, we note that in the case with multiple solutions, each solution will still take the form of Eq. (8), and together they will span the solution subspace. The convergence and stability arguments given above will apply to the entire solution subspace in so far as they apply for each of the individual solutions Eq. (8) forming a basis for that space. Even in the multi–solution case, the solution space should here be defined as the root of ${\mathsf{g}}$, i.e., the common + 1 eigenspace of all the clause observables. From a control perspective, ${\mathsf{g}}$ is an objective function, and minimization of ${\mathsf{g}}$ implies staying as close to our target solution eigenspace as possible⁷⁰. See Supplementary Information Section I for more extended remarks.

To summarize: the adiabatic theorem for Lindbladian dynamics, which is equivalent to Zeno dragging in the time continuum limit, ensures that if one starts in the kernel of ${\mathcal{L}}(\theta )$, and if the total evolution time T_f is long enough compared to the minimum Liouvillian gap of ${\mathcal{L}}(\theta )$, then the quantum system will stay near the instantaneous pure–state kernel of ${\mathcal{L}}(\theta )$^86,88. In our case, it is easy to check that the pure-state kernel of ${\mathcal{L}}(\theta )$ is spanned by the solution state(s) $\left\vert {\phi }_{soln}(\theta )\right\rangle$¹, since a state being in the kernel is equivalent to its passing all clause checks with certainty. It is natural from a control perspective to imagine Zeno dragging in terms of a single measurement that isolates some target state or subspace (see⁷⁰ and references therein). Here however, we have a sort of mirror image of that scenario: instead of a single measurement that positively identifies some target dynamics, the continuous BZF algorithm contains a collection of measurements that each rule out a possible solution, with the desired solution emerging as the remaining option from the collective dynamics. We might term this “Zeno exclusion control”. We have essentially shown that a collective “ruling out” of all states that fail clause checks leads to dynamics with the same autonomous/stabilizing properties on the remaining solution subspace as in controlled Zeno dragging. While having many measurements appears experimentally cumbersome, this strategy makes sense from an algorithmic perspective, because it implements Zeno dragging without our knowing the target dynamics a priori (and here knowing target dynamics $\left\vert {\phi }_{soln}(\theta )\right\rangle$ would amount to already knowing a solution to the k-SAT problem).

Un-conditional BZF algorithm with finite measurement strength

The autonomous stability we have just described motivates us to further investigate a BZF-type algorithm based on Lindbladian dissipation ${\mathcal{L}}(\theta )=\mathop{\sum }\nolimits_{i = 1}^{m}\frac{1}{4\tau }{\mathcal{L}}[{\hat{X}}_{i}(\theta )]$ (from Eq. (14)) alone. Recall that Eq. (11) gives the average dynamics of our quantum system under a single clause check measurement with finite measurement strength. We use this to propose an algorithm based on the average dynamics for general Δt/τ (where Eq. (12) is recovered in the Δt → dt limit of Eq. (11)). Algorithmically, one can perform such clause check measurements for all m clauses in a predetermined order, which consists of a clause check cycle. At the end of each clause check cycle, one then updates the control parameter θ, proceeding monotonically from θ = 0 to π/2. Finally, one reads out all the qubits, in the computational basis. This is summarized in Algorithm 1 (with the readout procedure deferred to Algorithm 4).

Algorithm 1

k-SAT by average dynamics

1: input: τ, T_f, Δt, and a schedule function θ(t/T_f)

2: initialize t ← 0 and the state to $\rho (0)=\left\vert +\right\rangle {\left\langle +\right\vert }^{\otimes n}$

3: while t ≤ T_f do

4:  t ← t + Δt

5:  θ ← θ(t/T_f)

6:  sequentially dissipate clause checks according to by Eq. (11) for all clauses

7: end while

8: return ρ(T_f)

One can immediately check that the solution state defined in Eq. (8) is a fixed point of Eq. (11) applied over all clause dissipators. However, we also point out that the algorithm using average dynamics nevertheless allows the possibility of reaching the final solution state at θ = π/2 via some diabatic path, where the measurement (if recorded) has failed and thus the state deviates from the solution state at some intermediate time. A Lindbladian BZF algorithm is a special case of Algorithm 1, operating in the time–continuum limit. It relies on the convergence in mean and probability in the Zeno limit, as described in section “Convergence in the Zeno limit”.

Heralding BZF algorithm with finite measurement strength via filtering

We now formally consider the advantages of having a detector granting us access to the pure state conditional dynamics Eq. (9), instead of relying only on the average dynamics Eq. (11) and autonomous aspects of Zeno stabilization. It is possible that propagation of the conditional dynamics may be computationally very expensive in contexts where solving a k-SAT problem is of interest, even though it is always possible in principle. This is no barrier to the scheme presented here however, since it does not require computation of the conditional ρ(t), but instead only access to the clause readouts r_i (followed by local z readouts r_j after θ reaches π/2; see section “Readout scheme and time-to-solution” for details). Note that in the event that the conditional dynamics can actually be tracked through the entire evolution with high efficiency, the terminal local z readout may no longer be necessary.

The potential benefit of an algorithm employing heralded success of clause readout r_i is primarily in the possibility of feedback. We might quickly terminate trajectories that have already collapsed into the subspace associated with failure of clauses, which means they are no longer able to adiabatically follow the instantaneous solution state. Restarting the algorithm upon detection of an error is the simplest possible form of feedback we might employ in this scenario, and in this work we do not go beyond that simplest case of error detection. However, more sophisticated forms of feedback might aim to actively correct errors in real time, instead of simply restarting the algorithm when a clause fails; see section “Two–qubit 2-SAT: from discrete to continuous measurement” for additional discussion of these possibilities that might be investigated in future work.

Unlike projective measurements where one can easily diagnose the collapse into some subspace of the measured observable using the measurement result, in weak measurement the dynamics are diffusive, which complicates fast diagnosis of errors directly from the noisy measurement record. In order to overcome this, a filter is needed. We first use the time continuous situation to develop some intuition for the filter we are going to use. Such filtering is used in continuous quantum error correction to detect and correct errors in real-time^{71,72,73,74,75,76,77,78,79,80,81,82,83} (CQEC). In the language of error correction, an ideal Zeno dragging procedure conditioned on ${r}_{i}=+1/\sqrt{\tau }\,\forall \,i$ defines the “codespace” that we attempt to follow. A failed clause measurement will return readouts with a mean signal centered around $-1/\sqrt{\tau }$ instead of $+1/\sqrt{\tau }$, corresponding to an “error subspace” in error correction language. The main difficulty in realizing an effective CQEC implementation is in managing the tradeoff between rapid error detection and statistical confidence in the detection and characterization of the error. We consider filter functions on the readout of the form

$${{\mathcal{B}}}_{i}(t)=\frac{1}{2\,{{\mathcal{N}}}_{{\mathcal{W}}}\,\sqrt{\tau }}\mathop{\int}\nolimits_{0}^{t}d{t}^{{\prime} }\,{r}_{i}({t}^{{\prime} })\,{\mathcal{W}}(t,{t}^{{\prime} }),$$

(20)

where ${\mathcal{W}}(t,{t}^{{\prime} })$ is a window function to be chosen below, and ${{\mathcal{N}}}_{{\mathcal{W}}}=\mathop{\int}\nolimits_{0}^{t}{\mathcal{W}}(t,{t}^{{\prime} })\,d{t}^{{\prime} }$ is a normalization factor. For ${\mathcal{W}}/{{\mathcal{N}}}_{{\mathcal{W}}}=1$, and in the continuum limit where dt is infinitesimal, ${{\mathcal{B}}}_{i}$ can be interpreted as a time–continuum approximation of the log-likelihood ratio for a sequence of clause measurements heralding success $\left\langle {r}_{i}\right\rangle =+1/\sqrt{\tau }$ versus failure $\left\langle {r}_{i}\right\rangle =-1/\sqrt{\tau }$, over the entire measurement record. Thus, (20) should be similarly understood as being like a log-likelihood, where the role of the window function ${\mathcal{W}}(t,{t}^{{\prime} })$ is to weight that likelihood towards the “recent history” of the measurement record in an appropriate way. For the measurement signal r_i(t) for each clause i, we obtained the filtered signal ${\bar{r}}_{i}(t)$ obtained via an exponential filter with a finite integration window

$${\bar{r}}_{i}(t)=\frac{1}{{N}_{be}}\mathop{\int}\nolimits_{t-{T}_{be}}^{t}d{t}^{{\prime} }\,\frac{{e}^{-\frac{t-{t}^{{\prime} }}{{T}_{be}}}}{{T}_{be}}\,{r}_{i}({t}^{{\prime} }),$$

(21)

where N_be = 1 − e⁻¹ is the normalization constant, and T_be is the response time. This is essentially an exponential filter inside a single threshold boxcar filter^78,79.

Recall the general form of the clause readouts Eq. (16) in the time–continuum limit. If the signal has reached a steady value s₀ before t₀, i.e., $\langle {\bar{r}}_{i}({t}_{0})\rangle =\langle {r}_{i}({t}_{0})\rangle ={s}_{0}$, and the “signal part” of the raw signal changes from s₀ to 〈r_i(t > t₀)〉 = s₁ at t₀, then the expectation value of the filtered signal will approach to the new steady value s₁ exponentially as

$$\langle {\bar{r}}_{i}(t)\rangle =\frac{1}{{N}_{be}}\left[{s}_{1}\left(1-{e}^{-\frac{t-{t}_{0}}{{T}_{be}}}\right)+{s}_{0}\left({e}^{-\frac{t-{t}_{0}}{{T}_{be}}}-{e}^{-1}\right)\right],$$

(22)

for t₀≤ t ≤ t₀ + T_be, with 〈 ⋅ 〉 understood as an ensemble average. One can check that $\langle {\bar{r}}_{i}(t+{T}_{be})\rangle ={s}_{1}$, which will remain for t > t₀ + T_be. In the steady state, the variance of the filtered signal is

$${\rm{Var}}[{\bar{r}}_{i}(t)]=\frac{e+1}{2(e-1)}\frac{1}{{T}_{be}}\approx \frac{1}{{T}_{be}},$$

(23)

where e ≈ 2.7183. This is consistent with the intuition that in the filtered signal, a larger T_be value results in smaller fluctuations but a longer response time, while a smaller T_be value results in a quicker response but bigger fluctuations.

When implementing the error detection for a discrete-time algorithm, one then discretizes Eq. (21) to get an update equation for the filtered signal ${\bar{r}}_{i}(t)$ as

$${\bar{r}}_{i}(t+\Delta t)={\bar{r}}_{i}(t)\left(1-\frac{\Delta t}{{T}_{be}}\right)+\left[e\cdot {r}_{i}(t)-{r}_{i}(t-{T}_{be})\right]\frac{\Delta t}{(e-1){T}_{be}}.$$

(24)

The error-detection strategy using the filtered signal depends on a threshold value r_thr. During the evolution of the system under Eq. (9) for all clauses, if any of the filtered signal corresponding to the i^th clause is below the threshold, i.e., ${\bar{r}}_{i}(t) < {r}_{th}$, at time t, then the algorithm is terminated at time t and diagnosed with “FAILED”. This subroutine is summarized in Algorithm 2.

Algorithm 2

k-SAT by single trial heralded dynamics

1: input: τ, T_f, Δt, T_be, r_th, and a schedule θ(t/T_f)

2: initialize t ← 0 and the state to $\rho (0)=\left\vert +\right\rangle {\left\langle +\right\vert }^{\otimes n}$

3: while t ≤ T_f do

4:  t ← t + Δt

5:  θ ← θ(t/T_f)

6:  sequentially measure all clauses as defined by Eq. (9) and get measurement records ${\{{r}_{i}(t)\}}_{i = 1}^{m}$.

7:  update the filtered signals ${\{{\bar{r}}_{i}(t+\Delta t)\}}_{i = 1}^{m}$ via Eq. (24).

8:  if any ${\bar{r}}_{i}(t) < {r}_{th}$ then

9:   terminate and return “FAILED”, t

10:  end if

11: end while

12: return ρ(T_f)

Notice that in the projective limit where Δt/τ ≫ 1, one can choose T_be = Δt, so that the projection into the failed subspace can be detected immediately. In the continuum limit where Δt/τ ≪ 1, one can typically choose T_be ~ τ, so that the collapse caused by the measurement is sufficiently far along to be confidently detectable through the readout noise.

As discussed above, the heralded dynamics benefit from earlier detection of the failure. This advantage allows us to define a heralded algorithm that restarts when the failure is detected early, and thus is more likely to follow the correct trajectory given a fixed amount of temporal computational resource (total algorithm running time), even without feedback. This heralded algorithm is summarized in Algorithm 3.

Algorithm 3

k-SAT by heralded dynamics

1: input: τ, T_f, Δt, T_be, T_min, r_th, and a schedule θ(t/T_f)

2: initialize t_rest ← T_f and the state to $\rho (0)=\left\vert +\right\rangle {\left\langle +\right\vert }^{\otimes n}$

3: while t_rest≥T_min do

4:  run Algorithm 2 with input τ, t_rest, Δt, T_be, r_th, θ(t)

5:  if Obtained “Failed” and t then

6:   t_rest ← t_rest − t

7:  else

8:   return ρ(t_rest)

9:  end if

10: end while

11: run Algorithm 2 without failure detection and with schedule θ(t/t_rest) from t = 0 until time t = t_rest

12: return ρ(t_rest)

Notice that in Algorithm 3, we do not terminate the dynamics when the remaining time t_rest is smaller than a minimum value T_min. This is because when the total dragging time is too small (comparable to T_be and τ), the quantum Zeno effect is not strong and the failure detection based on the filter is also not reliable anymore. However, in this situation we can still use conditional dynamics, i.e., Eq (9) rather than the averaged dynamics of Eq. (11).

We reiterate that although the clause measurement outcomes are recorded in the implementation of Algorithm 3, we do not assume that these measurement records are used directly to estimate the solution bitstring or conditional state, even if the solution state might be successfully prepared at the end of the algorithm. We only use these measurement signals to herald the success of trajectories. Therefore, for both Algorithm 1 and Algorithm 3, we would need to perform local Pauli-z measurements to read out the solution bitstring at the final time T_f. We shall discuss the final readout measurements in the next section.

We would like to emphasize that although Algorithms 1–3 are defined with finite Δt, one can also obtain continuous–time versions of each algorithm by going into the limit of Δt → 0. In this case, the dynamics are described by Eq. (14) and (15), and the filter is given by Eq. (21).

Readout scheme and time-to-solution

Before we move on to illustrate the algorithms, we shall first introduce some performance metrics that we use to benchmark the algorithms in sections “Two–qubit 2-SAT: from discrete to continuous measurement” and “Scaling the problem up”.

For n-qubit systems, if we make the weak measurements in the computational basis, the Kraus operator for obtaining a readout signal tuple ${\bf{r}}=({r}_{1},\cdots \,,{r}_{n})\in {{\mathbb{R}}}^{n}$ is

$$\begin{array}{rcl}{\hat{M}}_{{\bf{r}}}&=&\mathop{\bigotimes }\limits_{j=1}^{n}{\left(\frac{\Delta {t}_{m}}{2\pi }\right)}^{\frac{1}{4}}\left\{{e}^{-\frac{\Delta {t}_{m}}{4}{\left({r}_{j}-\frac{1}{\sqrt{\tau }}\right)}^{2}}\frac{\hat{{\mathbb{1}}}+{\hat{\sigma }}_{z}^{(j)}}{2}+{e}^{-\frac{\Delta {t}_{m}}{4}{\left({r}_{j}+\frac{1}{\sqrt{\tau }}\right)}^{2}}\frac{\hat{{\mathbb{1}}}-{\hat{\sigma }}_{z}^{(j)}}{2}\right\}\\ &=&{\left(\frac{\Delta {t}_{m}}{2\pi }\right)}^{\frac{n}{4}}\mathop{\sum}\limits _{{\bf{b}}\in {\{-1,+1\}}^{n}}{e}^{\frac{-\Delta t}{4}\mathop{\sum }\nolimits_{i = 1}^{n}{\left({r}_{j}-\frac{{b}_{j}}{\sqrt{\tau }}\right)}^{2}}{\hat{P}}_{{\bf{b}}},\end{array}$$

(25)

where Δt_m is the duration of the readout. Here b = (b₁, ⋯ , b_n) ∈ {−1, +1}ⁿ represents a possible solution bitstring, and

$${\hat{P}}_{{\bf{b}}}=\mathop{\bigotimes }\limits_{j=1}^{n}\left[\frac{1}{2}\left(\hat{{\mathbb{1}}}+{b}_{j}\,{\hat{\sigma }}_{z}^{(j)}\right)\right]$$

(26)

is the corresponding projector in the computational basis (z basis). Suppose that upon performing local readouts of the state ρ = ρ(T_f) returned by one of Algorithms 1–3 to obtain r, we then generate the our candidate solution bitstring via $\tilde{{\bf{s}}}={\rm{sign}}({\bf{r}})$. Let s = (s₁, ⋯ , s_n) ∈ {−1, +1}ⁿ be the actual solution bitstring of the k-SAT problem. Then the probability of getting $\tilde{{\bf{s}}}={\bf{s}}$, i.e., the probability that our algorithm and readout return a correct solution, is

$$\begin{array}{lll}{{\mathbb{P}}}_{{\bf{s}}}&=&\mathop{\int}\nolimits_{0}^{{\rm{sign}}({\bf{s}})\infty }d{\bf{r}}\,\,\,{\rm{Tr}}\left({M}_{{\bf{r}}}\rho {M}_{{\bf{r}}}^{\dagger }\right)\\ &=&\sum _{{\bf{b}}}{\rm{Tr}}(\rho {\hat{P}}_{{\bf{b}}})\left[\mathop{\prod }\limits_{j=1}^{n}\mathop{\int}\nolimits_{0}^{{\rm{sign}}({s}_{j})\infty }d{r}_{j}{{\mathcal{G}}}_{j}\right],\end{array}$$

(27a)

where we have abbreviated

$${{\mathcal{G}}}_{j}=\sqrt{\frac{\Delta {t}_{m}}{2\pi }}{e}^{\frac{-\Delta {t}_{m}}{2}{\left({r}_{j}-\frac{{b}_{j}}{\sqrt{\tau }}\right)}^{2}}.$$

(27b)

Simplifying this yields

$$\begin{array}{ll}{{\mathbb{P}}}_{{\bf{s}}}\;=\;\displaystyle\frac{1}{{2}^{n}}\sum\limits_{{\bf{b}}}\left\{{\rm{Tr}}(\rho {\hat{P}}_{{\bf{b}}}){\left[1+{\rm{erf}}\left(\sqrt{\frac{\Delta {t}_{m}}{2\tau }}\right)\right]}^{n-{h}_{{\bf{s}},{\bf{b}}}}\right.\\\qquad\quad \left.\times {\left[1-{\rm{erf}}\left(\sqrt{\frac{\Delta {t}_{m}}{2\tau }}\right)\right]}^{{h}_{{\bf{s}},{\bf{b}}}}\right\},\end{array}$$

(27c)

where h_s,b is the Hamming distance between s and each possible bitstring b. The above derivation gives a procedure of reading out a bitstring via generalized measurement from the final state of either quantum Algorithm 1 or Algorithm 3. The overall general algorithm using any one of these two generalized measurement algorithms together with the final state readout is summarized in Algorithm 4 below.

Algorithm 4

k-SAT with generalized qubit readout

1: input: a CNF Boolean formula F, τ, T_f, Δt, Δt_m, a schedule θ(t/T_f): if Algorithm 3 is used, values of T_be, T_min, r_th are also input.

2: run either Algorithm 1 or Algorithm 3, and obtain a final state ρ(T_f)

3: read out local ${\hat{\sigma }}_{z}$ of ρ(T_f) with Kraus operators given in Eq. (25), obtaining readouts ${\bf{r}}={\{{r}_{i}\}}_{i = 1}^{n}$

4: extract the candidate bitstring b = sign(r)

5: if b is classically verified to be a solution bitstring then

6:  return verified solution b

7: else

8:  repeat 2 − 4

9: end if

Recall from the arguments of section “Convergence in the Zeno limit” that in the limit of long dragging times T_f, ρ is expected to concentrate itself in the solution subspace, i.e., ${\rm{Tr}}(\rho \,{\hat{P}}_{{\bf{b}}})$ will only contribute to bitstrings that are actually solutions (assuming one exists). Moreover, as the readout time also becomes long (Δt_m ≫ τ, such that the local readout is effectively projective), ${\rm{erf}}(\sqrt{\Delta {t}_{m}/2\tau })$ also tends to one, so that the leading 2⁻ⁿ is canceled out, and we expect to deterministically recover a correct solution bitstring.

We analyze the tradeoffs between the success probability ${{\mathbb{P}}}_{{\bf{s}}}$ in an individual run of Algorithm 4 and algorithm runtime by first defining a time-to-solution (TTS) as

$${{\rm{TTS}}}^{(m)}=N\cdot ({T}_{f}+\Delta {t}_{m}),$$

(28)

where an algorithm realized within a dragging time T_f is followed by qubit readout of duration Δt_m and is repeated N times. The superscript (m) denotes that the final measurement time Δt_m is included. Suppose we allow ourselves to perform these N shots with the assumption that classically verifying whether each output bitstring b is actually a solution to our k-SAT problem is easy. This is true since k-SAT is in NP. How much time, and how many shots N, should be required to guarantee that the correct solution were to appear at least once with probability greater than some confidence cutoff ${{\mathbb{P}}}_{\star }$? We can say that the probability that M shots out of N are successful are governed by binomial statistics, i.e.,

$${{\mathbb{P}}}_{{\bf{s}}}^{(M/N)}=\left(\begin{array}{c}N\\ M\end{array}\right){{\mathbb{P}}}_{{\bf{s}}}^{M}\,{(1-{{\mathbb{P}}}_{{\bf{s}}})}^{N-M}.$$

(29a)

Then the probability of at least one successful run is

$$1-{{\mathbb{P}}}_{{\bf{s}}}^{(0/N)}=1-{(1-{{\mathbb{P}}}_{{\bf{s}}})}^{N},$$

(29b)

where ${{\mathbb{P}}}_{{\bf{s}}}^{(0/N)}$ is the probability that all N runs fail. Consequently our condition of interest is

$$1-{(1-{{\mathbb{P}}}_{{\bf{s}}})}^{N}\ge {{\mathbb{P}}}_{\star },$$

(29c)

such that the expected number of runs needed to achieve a solution with probability at least ${{\mathbb{P}}}_{\star }$ is

$${N}_{\star }={\rm{ceil}}\left[\frac{\log (1-{{\mathbb{P}}}_{\star })}{\log (1-{{\mathbb{P}}}_{{\bf{s}}})}\right].$$

(30)

Here, ${{\mathbb{P}}}_{\star }$ should be understood as a desired level of solution confidence specified by the experimenter.

Given the above, we may now define a modified TTS that replaces N by N_⋆, i.e.,

$${{\rm{TTS}}}_{\star }^{(m)}={\rm{ceil}}\left[\frac{\log (1-{{\mathbb{P}}}_{\star })}{\log (1-{{\mathbb{P}}}_{{\bf{s}}})}\right]({T}_{f}+\Delta {t}_{m}).$$

(31)

This is now consistent with the confidence bound ${{\mathbb{P}}}_{\star }$, i.e., it measures the time to solution for achieving a solution with probability at least ${{\mathbb{P}}}_{\star }$. The readout time Δt_m is often neglected¹¹⁴ below, in order to emphasize the scaling of the TTS with the pure dragging time T_f alone, which is consistent with common analyses of asymptotic scaling of quantum algorithms.

The expression N_⋆(30) may also be understood as a means of assessing whether a given set of parameters T_f/τ and Δt_m/τ are sufficient to achieve any useful advantage between this measurement–driven algorithm and some other option. For example, a choice of parameters requiring N_⋆ ≥ 2ⁿ to achieve the desired confidence level is clearly useless, because it would be faster to simply guess solution bitstrings at random and check whether they satisfy all m clauses. More generally, we can impose a condition that we want ${N}_{\star }\le {\lambda }_{c}^{n}$, where λ_c is some critical rate parameter that we want to beat. Some algebra reveals that

$${{\mathbb{P}}}_{{\bf{s}}}=1-{(1-{{\mathbb{P}}}_{\star })}^{{\lambda }_{c}^{-n}},$$

(32)

such that we can understand the ${{\mathbb{P}}}_{{\bf{s}}}$ required in an individual run of the algorithm to achieve a given scaling rate λ_c. We will soon see that in practice, the most difficult aspect of these expressions to evaluate is the dependence of ${{\mathbb{P}}}_{{\mathsf{s}}}$ on T_f.

Two–qubit 2-SAT: from discrete to continuous measurement

In order to gain some intuition about the dynamics under our measurement-driven algorithm, it is insightful to analyze the minimal version of the SAT problem. 2-SAT belongs to complexity class P and thus might be viewed as less interesting compared with other intractable SAT problems. The particular situation in which there are only two Boolean variables involved in the 2-SAT CNF formula is nevertheless of interest here, because the application of our generalized measurement BZF algorithms 1–3 illustrates the continuous form of BZF dynamics, while remaining relatively simple and accessible to detailed analysis. We will refer to this illustrative toy problem as the 2-qubit 2-SAT problem.

The simplest 2-SAT problem

2-qubit 2-SAT is the minimal version of the SAT problem that captures most of the significant features of SAT while involving a minimum number of qubits and clause measurements. In this section, we will analyze the algorithmic dynamics of the two-qubit system under generalized measurements. In particular, we will show that for a given total algorithm running time, weak continuous measurements lead to the highest success probability for finite T_f /τ. This motivates a detailed study of those continuous dynamics. We first examine the unconditioned average dynamics in Algorithm 1 with LME (14), and then consider the heralded dynamics of Algorithm 3 with the SME of Eq. (15).

More specifically, we consider a 2-qubit 2-SAT problem with a single satisfying solution. Without loss of generality such a problem can be defined by the following CNF formula

$$F={C}_{1}\wedge {C}_{2}\wedge {C}_{3},$$

(33a)

where

$$\begin{array}{ll}{C}_{1}\,=\,{b}_{1}\vee {b}_{2}\\ {C}_{2}\,=\,{b}_{1}\vee {\bar{b}}_{2}\\ {C}_{3}\,=\,{\bar{b}}_{1}\vee {\bar{b}}_{2}.\end{array}$$

(33b)

It can be easily checked that the only solution to this simple 2-qubit 2-SAT problem is (b₁, b₂) = (0, 1). Classically, one can imagine solving this by the following procedure. In the space {0, 1}², each clause excludes an assignment that will violate it. For example, C₁ = b₁ ∨ b₂ will exclude (b₁, b₂) = (1, 1) as a solution assignment. After the last clause check, the legal assignments that survive this procedure correspond to the solution. The BZF algorithm is similar, in that each clause measurement checks whether the quantum state is projected into the subspace it excludes as a failure subspace and the surviving quantum state conditioned on successful clause checks is the solution subspace. The three observables corresponding to the three clause checks in Eq. (33b) are given by

$$\begin{array}{rcl}{\hat{X}}_{1}(\theta )&=&\displaystyle\frac{1}{2}\left\{\hat{{\mathbb{1}}}+{\hat{\sigma }}_{+\theta }^{(1)}+{\hat{\sigma }}_{+\theta }^{(2)}+{\hat{\sigma }}_{+\theta }^{(1)}\,{\hat{\sigma }}_{+\theta }^{(2)}\right\}\\ {\hat{X}}_{2}(\theta )&=&\displaystyle\frac{1}{2}\left\{\hat{{\mathbb{1}}}+{\hat{\sigma }}_{+\theta }^{(1)}+{\hat{\sigma }}_{-\theta }^{(2)}+{\hat{\sigma }}_{+\theta }^{(1)}\,{\hat{\sigma }}_{-\theta }^{(2)}\right\}\\ {\hat{X}}_{3}(\theta )&=&\displaystyle\frac{1}{2}\left\{\hat{{\mathbb{1}}}+{\hat{\sigma }}_{-\theta }^{(1)}+{\hat{\sigma }}_{-\theta }^{(2)}+{\hat{\sigma }}_{-\theta }^{(1)}\,{\hat{\sigma }}_{-\theta }^{(2)}\right\},\end{array}$$

(34a)

with

$${\hat{\sigma }}_{\pm \theta }^{(j)}=\cos (\theta ){\hat{\sigma }}_{x}^{(j)}\mp \sin (\theta ){\hat{\sigma }}_{z}^{(j)}$$

(34b)

where ${\hat{\sigma }}_{x}^{(j)}$ and ${\hat{\sigma }}_{z}^{(j)}$ are Pauli-x and Pauli-z operators that only acts on the j^th qubit. ${\hat{\sigma }}_{x}^{(j)}(\theta )$ is then the Pauli-x operator rotated clockwise in the x-z plane by θ as indicated in Fig. 2.

The quantum system is then driven by the generalized measurements of these three observables, and we adopt a simple linear schedule for the control parameter θ: for the cth cycle of clause measurements, ${\theta }_{c}=\frac{c}{N}\cdot \frac{\pi }{2}$ where N is the total number of cycles of clause measurements. The instantaneous solution state $\left\vert {\phi }_{soln}(\theta )\right\rangle$, which is the common “+1”-eigenstate of ${\hat{X}}_{1}(\theta ),{\hat{X}}_{2}(\theta ),{\hat{X}}_{3}(\theta )$ is given by

$$\begin{array}{lll}\left\vert {\phi }_{soln}(\theta )\right\rangle &=&\left[\cos \left(\frac{\theta }{2}+\frac{\pi }{4}\right)\left\vert 0\right\rangle +\sin \left(\frac{\theta }{2}+\frac{\pi }{4}\right)\left\vert 1\right\rangle \right]\\ &\otimes &\left[\cos \left(-\frac{\theta }{2}+\frac{\pi }{4}\right)\left\vert 0\right\rangle +\sin \left(-\frac{\theta }{2}+\frac{\pi }{4}\right)\left\vert 1\right\rangle \right].\end{array}$$

(35)

The probability of successfully implementing the algorithm and thus also the running time then depend primarily on the ability to follow this instantaneous solution state in an adiabatic (Zeno) sense.

Zeno dragging for discrete and continuous generalized measurements

Burgarth et al.⁸⁹ showed that the weak continuous limit is favorable for generating Zeno dynamics in the case of single measurement channel. We now show that a similar result can be obtained for the dynamics generated by multiple measurement channels. In particular, we will demonstrate that dynamics driven by weak continuous measurements approaches the target dynamics $\left\vert {\phi }_{soln}(\theta )\right\rangle$(35) better than discrete stronger measurements executed using the same total measurement strength and duration.

It will be adequate to consider the average dynamics given by Eq. (11) to make this point. Let the final state following the average dynamics driven by the generalized measurements be ρ_f. We then calculate the fidelity f between ρ_f and $\left\vert {\phi }_{soln}(\theta =\frac{\pi }{2})\right\rangle =\left\vert 10\right\rangle$, i.e., f = 〈10∣ρ_f∣10〉. More specifically, we calculate the fidelity f(Δt/τ, T_f/τ) as a function of both Δt/τ, which controls the effective individual measurement strength, with τ the measurement time, and T_f/τ, where T_f = ℓ ⋅ Δt is the total duration of Zeno dragging. Figure 2 illustrates the relevant simulation of the average dynamics Eq. (11) for the 2-SAT problem on 2 qubits. This computation is consistent with the intuition that for a given measurement strength, increasing the total duration T_f (thus dragging more slowly) brings us towards the adiabatic/Zeno regime. However, for a given fixed and finite value of T_f, the fidelity finds its maximum value at Δt/τ = 0. This means that rather than multiple pulsed and discrete strong measurements, Zeno dragging in our two–qubit 2-SAT problem is most effective in the continuum limit, for any given value of T_f/τ.

Fig. 2: Visual representation of Eq. (4) for the 2-qubit 2-SAT problem, with each qubit located in the xz-plane of its Bloch sphere.

The three projectors corresponding to the three clauses in the 2-qubit 2-SAT defined by Eq. (33b) are shown as tensor products of $\left\vert {\theta }^{\perp }\right\rangle =\hat{R}(\pi +\theta )\left\vert +\right\rangle$ (indicated as a red dot) and $\vert {\bar{\theta }}^{\perp }\rangle =\hat{R}(\pi -\theta )\vert + \rangle$ (indicated as a blue dot). Upon measuring the observable corresponding to each ${\hat{P}}_{j}(\theta )$, an outcome +1 heralds success (and corresponds to the ±θ states), while an outcome −1 heralds failure (and corresponds to the ±θ^⊥ states). Thus, each measurement serves to rule out a possible final solution, shown to the right of drawings of each projector. The unique solution that remains is the solution to this 2-SAT problem.

Illustration of adiabatic convergence via Lindblad dynamics

We demonstrate here the convergence of the LME Eq. (14) to the adiabatic limit in the long time using the 2-qubit 2-SAT problem. Firstly, it is illustrative to show the exact diagonal form of the solution subspace in the Zeno frame defined by Eq. (17). For the 2-qubit 2-SAT example in Fig. 3, we have $\hat{Q}={\hat{R}}_{Y}(\theta -\pi /2)\otimes {\hat{R}}_{Y}(\pi /2-\theta )$, and the observables of Eq. (34a) are then equal to

$${\hat{{\mathcal{X}}}}_{1}=\left(\begin{array}{cccc}\cos (2\theta )&\sin (2\theta )&0&0\\ \sin (2\theta )&-\cos (2\theta )&0&0\\ 0&0&{\mathbf{1}}&0\\ 0&0&0&1\end{array}\right),$$

(36a)

$${\hat{{\mathcal{X}}}}_{2}=\left(\begin{array}{cccc}1&0&0&0\\ 0&-1&0&0\\ 0&0&{\mathbf{1}}&0\\ 0&0&0&1\end{array}\right),$$

(36b)

$${\hat{{\mathcal{X}}}}_{3}=\left(\begin{array}{cccc}1&0&0&0\\ 0&-\cos (2\theta )&0&\sin (2\theta )\\ 0&0&{\mathbf{1}}&0\\ 0&\sin (2\theta )&0&\cos (2\theta )\end{array}\right)$$

(36c)

in the $\hat{Q}$–frame, represented in the ${\{\left\vert 11\right\rangle ,\left\vert 10\right\rangle ,\left\vert 01\right\rangle ,\left\vert 00\right\rangle \}}^{\top }$ basis. The solution state, which is now θ–independent, is marked in boldface in Eq. (36a). Clearly, the solution subspace is isolated in a block diagonal form and becomes θ-independent, as discussed in previous sections.

Fig. 3: Fidelity of the final state ${\mathscr{F}}=\langle 10| {\rho }_{f}| 10\rangle$ for the 2-SAT problem on 2 qubits Eq. (33b), shown as a function of single clause measurement time Δt/τ and total dragging time T_f/τ, where we set the time scale for the generalized measurement τ = 1 to be the reference time scale.

The two panels differ only in the scale and range of their axes. These results are obtained from simulating the average dynamics driven by measuring the three clause observables ${\hat{X}}_{1}(\theta )$, ${\hat{X}}_{2}(\theta )$ and ${\hat{X}}_{3}(\theta )$ in the 2-qubit 2-SAT problem Eq. (33b) according to Eq. (11). For a given dragging time T_f = ℓ ⋅ Δt, where T_f is subdivided into ℓ measurements each of duration Δt, the optimal value of Δt/τ is found at Δt/τ → 0, which implies that ℓ → ∞. The upper panel also shows small values of T_f ~ Δt: in this region we set Δt to the nearest ℓ value that evenly subdivides T. The small fidelity oscillations seen in this region are due to the discrete nature of this operation. For Δt > T_f (red hatched region, which is forbidden), we perform only the clause measurement at θ = π/2, yielding the lowest possible value of fidelity ${\mathscr{F}}=\frac{1}{4}$ for a two-qubit problem. This forbidden region is a general feature of such an analysis, and informs the behavior of the surrounding contours. The maximization of the fidelity for a given T_f/τ via taking Δt → 0 illustrates the advantages of operating in the limit of continuous weak measurements that is located towards the bottom edge of each plot.

We may now consider the dynamics of the algorithm on average, i.e, as modeled by Eq. (12). These dynamics represent the average performance, but can also be interpreted as the dynamics arising in the event that we dissipate information to the environment without actually detecting it^28,29,30,31. This reflects the perspective that the average/Lindbladian dynamics are equivalently the conditional dynamics in the limit of vanishing measurement efficiency. In looking at the Lindblad dynamics, we are then looking at an “un-heralded” version of the continuous–time BZF algorithm, which is the time-continuous limit Δt/τ → 0 of Algorithm 1. Note that from the discussion of convergence in section “Convergence in the Zeno limit”, we can expect to deterministically achieve perfect solution dynamics in the limit of long dragging time, even in the case without detection.

Some key features of these Lindblad algorithm dynamics are illustrated in Fig. 4. Here we integrate the Lindblad dynamics for a variety of Γ T_f values (where Γ = 1/4τ is the measurement rate), scanning from the quasi-adiabatic/Zeno regime Γ T_f ≫ 1, to the diabatic regime Γ T_f ~ 1. We see that in the adiabatic limit Γ T_f → ∞, the dynamics converge to the pure and separable solution Eq. (35), as expected. For smaller values of Γ T_f, the fidelity is clearly reduced. We show that the reduced density matrices become less and less pure, with reduced contrast along the local z–axes along which we wish to read out a final 2-SAT solution. This loss of purity in the reduced density matrices is due both to overall purity loss of the two–qubit state due to dissipation, and due to the formation of spurious measurement–induced entanglement between the qubits when the Lindblad algorithm is constrained to finish within a finite time.

Fig. 4: Properties of the Lindblad dynamics for the 2–SAT problem of Eq. (33b) illustrated in Fig. 3, on scanning through a range of values of measurement strength Γ = 1/(4τ).

The same measurement strengths and linear schedule θ = π t/2 T_f are used through all four panels. The time axis is displayed here in units of the total evolution time T_f. a Illustrates the reduced density matrix evolution for qubit 1 (teal) and qubit 2 (purple), shown for both in the xz Bloch plane; results are shown for a variety of measurement strengths spanning from Γ T_f = 1 (pale) to Γ T_f = 1 × 10⁴ (dark). b Shows the corresponding time traces of the local z coordinates for the two qubits. c shows the behavior of the separability ($1-{\mathcal{C}}$, where ${\mathcal{C}}$ is the concurrence¹²⁷) throughout the Lindblad evolution. d Plots the purity of the two-qubit state as it undergoes Lindblad evolution. These results show that in the adiabatic regime Γ T_f ≫ 1, we converge towards a pure-state and completely separable evolution (see Eq. (35)) that deterministically generates the solution of this very simple 2-SAT problem, i.e., z₁ = 1 and z₂ = −1, corresponding to (b₁, b₂) = (0, 1) as expected from Eq. (33b). We showed in section “Convergence in the Zeno limit” that this is in fact a general feature of k-SAT problems with a unique solution in this measurement--driven algorithm. Even far from the adiabatic regime (Γ T ~ 1), we still see that some information about this solution manifests itself on average, since the reduced density matrix traces (local z coordinates in (b)) still drift discernibly apart and move towards their respective solution states.

In Fig. 4a, b (and also in Fig. 5b below) one may immediately observe that as the dragging time Γ T_f increases, the system enters a time regime where lengthening the algorithm evolution time leads to rapid improvement in the contrast between the output states (around Γ T_f ≲ 200). However, the benefit of increasing Γ T_f is comparatively small beyond this point (Γ T_f ≳ 200). Therefore, to obtain the solution state with a desired high probability, we expect that there may generically exist an optimal runtime value ${T}_{f}^{opt}$, such that repeating this Lindbladian dragging process some number of times leads to extraction of the solution at the desired confidence level. We devote the next section to developing conceptual and formal tools needed to probe this idea in our two–qubit problem, and will return to it later at scale.

Fig. 5: Illustration of the expected time to solution for the two-qubit 2-SAT problem of Eq. (33b) and Fig. 3, as obtained by the Lindblad solver (Algorithm 4 with Algorithm 1) using a linear schedule θ = π t/2 T_f.

The times T_f, Δt_m, and TTUS_99% (Eq. (40)) are all given in units of the characteristic measurement time τ, which is assumed to characterize the strength of both the clause measurements and subsequent local readout measurements. We illustrate the timeline of each experimental run of the protocol in (a). b Shows the time evolution of the local z coordinate (see Fig. 4c), and illustrates the average z resolution we can expect to obtain on any one of the two qubits, and illustrates how this depends on the Lindblad dragging times T_f expended on the analog measurement-driven computation. c Analyzes the readout time Δt_m required to achieve a solution in N shots, given the local bias ∣z∣ on the qubits. We plot Eq. (39) for n = 2 and required confidence level ${{\mathbb{P}}}_{\star }=0.99$, which we denote N_99%. Since we consider a two-qubit problem (n = 2), it is effectively meaningless to consider performing N > 2ⁿ = 4 shots; the contour separating the useful (lower) region from this region is highlighted in red. d Aggregates the results of (b, c). Here we plot Eq. (40) (a special case of Eq. (31)) for ${{\mathbb{P}}}_{\star }=0.99$, notated as ${{\rm{TTS}}}_{99 \% }^{(m)}$. Some selected contours of N_99% Eq. (39) are overlaid, highlighting the discrete nature of the ceiling function introduced to enforce the confidence threshold. For this very small toy problem, we observe that there is not an optimal TTS visible. Because 2ⁿ is small in this instance, the stipulation that N be at most 2ⁿ is quite restrictive (it is, after all, very easy to solve this toy problem just by checking all candidate solutions). We will see in later sections that the importance of these small-size effects falls away as we consider larger problems and TTS scaling.

Illustration of readout scheme and TTS

In the Lindbladian setting the observer gains no information during the dragging time T_f, due to performing dissipation without detection. All solution information must then be obtained from local measurements to read out the qubit states at the end of the algorithm, as described in Algorithm 4 and section “Readout scheme and time-to-solution”.

Let us consider the statistics of the measurement outcomes when such a measurement is applied to the reduced density matrix ρ_j for the jth qubit in our register. This means that we apply Eq. (25) under the simplifying assumption that there is negligible correlation between any of the qubits (Fig. 4 indicates that for relatively long dragging times, this is a reasonable assumption to make). We have the probability density

$$\begin{array}{lll}\wp ({r}_{j}| {\rho }_{j})=\left(\frac{1+{z}_{j}}{2}\right){\left(\frac{\Delta {t}_{m}}{2\pi }\right)}^{\frac{1}{2}}{e}^{-\frac{\Delta {t}_{m}}{4}{\left({r}_{j}-\frac{1}{\sqrt{\tau }}\right)}^{2}}\\\qquad\qquad\;\;\;\; +\left(\frac{1-{z}_{j}}{2}\right){\left(\frac{\Delta {t}_{m}}{2\pi }\right)}^{\frac{1}{2}}{e}^{-\frac{\Delta {t}_{m}}{4}{\left({r}_{j}+\frac{1}{\sqrt{\tau }}\right)}^{2}}\\\qquad\quad\;\;\; ={\mathcal{P}}(0)\wp (r| 0)+{\mathcal{P}}(1)\wp (r| 1)\end{array}$$

(37)

for each qubit, where ℘(r∣0) and ℘(r∣1) are Gaussians with positive and negative mean signals respectively, and variances 1/Δt_m (such models are commonly used for dispersive or longitudinal readout of individual qubits^109,110). As in section “Readout scheme and time-to-solution”, suppose that upon reading out r_z (a vector of all the r_j), we obtain the solution bitstring from that run of the experiment via $\tilde{{\bf{s}}}={\rm{sign}}({{\bf{r}}}_{z})$. The probability that each ${\tilde{s}}_{j}$ correctly reflects the underlying biases z_j, such that $\tilde{{\bf{s}}}$ matches the correct solution s, is given by

$$\begin{array}{lll}P({\bf{b}}={\bf{s}}| \{{z}_{j}\})=\left(\mathop{\prod }\limits_{j}^{n}\left|\mathop{\displaystyle\int}\nolimits_{0}^{{\rm{sign}}({b}_{j})\infty }d{r}_{j}\wp ({r}_{j}| {\rho }_{j})\right|\right)\\\qquad\qquad\qquad\; =\mathop{\prod }\limits_{j}^{n}\frac{1+| {z}_{j}| \,{\rm{erf}}\left(\sqrt{\Delta {t}_{m}/2\tau }\right)}{2}\\\qquad\qquad\qquad\; ={\left(\frac{1+| {z}_{T}| {\rm{erf}}\left(\sqrt{\Delta {t}_{m}/2\tau }\right)}{2}\right)}^{n},\end{array}$$

(38)

where in the last line the biases ∣z_j∣ = ∣z_T∣ are assumed the same up to a sign. We note that this expression is a special case of Eq. (27), under the simplifying assumptions that the state of the different qubits is approximately separable, and that the local biases are uniform and correctly reflect the solution state. The assumptions of separability and correct solution bias are generically valid for sufficiently long T_f, and when applied to problems with a unique solution. Notice that in the limit of deterministic dragging T/τ → ∞ and strong readout Δt_m/τ → ∞, this expression scales as 1ⁿ. In the opposing limit of T → 0 (so that ∣z_T∣ → 0), the scaling instead goes as 2ⁿ. This corresponds to the readout essentially choosing one of the 2ⁿ candidate solution bitstrings at random, in analogy with the worst, i.e., brute-force classical approach to k-SAT.

Let us next consider the number of runs N_⋆ required to achieve a solution probability at least ${{\mathbb{P}}}_{\star }$, Eq. (30), to this special case of 2-qubit 2-SAT. For k-SAT problems with unique solution and uniform local bias, we may write

$${\check{N}}_{\star }={\rm{ceil}}\left[\frac{\log (1-{{\mathbb{P}}}_{\star })}{\log \left(1-\frac{1}{{2}^{n}}{\left(1+| {z}_{T}| {\rm{erf}}\left(\sqrt{\Delta {t}_{m}/2\tau }\right)\right)}^{n}\right)}\right],$$

(39)

using Eq. (38). A visualization of this expression for n = 2 2-SAT appears in Fig. 5c. We remark that if a bound on the bias ∣z_T∣ could be systematically derived in the case of a unique solution, then the behavior of this dissipation–driven algorithm could in turn be systematically bounded using the expressions above. Given the above, we may now define the time to a unique solution,

$${{\rm{TTUS}}}_{\star }^{(m)}={\check{N}}_{\star }\cdot ({T}_{f}+\Delta {t}_{m}).$$

(40)

This is a special case of Eq. (31), using the further assumptions about the local qubit bias implicit in Eq. (39). These assumptions are compatible with dynamics like those of Fig. 4, and this expression is consequently used in the analysis of Fig. 5 for that same example. Figure 5c, d are instructive with regards to the process of estimating a time to solution, illustrating how one might derive regions of T_f and Δt_m required to solve a k-SAT problem with a continuous measurement–driven approach, within a certain number of shots and/or with a specified confidence threshold.

One may infer from Fig. 5 that if an optimal TTS exists in this system, it falls in the regime of very short dragging times T_f and readouts Δt_m, requiring far more than the N = 4 runs in which the solution to this toy problem can be obtained via a guess and check approach (the worst solution approach). This formally tells us that this toy problem is too simple for our algorithm to be worthwhile, and that we are nearing the end of this small problem’s utility as an instructional tool. We will see in section “Scaling with qubit number for 3-SAT” that a transition occurs at which we will find a genuine optimal TTS, indicating that we can tell when a problem becomes large enough to become more computationally worthwhile.

Remarks: multi-solution and unsatisfiable problems

In the analysis above, we have emphasized the sample two–qubit 2-SAT problem of Fig. 3, which has a unique solution. However, variants on this problem containing either more than one solution, or no solutions at all, are also illuminating to consider. We describe such alternative two–qubit 2-SAT problems in detail in Supplementary Information Section II, restricting ourselves here to a brief summary.

When multiple solutions satisfy our two–qubit 2-SAT problem, or when no solution can satisfy our two–qubit 2-SAT problem, we are no longer guaranteed any bias in the local z coordinates on average at the end of a Lindbladian dragging interval, even in the Zeno limit. However, the output of the two problems, i.e., when multiple solutions exist or when no solution exists, still differ in meaningful ways. In the case of multiple solutions, we will generate relatively high purity entangled states within the solution subspace, i.e., superpositions of the possible classical solutions, one of which is highly likely to be correctly resolved by reading out the qubits in the desirable regime T_f ≫ τ and Δt_m ≫ τ. This means that although the individual readout measurements of ${\hat{\sigma }}_{z}^{(j)}$ will appear random run-to-run, information about the solution space will still appear in the structure of the correlations between those z_j outcomes on a run-by-run basis. On the other hand, when the SAT problem is unsatisfiable, we obtain the maximally–mixed state on average, so that the local qubit readouts at the end will be random and not exhibit any mutual qubit correlations.

Illustration of heralded algorithm

We conclude our discussion of two–qubit 2-SAT with a demonstration of the heralded algorithm (Algorithm 3) using the 2-qubit 2-SAT defined by Eq. (33b). We have set the threshold to be ${r}_{th}=-2.5/\sqrt{{T}_{be}}$ so that some level of fluctuation due to noise is allowed by the filtered signal. This corresponds to correctly identifying the failure with a confidence probability of 99.65% in the steady state. Figure 6 shows the evolution of the qubit dynamics z_i(t) and the filtered signals ${\tilde{r}}_{i}(t)$ under the heralded algorithmic dynamics. A successful run of the algorithm will drag the qubits to their corresponding solution states, analogously to the fixed point algorithm driven by the Lindbladian. The difference is that with the heralded algorithm, we can now detect any failure shortly after it occurred instead of at the end of the algorithm. This can be seen in Fig. 6, where the failed trajectory is detected within an interval ~T_be of a failure event.

Fig. 6: Qubit dynamics and filtered clause readout signals under the heralded Algorithm 2.

The SAT problem here is the same as the one defined in Eq. (33b). We set the measurement collapse time τ = 1 and the total dragging time T_f = 100. The filter response time is set to be ${T}_{be}=\max \{2\tau ,0.1{T}_{f}\}$, and the threshold is ${r}_{th}=-2.5/\sqrt{{T}_{be}}$. a Shows the evolution of a successful run, where the filtered signals $\bar{r}$ Eq. (21) never reach the threshold value and the reduced conditional qubit dynamics (inset) diffuse relatively cleanly towards the correct solution state. b Shows the evolution of a failed run. In this example, qubit 0 is collapsed into an incorrect subspace near t/τ ≈ 50 (see inset) and the filtered signal 1 reaches the threshold near t/τ ≈ 60, heralding violation of a particular clause, and therefore a failure of the algorithm. The failure is detected when the threshold is crossed: the algorithm is terminated at this point. We also show the evolution for some time past this point, up to t = T_f, for illustrative purposes.

Scaling the problem Up

We have gained some intuition about the workings of the continuous BZF algorithm for k-SAT by investigating the simplest version of it, namely for k = 2 with 2 qubits. We now extend our analysis towards cases of greater computational interest, to study the algorithm’s performance on k-SAT problems with both k = 2 and k = 3, on 4–10 qubits. In this section, we will benchmark the Zeno dragging algorithms at various values of clause density α, as well as for different parameters Δt and T_f. In order to study the dependence only on the dragging time T_f, we will then assume projective measurement at the final readout phase, and thus we will make calls to Algorithm 1 and Algorithm 3 instead of to Algorithm 4.

Quantum computational phase transition

It has been rigorously proven that in the large n limit, the probability of satisfying a random SAT problem exhibits a phase transition from satisfiable to unsatisfiable (SAT-UNSAT) when the number of clauses per qubit number, i.e., α = m/n, exceeds a critical value α_c¹¹⁵. For 2-SAT, the critical clause density is analytically determined to be α_c = 1¹¹⁶. For 3-SAT, the critical value is empirically evaluated to be α_c ≈ 4.26^117,118. The computational cost for solving these random SAT problems correspondingly exhibits an easy-hard-easy pattern, with the computational cost transition occurring at the critical value of α_c^118,119. Quantum algorithms that optimize solutions for k-SAT, such as the quantum approximate optimization algorithm (QAOA), show a similar computational phase transition near α_c, even for systems as small as 6 qubits^120,121.

Here, we show evidence of an analogous quantum computational phase transition for both random 2-SAT and 3-SAT under our measurement-driven quantum algorithms. Specifically, we numerically estimate the probability of successfully determining the satisfiability of a random instance as a function of the clause density α, under different values of dragging time T_f. The empirical estimation of this success probability P_succ(α, n, T_f) is given by

$${P}_{{\rm{succ}}}(\alpha ,n,{T}_{f})=\frac{{N}_{{\rm{succ}}}(\alpha ,n,{T}_{f})}{{N}_{{\rm{prob}}}(\alpha ,n)},$$

(41)

where N_prob(α, n) is the number of random instances generated for clause density α and number of variables n, and N_succ(α, n, T_f) is the corresponding number of instances whose satisfiability are correctly determined by the measurement-driven quantum algorithm with total dragging time T_f.

Figure 7a, b show results for calculations with n = 5 qubits using the Lindblad Algorithm 1. We can see that even with such a relatively small system, for both 2-SAT and 3-SAT problems the SAT probability undergoes a clear SAT-UNSAT transition crossing at a distinct value α_c, while P_succ(α, n, T_f) shows an easy-hard-easy transition, with the hardest part located near α_c. We also see that when more quantum computational resources are provided, specifically, for larger T_f, the algorithm can obtain higher values of P_succ(α, n, T_f), indicating better performance.

Fig. 7: We demonstrate the quantum computational phase transition by evaluating the probability of successfully determining the satisfiability P_succ(α, n, T_f) as a function of clause density α, i.e., Eq. (41), for n = 5 qubits, using a range of values of the total dragging time T_f.

a, b are for 2-SAT and 3-SAT with the Lindblad Algorithm 1 (Δt → dt) respectively, while (c, d) are with the heralded Algorithm 3. The same measurement strength Γ = 1/(4τ) is used for all panels, together with a linear schedule θ(t) = πt/2T_f for 0 ≤ t ≤ T_f. We have set the measurement time τ = 1 throughout all the simulations. In the heralded algorithm, we have additionally set ${T}_{be}=\max \{2\tau ,0.1{T}_{f}\}$, T_min = 5τ, and ${r}_{th}=-2.5/\sqrt{{T}_{be}}$. The black dotted vertical lines are the locations of critical clause densities in the limit of large n, i.e., α_c = 1 for 2-SAT and α_c ≈ 4.26 for 3-SAT. The black curves are the probabilities of satisfiability as a function of α for the randomly generated SAT instances. The colored curves are P_succ(α, n, T_f) under various values of T_f. Each datum on the curve is obtained using a sample size N_prob(α, n) = 500. The non-zero width of the critical region and the deviation of the location of the lowest value of P_succ from α_c result from the finite system size n.

As discussed in section “Heralding BZF algorithm with finite measurement strength via filtering”, the heralded dynamics benefit from real-time detection of any failures. This advantage allows us to define the heralded algorithm (Algorithm 3) that restarts when the failure is detected early, and thus is more likely to follow the correct trajectory given a fixed amount of computation time T_f even without feedback. Notice that in Algorithm 3, we do not terminate the dynamics when the time left t_rest is smaller then a minimum value T_min. This is because when the total dragging time is too small (comparable to T_be and τ), the quantum Zeno effect is not strong and the failure detection based on the filter is also not reliable anymore. However, we can still use conditional dynamics, i.e., SME Eq (15) rather than the averaged dynamics LME Eq. (14), in this situation.

We perform the same type of calculation for the success probability Eq. (41) as a function of the clause density α under the heralded algorithm 3. The results are shown in Fig. 7c, d. We can see that the heralded algorithm shows the same type of computational phase transition as the Lindblad algorithm in panels (a) and (b). However, the performance of the heralded algorithm is better than that of the Lindblad algorithm, especially near the critical clause density α_c, and also when T_f is large. We can understand the latter as a consequence of the combination of earlier detection of failure and the possibility of running multiple trials.

This analysis has shown that for the continuous measurement–driven quantum algorithms, it would be most difficult to successfully solve SAT problems having the critical clause density α_c, similar to known results for QAOA and for classical algorithms. Therefore, in order to establish the scaling of the algorithm with respect to the system size n, we shall focus on the hardest SAT instances for the quantum algorithm, i.e., instances with α = α_c from now on.

Scaling with qubit number for 3-SAT

In this section, we study the scaling of the 3-SAT TTS with the qubit number n, which is central to quantifying the algorithm performance in terms of computational complexity. Specifically, we do not expect the TTS to scale polynomially with the qubit number n, which would imply NP ⊆ BQP. Since there are no strong computational complexity arguments implying this, we will then instead assume that TTS scales exponentially with the qubit number n throughout the rest of this work, i.e., TTS ~ λⁿ. We shall focus on studying the base number λ for the algorithms with different parameter settings.

In section “Illustration of Heralded algorithm” we demonstrated the behavior of the TTS as a function of the sum of the dragging time T_f and the final readout time Δt_m. However, in the context of algorithmic scaling, the TTS is generally characterized without taking the final readout time into account, which corresponds to using the dragging time T_f alone. To enable comparison with the literature, we therefore define the algorithmic time to solution as the following¹¹⁴

$${{\rm{TTS}}}_{99 \% }={T}_{f}\frac{\log (1-0.99)}{\log (1-{{\mathbb{P}}}_{{\bf{s}}})}={T}_{f}\,{N}_{99 \% },$$

(42)

where ${{\mathbb{P}}}_{{\bf{s}}}$ is the solution state probability at the end of one run of the algorithm.

We have shown that for infinitesimal dt, there exists a limit of deterministic and pure–state dynamics following the solution subspace; this implies that there exists a sufficiently long T_f for any satisfiable problem such that N_99% becomes 1. Our challenge now however is to navigate the tradeoff between T_f and N_99% that determines the TTS_99%. In order to do this, we consider 3-SAT problem instances that are chosen to have critical clause density α_c ≈ 4.26 and a unique satisfying assignment. Those problems are among the hardest to solve and thus serve as good testing problems for benchmarking our generalized measurement algorithms.

Scaling of TTS_99% as a function of T _f and Δt

In this subsection, we now study how the base number λ of the scaling with n depends on the total pure dragging time T_f and on the individual clause measurement duration Δt for Algorithm 1 with average dynamics, as well as for Algorithm 3 with heralded dynamics.

We simulated both algorithms using the same sets of parameters as in section “Quantum computational phase transition”, for up to n = 9 qubits. The results are shown in Figs. 8 and 9, from which it is evident that as the number of qubits increases, the TTS_99% increases exponentially. Furthermore, for different values of total pure dragging time T_f, the TTS_99% exhibits different scaling base numbers λ. Typically, one can reach a better (smaller) value of λ by implementing the algorithms with a larger value of T_f : this is observed over a range of Δt values, for both algorithms. This makes sense because for a fixed T_f, the TTS scaling parameter λ derives only from the number of runs ${N}_{99 \% }=\log (1-0.99)/\log (1-{{\mathbb{P}}}_{{\bf{s}}})$ required to achieve 99% confidence threshold as per Eq. (42) and one would therefore expect better performance (smaller N) with more computational resources (larger T_f).

Fig. 8: Time to solution scaling for 3-SAT under averaged and heralded quantum algorithms.

The 3-SAT time to solution TTS_99% defined by Eq. (42) is plotted as a function of the number of qubits, for different values of the total dragging time T_f and for different time duration Δt of a single clause measurement under both Algorithm 1 with average dynamics (upper (a), (b), (c)) and Algorithm 3 with heralded dynamics (lower (d), (e), (f)). The 3-SAT instances are randomly generated at α ≈ α_c with a unique solution. We have set τ = 1 and used a linear schedule θ(t) = πt/2T_f for all simulations. We use Δt = 0.01 (a, d), Δt = 0.1 (b, e), and Δt = 1 (c, f), all in units of τ. For the heralded algorithm, we have additionally set ${T}_{be}=\max \{2\tau ,0.1{T}_{f}\}$, T_min = 5τ, and ${r}_{th}=-2.5/\sqrt{{T}_{be}}$. The data for the heralded algorithm are averaged over more than 10,000 trajectories while the data for averaged algorithm are averaged over more than 150 trajectories. We see that TTS_99% generally increases exponentially as a function of the number of qubits. Notice the appearance of line-crossings, which is a signature of non-monotonic dependence of TTS_99% on T_f that indicates the possible existence of optimal values of TTS_99%. This figure continues with larger values of Δt in Fig. 9.

Fig. 9: We continue Fig. 8 for larger values of Δt.

We again have Algorithm 1 with average dynamics (a, b, c), and Algorithm 3 with heralded dynamics (d, e, f). Here Δt = 1 (a, d), Δt = 10 (b, e), and Δt = 100 (c, f), in units of τ. All other considerations and comments match those of Fig. 8.

Another interesting behavior is the dependence of λ on Δt. We recall that Δt/τ ≪ 1 corresponds to weak measurement and Δt/τ ≫ 1 corresponds to strong measurement. Figure 10 shows the scaling base λ as a function of Δt for different values of dragging time T_f. We observe that for fixed T_f, both average and heralded algorithms display better scaling of λ (smaller values) in the weak continuum limit (Δt → 0) than in the strong measurement limit (Δt → ∞). This indicates the advantage of weak continuous measurement for the TTS_99% scaling, in addition to the advantage demonstrated in Fig. 2 in terms of final state fidelity with respect to the solution state.

Fig. 10: Scaling parameter λ as a function of clause measurement duration Δt.

The fitted values of the base scaling parameter λ (not λ_opt) shown in Figs. 8 and 9 are aggregated and plotted here as a function of the duration Δt of clause measurement, for different dragging times T_f under both Algorithm 1 with average dynamics (red and orange points) and Algorithm 3 with heralded dynamics (blue and green points).

It is worth noting here that the TTS_99% scaling λ studied in this subsection should not be interpreted as a performance metric of the algorithm in the asymptotic sense. For the limited size of systems that we are able to simulate, the absolute value of the scaling base number λ can be easily manipulated. To see this, consider either Algorithm 1 or Algorithm 3 for some set of finite system sizes n_list = {n₁, …, n_d}. One can choose T_f finite but large enough such that the dynamics for all n_i in n_list is in the quasi-adiabatic limit, where the final solution state probability is close to 1. In this case, one only needs one attempt of the algorithm in order to find the solution bitstring, and thus the benchmarked scaling parameter λ is screened by the limited system size and appears to be 1, which is not reasonable. Nevertheless, λ can serve as a good metric for demonstrating performance improvement when using different parameters in the algorithm or when comparing different variants of the algorithm, e.g., the heralded and unheralded (average) generalized measurement algorithms (Algorithm 3 and Algorithm 1, respectively).

Optimal TTS_99% scaling

As shown in refs. ^114,122 for quantum annealing, to benchmark the scaling of such algorithms in a manner independent of the value of the single-shot running time, one needs to identify an optimal TTS_99% for each system size n and then obtain the scaling parameter λ_opt, such that ${{\rm{TTS}}}_{opt} \sim {\lambda }_{opt}^{n}$. The existence of an optimal TTS_99% value is intuitive from the following arguments. When T_f is small, one typically needs a diverging (or 2ⁿ) number of repeats of the algorithm in order to find the solution bitstring, therefore in this case the TTS_99% is also diverging or as large as ~2ⁿ. In contrast, when T_f is large and divergent, while one only needs a single attempt of the algorithm, the TTS_99% is also divergent. Therefore, one would expect a sweet spot where T_f is finite and the TTS_99% attains an optimal value by balancing the trade-off of using a large T_f with a single attempt versus using a small T_f with many attempts.

We demonstrate here that similar to quantum annealing, both the unheralded and heralded Zeno-dragging algorithms also exhibit an optimal TTS_99% that depends on the system size n and on Δt. To understand how the performance of the algorithms scales with the system size in a well-defined sense, we study here the scaling of this optimal TTS_99% with n.

In Figs. 8 and 9 it is evident that when the number of qubits is larger than some value, there can be some crossings of the TTS_99% lines, e.g., for both algorithms with Δt = 10. This implies that when increasing T_f, the TTS_99% exhibits a nonlinear behavior and does not necessarily increase or decrease with T_f, which is an indication of the possible existence of an optimal TTS_99% value. We investigate this nonlinearity by plotting the TTS_99% as a function of T_f for system size up to n = 10 in Fig. 11. This shows the TTS_99% versus T_f for both unheralded and heralded algorithms with Δt = 10, for system sizes n = 8 and n = 9. For these sizes the TTS_99% clearly exhibits an optimum value. By fitting the optimal values obtained from different system sizes n ∈ [5, 10] with an exponential function (Fig. 11c, f), we determined the optimal TTS_99% to scale as $\sim {({\lambda }_{opt})}^{n}$, with λ_opt ≈ 1.4346 for Algorithm 1 (average dynamics) and λ_opt ≈ 1.3492 for Algorithm 3 (heralded dynamics).

Fig. 11: Extracting optimal time to solution and optimal scaling parameter.

We plot TTS_99% as a function of the total dragging time T_f under both Algorithm 3 with heralded dynamics (a–c), and Algorithm 1 with average dynamics (d–f). Simulation parameters are the same as Fig. 8 with Δt = 10 and a linear schedule is also used. We observe clear optima for TTS_99% in (a, b, d, e). We locate these optimal TTS_99% values by fitting the data with a polynomial function. In (c, f), we plot the obtained optimal TTS_99% as a function of qubit number n, and fit the data with an exponential function to evaluate the scaling base number λ_opt. These figures with Δt = 10 serve as a demonstration of how λ_opt is extracted. Similar calculations were made for Δt ∈ {0.01, 0.1, 1, 10, 100} to allow construction of Fig. 12 below.

We then repeat the procedure for a range of measurement times Δt ∈ {0.01, 0.1, 1, 10, 100} for both algorithms, and obtain the values of λ_opt for each value of Δt. The results are shown in Fig. 12, where we see that for n = 9, 10 qubits, the TTS_99% from the heralded algorithm is smaller (better) than for the average algorithm (left panel (a)), and more importantly, the scaling base parameter λ_opt is significantly smaller for the heralded algorithm, over a wide range of Δt values (right panel (b)). We notice here that the scaling λ_opt achieved by the heralded algorithm is systematically smaller than that for Grover’s algorithm⁴ which has a scaling base number $\lambda =\sqrt{2}\approx 1.414$. This is a result of the proper usage of structure in our algorithm (recall that Grover is for unstructured search). Overall, it is evident that the heralded algorithm using signal filtering shows better TTS_99% behavior than the unconditional algorithm for all values of Δt. This indicates the advantages of implementing the earlier error detection of the heralded algorithm in the quasi-adiabatic regime, rather than relying solely on the autonomous features on which the unconditional algorithm is based, deep in the adiabatic regime.

Fig. 12: Dependence of the optimized TTS_99% performance of the generalized measurement-based algorithms on Δt for both the average algorithm, Algorithm 1 and the heralded algorithm, Algorithm 3.

a Displays the optimal TTS_99% as a function of Δt for different system sizes. We see that the optimal TTS_99% increases as Δt increases, and the heralded algorithm has a consistently smaller optimal TTS_99% than the corresponding average algorithms. b Shows λ_opt as a function of Δt for both algorithms. The scaling λ_opt is seen to be generically better in the strong measurement region than in the weak measurement region. It also evident that λ_opt for the heralded algorithm is uniformly better than that for the average algorithm, consistent with the behavior in (a).

Discussion and outlook

In this paper we have extended a quantum algorithm first proposed by Benjamin, Zhao, and Fitzsimons¹ (BZF), that uses projective measurements for solving Boolean satisfiability problems, to use instead generalized measurements for measurements of the Boolean clauses and for readout. First, we outlined a dissipation-only (unheralded) variant of the generalized algorithm, which is equivalent to discarding all the measurement results along the dynamics, or equivalently, using average dynamics. Second, we developed a filtering protocol for detecting clause failure based on the noisy signals of the generalized measurements that enables a heralded variant of the generalized algorithm employing dynamics conditioned on no clause failures. We discussed the statistics of solution readout following both versions of the generalized algorithm, again using generalized measurements, and showed how this readout time can be incorporated into the estimation of the expected time to solution (TTS). We then established the convergence of the algorithm in the limit of long dragging time and time–continuous measurement, noting that the time–continuous algorithm is an instance of “Zeno dragging”⁷⁰, where autonomous and deterministic convergence of the dynamics to a solution subspace is guaranteed in the Zeno limit. Finally, we illustrated the algorithmic dynamics, including the convergence in the Zeno limit and the filtering protocol. We have done this in detail for an illustrative and relatively simple 2-qubit 2-SAT problem, and then performed extensive numerical simulations on larger 2-SAT and 3-SAT problems involving 4–10 qubits.

With these larger simulations we numerically benchmarked the performance of both the heralded and unheralded algorithms as a function of the total pure dragging time T_f, the clause density α, as well as the duration of the clause measurements, Δt. We found that both algorithms exhibit a computational phase transition, as many other classical and quantum algorithms do, where the k-SAT problem is only hard for the algorithms to solve in the vicinity of the region of a critical value of α. We found strong evidence that working in the weak continuous limit is advantageous over operating in the strong measurement limit, at least for problems on moderate numbers of qubits. This result can be extracted from the observations that: (i) for fixed T_f, the scaling base number λ decreases as Δt decreases, and (ii) the optimal TTS decreases as Δt decreases. Finally, we also demonstrated that the algorithm performance can be systematically improved using clause detection and filtering in order to herald errors and restarting runs. This is shown in the improvement of the success probability for identifying a satisfying solution near the critical α that is enabled by heralded dynamics, as well as the smaller value of the optimal TTS scaling base parameter λ_opt in the heralded dynamics relative to the average dynamics.

This generalized measurement–driven approach shows some unique advantages and potential. For example, even though there are still many strategies by which one might optimize the algorithm, the optimal TTS scalings that we evaluate here are better than those achieved by Grover’s algorithm^4,123,124, characterized by λ ≈ 1.414, and are comparable to those of Schöning’s celebrated results²⁵, characterized by λ ≈ 1.33, respectively. BZF¹ have shown that their projective algorithm admits a solution state of the form of Eq. (8) for every solution bitstring to a k-SAT problem. Adapting this to the case of time–continuous monitoring, we have shown in section “Convergence in the Zeno limit” and Supplementary Information Section I that in the limit of slow Zeno dragging, we can expect to deterministically converge to such a solution, assuming we apply the dynamics to a satisfiable k-SAT problem, i.e., when a solution does exist. This implies that for large T_f /τ, we can push λ arbitrarily close to 1 (albeit with a diverging pre-factor in the TTS). This is a direct consequence of the fact that operations that use the Zeno effect for stabilization generally do so in the mean, i.e., they stabilize autonomously^{56,57,58,59,60,61,62,63,64,65,66,70,87,89,92}. The use of feedback in addition to this autonomous stabilization offers the possibility of not only detecting errors in real time, as we have discussed in sections “Illustration of Heralded algorithm” and “Scaling the problem up”, but also of correcting them immediately. Such feedback would be a natural subject for theoretical work following up on the present investigation, and would be closely related to continuous quantum error correction^{57,58,59,60,61,62,63,64,65,66,70,71,72,73,74,75,76,77,78,79,80,81,82,83,102,103}.

There are still many modifications that could be made to optimize the performance of the algorithm beyond what we have developed above. For instance, based on the equivalence of Zeno–dragging control and Zeno–exclusion control, one can exploit the newly developed CDJ–P method⁷⁰, which is a open-loop control technique to optimize the schedule function θ(t). Another direction for future work could be developing better filters for error detection, such as a Bayesian filter or machine learning filter⁸³, for use in the feedback strategies mentioned in the preceding paragraph.

Implementation of this algorithm on real hardware will require the engineering of several complicated measurements (or dissipators), which do not commute and will have to be implemented simultaneously. We suggest that progress on this front could realistically aim to follow a similar roadmap to the one we have followed in this theoretical paper, namely, to start with implementation of a two–qubit 2-SAT problem. Successful realizing of such a 2-SAT problem would be a strong step towards understanding and solving some of the engineering challenges involved and establishing proof-of-principle, at which point one could reasonably then consider attempting to scale the relevant experimental methods towards problems of a computationally more interesting size. Several experimental results that suggest ways forward here already exist. In particular, measuring or dissipating dynamic observables has been realized in a few contexts^68,125,126, as has measurement of non-commuting observables^36,82. Reference ⁸², focused on continuous quantum error correction, is especially relevant to our current context since the real-time error correction is implemented in that work on three qubits by simultaneously monitoring the parity of overlapping pairs of qubits, thereby connecting with several conceptual aspects of the generalized BZF algorithm presented in this work. In addition, the Zeno effect has been used for control, demonstrating that it is possible to engineer measurements that divide a larger system into specific subspaces^95,96, much like the clause measurements used here.

Taken together, we believe that our results indicate that the generalized BZF k-SAT algorithm shows promise for realization of a measurement-driven k-SAT solver, suggesting new avenues along which measurement–driven quantum computation might be further developed.