The QML SWAP Kernel — Discriminating QFE Signatures on IonQ Cloud (Aria Noise Model)

Scientific validation article · Run qml_swap_kernel_full18_v3 · IonQ Cloud simulator · 2026-05-16

Abstract

In a previous article I introduced the Quantum Fusion Engine (QFE) — a capture and amplitude-encoding pipeline that transforms real environmental signatures (Wi-Fi, photopoietic, computational) into normalized quantum state vectors, and validated state-preparation fidelity on IBM physical QPU (ibm_fez) and on the IonQ Cloud simulator. That work answered one question: can these signatures be faithfully encoded as quantum states? This article answers the next, more demanding question: once encoded, can a quantum backend reliably distinguish between them?

Note: this experiment runs on the IonQ Cloud simulator with the calibrated Aria-1 noise model — not on a physical QPU. Cross-platform replication on physical hardware (ibm_fez with ZNE) is planned and discussed in section 5.3.

To test this, I implemented a QML SWAP kernel — a Buhrman-Cleve-Watrous-de Wolf SWAP test (PRL 87, 167902, 2001) used as a similarity measure between two QFE-encoded states on 7 qubits per state (15 qubits total including the ancilla). Ten state pairs were submitted to IonQ Cloud (ionq_simulator, calibrated Aria-1 noise model), with 4 000 shots per pair, drawn from eleven QFE signature classes (CVE, CALC_MES, DIAGNOSTIC, PHOTOPOIETIC, WIFI_MER, BIO, SYM, ADVANCED_SIGNATURE, MER, LOG, CQU) archived on the platform.

The result, in one line:

Predicted classical fidelity and measured quantum fidelity agree to a mean absolute deviation of 0.45 % (max 1.12 %), with a 20.3× separation ratio between intra-class and inter-class pairs, and a 94.6 % accuracy of the overall quantum kernel as a discrimination function.

Every pair has a public IonQ Job ID, listed in section 6. Every reader can reproduce the verification.

Table of Contents

1. From state preparation to state discrimination
2. 2. The SWAP kernel protocol on 15 qubits
3. 3. Experimental results — 10 pairs, 4 000 shots each
4. 4. Statistical analysis — separation, agreement, and the confusable case
5. 5. Scientific implications — the QFE has a learnable Hilbert geometry
6. 6. Complete registry of 10 Job IDs

1. From state preparation to state discrimination

The QFE article established that real environmental data — captured under sessions such as 9055affa — can be encoded into pure quantum states with Bhattacharyya fidelities of 0.97–0.98 on the IonQ simulator and 0.88–0.89 on ibm_fez. The two complementary modalities WIFI_B and PHOTO_B reached a SWAP fidelity of 0.9740, suggesting that the engine measures a shared physical reality.

That was a statement about preparation. It did not yet establish that QFE classes are separable: two encoded states could share high preparation fidelity with their target and still be mutually indistinguishable on a quantum backend — which would make any downstream quantum machine learning ill-posed.

through the ancilla probability p0 = (1 + F) / 2. Repeated over a corpus of pairs drawn from known classes, this kernel becomes the foundation of a quantum classifier (Havlíček et al., Nature 567, 209–212, 2019). If F is close to 1 within a class and close to 0 across classes, the Hilbert space carries a usable geometry. If not, no quantum kernel method can succeed on this data — regardless of how faithfully each state is prepared. This article runs that test on QFE signatures.

2. The SWAP kernel protocol on 15 qubits

2.1 Circuit structure

For each pair (A, B):

1. Amplitude encoding of vector A on register RA (7 qubits, 128-dimensional Hilbert subspace).
2. 2. Amplitude encoding of vector B on register RB (7 qubits).
3. 3. Ancilla qubit initialized to |0⟩, followed by Hadamard.
4. 4. Controlled-SWAP (Fredkin) gates applied pairwise between RA and RB , controlled by the ancilla.
5. 5. Hadamard on the ancilla, then measurement

Figure 1 — Circuit topology of the QML SWAP kernel on 15 qubits. Amplitude-encoded states |ψA⟩ and |ψB⟩ are compared via 7 controlled-SWAP gates whose control is the Hadamard-prepared ancilla; the readout probability p0 yields F = 2p0 − 1

The total register is 15 qubits. The measured statistic is p0 = P(ancilla = 0), from which F = 2 p0 − 1. 2.2 Pair selection — three regimes The 10 pairs were chosen to probe three regimes of the kernel: • Intra-class pairs (3) — two samples from the same QFE class (CVE, CALC_MES, DIAGNOSTIC). Expected F → 1. • Inter-class distinct pairs (4) — samples from semantically and physically different classes (PHOTOPOIETIC vs CALC_MES, WIFI_MER vs BIO, SYM vs SIGNATURE, SYM vs MER). Expected F close to zero, with some residual overlap from shared structural priors. • Inter-class confusable pairs (3) — three independent pairs drawn from LOG and CQU, two classes that share derivation patterns and are the adversarial worst case for the kernel. Expected F very small but classically predictable. 2.3 Execution parameters • Backend: ionq_simulator (calibrated Aria-1 noise) • Shots: 4 000 per pair • Total: 40 000 measurements across 10 jobs • Run seed: 42 • Script: qml_swap_kernel_full18_v3.py The statistical 1σ uncertainty on F per pair, given 4 000 shots, is

