Quantum Chemistry for Drug Discovery: 15.5x Circuit Depth Reduction on Real Hardware

The pharmaceutical industry seeks drugs with high potency and precise selectivity to improve efficacy, reduce side effects, and lower late-stage failure rates. Targeted covalent drugs are especially promising because they form a specific, irreversible bond with a target protein via a reactive chemical group called a warhead. When properly tuned, this mechanism delivers exceptional potency and durability—aspirin being one of the earliest examples. The challenge is predicting warhead reactivity: higher reactivity generally improves potency, but excessive reactivity undermines selectivity. Accurately balancing this trade-off remains a major bottleneck in drug discovery.

With R&D costs exceeding $2B per drug, pharma increasingly combines machine learning and computational chemistry to accelerate discovery. A powerful approach uses first-principles calculations to generate “quantum fingerprints”—physically grounded features that improve reactivity prediction. However, classical simulation methods scale poorly: they rely on approximations that are either too inaccurate to capture critical many-body effects or too expensive for practical screening.

Quantum computing offers a solution, but until now has been constrained by hardware noise, limiting usable circuit depth to a few hundred two-qubit gates. Haiqu, working with Capgemini, IBM, and GSK, broke this barrier by demonstrating one of the largest electronic-structure Hamiltonian simulations ever run on real quantum hardware for covalent drug warheads. Using advanced circuit compression and middleware execution, the team initially reduced circuit depth by 15.5× and further allowed end-to-end execution by running sub-circuits up to 371 gates.

Collectively, these results establish a scalable, hardware-realistic path for running Hamiltonian simulations on larger active spaces, while maintaining sufficient accuracy for molecular reactivity prediction.

For decision makers, the implications are clear and immediate: Haiqu dramatically lowers the cost and increases the performance of quantum chemistry workloads, transforming quantum computing from a long-term theoretical research bet into a near-term commercial piloting program on real quantum hardware. By making deep Hamiltonian simulations feasible on today’s quantum hardware, Haiqu enables pharmaceutical teams to:

Crucially, this is not a promise for the next decade. Haiqu makes high-value quantum workloads commercially viable today, allowing enterprises to capture competitive advantage years ahead of hardware-only roadmaps.

Quantum for business. Run more with Haiqu.

Explore the full research paper.

Book a Demo 

Loading Heavy-Tailed Financial Distributions on Quantum Hardware — at 156 Qubits

Quantitative finance is fundamentally about allocating capital and redistributing risk in ways that support long-term economic health. By making uncertainty explicit and actionable, quantitative methods help firms allocate resources with confidence and contribute to more transparent, reliable markets.

A canonical example is the Black–Scholes equation, which provides a principled framework for pricing derivatives. By making the cost of risk explicit, derivative pricing improves market efficiency and enables firms to hedge uncertainty and invest over longer horizons. In practice, however, many of today’s most important financial problems extend beyond closed-form solutions and rely on computationally intensive techniques such as Monte Carlo simulation. As models become more realistic, higher-dimensional, and sensitive to tail risk, these methods become increasingly slow and expensive to simulate on classical hardware.

Quantum computing has emerged as a promising way to accelerate financial workloads by offering fundamentally different scaling behavior than classical approaches. Beyond derivative pricing, applications such as portfolio optimization, fraud detection, and machine learning are all to benefit from quantum computation. These applications share a common and often overlooked requirement: realistic financial distributions must first be loaded into a quantum computer to govern the modelled instrument.

Distribution loading is extremely challenging. The number of required quantum operations in conventional algorithms can scale exponentially with the number of qubits, making it a significant bottleneck on today’s noisy, depth-limited hardware.

Haiqu addresses this challenge by exploiting structure and smoothness in distributions to factor the loading process into compact quantum circuits with linear (rather than exponential) scaling. Using this approach, Haiqu demonstrated the largest-scale loading of realistic financial distributions on quantum hardware by successfully encoding heavy-tailed distributions on up to 64 qubits on IBM’s Torino processor and validating the results with standard statistical tests on up to 25 qubits. Following the initial project, Haiqu demonstrated the applicability of this method at a scale of up to 156 qubits. 

Combined with Haiqu’s optimized execution tools, this capability enables, for the first time, the execution of Quantum Monte Carlo routines on realistic fat-tailed financial distributions directly on quantum hardware. It also unlocks practical exploration of quantum machine learning applications, such as fraud detection, by enabling high-dimensional feature encoding with only a few dozen qubits.

For business decision makers, the implications are immediate. Haiqu lowers the cost and increases the performance of financial quantum workloads, transforming quantum computing from a long-term research bet into a near-term commercial piloting opportunity. By enabling realistic distribution loading on today’s devices, Haiqu allows financial teams to test larger models, integrate quantum methods into existing workflows, and build expertise ahead of broader hardware advances.

Ultimately, this progress reinforces the core promise of quantitative finance: using better models and better computation to manage risk more effectively, allocate capital more wisely, and support a more stable and transparent financial system.

Quantum for business. Run more with Haiqu.

Book a Demo 

Record-Scale Quantum CFD: 64×64 Grid Simulation on IonQ Hardware

People want safe, affordable, and comfortable transportation. The economics of delivering quality to end customers are set early in the value chain: aircraft manufacturers make efficiency decisions that airlines convert into lower operating costs, which people then experience as lower fares and improved comfort. The introduction of Airbus A320 sharklets to reduce wingtip vortex drag and cut fuel burn is a good example. Airlines recovered retrofit costs in as little as two years per aircraft, achieved fleet-wide savings in the multi-billion-dollar, and supported lower operating cost per seat.

Producing innovations like the Airbus A320 sharklets is slow and expensive. Development spans years and depends on repeated wind-tunnel testing and flight campaigns to validate performance and safety. Each cycle consumes capital, engineering effort, and limited testing capacity. Errors discovered late in development are especially costly, often triggering redesigns and delays.

Computational Fluid Dynamics (CFD) shortens this cycle by predicting how fluid flow affects aerodynamic forces, moments, pressure distributions, and thermal loads before physical testing begins. Accurate simulations reduce reliance on experiments and avoid costly late-stage changes. However, in complex flow conditions—most notably turbulence—classical CFD struggles because flows span large swirling regions down to very small eddies. 

