Quantum Link Research

Talk to anywhere, as fast as light allows.
Physics-first simulations, interactive labs, and a staged two-room experiment toward secure communication at the light-time floor, wherever the two ends are.

The goal: communication that is as close to instantaneous as physics allows, wherever the two ends are, and secure. Physics sets the limit exactly. No signal outruns light, and entanglement does not change that: whatever one end does to its half of a shared pair, the other end sees nothing new until a classical message arrives. So "almost instantaneous" means one trip at the light-time floor with nothing waiting on top: routes that travel at nearly c, and key and entanglement banked before the message exists. On Earth that floor is at most 67 ms; to the Moon about 1.3 s; to Mars 3 to 22 minutes. This repository computes how close each route and protocol gets, what hardware could close the gap, and what a student can build on the way, in code where every formula is cited and every module has an analytic test.

Development status: experimental research software, not a production cryptographic system. Numbers are model outputs unless a section says measured, and nothing here is a security-reviewed link; the audit findings matrix records what is fixed, tested, deferred, and blocked. The tests badge is written by the CI run that built the deployed website. Do not use simulated keys or the browser messenger for sensitive data.

_{The live landing page, recorded in headless Chromium: planets placed by the same Kepler ephemeris the Python tests check.}

The goal: anywhere, at the speed of light

Three things separate a message from the floor, and qll/space/latency_floor.py computes each of them:

1. The route. Light in glass fiber moves at about 1/1.47 of c, and real cables wander from the great circle. Hollow-core fiber carries light at about 99.7 % of c; a low-orbit laser mesh climbs a few hundred kilometers and then travels in vacuum, which beats terrestrial fiber over long distances; a geostationary relay adds a quarter of a second. Between planets the straight line through free space is the only route, and it already sits on the floor.
2. The handshake. A fresh internet connection spends two round trips (TCP, then TLS 1.3) before the first byte of data, so the receiver reads the message after five one-way trips. Key made by QKD on demand needs three.
3. The key. Key banked in advance, from QKD sessions run earlier, lets the ciphertext leave at once: one trip, at the floor of that route. Teleportation behaves the same way with entanglement banked in memories: only the two classical bits travel.

A one-time pad is information-theoretically secure only if its key is truly random, secret, used once, and paired with authentication, and it spends a key bit per message bit. AES-256 under a link key is estimated to keep about 128-bit security against known quantum attacks (Grover search) and keys millions of messages. Public-key messengers need no bank, but a recording can be decrypted later by a large quantum computer. That is why the Mars messenger banks key: at 22 minutes a trip, waiting for fresh key would cost another 44.

From Los Angeles to	Light-time floor	Terrestrial fiber	Fastest route	Secure message, banked key	QKD on demand	New TCP + TLS 1.3
New York	13.1 ms	28.9 ms	LEO laser mesh: 17.9 ms (1.37×)	17.9 ms	53.8 ms	89.7 ms
London	29.2 ms	64.4 ms	LEO laser mesh: 35.4 ms (1.21×)	35.4 ms	106.2 ms	177.0 ms
Tokyo	29.4 ms	64.9 ms	LEO laser mesh: 35.6 ms (1.21×)	35.6 ms	106.9 ms	178.1 ms
Sydney	40.3 ms	88.8 ms	LEO laser mesh: 47.4 ms (1.18×)	47.4 ms	142.3 ms	237.1 ms
Cape Town	53.5 ms	118.1 ms	LEO laser mesh: 61.8 ms (1.15×)	61.8 ms	185.5 ms	309.2 ms
the Moon	1.28 s	—	free space: 1.28 s (1.00×)	1.28 s	3.85 s	6.41 s
Mars at its closest	3.1 min	—	free space: 3.1 min (1.00×)	3.1 min	9.3 min	15.5 min
Mars at its farthest	22.3 min	—	free space: 22.3 min (1.00×)	22.3 min	66.9 min	111.4 min

The farthest any two places on Earth can be is antipodal: 66.8 ms along the surface, 42.5 ms through the planet. The fiber route factor (1.5) and the orbit altitude (550 km) are assumed planning values; every number is a model output from qll/space/latency_floor.py, tested in tests/test_latency_floor.py.

The answer, computed

