A quantum algorithm’s decision-making process can be mapped onto a classical random walk through a memory space—but the mapping forces a trade-off: either the walker uses negative probabilities or it must remember every step of its history. The choice is not a philosophical curiosity; it dictates the classical resources needed to compile and run the quantum algorithm on actual hardware.
This matters because the same tension between negativity and path-dependence appears in a second paper published on July 20, 2026, in the journal Quantum. That study quantifies the resources required to program low-depth quantum circuits—the kind that today’s noisy intermediate-scale quantum (NISQ) processors execute. The timing is not coincidental. As quantum computers grow beyond 1,000 physical qubits, the industry faces a bottleneck: the software that controls these machines must itself become efficient, yet the very non-classicality that gives quantum algorithms their edge resists clean decomposition into classical instructions.
How It Works
The first paper, posted to arXiv on July 19, 2026 ([arXiv:2607.17327]), tackles a foundational problem in quantum machine learning. Quantum learning models map inputs to outputs via coherent evolution and measurement, but that mapping is opaque. The authors ask: can we represent the inner workings of a quantum algorithm as a stochastic process—a probabilistic walk through a space of configurations? The answer is yes, but only if we accept a fundamental trade-off.
Starting from a fixed Positive Operator-Valued Measure (POVM), any quantum channel can be rewritten as a transition kernel on a probability representation. For informationally complete POVMs, such as symmetric informationally complete POVMs (SIC-POVMs), the resulting kernel is Markovian—the future depends only on the present state—but the kernel is quasi-stochastic: it contains negative entries. If instead one uses a projective representation, the kernel is strictly positive, but the dynamics become non-Markovian; the walker must carry a memory of its entire past. The paper states: “quantum dynamics can be represented either by Markovian quasi-stochastic maps or by positive stochastic processes with higher Markov order.”
This duality is a resource trade-off. Negativity is a signature of quantum interference, but it can be paid for by adding memory. The authors connect this to Projective Simulation, a learning model developed by Hans J. Briegel at the University of Innsbruck, in which an agent walks randomly through an episodic memory network. The quantum algorithm, reinterpreted as a stochastic deliberation through a memory space, can be approximated by finite-order kernels, effectively recovering a classical machine learning model when the memory order is low.
The Programming Cost of Quantum Advantage
The second paper, “Resource quantification for programming low-depth quantum circuits,” published in Quantum (Quantum 10, 2166, 2026), examines the other side of the coin. NISQ devices such as IBM’s 1,121-qubit Condor processor, Google’s Sycamore, and Quantinuum’s H-series run low-depth circuits because noise and decoherence limit the number of sequential operations. To execute a quantum algorithm, a classical computer must send program states that encode the circuit instructions, typically via a cloud service. The paper’s authors investigate the circuit complexity of programming these low-depth circuits as the number of qubits N increases.
Existing programming approaches that treat circuits as generic unitary transformations are computationally inefficient for shallow circuits. The paper shows that the classical resources needed to program a low-depth circuit scale with the circuit’s depth and the structure of entanglement, but that efficient methods exist when the circuit admits a description that compresses the non-Markovian correlations. The connection to the first paper is direct: the very same trade-off between negativity and memory that appears in the stochastic-process interpretation of quantum learning models also governs the compilation cost. A quantum algorithm that requires a large memory order in its stochastic representation will demand more classical horsepower to program on a real chip.
Who’s Moving
The theoretical work sits at the intersection of several industrial efforts. IBM (NYSE: IBM) continues to push its Qiskit runtime and dynamic circuit capabilities, explicitly targeting low-depth circuits for its Condor and Heron processors. Google Quantum AI (Alphabet, NASDAQ: GOOGL) has demonstrated quantum advantage on Sycamore and is now building a 1-million-qubit roadmap, with low-depth algorithms central to its error-mitigation strategy. Quantinuum, a subsidiary of Honeywell (NASDAQ: HON), operates the H2 trapped-ion processor with 56 high-fidelity qubits and has invested heavily in middleware that compiles circuits into hardware-native gates. Rigetti (NASDAQ: RGTI) and IonQ (NYSE: IONQ) also compete in the NISQ cloud market, each with proprietary compilers that must handle circuit depth constraints.
On the software side, the Projective Simulation framework has been licensed by several startups exploring agent-based quantum AI, though none have announced funding rounds tied directly to these results. The arXiv preprint’s authors are not named—the paper is under double-blind review—but the work builds on Briegel’s group at the University of Innsbruck, which has received funding from the Austrian Science Fund (FWF) and the European Research Council. The Quantum paper’s authors also remain anonymous in the journal’s metadata, a reflection of the peer-review process.
Why 2026 Is Different
The convergence of these two papers in July 2026 is not accidental. Quantum hardware has crossed the 1,000-qubit threshold, and the number of installed cloud-accessible quantum computers now exceeds 50 globally. The market for quantum software and programming tools is projected to reach $1.5 billion by 2028, according to analyst estimates, driven by the need to squeeze every ounce of performance from NISQ devices. In the next 12 months, IBM plans to deliver a 2,000-qubit modular processor, and Google’s error-corrected logical qubit milestone is expected by 2027. Within three years, the industry will shift from demonstrating quantum advantage on contrived benchmarks to running commercially relevant quantum algorithms in materials science and drug discovery. By 2031, the first error-corrected machines will obsolete the low-depth paradigm, but until then the resource trade-off between negativity and memory will define the competitive landscape for quantum software.
Conclusion
The two papers reframe quantum advantage as a resource allocation problem: every quantum algorithm can be simulated by a classical stochastic process, but the simulation’s cost—paid in negative probabilities or memory—is precisely the resource that must be managed when programming the algorithm on real hardware. The closer the classical simulation comes to the true quantum dynamics, the more expensive the compilation. In short: a quantum algorithm’s advantage is measurable by the memory order of its cheapest classical stochastic proxy, and that measurement now has a direct programming cost on NISQ machines.