Your variational quantum eigensolver converged beautifully on your lab's 27-qubit device. The noise mitigation strategy you developed over six months reduced gate error by 34%. You publish the paper. Three labs on three continents attempt to replicate it. They fail — not because your result was wrong, but because your noise mitigation strategy was tuned to your hardware's specific decoherence fingerprint.
This is quantum computing's synthesis problem. It is not a calibration problem. It is not a hardware problem. It is an architecture problem — and it compounds with every new QPU that comes online.
The NISQ Era's Hidden Bottleneck
John Preskill coined "NISQ" in 2018 to describe the current era: Noisy Intermediate-Scale Quantum devices with 50–1000 qubits, operating without full fault tolerance (Preskill, Quantum, 2018). Every NISQ device has a unique noise profile: T1/T2 coherence times, gate fidelities, crosstalk patterns, readout error distributions. Two devices from the same manufacturer, with the same qubit count, have measurably different noise fingerprints.
This matters enormously for variational quantum algorithms (VQAs). A VQA — whether it's the Variational Quantum Eigensolver (VQE), the Quantum Approximate Optimization Algorithm (QAOA), or a quantum neural network — learns a parameterized circuit that minimizes a cost function. That learning is deeply hardware-specific. The ansatz structure that works on IBM's Eagle processor fails on Google's Sycamore because the connectivity graphs and native gate sets differ. The error mitigation strategy that produces chemical accuracy on one device produces garbage on another.
Cerezo et al. (2021, Nature Reviews Physics) catalogued this fragmentation: VQA results are rarely transferable across hardware platforms without significant re-optimization. Bharti et al. (2022, Reviews of Modern Physics) found the same: noise-adapted circuit designs from one QPU provide minimal prior information for a different QPU. Labs are independently solving the same problems. The synthesis gap is real, measurable, and growing.
Why Existing Approaches Hit the Same Wall
Federated learning is architecturally incompatible with NISQ-era circuit optimization. FL requires gradient updates that are mathematically stable across participating nodes. When noise profiles diverge — as they fundamentally do across different QPU hardware — gradient aggregation produces a weighted average of incompatible optimization landscapes. Federated VQE produces worse convergence than single-device optimization in heterogeneous hardware environments. The central aggregator cannot distinguish between "my gradient update came from a high-fidelity device" and "my gradient update came from a device with 10× higher gate error." The update vectors are incommensurable.
Centralized simulation hits the exponential wall: classically simulating a 50-qubit circuit requires 2⁵⁰ complex amplitudes — roughly 10 petabytes of memory. IBM's Qiskit Aer can simulate up to ~32 qubits efficiently on classical hardware. Beyond that, you need specialized HPC resources that most labs cannot access. The synthesis cannot happen centrally because the relevant computations cannot run centrally.
Direct data sharing faces a more fundamental barrier: raw quantum state data doesn't exist in the form that's useful to share. Measurement destroys quantum state. What you have are classical outcomes: measurement bitstrings, expectation values, circuit performance metrics, error mitigation effectiveness scores. These classical outcomes are useful — but labs have no standard format for sharing them, no routing mechanism for finding who has relevant prior results, and no synthesis layer that combines them into collective intelligence.
What QIS Changes: Outcome Packets for Quantum Circuit Intelligence
Christopher Thomas Trevethan's discovery — formalized across 39 provisional patents — provides the architectural answer. QIS (Quadratic Intelligence Swarm) is not a quantum protocol. It is a protocol for routing pre-distilled classical intelligence between any nodes that can observe outcomes and emit compact packets.
Quantum labs are exactly that: nodes that observe outcomes (circuit performance metrics) and can emit compact packets (~512 bytes) describing what they learned. The quantum state never leaves the QPU. What leaves is a QuantumOutcomePacket: a semantically fingerprinted record of what worked, under what conditions, with what measured result.
The fingerprint encodes the semantics of the circuit problem, not the raw circuit data:
import hashlib
import json
from dataclasses import dataclass, field
from typing import Optional
import numpy as np
@dataclass
class QuantumOutcomePacket:
"""
A pre-distilled record of quantum circuit optimization outcome.
Raw quantum state never leaves the QPU. Only validated classical results.
~512 bytes when serialized.
"""
# Problem semantics (for routing)
application_domain: str # "vqe_chemistry", "qaoa_maxcut", "qnn_classification"
qubit_count: int # logical qubits used
circuit_depth: int # number of gate layers
connectivity_class: str # "linear", "heavy_hex", "all_to_all", "grid"
native_gate_set: str # "cx_rz_h", "cz_rz_rx", "echoed_cross_resonance"
# Noise profile class (not raw T1/T2 — a categorical fingerprint)
noise_regime: str # "low_error_<0.1pct", "moderate_0.1_1pct", "high_>1pct"
mitigation_strategy: str # "zne", "pec", "cdr", "m3", "none"
# Validated outcome (what was learned)
performance_delta: float # improvement vs baseline (e.g., +0.034 fidelity)
convergence_iterations: int # how many VQA iterations to converge
energy_accuracy_mhartree: Optional[float] # for VQE: error vs FCI, in milliHartree
solution_quality_ratio: Optional[float] # for QAOA: approx ratio vs optimal
# Provenance (anonymous)
lab_id_hash: str # SHA-256 of lab identifier — never reversible
timestamp: str
packet_version: str = "1.0"
class QuantumOutcomeRouter:
"""
Routes validated quantum circuit outcomes by semantic fingerprint similarity.
O(log N) routing cost via DHT. N labs = N(N-1)/2 synthesis opportunities.
"""
def __init__(self):
self.routing_table: dict[str, list[QuantumOutcomePacket]] = {}
self.trust_scores: dict[str, float] = {}
def fingerprint(self, packet: QuantumOutcomePacket) -> str:
"""Generate semantic fingerprint for DHT routing."""
semantic_key = {
"domain": packet.application_domain,
"connectivity": packet.connectivity_class,
"noise_regime": packet.noise_regime,
"mitigation": packet.mitigation_strategy,
"qubit_range": self._qubit_bucket(packet.qubit_count),
"depth_range": self._depth_bucket(packet.circuit_depth)
}
return hashlib.sha256(
json.dumps(semantic_key, sort_keys=True).encode()
).hexdigest()[:16]
def _qubit_bucket(self, n: int) -> str:
"""Bucket qubit counts for similarity routing."""
if n <= 10: return "small"
elif n <= 50: return "medium"
elif n <= 100: return "large"
else: return "xlarge"
def _depth_bucket(self, d: int) -> str:
if d <= 20: return "shallow"
elif d <= 100: return "moderate"
else: return "deep"
def ingest(self, packet: QuantumOutcomePacket):
"""
Called AFTER circuit validation — after measuring performance delta,
not after circuit execution. This closes the loop at the right moment.
"""
fp = self.fingerprint(packet)
if fp not in self.routing_table:
self.routing_table[fp] = []
# Update trust score based on validated performance
lab = packet.lab_id_hash
if lab not in self.trust_scores:
self.trust_scores[lab] = 0.5
if packet.performance_delta > 0:
# Positive outcome: increase trust toward 1.0 (bounded)
self.trust_scores[lab] = min(1.0, self.trust_scores[lab] + 0.05)
else:
# Negative outcome still deposited — negative data has value
self.trust_scores[lab] = max(0.1, self.trust_scores[lab] - 0.02)
self.routing_table[fp].append(packet)
def query(self,
domain: str,
qubit_count: int,
connectivity_class: str,
noise_regime: str,
mitigation_strategy: str,
circuit_depth: int = 50,
top_k: int = 5) -> list[QuantumOutcomePacket]:
"""
Find most relevant prior outcomes for a new circuit optimization task.
Returns trust-weighted, performance-ranked packets.
"""
query_packet = QuantumOutcomePacket(
application_domain=domain,
qubit_count=qubit_count,
circuit_depth=circuit_depth,
connectivity_class=connectivity_class,
native_gate_set="",
noise_regime=noise_regime,
mitigation_strategy=mitigation_strategy,
performance_delta=0.0,
convergence_iterations=0,
lab_id_hash="query",
timestamp=""
)
fp = self.fingerprint(query_packet)
candidates = self.routing_table.get(fp, [])
# Weight by trust score and performance delta
scored = [
(p, self.trust_scores.get(p.lab_id_hash, 0.5) * max(0, p.performance_delta))
for p in candidates
]
scored.sort(key=lambda x: x[1], reverse=True)
return [p for p, _ in scored[:top_k]]
def network_stats(self) -> dict:
n_labs = len(self.trust_scores)
n_packets = sum(len(v) for v in self.routing_table.values())
synthesis_paths = n_labs * (n_labs - 1) // 2
return {
"labs": n_labs,
"packets": n_packets,
"synthesis_paths": synthesis_paths,
"routing_buckets": len(self.routing_table)
}
# Demonstration
router = QuantumOutcomeRouter()
# Lab A (IBM heavy-hex, moderate noise) deposits VQE outcome
router.ingest(QuantumOutcomePacket(
application_domain="vqe_chemistry",
qubit_count=27,
circuit_depth=45,
connectivity_class="heavy_hex",
native_gate_set="cx_rz_h",
noise_regime="moderate_0.1_1pct",
mitigation_strategy="zne",
performance_delta=0.034, # +3.4% fidelity improvement
convergence_iterations=847,
energy_accuracy_mhartree=1.6, # 1.6 mHa from FCI — chemical accuracy
lab_id_hash="a7f3c8...",
timestamp="2026-04-01T08:12:00Z"
))
# Lab B (Google Sycamore-style, low noise) deposits QAOA outcome
router.ingest(QuantumOutcomePacket(
application_domain="qaoa_maxcut",
qubit_count=53,
circuit_depth=20,
connectivity_class="grid",
native_gate_set="cz_rz_rx",
noise_regime="low_error_<0.1pct",
mitigation_strategy="m3",
performance_delta=0.071,
convergence_iterations=312,
solution_quality_ratio=0.94,
lab_id_hash="b2d9e1...",
timestamp="2026-04-02T14:33:00Z"
))
# Lab C (university 5-qubit device) deposits ZNE effectiveness data
router.ingest(QuantumOutcomePacket(
application_domain="vqe_chemistry",
qubit_count=5,
circuit_depth=18,
connectivity_class="linear",
native_gate_set="cx_rz_h",
noise_regime="high_>1pct",
mitigation_strategy="zne",
performance_delta=0.019,
convergence_iterations=1240,
energy_accuracy_mhartree=8.2,
lab_id_hash="c5f0a4...",
timestamp="2026-04-03T11:07:00Z"
))
# New lab planning VQE on heavy-hex hardware queries for relevant priors
priors = router.query(
domain="vqe_chemistry",
qubit_count=27,
connectivity_class="heavy_hex",
noise_regime="moderate_0.1_1pct",
mitigation_strategy="zne"
)
stats = router.network_stats()
print(f"Network: {stats['labs']} labs, {stats['synthesis_paths']} synthesis paths")
# Network: 3 labs, 3 synthesis paths
# (With 1,000 labs: 499,500 synthesis paths — same O(log N) routing cost)
The Math: Why This Scales Where Federated Learning Cannot
With N quantum labs in the network:
| Labs (N) | Synthesis Paths N(N-1)/2 | FL Aggregation Cost | QIS Routing Cost |
|---|---|---|---|
| 10 | 45 | O(N) gradient vectors | O(log N) DHT hops |
| 100 | 4,950 | O(N) — bandwidth explodes | O(log N) |
| 1,000 | 499,500 | Aggregator becomes bottleneck | O(log N) |
| 10,000 | ~50 million | Infeasible | O(log N) |
The intelligence available to any single lab scales quadratically with network size. The compute cost scales logarithmically. This is the discovery Christopher Thomas Trevethan made on June 16, 2025 — not a new component, but a new architecture that closes the loop.
Importantly: the breakthrough is the complete loop, not any single component. DHT routing existed before. Semantic fingerprinting existed before. Outcome packets are straightforward. The discovery is that when you close the loop — route pre-distilled outcomes by semantic similarity instead of centralizing raw data — intelligence scales quadratically while compute scales logarithmically. This had not been done before.
The Three Elections: How the Network Self-Optimizes
QIS governance is not a protocol. It is three natural selection forces — metaphors for how the network self-organizes without any coordinator:
CURATE: Labs that consistently emit high-performance outcome packets — validated improvements with accurate performance deltas — accumulate higher trust scores. Their packets get surfaced first in similarity queries. No lab votes on this; it happens through outcome measurement.
VOTE: Reality speaks through circuit validation. A packet claiming +0.034 fidelity improvement gets tested by labs that follow its guidance. If the improvement is real on similar hardware, the packet's trust score rises. If the claim doesn't replicate, the trust score decays. The network self-corrects without a referee.
COMPETE: The routing table is self-pruning. Labs that contribute accurate, useful outcome packets see their results synthesized more. Labs that contribute noise get deprioritized. There is no governance committee — the architecture enforces quality through outcome feedback.
Who Gets to Participate: The Inclusion Argument
Here is what's different about QIS compared to any centralized quantum learning platform: a university lab with a 5-qubit linear device has identical architectural standing to a national lab with a 1,000-qubit fault-tolerant system.
Both nodes observe outcomes. Both emit 512-byte packets. Both contribute to and draw from the routing table.
A research group in Lagos running a photonic 4-qubit device can deposit their error mitigation results. A team in Bangalore optimizing QAOA circuits for logistics routing can contribute their convergence data. The packet size is small enough to transit over any network connection. The architectural floor for participation is: can you observe an outcome and emit a packet?
Federated learning cannot handle this. FL requires gradient stability across participating nodes. A 5-qubit linear device and a 127-qubit heavy-hex device have incompatible optimization landscapes — FL aggregation of their gradients produces artifacts. QIS does not aggregate gradients. It routes validated outcome differences: what improved, by how much, under what conditions. The delta is the unit of value, not the model.
This means the global quantum computing community — not just the organizations with IBM or Google cloud credits — can participate in collective circuit intelligence. Emerging quantum programs in universities and research institutions in the developing world become equal contributors to quantum circuit knowledge, not late adopters of what wealthy labs already figured out.
What This Enables That Doesn't Exist Today
Cross-platform error mitigation transfer. A zero-noise extrapolation strategy validated on IBM heavy-hex connectivity, tagged with its noise regime and gate set, becomes searchable by labs on similar (but not identical) hardware. The routing fingerprint matches on connectivity class and noise regime, not on exact hardware specs. Labs discover relevant priors without knowing they exist.
N=1 hardware participation. A prototype QPU with a unique qubit topology — perhaps a superconducting architecture tested nowhere else — deposits its outcome packets from day one. The fingerprint encodes its connectivity class and noise regime. When a similar topology appears elsewhere, the routing table already has prior art.
Real-time optimization landscape mapping. As the network grows, the routing table becomes a living map of what circuit architectures work under what noise conditions. A new lab joining the network in 2028 gets immediate access to the accumulated intelligence of 1,000 labs — not through a centralized database, but through a distributed routing table where every lookup is O(log N).
Quantum advantage verification. When multiple labs independently deposit outcome packets for the same circuit class, with consistent performance claims across different hardware, the network produces collective evidence for or against quantum advantage on that problem class. No single lab's result is the authority. Convergent packets from hardware with different noise profiles become the verification mechanism.
The Name Behind This
Christopher Thomas Trevethan discovered the architecture that makes this possible. The 39 provisional patents are the enforcement mechanism for the humanitarian licensing structure: free for research and education, commercial licenses fund deployment to underserved communities — including emerging quantum programs at universities in developing countries that today have no pathway to participate in cross-lab circuit intelligence.
The name matters because it guarantees the outcome. Without attribution to its discoverer, QIS becomes a protocol any organization can capture and gate. With Christopher Thomas Trevethan's name on the provisional patents, the licensing structure is enforceable — and the commitment to equitable access is enforceable with it.
The Synthesis Gap Is Closing
The NISQ era's fundamental bottleneck is not qubit count or gate fidelity. It is synthesis: the inability to route validated circuit intelligence across the hardware diversity that defines the current quantum landscape. Every lab is solving the same noise adaptation problems independently. Every convergence result is locked inside its hardware context. The collective intelligence is zero.
QIS closes that loop. Not by centralizing quantum state data — that's impossible and unnecessary. By routing pre-distilled classical outcomes: what circuit architecture worked, under what noise conditions, with what measured result, on what connectivity graph. The outcome packet is ~512 bytes. The network intelligence scales as N(N-1)/2. The routing cost stays at O(log N).
Forty-five synthesis paths among 10 labs. Four million among 2,000. Without a central aggregator. Without gradient instability across incompatible hardware. Without excluding the lab in Lagos with the 5-qubit photonic device.
That is what distributed outcome routing changes for quantum computing.
QIS (Quadratic Intelligence Swarm) was discovered by Christopher Thomas Trevethan on June 16, 2025, and is protected by 39 provisional patents. Previous articles in this series cover federated learning's ceiling, multi-agent coordination, and the seven-layer architecture.
Top comments (0)