Every number above is written by scripts/make_readme_art.py from docs/site_data.json, which scripts/build_site_data.py regenerates from the tested code on every commit, so the README, the website, and the thesis quote the same computation. That keeps the displays consistent with each other; it is not independent validation, since one wrong equation would propagate everywhere. The test count is an inventory of collected tests; pass and fail results come from the CI run.

The full table, with the module that computes each number

Question	Answer from the code	Module
One-way light time, Earth → Mars	3.1–22.3 min	qll/space/ephemeris.py
Round trip a memory must survive (Mars max)	44.6 min	qll/channels/light_time_delay.py
Demonstrated memories that survive it (f₀ = 0.95)	3 of 6: hour-class ions (99 % retrieval) and rare-earth crystals (< 5 %)	qll/network/memory_decoherence.py
Micius two-downlink loss at 30° elevation	65.7 dB (reported 64–82 dB)	qll/channels/link_budget.py
Thermal photons a 5 GHz qubit sees	1250 at 300 K, 1.1e-07 at 15 mK	qll/circuits/noise/thermal.py
BB84 error threshold	11.00 %	qll/qkd/key_rate.py
Where a repeater chain (1 s memories) beats direct fiber	393 km	qll/network/repeater_chain.py
Teleportation fidelity of the pairs it delivers there, without purification	0.58 (below 2/3: rate is not enough)	qll/network/repeater_chain.py
Memory needed for a useful chain (F > 2/3) that beats direct fiber over 1000 km	39 s (best: 16 segments, 2 purification rounds)	qll/network/purified_chain.py
Useful Earth–Mars pairs per day, source in space at 384,000 km from Earth (beam waist 0.5 m, 4 m receiver, 1,000 modes)	6.0e+06 at closest, 1.8e+05 at farthest (F = 0.72); 2e-06 through an L4 relay's two downlinks	qll/systems/mars_budget.py
Secret key, measured on arrival (no memory), and the bank that spends it evenly	9.9e+06 bits/day at closest, 2.2e+05 at farthest, none for 3 weeks at conjunction; a 36.9 MB bank carries 10⁶ bits/day through every day (refused on 484 of 780 days without one)	qll/app/key_bank.py
Sunlit Earth behind a ground transmitter, seen from Mars (100 MHz per mode)	99.4 % of daytime heralds are noise; no dark-sky view of Mars on 333 of 780 days; from space, 96 % of heralds are signal even at full-phase Earth	qll/channels/planetshine.py
Purification 0.80 → 0.99	BBPSSW 10 rounds / 2917 pairs; DEJMPS 4 / 32	qll/network/purification.py
Rounds for a device-independent key at S = 0.95·2√2	2,535	qll/qkd/e91.py
Key buffer to message once a minute through a Mars round trip	1.43 kB	qll/app/messenger.py

Choose your path

Your goal	Start here	What you will get
Understand quantum communication	Learning guide and the interactive website	Explanations and controllable models
Run or modify the code	Simulation quickstart and qll/link/	Reproducible inputs, protocol outcomes, and tests
Build a practical experiment	Two-room plan (P10) and its evaluation specification	A staged procedure that must be safety-reviewed and calibrated before any hardware use
Evaluate the research	Physics overview, references, thesis draft, and the systems documents	Equations, assumptions, sources, and open questions

What is implemented?

Implemented is not the same as tested, tested is not the same as measured, and measured is not the same as secure under a stated threat model.

Component	Implemented	Tested	Measured	Security-reviewed
BB84 link pipeline: decoy states, Cascade reconciliation, privacy amplification, key accounting	Yes, simulation	Against closed-form models	No	No; finite-key length is a simplified estimate
Authentication and key lifecycle: OPEN/VERIFIED/FAILED channel, one-time key store, seeded simulation ledger or a secret byte pool	Yes	Sticky failure, sealed transcript, reuse, and atomicity tests	No	No
Two-site log workflow: strict per-site CSV parsing with SHA-256 provenance	Yes, offline analysis	Invalid-log regressions	Synthetic logs only, labelled synthetic	No
Classical transport: session-bound authenticated TCP (a lab construction)	Yes	Replay, reflection, timeout, and partial-frame tests on loopback	No	No; mutual TLS is the recommended replacement
Independent endpoints running the full protocol	No; both sites share one process	Not applicable	No	No
Browser labs and messenger	Local demonstrations; simulated key supply and simulated KEM secret	Headless Chromium tests	No	No
Two-room optics (P10)	Planning model and procedure; FPGA timing planned, not implemented	Model only	No; safety review BLOCKED	No
Earth–Mars, repeater, and memory studies	Analytic budgets	Against limiting cases	No	Not applicable