Quantum Computational Fluid Dynamics (Q-CFD) aims to model the full dynamics of turbulent flows by encoding large grids using only logarithmically many qubits—changing the resource scaling relative to classical solvers. Unfortunately, today’s quantum processors are noisy. Current devices only support on the order of ~20 high-quality qubits (as measured by Quantum Volume metrics) and only reliably sustain algorithms  with a depth of ~300 two-qubit operations.

Haiqu, in partnership with Quanscient, overcame this barrier as finalists in the BMW–Airbus Quantum Computing Challenge. Using Haiqu’s middleware, the team executed the largest quantum CFD simulation to date on real hardware, running a 64×64 computational grid over multiple time steps on IonQ’s Aria 1 processor. By compressing circuits, optimizing execution, and mitigating noise, Haiqu enabled deep simulations that were previously impractical on today’s devices.

For decision makers, the implications are clear and immediate. Haiqu increases the performance of CFD workloads, transforming quantum computing from a long-term theoretical research bet into a near-term empirical piloting program on real quantum hardware. 

Crucially, this is not a promise for the next decade. Haiqu makes quantum workloads executable today, allowing enterprises to capture competitive advantage years earlier.

Quantum for business. Run more with Haiqu.

Read more about this result on the AWS Blog.

Book a Demo 

Folding mRNA on 120 Qubits: 89% Circuit Depth Reduction on Real Hardware

Biology is governed by the relationship between molecular form and biological function. Cellular processes such as signaling, metabolism, and regulation depend on proteins that are precisely folded to perform specific tasks.

Fundamentally, protein folding is an optimization problem with exponential complexity, making accurate, physics-based simulations impractical at scale on classical computers. As proteins grow larger, computational costs rise rapidly, limiting the use of traditional methods in drug discovery and molecular design.

Quantum computing offers a new approach by mapping protein folding to a problem that quantum algorithms are naturally suited to solve. Techniques such as variational quantum algorithms can directly search for low-energy configurations (the biologically relevant folded states) within vast and complex solution spaces.
 

A common industry-wide bottleneck in applying quantum computing to real-world optimization problems is the mismatch between algorithm design and current hardware limits. Many promising algorithms assume ideal connectivity and require deep, noisy circuits, making them impractical on today’s quantum devices where errors accumulate before convergence. This keeps most demonstrations confined to small, non-industrial benchmarks.

Haiqu addressed this challenge by redefining folding at scale on today’s quantum hardware. This included applying Haiqu’s topology-aware quantum circuits, lightweight error-mitigation techniques, and integrated classical pre- and post-processing to stabilize training and improve results.

By reengineering how the algorithm runs on real quantum processors, Haiqu enabled execution at 120 qubits (51 nucleotides) while cutting circuit depth from 177 to 20 and reducing two-qubit gates from 479 to 127. Using this approach, Haiqu successfully trained and executed the algorithm directly on a quantum processor, achieving the optimal folding solution in approximately 50 minutes of QPU time—compared to roughly 12 hours on a classical simulator. This work scaled prior efforts of a partner to 120 qubits and established a credible path to ~200-qubit problem sizes, aligned with next-generation quantum hardware roadmaps.

For decision makers, the implications are immediate. Haiqu reduces cost and increases the practical performance of quantum folding workloads, shifting quantum computing from a long-term research investment to a hardware-backed piloting opportunity. By making large-scale energy minimization and folding simulations feasible on today’s quantum processors, Haiqu enables life-science teams to:

• Explore larger and more realistic folding landscapes than are accessible with classical physics-based methods
   
• Identify low-energy folding configurations that are difficult to obtain with existing optimization techniques
   
• Integrate quantum-derived folding results into existing computational biology and machine-learning workflows
   
• Accelerate early-stage discovery and design decisions while controlling computational cost and hardware usage

Crucially, this capability is available now. Haiqu enables meaningful protein and mRNA folding workloads on current quantum hardware, allowing organizations to build expertise, validate value, and establish early competitive advantage ahead of future hardware advances.

Quantum for business. Run more with Haiqu.

Book a Demo 

Book a Demo 

NEW YORK CITY, NY, UNITED STATES, May 6, 2026 -- Haiqu, a leading developer of quantum middleware, today announced the launch of its Agentic Quantum Operating System (OS), the first full-stack quantum intelligence platform for enterprise and scientific quantum R&D.

Currently, quantum development is impeded by the time and costs it takes to design the right application, execute the experiment, and iterate on the results.

Haiqu’s Agentic Quantum OS is designed to bring new performance standards to quantum R&D teams. It combines quantum research agents with Haiqu’s proprietary software stack to help teams identify the right problem, design executable quantum experiments, and run them efficiently on real quantum hardware.

Coupled with additional performance and execution layers, the platform is designed to help enterprise R&D teams get usable results faster, spend less money per experiment, train new researchers more easily, and turn early ideas into testable prototypes faster.

Haiqu’s end-to-end platform equips quantum engineers to guide application development using natural language through business questions or exploratory research ideas to produce an execution-ready quantum application plan using three key pillars:

- Agentic Intelligence — built on Haiqu's proprietary quantum algorithm research, domain-specific workflows, and a curated quantum theory knowledge base, that automates application design and guides users to optimal approaches.

- Haiqu SDK — developer tools built using agents with users in mind that can be easily deployed in agentic development workflows to maximize performance through data loading, algorithmic optimization and error mitigations, enabling users to extract more value from every quantum operation.

- Haiqu Runtime — an orchestration engine that streamlines how applications execute with an optimal infrastructure layer, reducing cost and time required to iterate on quantum applications.

In recent tests completed by the company on a quantum system, a molecular dynamics simulation that previously required $30,000 and more than nine hours to run was reproduced for about $25 in roughly 30 seconds by optimizing execution on the Haiqu platform. Similar results or better were found for optimization algorithms, quantum machine learning models, and probability distributions.

HaiquOS also demonstrated that agentic quantum workflows can translate advanced scientific problems into executable experiments. The system prepared simulations of the single-impurity Anderson model, a foundational model for strongly correlated electron systems, from scratch and built a Haiqu OS/SDK pipeline for simulating neutron-scattering experiments on one-dimensional quantum magnets. The pipeline reproduced experimentally observed signatures of magnetic materials, showing that today’s quantum computers, when paired with the right software stack, can already support meaningful scientific simulations. Learn more about these results here.

A number of enterprises have already received early access to the OS, including Capgemini and Deloitte.