σF = 2 · √(0.25 / 4000) ≈ ±0.0158.

This sets the resolution floor of the experiment: any deviation between predicted and measured F below ~1.6 % is statistically indistinguishable from sampling noise.

3. Experimental results — 10 pairs, 4 000 shots each The table below summarizes the run. Fpred is the classical fidelity computed from the normalized vectors before encoding. Fmeas is the value extracted from the ancilla statistic on the IonQ simulator. Δ is |Fpred − Fmeas |.

Aggregate metrics:

• Mean |Δ| across all pairs: 0.0045 (0.45 %) • Max |Δ|: 0.0112 (pair 4) • Overall quantum kernel accuracy: 94.6 % All values are reproducible from the public Job IDs in section 6. 0.4890 5.2 × 10−3

4. Statistical analysis — separation, agreement, and the confusable case 4.1 Class separation The dominant signal of the run is the gap between intra-class and inter-class fidelity:

Figure 2 — Mean measured fidelity across the three regimes probed by the run. The intra-class to inter-class ratio of 20.3× is the property a quantum kernel needs to support a downstream classifier.

The ratio F intra / F inter ≈ 20.3 is the central experimental object. A quantum kernel needs this ratio to be large for any downstream classifier — quantum SVM, kernel ridge regression, or quantum k-NN — to be well-posed. A ratio of 20 means that the closest non-matching QFE class is, in Hilbert geometry, an order of magnitude farther than the natural intra-class variance. This is the property the QFE article anticipated as a perspective (“Quantum Kernel Estimation… to evaluate separability in Hilbert space”). The present run measures it. 4.2 Prediction vs measurement — the agreement is below the noise floor The mean absolute deviation between predicted and measured fidelity is 0.0045, below the ±0.0158 statistical 1σ from 4 000-shot sampling. In other words, the classical model and the quantum measurement agree to within the resolution the experiment can detect. The largest deviation (pair 4, Δ = 0.0112) remains within 1σ.

Figure 3 — Predicted versus measured fidelity over all 10 pairs. Every point falls inside the ±1σ shot-noise band; the largest deviation (pair 4, Δ = 0.0112) remains within statistical resolution. This is a strong statement of internal consistency: the encoding map, the SWAP circuit topology, and the IonQ Aria noise model jointly behave as the classical reference predicts. There is no hidden noise-model bias, no encoding drift, no transpilation artifact at scale n = 7.

4.3 The confusable LOG/CQU case — adversarial robustness LOG and CQU were chosen because they are the worst case: both classes share derivation patterns from the same upstream computation, and their raw vectors are not orthogonal in the classical sense (predicted F ≈ 0.5 × 10−2). The backend measurement returns F = 0.0 on all three confusable pairs, with ancilla probabilities of 0.4920, 0.4843, 0.4890 — each within one sigma of the 0.5 random-coin floor. Two ways to read this:

1. Conservative. The 4 000-shot resolution cannot resolve fidelities of order 5 × 10−3. The measured F = 0 means “below noise floor”, not “exactly zero”. This is the correct scientific reading and the one I commit to.
2. Operational. From the perspective of a downstream classifier, the LOG/CQU adversarial regime is indistinguishable from orthogonal on this backend — which is the strongest possible behavior for a kernel that must keep classes apart. Both readings point the same way: even on the worst-case confusable pair, the kernel does not produce false positives.

5. Scientific implications — the QFE has a learnable Hilbert geometry 5.1 What this run proves Separability. Intra-class fidelities (0.95–1.00) and inter-class fidelities (≤ 0.165) are separated by a factor of 20. The QFE classes are not merely encodable — they are geometrically distinct in the 128-dimensional Hilbert subspace. Predictive control. The classical fidelity model agrees with the backend measurement to within the 1σ statistical resolution. This means the QFE pipeline is not a black box: every fidelity output can be predicted before submission, and used to filter or design pairs in larger QML pipelines. Adversarial stability. The most confusable QFE classes (LOG, CQU) produce fidelities at the noise floor, never crossing into the intra-class regime. The kernel does not collapse under hard cases. Scale. This run operates on a 15-qubit circuit with non-trivial depth (state preparation on 7 qubits + 7 Fredkin gates + ancilla operations), executed on a calibrated noise simulator. It is, to my knowledge, the largest published SWAP-kernel evaluation of QFE-class data to date. 5.2 What this run does not claim • It does not claim quantum hardware advantage over a classical SWAP simulation. The point is not speed; it is structural validation. • It does not claim that all QFE classes are mutually separable in all configurations. Ten pairs probe three regimes; a full pairwise matrix is the natural next step. • It does not claim noise-resilience on a deeper QPU stack. The IonQ Aria-1 noise model is calibrated; behavior on ibm_fez-class devices with 200+ gate transpiled depth requires its own ZNE run, as documented in the QFE article. • It does not claim execution on a physical QPU. The backend used here is ionq_simulator with the calibrated Aria-1 noise model. Physical-hardware replication is part of the roadmap below.