For the two-room experiment the paths are separate: fiber Ethernet carries only the classical channel; the initial P10 quantum path is free space, inside an enclosed path between the rooms. A bright-light polarization analogue is educational, not secure quantum key distribution (QKD).

How the link fits together

Site A                                         Site B
preparation / emission  -- quantum path -->    measurement / detection
        |                                              |
        +------- authenticated classical messages -----+
        |                                              |
        +-- parameter estimation and reconciliation ---+
        +-- verification and privacy amplification ----+
        |                                              |
 accepted key material                          accepted key material
        |                                              |
        +-------- application / key accounting --------+

This is a conceptual view. Each run labels which blocks are simulated, analyzed offline, or physically present: python -m qll.link.run session prints its execution mode, its execution identifier, and whether its authentication pool is a seeded simulation ledger. Authentication is required, and a low observed error rate alone does not prove that a finite key is secure.

Which memory reaches Mars?

This is the thesis question in one picture. A stored Bell pair decays toward the useless mixture while the two classical bits cross the Solar System; the bar is how long it stays useful. Hour-class trapped ions and rare-earth crystals clear Mars' farthest round trip, the rare-earth crystals only with a retrieval efficiency below 5 %. The lifetimes are the reported coherence times; the efficiencies are assumed operating points, not values measured together with those lifetimes, and a long spin coherence is not by itself a complete photonic memory. qll/network/memory_decoherence.py computes it and learn/03_quantum_communication explains it.

The website

Ten interactive pages and an installable lab with six builds, one menu and one design across all of them, all driven by the same tested numbers and tested themselves in headless Chromium on every push. Animations compress time and use illustrative quantities; a 3D reenactment is not a measurement record. The animations are recordings of the real pages (scripts/record_site.py); click one to open it. Every lab opens with a six-step picture of how the experiment works, shows where the photons go and where the decibels are lost, labels every part in 3D on request, and adds a plain-language note under every line of the math terminal.

Anywhere at light speed new The goal, made concrete: pick any two places on Earth, the Moon, or Mars and see the light-time floor, how close fiber, hollow-core fiber, a low-orbit laser mesh, and a geostationary relay come to it, a race of pulses you can pause and step, and how banked key brings a secure message down to one trip.	Two-room link lab new The main experiment as it would stand in the rooms, from the $40–120 starter to entangled photons: every part placed, priced, and tied to its build stage; sliders for the parts you will measure; a terminal printing every formula, substitution, and citation; and a session sampled in the browser that downloads as the two per-site logs the Python pipeline ingests.
Cloud circuits lab new The collapse code (P11), teleportation and superdense coding (P12), and Majorana parity teleportation (P13) as exact density matrices, checked against Qiskit Aer, with the desk, the cloud, and the processor in 3D and the commands that run each one on hardware.	Quantum channel lab new What the trip does to a qubit, drawn as the sphere of polarizations becoming an ellipsoid; a certificate from the BB84 error rates that no classical relay could match; what the channel can carry (bits, qubits, secret key); a tomography run whose log loads into the Python; teleportation as a channel; and superdense coding through the hallway at more than one bit per photon.
Outdoors and orbit lab new The link between two roofs, then two buildings at night, then a ground station tracking a Micius-class satellite: the beam spreading, pointing jitter, the air, and the sky's glow as a loss budget and a signal-to-noise chart, the key against distance for each receiver, and a pass you can play second by second.	Frontier lab new Teleportation across a distance, honestly timed: a free cloud-processor run with the two bits delayed, a swapping node that learns nothing, photonic teleportation between the rooms, and Earth to Mars with entanglement banked in memories, each drawn as a spacetime diagram in which nothing outruns the light time.
Messenger lab new A local demonstration of the application on every link: messages encrypted in the browser from a simulated link-key supply (a one-time pad with a Wegman–Carter tag, link-keyed AES-256-GCM, or a hybrid whose KEM secret is simulated), a key bank sized so it never refuses, a messenger that fails closed when it is empty, delivery shown only after an authenticated acknowledgment, and the light time on every message. Both endpoints run in one browser; do not enter sensitive information.	Mars link simulator Orbits, conjunction, L4/L5 relays, and which memories outlive today's round trip.
Link monitor Two synodic periods of light time and blackouts, and a fail-closed messenger that refuses to send when conjunction drains its key, until relays are switched on.	Teleportation, step by step Scroll through the protocol with the exact eight-amplitude state (checked against Qiskit to 10⁻¹²), the no-signalling average, and the bits in flight.
Interference lab A WebGL shader sums the two slit waves exactly; which-path information erases the fringes (protocol P06).	Repeater lab new One random run of a nested repeater chain: segments herald, stored pairs fade as they decay, swaps join them, failed swaps in red; beside it the average rate against direct fiber and the repeaterless bound, and the fidelity check that rate alone misses.
Coupler lab Park a tunable coupler where the always-on ZZ vanishes, watch the Ramsey fringes that measure it (E16), and play a simulated CZ gate reaching π with fidelity 0.99998.	QEC lab new A distance-5 surface code under bit flips: errors appear, parity checks light up, PyMatching pairs them, and the correction either saves the logical qubit or closes a string across the lattice. Every shot is decoded in the tested Python and re-checked by the page.
Earth–Mars link budget new A trillion pairs a second leave the Earth end; the stream narrows at every stage (87 dB of it at diffraction) as Mars recedes. See Earth as the Mars receiver does, at its true phase, and why sunlit ground swamps a transmitter on the ground. Pick the architecture, the memory, the telescopes, the filter, and the day, count the useful teleportations and secret bits that arrive, and size the key bank that carries a messenger through conjunction.	Traceability Needs, requirements, trades, and risks on a V model you can filter, each requirement pointing at the test that must pass in CI.