Dr. Kristin Milchanowski, Chief AI & Quantum Officer at BMO and Founding Director of the BMO Institute for Applied Artificial Intelligence & Quantum, said research into emerging quantum software platforms can help inform how the industry addresses foundational scalability challenges.

About Haiqu
Haiqu is an emerging leader in quantum software that supports the notion that near-term, commercially viable quantum applications are achievable with the right software, even on current hardware. Haiqu’s hardware-agnostic software can run applications with up to 100x more operations on current devices compared to competitors. Headquartered in New York City in the United States, Haiqu’s expert team operates from US, Canada, Ukraine, UK, EU, and Singapore, contributing to the company’s mission to make quantum computing practical as soon as possible.

Taylor White
HKA, Inc. Marketing Communications
+1 714-426-0444

Book a Demo 

Advanced quantum simulations should not require a months-long custom engineering effort each time. That is the central idea behind Haiqu’s Agentic Quantum OS. Frontier quantum R&D can become a structured workflow: from research problem formulation to baselines to optimized quantum execution to interpretable scientific results.

As we built some of the most advanced tools to execute quantum algorithms, we learned that the R&D process matters. The hard part of quantum computing is often not sending a quantum algorithm to a quantum processor, but rather deciding what to compute, how to build and validate a quantum application, how to make the circuit survive hardware noise, and how to interpret the output once the hardware returns data.

In chemistry and material science applications, that challenge is especially sharp. A serious calculation needs a physical model, numerical and theoretical baselines, initial state preparation, time evolution or sampling, hardware-aware optimization, error handling, and scientific interpretation. Combining all of these in an orchestrated workflow is not trivial.

In this blog, Haiqu has tested its Agentic Quantum OS on two advanced quantum workflows for material physics and chemistry, demonstrating that we are now entering a new era in building advanced quantum applications. In one example, we looked for the low-energy structure of a strongly correlated electron model. The other reconstructed a magnetic excitation spectrum. Both of these fingerprints are used by scientists to understand the properties of real materials.
 

Why quantum materials are a strong test?

Materials are quantum systems. Their useful properties — conductivity, magnetism, superconductivity, optical response, transport — come from how quantum particles organize and behave collectively.

That is why materials simulation is one of the natural long-term targets for quantum computing.

But the useful study object is rarely a single algorithmic circuit. It is a physical quantity in the target system, in whose computation circuit, executions are only one step. It's computation requires setting up a model, approximation choices, validation path, hardware execution, and finally physical interpretation.

In the following demonstrations, Haiqu’s system did not merely produce quantum programs. It helped assemble the chain of decisions needed to make the result testable and executable on real quantum hardware.
 

Case 1: Low-energy physics of correlated electrons

The first workflow targeted the single-impurity Anderson model. This is a minimal model with nontrivial many-body physics. It describes one interacting electronic site — the impurity — coupled to a surrounding bath of electrons. Electrons can move through the bath and hop onto the impurity. When two electrons occupy the impurity, they interact strongly.

That local interaction is enough to produce correlated-electron behavior that is difficult to simulate.

The model is important because it captures a basic motif in quantum matter: how a local interacting degree of freedom behaves inside a larger electronic environment. This connects to magnetic impurities, correlated conductors, superconducting systems, and quantum devices.

To simulate the low-energy physics of the model, our goal was to build a workflow around sample-based Krylov quantum diagonalization, or SKQD, and use Haiqu’s OS to extend and improve its performance.

At a high level, SKQD uses the quantum processor to sample a sequence of related quantum states. A classical solver then operates within that smaller, sample-selected space to identify the low-energy states, rather than attacking the full, exponentially large Hilbert space. 
 

The workflow had to assemble the full calculation: model construction, basis choice, initial state preparation, time-evolution circuits, Krylov sampling, noisy bitstring recovery, projected diagonalization, and comparison against classical exact diagonalization and DMRG references at small scales.

The final computation ran a 40-qubit hardware experiment to find the ground-state of a strongly correlated 20-site single impurity Anderson model (SIAM), and to build a direct comparison with the results of an independent application of the SKQD approach to SIAM.

Hardware experiments gave insights into how noise affects the performance of the method, and how compression may alleviate this problem. In principle, adding more Krylov states should improve the ground state estimate, but these require deeper circuits which are more affected by the noise on real hardware, slowing down the convergence of the method.

With Haiqu’s compression stack applied to the Krylov states, the expected convergence behavior was recovered. The compressed workflow also reduced the dimension of the subspace used in the classical post-processing  by roughly 2–4× at matched accuracy.

That is not just about a nicer plot or faster convergence. In SKQD, the classical post-processing becomes a scaling bottleneck as it involves large-scale classical diagonalization, preventing the method's ability to attack larger system sizes. Making the resulting subspace dimension smaller, while maintaining comparable accuracy, directly improves the method's practicality. In practice, it also allows for making the method less reliant on advanced HPC backends. In this demonstration, the workflow ran locally on an ordinary laptop, and the quantum execution required only a few seconds of QPU time.
 

Case 2: Reconstructing a magnetic fingerprint

The second workflow examined a different kind of material signature: how a magnetic system responds to perturbations, which is how most physical properties are probed. 

In experiments, one of the main tools for this is inelastic neutron scattering. Scientists send neutrons into a crystal and measure how energy and momentum are exchanged with the material. The result is a map of magnetic excitations, called the excitation spectrum.

For a theorist, reproducing the excitation spectrum from a microscopic model is a serious test: it means the model captures the structure and physics of the material. The quantity behind that map is the dynamical structure factor. It connects a Hamiltonian to the magnetic-scattering signal that an experiment should observe.

We used Haiqu’s Agentic Quantum OS to build and execute a workflow to reconstruct the dynamical structure factor for real quasi-one-dimensional magnetic materials.

For this workflow, we focused on 2Dioxane·2H₂O·CuCl₂, often abbreviated as CuDCl, as a reference material. It is a metal-organic copper chloride material whose copper ions form nearly one-dimensional magnetic chains.

This quasi-linear structure allows the compound to be modelled by a spin-1/2 Heisenberg chain, a foundational model for quantum magnetism. In this system, the excitations are not simple classical spin waves, but a broad two-spinon continuum — a characteristic signature of a material's magnetic structure.

The agentic flow first helped to set up a stack of analytical and numerical benchmarks and validation tests. With their help, it then proceeded to build the complete computation, including the required quantum circuits and their hardware execution.