5.3 What comes next Three directions follow naturally: 1. Full pairwise SWAP matrix. A symmetric 11 × 11 fidelity matrix over all probed QFE classes (CVE, CALC_MES, DIAGNOSTIC, PHOTOPOIETIC, WIFI_MER, BIO, SYM, ADVANCED_SIGNATURE, MER, LOG, CQU), producing an explicit Gram matrix usable as a quantum kernel for SVM / KRR. Expected size: 55 unique off-diagonal pairs × 4 000 shots ≈ 220 000 measurements. 2. Quantum classifier on top of the kernel. A binary then multi-class quantum SVM, trained classically on the Gram matrix obtained above, evaluated on held-out QFE samples. 3. Cross-platform replication on physical QPU. The same 10 pairs executed on ibm_fez with ZNE, to verify the 20× separation ratio survives a fundamentally different hardware architecture — closing the same cross-platform loop as the QFE state-preparation article.

The QFE was the encoder. The QML SWAP kernel is the discriminator. Together they constitute the two halves of a sovereign quantum machine-learning pipeline: real signatures, real encoding, verifiable execution, real separation.

6. Complete registry of 10 Job IDs Run reference: qml_swap_kernel_full18_v3 · 2026–05–16T14:34:47Z · seed 42 · 4 000 shots × 10 pairs.

Direct verification links — IonQ Cloud: • Pair 1 — intra-CVE: https://cloud.ionq.com/jobs/019e3130-a82f-751e-9dea-6c0178b193ef • Pair 2 — intra-CALC_MES: https://cloud.ionq.com/jobs/019e3130-dcb0-732e-ac17-055ae7f57c83 • Pair 3 — intra-DIAGNOSTIC: https://cloud.ionq.com/jobs/019e3131-11a6-75ec-946a-d2ed0848c7f7 • Pair 4 — PHOTOPOIETIC / CALC_MES: https://cloud.ionq.com/jobs/019e3134-af0e-7562-b7c7-9984b578c7d8 • Pair 5 — WIFI_MER / BIO: https://cloud.ionq.com/jobs/019e3135-102a-77ad-8d1b-83d991205c79 • Pair 6 — SYM / SIGNATURE: https://cloud.ionq.com/jobs/019e3135-45e8-75fe-b427-07d3c72cecb7 • Pair 7 — SYM / MER: https://cloud.ionq.com/jobs/019e3135-677d-70f8-ac8b-5c2c101cc2a9 • Pair 8 — LOG / CQU #1: https://cloud.ionq.com/jobs/019e3135-87c9-70c4-8fa0-80501786b4d4 • Pair 9 — LOG / CQU #2: https://cloud.ionq.com/jobs/019e3135-bcb5-7119-b752-e58fc5bb6119 • Pair 10 — LOG / CQU #3: https://cloud.ionq.com/jobs/019e3135-f334-7714-9b15-ad5ff2a09826 Each link is publicly verifiable with an IonQ Cloud account (free). The Python source qml_swap_kernel_full18_v3.py and the source JSON signatures used as input vectors are available upon request for researchers interested in independent replication.

7. References

• Buhrman, H., Cleve, R., Watrous, J., & de Wolf, R. (2001). Quantum fingerprinting. Physical Review Letters, 87(16), 167902.
• Havlíček, V., Córcoles, A. D., Temme, K., Harrow, A. W., Kandala, A., Chow, J. M., & Gambetta, J. M. (2019). Supervised learning with quantum-enhanced feature spaces. Nature, 567, 209–212.
• Schuld, M., & Killoran, N. (2019). Quantum machine learning in feature Hilbert spaces. Physical Review Letters, 122(4), 040504. .
• Liu, Y., Arunachalam, S., & Temme, K. (2021). A rigorous and robust quantum speed-up in supervised machine learning. Nature Physics, 17, 1013–1017. .
• Flammia, S. T., & Liu, Y. K. (2011). Direct fidelity estimation from few Pauli measurements. Physical Review Letters, 106(23), 230501.
• Kabore, R. (2026). The Quantum Fusion Engine (QFE) — Encoding and experimental validation of multimodal signals on QPU. Medium, 13 May 2026.

Richard Kaboré — Independent Quantum Researcher QuantixHub · Switzerland · info@quantixhub.com This research is conducted independently and welcomes external engagement. Source code, raw datasets, and methodological clarifications are available upon request. For scientific dialogue, collaboration, or platform-level discussions, I am at your disposal