The argument in five equations

The same equations as LaTeX

$$\bar n(\omega,T)=\frac{1}{e^{\hbar\omega/k_BT}-1}\qquad\text{heat decides where each part of the link can live}$$

$$\eta_{\rm geo}=1-\exp\left(-\frac{2r_{\rm rx}^2}{w(L)^2}\right),\qquad w(L)=w_0\sqrt{1+(L/z_R)^2}\qquad\text{photons are lost as }1/L^2\text{ in space}$$

$$\tau=\frac{d(t)}{c}\qquad\text{the two classical bits of every teleportation arrive minutes later}$$

$$f(t)=\tfrac14+\left(f_0-\tfrac14\right)e^{-t/T_{\rm mem}},\qquad \bar F=\frac{2f+1}{3}>\frac23\qquad\text{so the memory must outlive }2d/c$$

$$K\le-\log_2(1-\eta)\qquad\text{and no repeaterless protocol beats this}$$

Each line is a module in qll/ with a test that checks it against its closed form; the full set, with figures, is in docs/physics_overview.md.

How the code fits together

Systems engineering

This is a systems-engineering thesis, and the repository is organized like a system. Five stakeholder needs (systems/needs.md) trace to the requirements in traceability_matrix.csv, each with a verification method and the named test that verifies it; python -m qll.systems.traceability fails if a test or test function is missing, and the requirements document (systems/requirements.md) is generated from the matrix. Five trade studies (systems/trade_studies.md) choose the architecture from tables the code regenerates on every commit, and the risk register, concept of operations, and technology-readiness assessment sit beside them. The traceability page puts it all on a V model you can filter.

The two-site key link (SEE 510 case study)

systems/see510/ takes flagship F1 down to a laboratory key link between Site A and Site B and simulates it end to end:

• BB84 states from an ideal single-photon source or an attenuated laser with decoy states, through a fiber of configurable length;
• detectors with finite efficiency and dark counts;
• two textbook adversaries: intercept-and-resend, and photon-number splitting on a laser source;
• Cascade error correction with hash verification, and privacy amplification;
• a classical channel authenticated with Wegman–Carter tags that fails closed and stays failed; in simulation a seeded ledger stands in for the authentication key, while a secret pool consumes real bytes and is replenished only from accepted key with recorded provenance;
• key delivery to an AES-256-GCM demonstration application through an ETSI GS QKD 014-style interface.