This computation is more challenging than the previous SKQD example, which only involved ground state, or zero-temperature, properties. At low temperature, the system sits close to its ground state, and the relevant physics is governed by how that state responds to small disturbances. The ground state is only the starting point. To reproduce a neutron-scattering-like observable, we need to disturb the system and follow how it evolves.

The complete quantum pipeline constructed by the Agentic OS involves ground-state preparation, its perturbation and time evolution, circuit optimizations and depth reduction, hardware execution, error shielding, and spectrum reconstruction.

Hardware experiments on a real quantum processor recovered the key physical feature in the relevant spectral window: spectral weight near the antiferromagnetic zone boundary, consistent with the expected two-spinon continuum. 

This demonstration is particularly important because it uses quantum hardware to compute a physically meaningful observable. The output is not only a bitstring distribution or an abstract benchmark. It is a neutron-scattering-like spectrum — the type of object materials scientists use to investigate the properties of real compounds.

The resource footprint was modest: the classical work ran on an ordinary MacBook Air M4 laptop. The quantum execution used less than 10 minutes of QPU (IBM Boston) time to produce a full energy spectrum from a batch of 160 circuits (some as large as 2380 two-qubit operations, and up to 14261 total operations). 

This makes a similar kind of simulation readily accessible to ordinary academic groups rather than only national-lab-scale teams.

What made this agentic, and why does this matter?
 

In both cases, Haiqu’s AI did not replace the physicist, but it helped to reduce the hidden engineering burden around quantum research while the human researcher supplied scientific supervision.

The agentic workflow helped structure the work, prepare implementation plans, assemble modules, track baselines, connect execution, and organize the result into something that could be checked.

Quantum R&D often fails at transitions: between theory and code, between an algorithm and its circuit implementation, between a simulator and hardware, and between raw measurements and physical interpretation. Haiqu’s Agentic Quantum OS is designed to make those transitions explicit, inspectable, executable and reproducible.

With these demonstrations, we aim to show something practical for the near term: with the right agentic workflow and software stack, today’s quantum hardware can already participate in meaningful scientific simulation workflows.

That is the role of Haiqu’s Agentic Quantum OS.
 

Book a Demo 

Quanscient's new quantum lattice Boltzmann algorithm and Haiqu's execution stack produced the first nonlinear Navier-Stokes flow with geometry on a quantum processor. 

A well-designed quantum algorithm is one thing. Getting it to run on hardware is another. Haiqu closed the engineering gap and enabled on-hardware execution thanks to the compilation, state preparation, tomography, and noise-mitigation stack that made the nonlinear obstacle benchmark practical on IBM's superconducting hardware.

Read a technical perspective from Haiqu in the recent blog. 

How a new quantum lattice Boltzmann algorithm and Haiqu's execution stack produced the first nonlinear Navier-Stokes flow with geometry on a quantum processor: a technical perspective from Haiqu on the Quanscient–Haiqu paper (arXiv:2603.02127, March 2026).

The invisible simulations behind everyday engineering

Every time an aircraft wing is shaped, a car body is profiled, or a gas turbine is optimized, the design passes through computational fluid dynamics (CFD) simulation. These simulations solve the equations governing how fluids move: where pressure builds, where flow separates, where turbulence forms. CFD is one of the most compute-intensive workloads in industrial engineering. A full-fidelity aeroacoustic simulation of a commercial aircraft can require billions of mesh points and weeks on the largest supercomputer clusters. Even with extraordinary classical HPC progress, many problems in turbulence, multiphase flow, and coupled multiphysics remain intractable at the resolutions engineers actually need.
Quantum computing enters the CFD conversation because of a structural advantage: a quantum computer can represent spatial grids whose size is exponential in the number of qubits, potentially enabling simulations at scales inaccessible to classical machines. Realizing that potential requires overcoming significant technical challenges, and the field's credibility depends on demonstrating progress on the right kind of problems.

_{"Progression landscape" from 1D linear transport → 2D advection-diffusion in empty domains → 2D nonlinear flow around an obstacle.} 
 

Why the lattice Boltzmann method suits quantum computing

The lattice Boltzmann method (LBM) models fluid dynamics not by solving the Navier-Stokes equations directly, but by evolving mesoscopic particle distributions on a discrete lattice through two local operations — collision and streaming — from which macroscopic quantities such as fluid pressure and velocity emerge. This structure is already massively parallel on classical hardware; landmark LBM simulations have reached trillions of lattice cells on GPU clusters.

The same structure maps naturally to quantum algorithms, forming the quantum lattice Boltzmann method (QLBM). Streaming becomes a quantum walk. Collision is local and independent of lattice size. And the heavy memory requirements that bottleneck classical LBM become a non-issue when the grid is encoded logarithmically in qubits.

So far, the complete record of QLBM on actual quantum processors — including our own earlier work with Quanscient on IonQ Aria (2024, the largest QLBM grid demonstrated on hardware) — has been limited to linear dynamics on 1D, 2D, and 3D grids. No obstacles. No boundaries beyond periodic conditions. No coupled velocity fields. Each result was an important milestone but the physics that makes real CFD hard was entirely absent from the hardware record.

Until now.

What does this paper demonstrate?

Our joint paper with Quanscientr introduces a new quantum algorithm for the lattice Boltzmann method based on the one-step simplified LBM (OSSLBM) and validates it across several cases, culminating in a nonlinear laminar flow benchmark on real quantum hardware.

The benchmark: a D2Q9 lattice on an 8×8 grid with a 2×2 immersed square obstacle, inlet-outlet boundary conditions, and zero Dirichlet walls. Flow is driven by a fixed inlet velocity, deflects around the obstacle, and evolves through a 15-step hybrid quantum-classical loop on IBM's ibm_boston processor (Heron R3, 156 qubits).

_{Domain schematic: 8×8 lattice with 2×2 obstacle}
 

Three features distinguish this from all prior QLBM hardware demonstrations.

Nonlinear Navier-Stokes physics. The incompressible Navier-Stokes equations govern the evolution. The nonlinear equilibrium terms are recomputed classically at each step and re-encoded into the quantum state; the quantum processor handles the structured linear update. This hybrid strategy keeps circuits shallow enough for current hardware while accommodating physics that cannot be implemented unitarily.

