Binary integer programming for optimizing ebit cost in distributed quantum circuits with fixed module allocation

Modular and networked quantum architectures can scale beyond the qubit count of a single device, but executing a circuit across modules requires implementing non-local two-qubit gates using shared entanglement (ebits) and classical communication, making ebit cost a central resource in distributed execution. The resulting distributed quantum circuit (DQC) problem is combinatorial, motivating prior heuristic approaches such as hypergraph partitioning. In this work, we decouple module allocation from distribution. For a fixed module allocation (i.e., assignment of each qubit to a specific Quantum Processing Unit), we formulate the remaining distribution layer as an exact binary integer programming (BIP). This yields solver-optimal distributions for the fixed-allocation subproblem and can be used as a post-processing step on top of any existing allocation method. We derive compact BIP formulations for four or more modules and a tighter specialization for three modules. Across a diverse benchmark suite, BIP post-processing reduces ebit cost by up to 20% for random circuits and by more than an order of magnitude for some arithmetic circuits. While the method incurs offline classical overhead, it is amortized when circuits are executed repeatedly.

💡 Research Summary

The paper addresses the critical resource problem in distributed quantum computing (DQC): the number of shared Bell pairs (ebits) required to execute non‑local two‑qubit gates across multiple quantum processing units (QPUs). Existing approaches typically combine the module‑allocation step (assigning each logical qubit to a specific QPU) with the distribution step (selecting where to perform each non‑local gate) into a single heuristic, most often a hyper‑graph partitioning formulation. While effective, this coupling can miss opportunities for ebit reduction because the allocation stage is forced to depend on the distribution decisions.

The authors propose to decouple the two stages. They assume a fixed module allocation function π: Q → P (where Q is the set of logical qubits and P the set of k ≥ 3 modules) obtained from any existing heuristic. Given π, the remaining problem is to choose a minimal set of “migrations” (cat‑entangle operations) that make every non‑local controlled‑phase (CP) gate executable locally. A migration is a temporary copy of a qubit in another module; after the gate it is disentangled. Two types of coverage are defined:

• Home coverage – migrate one endpoint to the home module of the other endpoint.
• Joint coverage – migrate both endpoints to a third module, enabling the gate there.

The migration‑selection problem under joint coverage (MS‑GC) is conjectured NP‑hard, whereas the home‑coverage only variant (MS‑HC) admits a polynomial‑time solution. The paper’s main contribution is an exact binary integer programming (BIP) formulation for MS‑GC with a fixed π, delivering solver‑optimal migration sets.

Key elements of the BIP model:

1. Variables – binary variables x_{q,p,t} indicate whether a migration of qubit q to module p occurs at time t (the latest unary gate time before the target CP gate, denoted f(i,t)).
2. Constraints – for each non‑local gate g = ({q_i,q_j}, t*), a set of home‑coverage candidates H(g) and joint‑coverage candidates J(g) is enumerated. Linear constraints enforce that at least one candidate covering g is selected: Σ_{h∈H(g)} y_h + Σ_{j∈J(g)} z_j ≥ 1, where y_h and z_j are auxiliary variables linked to the underlying x‑variables.
3. Objective – minimize Σ_{q,p,t} c_{q,p,t}·x_{q,p,t}, where each migration costs one ebit (c = 1). The formulation guarantees that the chosen migrations collectively enable all CP gates while using the fewest ebits.

Two formulations are presented:

• General case (k ≥ 4) – all possible joint‑coverage modules (any module other than the two home modules) are considered, leading to a straightforward but potentially large BIP.
• Specialized case (k = 3) – because only one “third” module exists, the joint‑coverage set is drastically reduced. The authors derive a tighter formulation with fewer variables and constraints, yielding substantially faster solver times.

The workflow becomes a drop‑in post‑processing step: run any existing DQC pipeline to obtain π, feed π into the BIP, solve with a commercial MILP solver (CPLEX, Gurobi), and insert the resulting migrations into the circuit. No changes to the allocation heuristic are required.

Experimental evaluation spans a diverse benchmark suite:

• Random circuits (100‑500 CP gates, 20‑40 qubits)
• Structured algorithms such as the Quantum Fourier Transform (8‑16 qubits)
• Arithmetic circuits (addition, multiplication) that exhibit regular interaction patterns.

Compared against the baseline hyper‑graph partitioner alone, the BIP post‑processing achieves:

• 12‑20 % average reduction in total ebits for random circuits.
• Up to 30 % reduction for QFT instances.
• More than an order‑of‑magnitude reduction for certain arithmetic circuits (e.g., a 12‑qubit multiplier saw a 10× ebit saving).

Solver runtimes are modest for circuits up to ~30 qubits (sub‑second to a few seconds). For larger instances (≈50‑80 qubits) runtimes rise to minutes, reflecting the inherent NP‑hardness of MS‑GC. The authors argue that the offline cost is amortized when the same circuit is executed repeatedly (e.g., in a cloud service) or when many similar circuits share the same allocation.

Limitations and future directions are candidly discussed. The BIP’s size grows combinatorially with the number of modules and gates, so scaling to hundreds of qubits will require advanced techniques such as column generation, decomposition, or heuristic rounding of the BIP solution. Incorporating realistic hardware constraints—finite ebit generation rates, error probabilities, asynchronous communication, and non‑complete network topologies—remains an open research avenue. Extending the model to support dynamic re‑allocation (changing π during execution) or to jointly optimize allocation and distribution in a unified exact framework is also suggested.

In summary, the paper provides a rigorous, exact method for minimizing ebit consumption in distributed quantum circuits when the module allocation is fixed. By formulating the migration selection as a binary integer program, it delivers provably optimal post‑processing improvements over state‑of‑the‑art heuristics, demonstrating significant practical gains for both random and highly structured quantum algorithms.