QONTOS Quantum SDK (qontosq)

A quantum programming and simulation stack for the hybrid superconducting plus photonic modular architecture. It is the software layer that the QONTOS hardware will plug into, and it runs today against simulators.

This is the same kind of stack that IBM (Qiskit), Google (Cirq), and Rigetti (pyQuil) ship, with one thing they do not have natively: a transpiler that compiles a gate between qubits on different modules into local operations plus a photonic Bell pair and classical feed-forward, which is exactly how the QONTOS machine performs an inter-module operation (research paper N04).

Honest scope: this is software. It does not by itself constitute a quantum computer. The physical machine is a planned hardware program; no QONTOS hardware has been fabricated yet, and this SDK is the control and programming layer that program targets. Every number this SDK produces is simulation.

What is in v0.4

• Circuit: gates (H, X, Y, Z, S, T, Rx, Ry, Rz, CX, CZ, SWAP), measurement, and classically-conditioned gates for mid-circuit feed-forward.
• simulator: a reference dense statevector simulator with measurement collapse, feed-forward, and stochastic Pauli noise (comfortable to ~16 to 20 qubits).
• StabilizerBackend: Clifford simulation via Stim, scales to thousands of qubits (a 1000-qubit GHZ runs in under a second); rejects non-Clifford gates.
• ModularDevice: modules, qubits per module, and photonic link topology.
• transpile: rewrites inter-module two-qubit gates into the entanglement-assisted ("non-local") form and reports the Bell pairs (ebits) consumed.
• LinkNoiseModel + NoisyModularBackend: inject the corpus's transduction efficiency and Bell-pair fidelity (papers N01, N03) as real per-link error.
• LogicalDevice + LogicalCircuit + LogicalBackend: a QEC-aware logical layer. Logical qubits are surface-code patches; the inter-module logical CNOT is lattice surgery across the link (paper N04); each logical operation's error rate comes from a real Stim surface-code simulation (paper N05), and a poor link raises the seam past threshold.
• interop: convert circuits to and from Qiskit and Cirq.
• pulse + hal: a pulse-schedule layer and a hardware abstraction layer (SimulatedModule, HardwareModule, HALBackend), the seam a real module fills.
• LocalStatevectorBackend, ModularSimulatorBackend.
• qec: optional Stim plus PyMatching surface-code helper (paper N05).

Quick start

from qontosq import Circuit, ModularDevice, ModularSimulatorBackend

device = ModularDevice(num_modules=2, qubits_per_module=2)
c = Circuit(4)
c.h(0); c.cx(0, 2)            # qubit 0 in module 0, qubit 2 in module 1
c.measure(0, 0); c.measure(2, 1)

backend = ModularSimulatorBackend(device)
print(backend.run(c, shots=1000))     # an inter-module Bell state
print(backend.last_report)            # ebits (photonic Bell pairs) consumed

Run

python examples/bell.py
python examples/ghz.py
python examples/cross_module.py
python examples/noisy_link.py
python examples/qiskit_interop.py
python examples/hal_pulse.py
python examples/logical_bell.py
python examples/stabilizer_scale.py
python tests/test_qontosq.py     # 25/25

Roadmap

• Tensor-network backend for large non-Clifford circuits.
• Magic-state and non-Clifford logical gates (logical T via distillation).
• A real hardware backend behind the HAL once a physical QONTOS module exists.