An immersed obstacle with boundary conditions. No prior QLBM hardware run included any internal geometry. The boundary treatment uses multi-controlled gates that are backpropagated and applied classically to the measured bitstrings — substantially reducing circuit depth.

Coupled full-field recovery over 15 time steps. The experiment recovers density and both velocity components (ρ, u_x, u_y) at each step, with the mean squared error relative to a steady-state reference decreasing over the evolution. While a steady state is not reached within the 15 steps executed on the quanutm device, the results show a convergence towards it.

_{Left: Ideal vs. hardware field maps after 15 time steps for ρ, u_x, u_y Right: MSE convergence plot (statevector, ideal + shot noise, IBM QPU). The IBM QPU execution is noisier but continues to reduce error with subsequent steps — evidence that hardware preserves the convergence physics.}

The algorithmic advance: OSSLBM

Our paper's contribution extends beyond the hardware benchmark. Traditional QLBM approaches treat collision and streaming as separate operations on distribution functions. The OSSLBM restructures this into a single-step update operating on macroscopic fields: density, velocity, and pressure, with distribution functions appearing only in the propagation subroutine.

This gives OSSLBM more flexibility to accommodate different physics (acoustics, diffusion, nonlinear Navier-Stokes) within one framework, while keeping the core gate and qubit complexity efficient. For linear problems, it supports multi-step evolution without intermediate measurement — a prerequisite for any future quantum advantage.

Making it run: Haiqu's hardware-enabling stack

A well-designed quantum algorithm is one thing. Getting it to run on hardware is another. Haiqu closed the engineering gap and enabled on-hardware execution thanks to the compilation, state preparation, tomography, and noise-mitigation stack that made the nonlinear obstacle benchmark practical on IBM's superconducting hardware.

The compilation challenge was substantial. A direct, unoptimized implementation produces approximately 1,825 two-qubit gates after transpilation to the Heron R3 heavy-hex connectivity. This is far beyond what today's error rates allow to execute accurately enough. Haiqu's optimization pipeline brought this down to around 540 two-qubit gates through several coordinated approaches.

_{Gate-count reduction pipeline}
 

Several techniques contributed to the reduction. The QLBM collision step was combined with initial state preparation, strongly compressing the circuit at the cost of only two extra qubits. The state preparation itself was optimized to take advantage of QPU's near-linear qubit layout. Furthermore, commutation of circuit parts implementing boundaries and obstacles with the final measurement was exploited to offload some computation to classical post-processing, shortening the circuit. Finally, all gate sequences were compressed using optimized decompositions of multi-qubit operations.

Noise mitigation was equally important. The execution combined several standard techniques like dynamical decoupling to protect idle qubits, Pauli twirling to symmetrize noise, and operator decoherence renormalization to correct the recovered field norms. With only 3–6% of the 30,000 shots per step surviving post-selection, induced by the QLBM unitary construction, the usable data for field reconstruction was thin. At these margins, every compilation and mitigation choice matters directly.

Finally, recovering full flow fields is required on each step as a part of QLBM’s hybrid pipeline, which is a major bottleneck, since standard tomography has prohibited scaling. We developed a novel variational function tomography method, allowing us to recover near-ideal field values with only a handful of shots. Previous demonstrations were focused on toy examples, where solutions are trivial and known, hence the readout problem did not arise. On the contrary, we demonstrated the most complex readout so far in the quantum CFD, applied to realistic flows.

This is an essential part of a realistic quantum computing workflow. The middleware layer: compilation, transpilation, error mitigation, readout, and runtime orchestration, determines whether a given algorithm produces meaningful results on a given hardware.

Orchestrating that full-stack end-to-end is what Haiqu's platform is built for, and experiments like this one are where it proves its value.

Honest scope: what this does and does not show

This paper demonstrates that QLBM can encode, evolve, and reconstruct a nonlinear Navier-Stokes flow field with an internal obstacle on a real quantum processor, preserving qualitative physics across 15 time steps. That is a material advance over every prior QLBM hardware run.

Whether QLBM can move to deeper end-to-end evolution remains open, depending on both hardware progress and fundamental algorithmic constraints.

The honest framing: this is the most physically complex QLBM simulation run on a real quantum processor in the public record. The advance is in the class of problems, not the immediate scale. The distance between that breakthrough and practical engineering application is still significant. But it is shrinking specifically in the areas where middleware investment pays off: compilation, noise mitigation, and orchestration.

Why should the industry pay attention now?

For R&D leaders in aerospace, automotive, and energy, the significance is strategic rather than operational.

Turbulence alone scales as O(Re³) with the Reynolds number; full-scale aircraft simulations at Re ~ 10⁸ imply roughly 10²⁴ floating-point operations. Quantum computing is one of the very few plausible paths to fundamentally different scaling for these workloads. But that path's credibility depends on the field solving the right kind of problems, not just bigger grids for linear transport.

These results are important because they demonstrate QLBM on real quantum processors, moving toward the very features that make real CFD hard: obstacles, boundaries, coupled fields, and nonlinear dynamics. The grid size is still very small, but the problem difficulty is a qualitative leap.

For organizations evaluating quantum simulation readiness, the practical takeaway is that the gap between a quantum algorithm on paper and a working hardware result is where most efforts stall. Closing that gap requires compilation respecting real device topology, noise mitigation tuned to the application, and runtime orchestration for hybrid loops. That stack is what Haiqu provides, and this paper is a concrete demonstration of its value.

From Haiqu's perspective, the paper validates a thesis we have held from the start: the path to practical quantum scientific computing runs through the execution layer. Better qubits and better algorithms are both necessary but not sufficient. Getting real physics onto real hardware requires an optimization and runtime stack that adapts to the realities of current devices. We will continue building that stack, and we look forward to the experiments it enables next.

Book a Demo 

The paper "Quantum Algorithm for the Lattice Boltzmann Method with Applications on Real Quantum Devices" by Bastida-Zamora, Budinski, Kerppo, Lahtinen, Niemimäki, Steadman, Zamora-Zamora, Sagaut, Bohun, Koch-Janusz, and Lukin is available at arXiv:2603.02127.