Twelve validation cases match closed-form models, and every run reproduces from its configuration and seed. A real-world ladder builds it in five tiers, from a $40–120 Arduino-and-polarizer analogue through fiber characterization and single-photon BB84 to entanglement-based BBM92. Each tier's log runs through the same protocol code with python -m qll.link.run ingest. Fifteen stakeholder needs trace to modules, tests, and evidence. python -m qll.link.run scenarios regenerates the evidence in about 45 seconds. A scripted operations day runs 96 sessions through drift, interception, a fiber bend, tampering, and a fiber cut; the operations console replays it, and shows the link failing closed during the cut.

The mission: from two rooms to orbit

systems/program/ turns the research into one phased plan, with gates, three-point costs, a critical-path schedule, a risk register, trade studies, and a path to a company:

1. Phase 1, two rooms (planning estimate: about $690 likely). A fiber classical channel between two rooms. Single-photon BB84 with decoys through an enclosed free-space path, using four silicon photomultipliers (P10), compared line by line with a planning model; blocked until a qualified safety review is recorded (evaluation specification). The collapse code on a free cloud processor (P11): a bound, to be measured, on whether the way a shared state collapses can carry a message (quantum mechanics says it carries none).
2. Phase 2, entanglement between the rooms. A borrowed source, a Bell test, an entanglement-based key, and superdense coding through the hallway: more than one bit per photon (E19).
3. Phase 3, outdoors and toward orbit. Free space between roofs and buildings, a ground station, and a satellite only with a partner. The outdoor lab shows what to expect: the SiPMs of P10 make no key outdoors, avalanche-diode modules reach about 2 km at night, daylight swamps a 405 nm receiver, and a Micius-class pass loses 26–39 dB (qll/link/outdoor_link.py, qll/link/satellite_pass.py).
4. Phase 4, the frontier. Entanglement-assisted communication: teleportation and superdense coding, each with its classical channel. The first step is free: teleportation on a cloud processor with the two bits delayed, whose fidelity follows the qubit's own T₁ and T₂ down through 2/3 after about 110 µs (E01). The frontier lab carries the same timing to a swapping node, the rooms, and Mars (qll/network/teleport_across.py).

The application. P15 spends the link's key on messages and measures how many a day each link can key and how big a key bank keeps the messenger from refusing (qll/link/keyed_messaging.py); the messenger lab does it live in the browser.

Quantum channels. The hallway already carries qubits, not just key bits. P14 certifies it as a quantum channel from the BB84 counts within a trusted qubit model (no classical relay could match them), maps it by process tomography with two $10 quarter-wave plates, and computes what it can carry; the same analysis shows that teleportation is a quantum channel only with its two classical bits (09).

Every experiment already in the repository is catalogued with the phase it feeds and what it takes to replicate it (02). The lab lists all of them and opens the ones with a build in 3D, from a starter to the real-world option (qll/systems/lab_scenes.py).

Three experiments, one physics

	F1 · two computers, one city	F2 · Earth ↔ satellite	F3 · Earth ↔ Mars
What	heralded entanglement and teleportation over 25 km of fiber	single-photon downlink from low orbit	the same protocol with a 6–45 min round trip
State of the art	done in the field (2024)	Micius 2017, Jinan-1 2025	done nowhere
Our version	P03 bench → campus fiber	Micius budget reproduced within 3 dB → rooftop link	delayed-bits bench, relay scheduling, fail-closed messenger
Plan	F1	F2	F3

F3 on a table: build it, stage by stage

Protocol P09 turns the Earth–Mars results into a bench you can build for a few hundred dollars: a lamp for the Sun, a matte white ball for Earth, a fiber tip for the transmitter, and a fiber collimator for the Mars receiver. Eight stages, from simulation only to photon counting, each with a prediction, a log format, and a pass criterion. A tested digital twin (qll/systems/bench_twin.py) predicts every reading with the same functions that evaluate the Mars link. python -m qll.analysis.bench_report synthetic and report run the whole analysis today on synthetic data; the bill of materials is tiered from $0 to photon counting.

What is inside

📚 Learn foundations, computing core, eight qubit platforms, communication; every file with equations, a figure, references, and exercises	🧪 Experiments three flagships, nine bench protocols, fifteen landmark experiments with cheap recreations, sixteen proposals, lessons	🔭 Research timeline, open problems, fifteen frontier theories, design process, thesis chapters
💻 qll/ tested physics from thermal occupation to a fail-closed Mars messenger, with Qiskit Aer, Stim, QuTiP, SeQUeNCe, and Perceval adapters	🎛️ Simulations eight scripts that predict what each bench must reproduce	🎓 Course 15 weeks, four machine-graded problem sets
📈 Data tested analysis pipelines waiting for the first ODMR (optically detected magnetic resonance) and T₁(T) measurements	🎬 YouTube verified English videos per topic	📖 References a bibliography that every code citation is checked against

