What this project is actually doing, why it is interesting, and what the mathematics looks like. Plain-language paragraphs paired with equations for experts.
We use quantum computers to test predictions from a classical theory of how networks of coupled oscillators synchronise — and we look for places where the quantum version behaves differently from the classical one in ways that carry physical meaning.
An oscillator is anything that ticks: a heart cell, a pendulum, a laser, a neuron firing, a power grid generator rotating, a firefly blinking. When many oscillators are connected, they can fall into step with one another even though no single oscillator is telling the others when to tick. This spontaneous collective behaviour is called synchronisation, and it shows up everywhere from cardiac pacemakers to superconducting circuits to the brain's gamma rhythms.
The mathematical workhorse for this is the Kuramoto model: a network of rotating phase oscillators, each with its own natural frequency, that nudge each other's phases through a coupling matrix $K_{ij}$. Depending on how strong $K$ is, the network can stay disordered, fall into perfect lockstep, or do something in between called partial synchronisation.
Each oscillator $i$ has a phase $\theta_i$ advancing at its natural frequency $\omega_i$, perturbed by coupling to its neighbours. The synchronisation order parameter
goes from 0 (no synchronisation) to 1 (perfect lockstep).
The classical Kuramoto model is nonlinear, so it is not directly runnable on a quantum computer in the simplest way. What is runnable is the linearised small-oscillation limit, where the phases barely deviate from their equilibrium. In that limit, the sine turns into its argument and the model collapses onto the XY spin Hamiltonian, which is linear, quantum-mechanical, and native to any superconducting qubit processor.
Each physical qubit represents one oscillator. The $XX + YY$ interaction between two qubits plays the role of the coupling $K_{ij}$. Single-qubit $Z$ rotations encode the individual natural frequencies $\omega_i$. Running the XY Hamiltonian in time on a real quantum processor simulates, up to the linear approximation, the dynamics of a classical oscillator network.
This is the central mathematical object of the entire project. All our algorithms, analyses, and hardware campaigns are built around it.
Time evolution is implemented via first or second-order Suzuki–Trotter decomposition: each "Trotter step" approximates the continuous evolution $e^{-i H_{XY} t}$ by a short sequence of two-qubit and single-qubit gates.
Take the Hamiltonian's building blocks. Compute every commutator between them. Then every commutator of those commutators. Keep going. The space of operators you end up with is the dynamical Lie algebra (DLA). It tells you everything the Hamiltonian can ever do — every unitary evolution it can generate, every observable it preserves, every symmetry it respects.
For the XY Hamiltonian, the DLA has a beautiful structure: it splits cleanly into two equal halves according to whether your quantum state has an even or odd number of excitations. This is called the parity sector of the state. The physics is that if you start in an even-parity state and apply the XY Hamiltonian (however long, however complex), you stay in an even-parity state. The same for odd.
This is exact. In the absence of noise, the two halves are perfectly isolated. On real noisy hardware, they leak into each other — and it turns out they leak at different rates. That leak-rate asymmetry is the central observation we reported from ibm_kingston in April 2026.
The parity operator $P$ commutes with the XY Hamiltonian. Its eigenvalues are $\pm 1$, splitting the Hilbert space into two blocks of equal dimension $2^{n-1}$.
The dynamical Lie algebra decomposes into two identical $\mathfrak{su}$ blocks, one per parity sector. Total dimension $2^{2n-1} - 2$. Full derivation →
SCPN stands for Self-Consistent Projection Network. It is a larger mathematical framework, developed over the past two decades, for treating multi-scale physical systems — plasmas in tokamaks, neural tissue, polymer dynamics, photosynthesis — as a stack of sixteen interacting layers, each with its own projection rule into the layer above it. The whole stack has to be self-consistent, which is where the name comes from.
The SCPN framework makes a specific prediction: in the small-oscillation limit of layer 12 (coupling topology), the dynamics reduce exactly to a Kuramoto-XY model with a coupling matrix that is determined by the SCPN projection rule $K_{nm}$. This means every SCPN prediction about, say, plasma turbulence or neural synchrony can in principle be tested on a quantum computer by running the corresponding XY Hamiltonian.
SCPN-Quantum-Control is the lowest-level layer of that programme: it takes an arbitrary $K$ matrix (from any SCPN source), compiles it to a quantum circuit, runs it on IBM hardware, and compares the observed synchronisation to the SCPN prediction. Phase 1 on ibm_kingston is the first such comparison to produce a genuinely novel hardware observation — the DLA parity asymmetry was predicted by the classical SCPN simulator before the quantum experiment was run.
Layer 16 — director (meta-control)
Layer 15 — identity (attractor selection)
Layer 14 — observer (measurement)
Layer 13 — bridge (cross-layer map)
Layer 12 — coupling topology $K_{nm}$
Layer 11 — phase dynamics
Layer 10 — field equations
Layer 9 — transport
Layer 8–1 — microscale ~ substrate
The XY Hamiltonian sits at Layer 12 (coupling) and Layer 11 (phase dynamics). Quantum hardware executes Layer 11 at the scale set by Layer 12.
The “15+1” naming refers to the sixteen physical layers plus a reflective meta-layer. Layer 0 is the substrate vacuum.
A typical Phase 1 circuit executes on ibm_kingston as follows. First, the classical side computes the coupling matrix $K_{ij}$ and the natural frequencies $\omega_i$ for a 4-oscillator network. A KnmCompiler turns those into an XY Hamiltonian object. A TrotterEvolution module compiles that Hamiltonian into a circuit of first-order Trotter steps, each step consisting of nearest-neighbour $R_{XX}(\theta)R_{YY}(\theta)$ gates plus single-qubit $R_Z$ rotations (about 19 ISA gates per step after optimisation level 2). The DynQ qubit placement heuristic selects the four lowest-error qubits on the device. The circuit is submitted via Qiskit's SamplerV2, runs on real hardware, and returns raw bitstring counts.
On the classical side again, the counts are parsed into sector populations, error bars are computed by bootstrap or SEM across independent repetitions, and Welch's t-test is run between the even and odd sectors. The whole loop from circuit construction to Welch statistic takes about ten seconds of wall time and under a minute of QPU time. Figures and summary JSON are written to figures/phase1/.
The Phase 1 results page walks through the dataset that came out of this loop.