From wind-turbine blades to jet engines, unwanted aerodynamic noise reduces efficiency, increases fuel burn, and is subject to regulatory limits. Engineers address these issues using computational fluid dynamics (CFD), which is the numerical solution of partial differential equations (PDEs) on a spatial grid that describes how pressure and velocity evolve in a flowing gas. CFD is everywhere — in aerospace, automotive, energy, climate research, and even consumer-electronics cooling — but it is notoriously expensive. Each increase in spatial resolution dramatically increases both the required memory and the run time. For high-fidelity aero-acoustic simulations, the computational grids easily require billions of points, which challenges even the largest HPC clusters.

Quantum CFD may accelerate these computations exponentially, but encoding realistic geometries while preserving the advantage is a problem in itself. Haiqu researchers have shown how to overcome this challenge for quantum acoustic simulations.
If you're exploring quantum-ready simulations beyond classical HPC limits, Haiqu can help you evaluate what’s possible today and what’s coming next.

Book a demo

The Quantum Leap

Quantum computers offer a potential breakthrough: since the entire spatial grid can be encoded with logarithmically many qubits and the PDE simulated in time polynomial in qubit numbers, an exponential advantage over classical CFD simulations could be achieved!

One of the recent approaches to solving the PDE itself is by mapping it to a quantum system evolving under a Hamiltonian, which can very naturally be simulated on a quantum computer. However, in order to apply to realistic problems, such as sound scattering from an aircraft wing, the appropriate fluid equations and boundary conditions that describe arbitrary geometries and obstacles must  be included in the quantum Hamiltonian, which is highly nontrivial.

This is precisely the problem that the Haiqu researchers addressed in their work, “Quantum Hamiltonian simulation of linearised Euler equations in complex geometries”. They showed how classical CFD equations for sound propagation can be directly mapped to a quantum computation, particularly when including complex obstacles (like wings!), in a way which preserves the exponential advantage of the quantum approach.

Turning Everyday Air Flow into a Quantum Algorithm

The air particles behave according to three simple bookkeeping rules: mass is never lost, momentum changes only when forces act, and energy has to go somewhere (it cannot appear or vanish). Writing those ideas down for every tiny parcel of air gives a system of linked equations—one for each rule—so that changes in pressure, density, and velocity stay consistent everywhere in the flow. For real-world viscous fluids, these equations are the famous Navier–Stokes equations.

To simplify the problem, we use the approximation that air is an inviscid fluid (no stickiness) and does not exchange heat. Under those two assumptions, the Navier–Stokes equations collapse into the much simpler Euler equations. Imagine now a smooth and uniform background flow of a fluid - picture a steady breeze moving in a single direction. The sound waves we care about are tiny ripples on top of that steady breeze, and we can therefore linearise the Euler equations: keep only the terms that describe these small disturbances and drop all higher-order contributions.

The linearised Euler (LE) equations so obtained (here: in two dimensions) describe how pressure and fluid velocity components evolve while being carried downstream by the uniform flow with speed u in x direction:
 

Above, u,v,p denote, respectively, the velocities in the x,y directions and the pressure deviation from the average, while is the density of the environment, and c is the speed of the sound.

As sound is a pressure wave, the LE equations model the propagation of noise through the air. In the absence of background flow (u=0) they reduce to a simple wave equation.

While approaches for solving the simpler wave equation on a quantum computer have been shown, until now, this was not the case for more complex linearized Euler equations. One of the ways quantum computers can be used to solve such classical problems is by looking at them as a kind of quantum evolution — that is, interpreting them as describing how a quantum system changes over time.

We can generally write our classical PDE system as df/dt=Af with f=(p,u,v), for a linear operator A. Interestingly, when A has certain properties — in particular, when it is made up of real numbers and is antisymmetric — we can rewrite this problem in a way that looks just like how quantum systems evolve. In quantum physics, the evolution of a system over time is described by the Schrödinger equation df/dt=-iHf, which depends on the Hamiltonian operator H. You can think of the Hamiltonian as the "energy operator", it prescribes how the system behaves, controlling its evolution. If we can rewrite our classical problem in terms of a Hamiltonian — by formally setting H=iA (where i is the square root of -1) — then solving the original problem becomes like simulating a quantum system over time. As Hamiltonian operators obey certain mathematical properties (hermiticity), such rewriting is only sometimes possible, and depends on the details not only of the equation, but also of the boundary conditions, all of which determine the structure of the matrix A.

Haiqu researchers have shown how this can be achieved for the linearized Euler equations, even when arbitrarily complex boundary conditions, describing obstacles such as wings, pipes, constructions etc. are included. This allows modeling aero-acoustic phenomena in realistic scenarios. Since the ultimate goal is the simulations of these systems on real quantum devices, an important contribution of the work is the detailed construction of explicit quantum circuits, which can be executed on typical QPU architectures, for example superconducting devices. 

_{Figure 1 - Ideal quantum simulation of the quantum circuits derived by Haiqu for the 2D pressure wave propagation on a constant background flow in the x direction with an impenetrable obstacle (colored in darkgreen). One can observe how the wave, starting from a single point source, propagates and moves with the flow, bending the object and reflecting from it.}

💡 What makes this work special is that these complex boundary conditions, key to solving realistic problems, are shown to be implementable without breaking the simulation’s efficiency.

That is, including obstacles in the flow does not lead to an asymptotically higher computational cost or increase the simulation error.

From Research to Real Quantum CFD

Haiqu researchers have developed a novel quantum algorithm for simulating the linearized Euler equations. The approach demonstrates a clear potential for quantum advantage by leveraging exponential grid encoding with only polynomial quantum resources, and allows to construct simulations of real-world aero-acoustic problems, thanks to an efficient implementation of complex obstacles and boundary conditions in the equation.

Move from insight to execution. See how Haiqu turns quantum CFD research into runnable workflows on today’s quantum hardware.

Talk to the Haiqu team

Download our research paper for more information.

Interested in more Quantum CFD research? Explore the AWS blog post about our work with Quanscient on running the largest-grid Quantum CFD simulation on a real QPU, as finalists in the Airbus & BMW quantum challenge.

Haiqu keeps the party going. 

Thank you to our new investors: Primary Venture Partners, Collaborative Fund, Alumni Ventures, Qudit Ventures, Silicon Roundabout Ventures, Harlow Capital, and Hyperion Capital. 

Thank you to our returning investors: MaC Venture Capital & Toyota Ventures.

Thank you to our champions across the industry.

Now Phase II begins: our Product phase.

Don't be a classicist. Try our beta. 

Read the full press release here.