Figures

Every figure is drawn by a function under test; python scripts/make_figures.py regenerates all of them.

More figures

Run a simulation

The supported environment is Python 3.12 in the pinned Conda environment, on Linux or Windows (CI runs both). From a checkout:

git clone https://github.com/Normansrule/quantum-link-research.git
cd quantum-link-research
conda env create -f environment.yml
conda activate qll
python scripts/check_env.py
python -m qll.link.run session

The session prints the configuration, the observed errors, the acceptance decision, and the modelled key accounting. A reproducible seed helps debugging; it is not a source of secret entropy.

python -m qll.link.run validate          # exits 1 if any validation check fails
python -m pytest -q -m "phase1 and not slow"
python -m pytest -q -m "not slow"        # the broad suite
python -m pytest -q -m browser           # headless Chromium: pip install playwright && python -m playwright install chromium

Locally, a missing optional tool (Node.js, Chromium, an optional simulator) skips its tests. In CI, each job lists what it requires in QLL_REQUIRE, and a skip for a required tool fails the job (tests/conftest.py).

Explore the labs

python -m http.server --bind 127.0.0.1 --directory docs 8000

Open http://127.0.0.1:8000. The site vendors its libraries and generated data, so it works offline. Animations compress time and use illustrative quantities; they are not experimental evidence.

Build the two-room experiment

Begin with the simulation and the classical transport, then a controlled polarization analogue, then detector and source characterization. Read P10 as a planning document: its build status is BLOCKED until a qualified review of the actual source, accessible emissions, and alignment is recorded in the evaluation specification. Never route an exposed beam through a hallway or other occupied space, and never treat a nominal attenuator setting as proof of safety.

Do not buy the whole hardware list before checking detector noise, timing, the optical-loss budget, available instruments, and a safe test arrangement. Record source type, calibration, uncertainty, instrument and firmware identifiers, and raw per-site logs, and label every result synthetic, analogue, or single-photon experimental data. A positive acceptance decision in the simulation does not promote a measured run to a secure implementation. The bill of materials and build order close this page.

Verification and evidence

CI runs · tests · requirements status · audit findings matrix · reference index

• Release gate. CI runs the tests on Linux and Windows and the browser suite in headless Chromium, uploads JUnit reports even on failure, and deploys the website only from a revision on which every required job passed. The deployed site carries ci_status.json, badges/tests.json, REVISION, and a MANIFEST.sha256 of its files.
• Requirements. python -m qll.systems.traceability --junit <report.xml> counts a requirement as proven only when its mapped tests ran and passed in that report. The counts in docs/status.md are an inventory, not a result.
• Numbers. Analytic expectations, simulated samples, and measurements are kept apart. Python and JavaScript share computed data, which keeps the displays consistent; that is a consistency check, not independent validation. Finite-key and device-independent estimates are heuristics unless a matching proof and its assumptions are stated, and a long spin coherence does not by itself make a capable photonic memory.

Phases

Phase	Deliverable	Must pass	Status
1	constants, channels, thermal model, QKD theory, explorers, library	analytic and integrity tests	done
2	Bell, teleportation, swapping, CHSH, fidelity, tomography, Kraus noise, no-cloning guard	$F_{\rm ideal}=1$; $F=(2f+1)/3$; $S=2\sqrt2$	done
3	atmosphere, turbulence, pointing, link budget; BB84/E91/decoy/MDI/TF/CV; sources, detectors, NV node	Micius within 3 dB; rates ≤ PLOB	done
4	memories, purification (BBPSSW, DEJMPS), repeaters, scheduling, routing	chain beats direct; $T_{\rm mem}$ vs $2d/c$	done
5	Kepler ephemeris, conjunction, relays, relativity, flown coolers, DSOC-class link	envelope within 1 %; L4/L5 > 99.9 % availability	done
6	ML-KEM + QKD hybrid, AES-GCM, fail-closed messenger, benchmark	never sends unkeyed	done
—	bench data (P01 ODMR, P02 T₁ vs temperature, P09 the Mars link on a table)	REQ-THM-003, REQ-CHN-003	waiting on hardware; P09's twin and analysis are tested

