Why Hybrid Quantum Computing Matters
Yes—all quantum algorithms are hybrid. What we mean is running part of an algorithm on the real QPU and the other part in simulation on a traditional computer. We could call this ‘blended execution’ or ‘simulation-assisted quantum computing’.
Quantum computing has made impressive strides in the last year, with commercial systems now scaling beyond 100 physical qubits. Yet despite hardware progress, today’s quantum computers are still limited by noise. Imperfect gates, decoherence, and measurement errors can drastically impact the reliability of results. That’s where hybrid quantum computing and Hybrid Computing come in.
By combining real quantum hardware with classical or noiseless quantum simulators, we can intelligently offload parts of a quantum program to the most appropriate backend. This idea isn’t just theoretical, at Qoro, we recently ran a series of experiments showing how automated hybrid execution with circuit cutting can improve quantum circuit fidelity with multiple IBM’s latest Heron QPUs in an orchestrated way, which underscores the importance of hybrid computing. Doing this without Qoro would mean a) painful manual infrastructure coding, and b) without that, the complete inability to create this 100-qubit GHZ state.
What is Circuit Cutting?
Circuit cutting is a technique for decomposing a large quantum circuit into smaller, more manageable sub-circuits. These sub-circuits can then be executed independently — in parallel, either on quantum hardware or classical simulators — and their results combined to approximate the full-circuit outcome.
Traditionally, circuit cutting requires manual decisions about how and where to cut, careful tracking of measurement bases, and heavy classical post-processing. It’s an error-prone and compute-intensive process that requires careful tracking during circuit execution, especially across a distributed system.
Qoro’s platform automates this pipeline, deciding on cutting points, distributing subcircuits across QPUs and simulators, and reconstructing the final output. The developer only needs to submit their circuit (or collection of circuits) and Qoro’s platform handles the rest. This enables scalable experiments that use both real and simulated qubits intelligently to improve overall performance.
Challenges in Today’s Quantum Hardware
The IBM Heron family of superconducting qubit processors represents the cutting edge of gate fidelity, with low two-qubit gate errors and scalable architectures. But even so, running large circuits (e.g., 50+ qubits) remains challenging due to cumulative noise and depth limits.
One promising solution is to blend real hardware with noiseless simulation. For example, by offloading part of a circuit to a classical simulator, we not only free up QPU resources but also inject noiseless information into the reconstructed result — boosting quality without increasing noise budget.
Our experiments show how this works in practice.
Our Experiment: GHZ splitting
We ran a series of executions on two IBM’s Heron 2 QPUs, IBM Fez and IBM Marrakesh, using Qoro’s automated circuit cutting, job scheduling, and orchestration engine. The goal: benchmark fidelity gains when offloading parts of a quantum circuit to simulation and validate multi-QPU execution. Although circuit cutting generates a significant amount of computational overhead, there are practical applications with circuit structures that allow circuit cutting to be used. This structure generally has a “cascading” sequence of gates, for example, the hardware efficient ansatz, or clusters of entangled qubits with limited entanglement between clusters, often found in QAOA problems.
GHZ States are a good initial test, as they have the cascading CNOT gates we need for circuit cutting to work well, and they are easy to simulate for validation for a large number of qubits. For our tests, we ran 100-qubit GHZ states in four different ways.
Our tests were:
- No cuts, 100-qubit execution on the IBM Fez Heron R2 chip with error mitigation enabled via MThree. The resulting noise overwhelmed this test
- 1 circuit cut, split with 74 qubits allocated to the QPU, 26 allocated to simulation, for a total of 100 qubits
- 2 circuit cuts, split with 48 qubits allocated to the QPU, 26 allocated to simulation twice for a total of 100 qubits
- 3 circuit cuts, split with 30-qubit circuits run in parallel across the two QPUs, then 26 allocated to simulation twice, 14 once, for a total of 100 qubits
We compare applying error mitigation via MThree to the reconstructed circuits for each case. Error mitigation provided a significant improvement, overcoming the Hellinger fidelity threshold of 0.5 on the second cut.
How it works
Behind the scenes, Qoro’s hybrid execution engine coordinates a complex, distributed pipeline, but for users, the process is seamless.
- Circuit Submission:
A user begins by submitting a quantum circuit through Qoro’s Divi software SDK. They don’t need to know anything about the underlying hardware, whether it’s a quantum processor, a classical simulator, or a hybrid mix of both. - Job Queuing and Network Coordination:
The submitted job is placed in a central execution queue. In the background, compute nodes — including QPUs and simulators — continuously report their availability to the platform. Once the resources are available, the scheduler is notified and circuit cutting begins, based on those resources. This happens with Qoro’s Usher and Conductor services. - Resource-Aware Circuit Cutting:
The scheduler initiates the circuit cutting phase through Qoro’s Composer service. This step is resource-aware: the cutting service dynamically determines where to partition the circuit based on the available hardware. The cutting approach looks to maximize the number of qubits used across the network of devices, finding and using the cutting location to do so. - Fragment Generation and Scheduling Execution:
The circuit is broken into fragments, each of which is dispatched to the appropriate backend to run in parallel, either on a real QPU or a noiseless simulator. Circuits fragments include mid-circuit measurement, often making them inefficient to simulate since efficient sampling methods cannot be used. Qoro’s simulator engine Maestro optimizes this by saving state information to avoid redundant computation where possible. Execution is parallelized across the network, and each node returns measurement samples from its assigned fragment. - Result Reconstruction:
Once all fragment results are collected, Composer performs classical post-processing to stitch the results together. This involves combining measurement data in a way that approximates the output of the original, uncut circuit. The final, recomposed result is returned to the user.
This entire pipeline, from hardware-aware decomposition to parallel execution and result synthesis, is fully automated. The user sees a single job execution, but under the hood, Qoro’s platform is orchestrating a hybrid compute network to deliver higher fidelity, more scalable results.
What’s Next?
These are early results, but they’re promising. With no user-side circuit decomposition, Qoro’s platform can run hybrid quantum-classical jobs across real QPUs and simulators — making the most of today’s hardware while pushing closer to fault-tolerant-scale results.
The GHZ state is useful primarily for testing purposes, but for practical use, we have also identified various circuits that can be used in applications. These include the hardware efficient ansatz, recently used to solve complex PDEs [1], and QAOA with strategic grouping [2].
For the next steps, we’ll be:
- Pushing the envelope on qubit numbers and introducing more effective error-mitigation
- Benchmarking across more quantum circuit types
- Testing end-to-end applications and use cases
- Ongoing optimisations
Hybrid quantum execution is not just a workaround, it’s a fundamental part of the near-term roadmap for quantum computing. At Qoro, we are building tools to unlock practical, scalable quantum computing.
References:
[1] ColibriTD announces H-DES for solving Differential Equations on IBM Quantum Computers: https://www.colibritd.com/blogs-posts/h-des-on-ibm-quantum-computers
[2] Investigating the effect of circuit cutting in QAOA for the MaxCut problem on NISQ devices: https://arxiv.org/abs/2302.01792