Quantum software startup Haiqu announced results from a trial this week demonstrating that current quantum computers could detect subtle financial anomalies that could indicate fraud more efficiently than purely classical systems.

The research, which used a hybrid computing approach pairing quantum processing power with traditional machine learning models, revealed performance gains that suggest a near-term path toward achieving "quantum advantage" for large-scale, real-world problems.

Read full article here.

A team of Haiqu-led researchers have developed a new approach to encoding complex financial data into quantum circuits, pushing the limits of IBM’s quantum processors, according to a paper published on the pre-print server arXiv. The team reports that the method, which focuses on shallow and efficient circuit designs, could advance the use of quantum computing in finance and other industries.

In a recent LinkedIn post on the paper, the team writes: “Quantum computing cannot achieve wide utility in the near term until we can efficiently load classical data onto quantum hardware. Now, we can.”

Read full article here.

Sifted asked investors in the field who they think is the next big thing in quantum computing.

European quantum startups are on the rise. Last year, while many VC-backed companies in the region were struggling to raise funds, Europe’s quantum startups actually saw investments grow by 3% to reach $781m — more than three times the amount raised in the sector in North America ($240m).

It also made Europe the only region to see funding for quantum startups increase, while investments in North America dropped by 80%, and by 17% in Asia-Pacific.

With strong support from governments — the UK has committed $4.3bn to quantum technologies, while Germany has pledged over $3.7bn — and burgeoning interest from VCs, Europe’s quantum scene is growing steadily. 

Read full article here.

The Perimeter Institute has established a new partnership with quantum software startup Haiqu (pronounced as ˈhaɪku) that will bring fundamental research and technological innovation closer together. Haiqu has established operations in the US, UK, and Ukraine. Through this partnership, the company will base its first Canadian hire, Dmitri Iouchtchenko, at the Perimeter Institute Quantum Intelligence Lab (PIQuIL).

Read full article here. 

Graduating Ventures Took to the Main Stage at Super Session, Sharing Their CDL Journeys

Founders and speakers representing four graduating ventures and three CDL alumni companies got onstage in front of a thousand of their peers, mentors and investors to share their inspiring stories of success, and reflect on their takeaways from the CDL program.

The concluding main stage event at June’s Super Session was a showcase of some of the incredible talent that’s recently been nurtured within the 24 global streams that make up the Creative Destruction Lab (CDL) program...Another venture invited to the main stage was quantum computing company Haiqu. Unlike other streams, applicants being considered for fall admission into the Quantum program travel to Toronto for several weeks between July and August for a bootcamp. That’s where this graduating company’s co-founders, Richard Givhan and Mykola Maksymenko, met last year.

Read full article here.

Haiqu Raises $4 Million in Pre-Seed Funding to Boost Adoption of Near-term Quantum Computing

Haiqu, a startup building software to enhance the performance of quantum processors, today announced it has closed a $4 million financing round led by MaC Venture Capital, with participation from Toyota Ventures, SOMA capital, u.ventures, SID Venture Partners and Roosh Ventures. The round also included private contributions from Paul Holland, Alexi Kirilenko and Gordy Holterman.

“We are accelerating the timeline to practical quantum computing by developing novel software that can extract value out of clumsy near-term quantum hardware, enabling quantum applications that were previously impossible.” said Richard Givhan, co-founder and CEO at Haiqu. “We are proud to be backed by investors with remarkable deep-tech ecosystems and a track record of supporting the commercialization of breakthrough tech.“

Read full article here.

Anomalies are the world’s early warning systems. They appear as subtle ripples before an earthquake, a sudden deviation in a patient’s vital signs, or a single fraudulent transaction hidden among millions of legitimate ones. Detecting such rare events is essential for safety, trust, and reliability in modern data-driven systems. Still, it remains one of the hardest problems in machine learning.

The reason lies in their rarity. By definition, anomalies are statistical outliers, making up only a fraction of a dataset. Classical models must learn to recognize these events despite being trained predominantly on normal examples. And in practice, the data itself compounds the difficulty. Hundreds of correlated features, nonlinear dependencies, and limited examples make it hard for algorithms to find meaningful structure.

Classical approaches like decision trees, logistic regression, and deep neural networks have achieved remarkable progress, but even the best of them eventually plateau. Particularly at high dimensionality and low sample size, they begin to lose their footing. This is where quantum computing, with its fundamentally different way of representing and processing information, may offer a new path forward.

Where Classical Representations Fall Short

Machine learning is dependent upon how we represent data. The features describing the data determine what a model can perceive, and, as a result, what it can learn. The goal of kernel methods and, more broadly, of representation learning is to construct new data features, often by embedding in larger spaces, which “expose” the inherent patterns in the data¹. This allows downstream machine learning models to achieve better performance in e.g. classification tasks. In most real-world data, however, the relations between these features are nonlinear and strongly correlated, which poses a major challenge to classical methods.

Quantum systems, by contrast, naturally take advantage of superposition and entanglement to process unstructured feature vectors². This allows both to embed data in an exponentially larger space of multi-qubit states and to reveal its structure through the use of quantum dynamics, enabling efficient classification. In other words, mapping classical data into this space effectively expands the representational canvas and allows the discovery of patterns that classical embeddings may flatten or miss entirely.

This concept is central to quantum machine learning. Through quantum embeddings, data is transformed into quantum states, and similarities between samples are evaluated via quantum kernels, comparable to kernel methods in classical machine learning but powered by the physics of interference. Even when run in simulation, these quantum representations reveal how computation in Hilbert space can enrich classical preprocessing².

Encoding Data of Previously Impossible Size

The first step to constructing a quantum embedding is to encode the original data in a quantum state, which is then transformed using e.g. quantum dynamics. While many existing studies rely on angular encodings, such methods quickly reach their limits as the number of qubits required grows linearly with the number of data features ^{3, 4}. Most near-term quantum devices have fewer than 150 qubits, yet anomaly-detection and other real-life datasets can easily contain hundreds or thousands of features. This creates a dimensionality gap that makes naïve quantum feature maps impractical.

To address this challenge, we developed a novel data encoding method, which allows us to encode polynomially more features with the same number of qubits. Moreover, our method awards control over the complexity of the resulting quantum state and of the quantum circuit creating it. This permits adjusting the embedding to both the number of features in the data, as well as to the parameters of the QPU. Our dataset contained 506 classical features which we mapped onto 128 qubits, but the same QPU could be used to encode an order of magnitude larger feature numbers with our technique.