Map of the repository

qll/            tested physics: constants → channels → circuits → qkd → network → space → app, plus hardware, analysis, viz
simulations/    S01–S08: predictions for each bench            data/       measured CSVs + tested fit pipelines
learn/          settled physics, course, problem sets           experiments/ flagships, protocols, landmarks, proposals, lessons
research/       frontier theories, timeline, thesis             docs/       website, explorers, figures, bibliography, status
systems/        needs, requirements, traceability, risks, TRL   tests/      500+ tests, run on every commit

Built on the shoulders of

The website and these README images re-implement ideas from twelve open-source projects. No code was copied; CREDITS.md records exactly what each one contributed.

Project	What it inspired here
Magic UI	number tickers and bento grid (the numbers card above), AnimatedBeam (the stack diagram and the repeater lab's links), Marquee (the landmark strip)
react-bits	gradient text, blur-in reveals, and spotlight cards on the website; the rotating "shine" borders on the README cards
Animate UI · motion-primitives	staggered entrances and easing curves; restrained glass panels
llm-viz · transformer-explainer	step-through explainers that show the real internal state: the teleportation page, the coupler lab's CZ player, the repeater lab's sampled run, the QEC lab's decoding steps, and the memory-versus-round-trip chart
WebGL-Fluid-Simulation	a full-canvas fragment shader driven by the pointer: the interference lab
folio-2019	the landing page as a 3-D scene to explore: the three.js Solar System
gods-eye-view · worldmonitor	a live situation view and a dashboard of tiles, timelines, and an event feed: the hero's live strip, the link monitor, and the link budget
GSAP	used directly for scroll reveals, tickers, and explainer steps
Remotion	rendering the product itself into the README's motion, done here with Playwright frame capture; the link budget's flowing pair stream

Contributing and credits

Start from a stated problem or a failing test. Explain the assumptions, preserve raw evidence, and name any public claim the change affects. Six rules in CONTRIBUTING.md: physics correct · established libraries · every formula cited · every module tested · one idea per file · commit only green. Cite with CITATION.cff; credits in CREDITS.md. Session history is in docs/SESSION_LOG.md and decisions in research/thesis/DESIGN_PROCESS.md. The package is MIT licensed (LICENSE).

Build the main experiment: Phase 1

The main experiment is P10: single photons between two rooms. Weak 405 nm pulses at about half a photon each carry four polarizations through an enclosed free-space path between the rooms, decoy pulses guard against photon-number attacks, and four silicon photomultipliers read them in the other room. A separate fiber Ethernet link carries only the classical channel. The planning model predicts a click on 5.85 % of pulses, an error rate of 3.7 %, and about 12,000 test-key bits from each ten-second session; these are model outputs, not measurements, and the key would have no security review. The link lab shows every part in 3D at the price below.

Before building. P10 is a planning document, not a laser-safety authorization: its build status is BLOCKED until a qualified review of the actual source, accessible emissions, and alignment is recorded in the evaluation specification. The FPGA timing system is planned, not implemented. Do not buy the whole list before the detector noise, timing, loss budget, instruments, and a safe test arrangement are checked.

Bill of materials (planning prices, October 2026; verify before buying; instruments and contingency not included)

Item	For	Cost
Two laptops with Ethernet	the two sites	owned
Two fiber media converters and a 10–30 m duplex patch cord	classical channel (M1.1)	$40–150
Four 405 nm laser diodes (5 mW class) with a nanosecond pulse driver	the four BB84 states	$40–120
Film polarizers, a half-wave retarder, neutral-density filters (OD 1–4)	encoding and attenuation	$50–120
Four non-polarizing beamsplitters and two polarizing beamsplitters	combining and analysis	$100–250
Four onsemi MicroFC-30035 SiPMs, breakouts, a 30 V boost module, four fast comparators	detection	$230–350
Two small FPGA boards (planned; gateware not yet implemented)	timing	$30–80
A coaxial cable or second fiber for the pulse clock	synchronization	$10–30
3D-printed mounts, black tubes, lens pairs, black card, felt	mechanics	$30–80
Total		$530–1,180

Phase 1 budget by milestone (low, likely, and high, from qll/systems/program_plan.py). The milestones count what each step adds, including the $40–120 bright-light analogue that comes first and the open-access fee for the paper. The likely total is $690, and the high case stays within $1,400.

Milestone	What	Low	Likely	High
M1.1	Fiber classical channel between the rooms (media converters, patch cord, authenticated frames)	$40	$70	$150
M1.2	The collapse code on a cloud processor (P11) and paper 1	$0	$0	$0
M1.3	Tier 1 bright-light analogue across the rooms	$40	$80	$120
M1.4	Silicon photomultiplier receiver, characterized against its datasheet	$150	$250	$400
M1.5	Pulsed 405 nm source with decoy drive, mean photon number calibrated	$80	$150	$300
M1.6	Two-room single-photon BB84 with decoys (P10), matched to its twin	$60	$120	$250
M1.8	The hallway certified and mapped as a quantum channel (P14)	$10	$20	$30
M1.7	Paper 2: a twin-validated single-photon link for under $1,000	$0	$0	$150
Phase 1		$380	$690	$1,400

Build order. Each stage is checked against the planning model before the next one starts.

0. Simulate first. Predict the bench and write a synthetic run ($0).
1. Classical channel. Laptops, media converters, fiber through the door (M1.1).
2. Bright analogue across rooms. Tier 1 through the enclosed path between the rooms (M1.3); an analogue, not secure QKD.
3. Single-photon receiver. SiPMs, comparators, dark box; measure dark counts (M1.4).
4. Source. Four diodes, polarizers, combiners, filters to μ = 0.5 (M1.5).
5. Receiver optics. Passive basis choice, PBS arms, waveplate at 22.5°.
6. Sessions. Clock over coax, gated counting, logs, twin check (M1.6).
7. Eavesdropper. Optional intercept-resend station inside the enclosed path.

python -m qll.link.run session --config systems/see510/hardware/two_room.json         # predict and write a synthetic run ($0)
python -m qll.link.run ingest room_a.csv --bob room_b.csv --config systems/see510/hardware/two_room.json   # your real logs

Scale the Majorana research: from one hop to a chain

Crogman, Dang, and Erenso (2025) teleport a qubit between Majorana-encoded qubits using joint parity measurements alone. The repository emulates their protocol on a free cloud processor, then scales it from one hop to a chain of hops. Each hop is the same local Bell measurement wherever it sits in the chain, because the Jordan–Wigner strings of neighbouring modes cancel, and each hop needs its own two classical bits. The chain's fidelity falls as $F_N = \tfrac12(1 + k,s^N)$, and the paper's error budget turns a target chain length into a requirement on the device.

Step	What	Hardware	Cost	Status
1. P13 (M4.6)	The paper's protocol, one hop: two parity bits against one	3 qubits on a free cloud processor	$0	device-copy rehearsal: 0.835 with two bits, 0.641 with one; hardware run next
2. E20 (M4.8)	The same protocol along 1, 2, 3, … hops; fit the loss per hop	2N + 1 qubits in a line	$0	device-copy rehearsal: 0.837, 0.797, 0.796 for 1–3 hops; s ≈ 0.94, k ≈ 0.70, about 11 hops above 2/3; hardware run next
3. Device requirement	Readout and poisoning a chain of N hops needs	the error budget	$0	table below
4. Tetron devices	Four Majorana modes per qubit at fixed parity, with the CSUDH authors and a device group	a partner's dilution refrigerator	outside funding	research version of E18 and E20

What a Majorana chain needs. Assume a gap Δ/kT = 5, poisoning 0.001 per readout window, and L/ξ = 6. The table gives the smallest parity-readout signal-to-noise ratio μ₀/σ that keeps the chain above each fidelity:

Hops	Above 2/3	Above 0.9	Above 0.99
1	0.92	1.66	2.65
4	1.56	2.25	3.21
16	2.17	2.79	not reachable
64	2.71	3.42	not reachable
128	2.98	not reachable	not reachable

Where a cell says "not reachable", poisoning alone caps every hop and no readout can compensate. Scaling the protocol therefore asks first for longer quasiparticle-poisoning times, and only then for better readout.

python experiments/bench/frontier/run_frontier.py majorana --backend aer                      # one hop (P13)
python experiments/bench/frontier/run_frontier.py chain --backend aer --hops 1 2 3            # the chain (E20)
python experiments/bench/frontier/run_frontier.py chain --backend ibm_torino --layout 0 1 2 3 4 5 6 7 8 --hops 1 2 3 4