Distributed quantum protocols require measurement outcomes produced at one node to control operations at another. We present QQLink, a programming and orchestration layer that expresses these dependencies in a single program, using workflow nodes, deferred measurement references, and declared entanglement, and derives the cross-node coordination automatically. Its planner constructs a provably acyclic dependency graph in time linear in the total size of the instructions' qubit footprints. The same programs execute through simulator backends or are lowered to dynamic circuits on partitioned quantum hardware. We evaluate seven protocol workflows. Exhaustive feedforward-branch tests on the simulator runtime path, over tomographically complete input sets, yield output-state infidelities of at most $5\times10^{-12}$ and no incorrect classical outputs, and replaying every plan in random topological orders leaves each final state unchanged. Separate executor processes run the plans with delayed messages, with the joint quantum state held by a centralized simulation service. Every run with the full plan is correct, and removing required cross-node dependencies causes protocol failures. The lowered circuits match hand-written implementations of the same construction in two-qubit gate and conditional-block counts. Runs on two IBM Heron processors, each partitioned into virtual QPUs, demonstrate same-chip execution in two sessions a week apart. The runs also show large variation between sessions and losses beyond what calibration-derived noise models predict. Coherence-sensitive checks do not establish coherent Toffoli operation or preservation of the intended repetition-code superposition. These results support QQLink's workflow semantics on the tested execution paths and identify limits of the current hardware realization; execution across physically networked QPUs remains future work.
AI Summary
QQLink asks whether coordination for multi-QPU protocols can be derived automatically from one backend-independent program rather than written as explicit per-node messaging. Its Python interface represents workflow nodes, deferred measurement handles, conditional gates, and declared entanglement. A planner derives dependencies from shared-qubit accesses in global authoring order and measurement references. The paper proves determinism, acyclicity, and equivalence of topological execution orders, with planning cost linear in total instruction-footprint size.
Evaluation covers seven protocol workflows, including teleportation, gate-teleported algorithms, a three-node Toffoli, and a repetition code. On the Qulacs runtime path, exhaustive feedforward-branch tests over tomographically complete inputs give output-state infidelities at most $5\times10^{-12}$ and no incorrect classical outputs. All 12,096 randomized-order replays preserve the reference state. Separate node-controller processes with delayed messages complete all 1,536 full-plan runs correctly; dependency-removal ablations cause failures. Planning takes 8–17 microseconds per instruction. Lowered dynamic circuits match hand-written versions of the same constructions in two-qubit-gate and conditional-block counts, although restricting conditions to single bits adds decoder resources relative to classical-expression implementations.
Hardware tests use disjoint virtual-QPU sectors within each of two IBM Heron processors, not networked QPUs. Success varies by up to 31 percentage points between sessions, with losses up to 65 points beyond calibration-derived simulations. Coherence-sensitive tests do not establish coherent Toffoli action or preservation of the repetition-code superposition. Separate-process tests retain a centralized quantum simulator and assume exactly-once message delivery; physical links, failure recovery, distribution optimization, and multi-bit conditions remain outside the demonstrated implementation.
Little sign of AI-generated textIncremental
Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.
Distributed quantum protocols require measurement outcomes produced at one node to control operations at another. We present QQLink, a programming and orchestration layer that expresses these dependencies in a single program, using workflow nodes, deferred measurement references, and declared entanglement, and derives the cross-node coordination automatically. Its planner constructs a provably acyclic dependency graph in time linear in the total size of the instructions' qubit footprints. The same programs execute through simulator backends or are lowered to dynamic circuits on partitioned quantum hardware. We evaluate seven protocol workflows. Exhaustive feedforward-branch tests on the simulator runtime path, over tomographically complete input sets, yield output-state infidelities of at most 5×10−12 and no incorrect classical outputs, and replaying every plan in random topological orders leaves each final state unchanged. Separate executor processes run the plans with delayed messages, with the joint quantum state held by a centralized simulation service. Every run with the full plan is correct, and removing required cross-node dependencies causes protocol failures. The lowered circuits match hand-written implementations of the same construction in two-qubit gate and conditional-block counts. Runs on two IBM Heron processors, each partitioned into virtual QPUs, demonstrate same-chip execution in two sessions a week apart. The runs also show large variation between sessions and losses beyond what calibration-derived noise models predict. Coherence-sensitive checks do not establish coherent Toffoli operation or preservation of the intended repetition-code superposition. These results support QQLink's workflow semantics on the tested execution paths and identify limits of the current hardware realization; execution across physically networked QPUs remains future work.
QQLink asks whether coordination for multi-QPU protocols can be derived automatically from one backend-independent program rather than written as explicit per-node messaging. Its Python interface represents workflow nodes, deferred measurement handles, conditional gates, and declared entanglement. A planner derives dependencies from shared-qubit accesses in global authoring order and measurement references. The paper proves determinism, acyclicity, and equivalence of topological execution orders, with planning cost linear in total instruction-footprint size.
Evaluation covers seven protocol workflows, including teleportation, gate-teleported algorithms, a three-node Toffoli, and a repetition code. On the Qulacs runtime path, exhaustive feedforward-branch tests over tomographically complete inputs give output-state infidelities at most 5×10−12 and no incorrect classical outputs. All 12,096 randomized-order replays preserve the reference state. Separate node-controller processes with delayed messages complete all 1,536 full-plan runs correctly; dependency-removal ablations cause failures. Planning takes 8–17 microseconds per instruction. Lowered dynamic circuits match hand-written versions of the same constructions in two-qubit-gate and conditional-block counts, although restricting conditions to single bits adds decoder resources relative to classical-expression implementations.
Hardware tests use disjoint virtual-QPU sectors within each of two IBM Heron processors, not networked QPUs. Success varies by up to 31 percentage points between sessions, with losses up to 65 points beyond calibration-derived simulations. Coherence-sensitive tests do not establish coherent Toffoli action or preservation of the repetition-code superposition. Separate-process tests retain a centralized quantum simulator and assume exactly-once message delivery; physical links, failure recovery, distribution optimization, and multi-bit conditions remain outside the demonstrated implementation.
Scalable quantum computing requires execution models that go beyond the capacity of a single quantum processing unit (QPU). Although current hardware platforms continue to increase in qubit count, large fault-tolerant applications require substantially more physical qubits, stronger connectivity, and lower effective error rates than a monolithic near-term device can provide. Multi-QPU and multi-core architectures therefore form an important route towards larger quantum systems. However, distributing a quantum computation introduces compiler and architecture constraints that do not arise in conventional classical distribution. A partitioned quantum circuit separates gates and qubits that may still be logically entangled or mutually dependent. The system must therefore provide quantum resources that support entanglement between the distributed circuit fragments, while each local subcircuit must remain executable on the hardware topology of its assigned QPU. In this thesis, graph states serve as the explicit interconnection resources for these nonlocal dependences: they encode the entanglement structure required to support teleportation-based operations across QPUs. This thesis studies scalable quantum execution as an architecture-driven compilation problem. It develops a staged framework in which distribution, graph-state-based interconnection, and interconnection robustness are treated as dependent compiler decisions. The framework addresses three connected questions: 1) how a large quantum circuit should be divided when the resulting subcircuits must match real QPU topologies; 2) how the graph states required to entangle and operate across the distributed circuit boundaries can be prepared efficiently on constrained hardware; and 3) how those graph-state resources can remain useful under the loss and fusion failures that arise during preparation and use. These questions define an execution path from a large logical circuit to distributed local workloads connected by explicit entanglement resources. The thesis makes three main technical contributions that instantiate this framework. 1) It introduces hardware-aware circuit cutting, which incorporates the relationship between subcircuit interaction graphs and target QPU topology into the partitioning objective. This stage produces distributed workloads and explicit cut boundaries where quantum entanglement must be supplied across QPUs. 2) It formulates graph-state preparation as the resource-generation stage for those boundaries and develops methods that reduce preparation depth and emitter usage by exploiting graph-state equivalence and divide-and-conquer construction. 3) It develops a robust graph-state interconnection scheme that uses tree-encoded fusion and spin-memory-assisted compilation to tolerate photon loss and probabilistic fusion failures, so that the graph state can serve as a reliable connection between distributed quantum program fragments.
Quantum Computing is advancing from isolated prototypes toward heterogeneous, cloud-accessed quantum processors that are noisy, capacity-limited, and operationally diverse. In this landscape, the prevalent device-centric execution model (i.e., compiling a circuit for a single backend and running all shots monolithically) constrains scale, reliability, and cost-effectiveness. This thesis argues for and instantiates a system-centric paradigm of distributed execution, which treats execution as an engineered process that orchestrates spatial and temporal distribution across multiple devices and time scales, guided by explicit Quality-of-Service (QoS) objectives. Spatial distribution aggregates multiple, heterogeneous Quantum Processing Units and supporting classical services into a shared resource pool, placing circuits, subcircuits, and workloads where their algorithmic needs best align with hardware characteristics and availability. Temporal distribution adapts execution over time, modulating sampling depth, pacing, and scheduling in response to drift, queue dynamics, and evidence of statistical convergence. Together, these dimensions are governed by policy-driven orchestrations that reconciles fidelity, latency, and cost, and that elevates user intent above device idiosyncrasies. This thesis delivers five main contributions: (1) a shot-wise execution methodology that distributes measurement shots across heterogeneous QPUs under policy control, reducing output variance and matching or surpassing single-device averages; (2) Quantum Broker, a QoS-aware orchestration framework with the Quantum QoS Specification Language (QQSpec) that consistently finds feasible, high-quality allocations and outperforms single-backend and uniform-shot baselines under competing fidelity/latency/cost goals; (3) Cut&Shoot, an integrated circuit-cutting + shot-wise pipeline that executes large circuits across multiple devices with significantly lower error than monolithic, cutting-only, or shot-wise-only baselines, at negligible time overhead relative to standard cutting; (4) a hybrid orchestration architecture, QCRAFT Scheduler–Shotwise, which combines high-level circuit scheduling with shot-wise distribution to achieve up to 95% cost reduction and 92% fewer job submissions while improving robustness to hardware variability; and (5) IncrementalExecution, an adaptive, evidence-seeking shot manager that approximates optimal allocations with minimal overhead and high fidelity across unseen circuits and backends. Evaluations on simulated and real cloud backends demonstrate practicality across heterogeneous providers. Situated within Quantum Software Engineering, this thesis promotes abstractions and runtime mechanisms that make distribution a first-class program property rather than a backend option. The resulting perspective embraces hardware diversity as an optimization opportunity, improves portability across providers, and lays a path from today’s Noisy Intermediate-Scale Quantum (NISQ) platforms to future networked and fault-tolerant regimes. The overarching vision is that, by engineering execution as a principled, evidence-seeking process, heterogeneous quantum resources become the substrate for scalable, reliable, and efficient Quantum Computing.
Distributed quantum computing (DQC) seeks to scale beyond the limits of monolithic processors by interconnecting multiple quantum processing units (QPUs) through entanglement-based links. Realizing this vision requires the co-design of hardware and software across the domains of quantum networking, compilation, and scheduling, yet existing tools remain fragmented between monolithic circuit compilers and long-distance quantum network simulators. We present an open-source, topology-informed framework for the compilation and scheduling of distributed quantum programs. Given an input circuit and a description of the target network, the framework partitions and reconstructs the circuit into a distributed program that respects the specified inter- and intra-QPU topology, covers cross-QPU operations through gate and state teleportation, and schedules the result under either deterministic or stochastic entanglement-generation models. By accepting and emitting standard OpenQASM, the framework interoperates with existing monolithic toolchains, and its standardized module interfaces allow partitioning and scheduling strategies to be interchanged and benchmarked. Using this framework, we show that the best-performing compilation strategy varies across the tested circuits and network configurations, and that both network topology and intra-QPU connectivity substantially affect the entanglement cost of execution. These findings underscore the need for a co-design approach to distributed quantum computing, which our framework is designed to support.
Connecting AI-generated quantum programs to executable experiments requires more than syntactically valid code: the workflow must also control execution authority and preserve the basis for interpreting its results. This paper develops a conceptual architecture organized around three responsibilities: AI-assisted circuit proposal, deterministic classical validation, and quantum measurement execution. A quantum-job contract binds circuit artifacts, measurement settings, resource allocations, backend information, and provenance to explicit admission conditions. The design separates permission to run an experiment from evidence that its output answers the intended scientific question. An analytical single-qubit variational example demonstrates this distinction through exact energy calculations, finite-shot variance, and budget-constrained measurement allocation. Responsibility allocation, runtime interception, and staged transformation provide the architectural principles, while uncertainty reporting and reference calculations supply the scientific checks. A prospective evaluation protocol covers accuracy, policy violations, reproducibility, end-to-end cost, and researcher effort. The framework is presented as a design proposal supported by mathematical illustration, not as a tested implementation; its operational benefits and applicability to larger quantum workloads remain to be established.
Quantum programming is today largely discussed at the level of circuits and application programminginterfaces: a developer constructs a circuit, submits it to a simulator or a cloud-hosted device, and readsback measurement results. As quantum computing moves toward shared, heterogeneous, andincreasingly hybrid quantum-classical environments, a complementary systems-level question becomesimportant — how should the lifecycle of a quantum computation be managed once it leaves the hands ofthe programmer, particularly when many such computations compete for limited execution resources?This paper presents QuantumOS, a research-oriented software platform that treats a quantum circuit notmerely as an object to be executed, but as a managed workload: a quantum job that is created, queued,scheduled according to a selectable policy, assigned to a computational resource by a resource manager,optionally transformed by a circuit-processing stage, executed on a local Quantum Virtual Machine(QVM), and finally recorded and surfaced through a monitoring dashboard. QuantumOS is explicitly aresearch prototype and does not control physical quantum hardware; its current execution backend is aclassical, local circuit simulator. We describe the system's layered architecture, its job-lifecycle andscheduling abstractions, and its execution workflow, and we report an experimental evaluation of theQVM's performance and correctness characteristics. Measured results show that QVM execution timeremains low for small circuits and rises sharply beyond approximately eight to nine simulated qubits,consistent with the expected cost of classical state-vector simulation, and that execution time growsroughly in proportion to the number of measurement shots requested. A correctness evaluation of fourcanonical circuits — a single-qubit Hadamard gate, a Pauli-X gate, a two-qubit Bell state, and a three-qubitGHZ state, each sampled at 10,000 shots — shows observed outcome probabilities within approximatelyhalf a percentage point of their theoretical values, consistent with ordinary statistical sampling variationrather than simulation error. We discuss how the broader scheduling and resource-managementarchitecture supports the paper's central systems claim even where full quantitative benchmarking ofevery subsystem remains for future work, and we outline the educational value of a locally runnableplatform that makes both quantum-circuit behavior and workload-management concepts directlyobservable. We conclude by identifying the prototype's current limitations and the concrete next stepsrequired to mature QuantumOS into a more completely benchmarked research platform.
Distributed Quantum Computing (DQC) enables scalable quantum execution by interconnecting multiple quantum processing units (QPUs) through quantum networks. In DQC, end-to-end performance is jointly affected by circuit partitioning, entanglement routing, scheduling, and heterogeneous hardware characteristics. However, existing studies often optimize these components independently, providing limited understanding of their cross-layer interactions. In this paper, we present a cross-layer joint-optimization study for DQC using the previously developed SimDisQ-Net simulator. Through simulations, we find that circuit orchestration is one of the dominant factors affecting distributed execution quality, while network-layer mechanisms provide secondary but still meaningful improvements. We further demonstrate that traditional communication metrics, such as hop count or remote-gate count alone, are insufficient predictors of execution quality due to the strong interaction among path fidelity, hardware characteristics, and circuit structure. Motivated by these findings, we propose a topology-aware fidelity proxy (TAFP) evaluation approach that approximates distributed execution fidelity, enabling efficient evaluation of candidate circuit optimizations without time-consuming simulation. Our results highlight the importance of integrated circuit-network orchestration for scalable DQC.