The resulting embeddings can be used as feature transformations in any machine-learning pipeline, feeding quantum-enriched data into classical models. This hybrid structure of classical models trained on quantum-preprocessed data forms the foundation of our experiment.

A Head-to-Head Comparison

To test the performance of our quantum embeddings against their classical counterparts task we designed an experiment with two parallel pipelines: a hybrid one (quantum+classical), and a fully classical one, as shown in Figure 1. The inputs to both are constructed from the Multivariate Time Series Anomaly benchmark used to evaluate the detection of rare events in temporal data. Our dataset consists of a smaller and balanced subset of 250 samples of coarse-grained time-series, where time-points within time windows in the original data have been merged together to form high-dimensional vectors of 506 features.

Fairness of comparison was central to our evaluation of the potential of quantum embeddings. In both pipelines, data is embedded into an enlarged space. In the quantum setting, we apply our novel data encoding, evolve the system under a parameterized quantum circuit implementing Heisenberg dynamics with randomly chosen parameters, and measure the resulting state to obtain new classical features. This is a form of projected quantum kernel (PQK) [3, 4]. In the classical pipeline, we tested two forms of embeddings with the same number of parameters as the quantum model: neural networks with random parameters, and random Fourier features. These embeddings produced new classical features of the same dimensionality as those generated by the quantum feature map.

Both the quantum-processed and classically-generated features were then input into the same families of classical classifiers, such as random forests and logistic regression. The hyperparameters of each classifier were independently optimized to ensure the best possible performance within each pipeline. We employed an 80/20 train–test split and evaluated performance using the F1 score, which balances precision and recall for imbalanced classification tasks.

Figure 1: Quantum versus classical embeddings experiment pipeline. Both process the same dataset, but use different feature construction methods before feeding it into classical classifiers. The input data has 506 features per data point (see the main text for details). The quantum embedding uses Haiqu's proprietary data loading to encode each point in a quantum state over 128 qubits, which is then transformed through an evolution circuit with random parameters, and, finally, read out with 1024 measurement shots. These measurements are used to compute the expectation values of 8256 observables. On the classical side, random neural networks and random Fourier Features are used to construct features, also of 8256 dimensions. Classical classifiers (see Fig.2) are then trained separately for the classical and quantum features (we selected the best quantum, and the best classical features) and their performance compared.

Results: Quantum-Enhanced Preprocessing Works

The results show a consistent trend: quantum-preprocessed features outperform classical ones across multiple models. Crucially, this is the case both in simulation and on real QPUs.

In ideal simulations, our projected quantum kernel (PQK) achieved an F1 score of 0.98, outperforming classical baselines of around 0.90–0.93. Even on real quantum hardware, in this case an IBM Quantum Heron processor, where noise and gate infidelity introduce imperfections, the model retained an impressive 0.96 F1, showing that the method is both effective and robust under realistic device conditions.

Figure 2. Top: The F1 score of different classical classifiers using either the classical (black) or the quantum (blue) features obtained on the IBM Quantum Heron processor. For most classifiers the quantum features provide better performance. Bottom: A more detailed comparison for the Logistic Regression Classifier. The classifier with original input data achieves an F1 score of 0.91, while the random classical embeddings essentially do not improve the score (0.92). In contrast, using the random quantum embedding a score of 0.98 is obtained when simulated without noise, and 0.96 when executed on the real noisy quantum processor.

The largest relative improvements appeared in tree-based models such as Decision Trees and Random Forests, which benefited most from the richer feature representations. Across the board, these results suggest that quantum embeddings can serve as a general-purpose preprocessing layer, improving performance without changing model complexity or parameter count. In other words, quantum systems need not replace classical models, but augment them.

A Glimpse of the Future
 

The importance of our findings is threefold:

— First, it shows that quantum-enhanced features can achieve superior performance over classical embeddings in complex data.

— Second, that extremely high-dimensional data can be embedded using our methods on existing QPUs.

— Third, we show that this superior performance is present both in idealized simulation that validates the pipeline, and on real noisy quantum hardware.

Taken together, the results provide an empirical signal that quantum advantage with QML may be possible to achieve in full-fledged industrial deployment to complex high-dimensional problems, and that investigating efficient quantum data embeddings on real datasets is a promising path towards realizing that advantage.

This holds even without training the embedding weights, which should further improve the features, and thus the final performance.

Thus, a hybrid QML pipeline which achieves superior performance in a complete end-to-end industrial deployment will likely involve a classical pre-training step of the quantum embedding using large scale simulation, followed by an optional fine-tuning step on a QPU, and finally, an inference step performed at test time on a QPU.

This hybrid workflow could extend beyond anomaly detection into fields like cybersecurity, financial modeling, predictive maintenance, and health diagnostics, all domains where interpretability and early warning signals matter most.

This paper uses Matrix Product States to convert classical probability distributions into shallow quantum circuits with linear gate counts.

Read on arXiv 

This work shows how to make deep simulations practical by partitioning them into manageable sub-blocks and subsequently reconstructing the quantum state with Haiqu.

Read on arXiv 

This paper introduces the Rivet transpiler, which optimizes iterative processes like machine learning by caching and reusing previously transpiled subcircuits.

Read on arXiv 

This is a research paper on simulating fluid dynamics around obstacles without increasing overall circuit complexity or Trotter error. It touches on data loading with tensor network approaches to prepare shallow circuits for complex initial conditions.

Read on arXiv 

This is a recent paper from this year on how large Hamiltonian evolution simulations can be executed across multiple smaller quantum processors.

Read on arXiv 

Working with researchers at Quantinuum, the Universities of Oxford and Cambridge, and the Perimeter Institute, we introduced Spin-ZX, a graphical language for reasoning about quantum systems with spin. By making complex spin structure easier to represent, manipulate, and connect to quantum circuits, the framework expands the tools available for designing and analysing more expressive quantum algorithms, setting the stage for new capabilities in quantum computing and quantum machine learning.

Read on arXiv 

Working with researchers at the CNRS and the Donostia International Physics Center, we developed a graphical way to identify topological order using ZX calculus, without relying on traditional entanglement-entropy calculations. Understanding and diagnosing these robust forms of quantum order is an important step toward controlling complex quantum systems, helping develop the foundations for fault-tolerant quantum computation and the quantum resources needed for useful computation.

Read on arXiv