Parallelizing Quantum Circuit Cutting for Hybrid Computing

We’ve recently added a new service to the Qoro platform that enables automatic quantum circuit cutting and parallel execution across heterogeneous compute resources.

Circuit cutting is a technique for decomposing a large quantum circuit into smaller fragments that can be executed independently on separate devices. This enables quantum computations to scale beyond the qubit limits of individual hardware units, allowing for parallel execution and better resource utilization in distributed or hybrid environments. While circuit cutting introduces overhead—particularly due to the exponential scaling in the number of cuts—it remains a valuable tool for scaling and distributing quantum workloads.

The workflow starts with Divi, our Python SDK, which allows users to submit full quantum circuits along with metadata about the available hardware — such as the number of qubits on each device. This information is passed to Composer, our scheduler and circuit orchestration layer.

Composer uses this topology information to perform network-aware circuit cutting, partitioning the input circuit into fragments that can be distributed to available devices or simulators. The fragments are designed to respect hardware constraints while maximizing parallelism across the system.

Once partitioned, circuit fragments can be sent to different compute nodes which may include QPUs, GPUs, or classical simulators. Composer also handles the post-processing needed to reconstruct measurement statistics, ensuring correctness and compatibility with stitching methods for cut circuits (e.g., using classical shadows, tensor contraction, and probabilistic reconstruction techniques).

This approach supports parallel execution of circuit fragments, enabling larger and more complex quantum circuits to be evaluated across distributed systems — even when no single device could handle the circuit alone.

We’re using this internally to evaluate hybrid quantum-classical workloads, and it’s now available via the Qoro platform as a service. Here's how simple it is to use:

from divi.services import QoroService

qasm_circuit= YOUR_QASM_CIRCUIT
network = {"qreg": [q1, q2], "creg": [c1, c2]}
qoro_service = QoroService(QORO_API_KEY)
cut_data = qoro_service.cut_circuit(qasm_string, network)

parent_circuit = cut_data.parent_circuit
fragments = cut_data.fragments
shots = cut_data.recommended_shots

fragment_results = parallel_execute(fragments, shots)
results = qoro_service.restore_circuit(fragment_results)        

The circuit fragments can be sent back to the application layer, Divi, and handled manually, or they can be passed forward to be executed through our orchestration platform, that can already automate the distribution of tasks between distributed systems.

Key Benefits:

• Scalability: Circuits that exceed the capacity of any single QPU can now be executed across multiple devices.
• Parallelism: Independent fragments are executed in parallel, reducing overall runtime.
• Hardware awareness: Circuit partitioning respects real-world device constraints, enabling deployment on heterogeneous clusters.
• Hybrid flexibility: Fragments can run on a mix of QPUs, simulators, or classical accelerators depending on availability and fidelity needs.
• Automation: Users only submit the circuit and topology — the system handles partitioning, routing, execution, and stitching.

This is part of our broader effort to support distributed, modular quantum computation and to bridge the gap between current NISQ devices and scalable quantum-classical workflows.

Feel free to reach out if you’re working on similar problems, especially around distributed quantum execution, circuit cutting strategies, or hybrid orchestration techniques.