neural-photonic

Neural Photonic — verified optical compute units

Neural networks that emulate the operations of a hybrid photonic computer, built to the same exhaustive (N/N) verification discipline as NeuralVerified/neural-aarch64-units: every unit is a small neural net trained until it is bit-identical to a golden reference over its entire finite input domain.

Light does the linear algebra by interference; a neural CPU does everything passive light cannot (gain, bias, nonlinearity, integer readout).

v2 — hardware non-ideality, robustness & calibration

Exhaustive (N/N) verification proves the discrete, quantized logic exactly and fabrication-independently. Real analog photonic hardware is a regime that cannot be exhaustively verified, so correctness there becomes a bounded-error / yield claim. photonic/nonideal.py + robustness_demo.py model it:

process fidelity (thermal drift):  sigma=0.02 -> 0.997 (100% yield);  sigma=0.10 -> 0.93 (0% yield)
two-moons classifier:  99% on idealized HW  ->  61% on real (noisy) HW
noise-aware training:  recovers to 98% on real (noisy) HW
per-device calibration:  fabrication fidelity 0.90 -> 1.0000;  thermal floor 0.983

Non-idealities modeled: coupler split error + static phase offsets (fabrication), thermal phase drift, detector responsivity + saturation, ADC gain/offset/ quantization/noise. Calibration tunes each device's control phases against its fixed fab errors, recovering the deterministic loss to ~unity; thermal drift and ADC noise are the irreducible floor. Run python robustness_demo.py. The interactive version is in the companion Space (NeuralVerified/neural-photonic-hybrid, "Hardware reality" section).

Exact where it can be proven (digital); error-bounded where it can't (analog); deterministic error is calibratable, random drift is the floor.

Simulate vs. emulate — what these models are

• The physics is simulated: photonic/mzi.py, linear.py, and prism.py model how light actually behaves — complex fields (amplitude + phase), interference, Snell/Sellmeier dispersion. This produces the golden reference.
• The models are emulators: MZI2.pt and PD.pt are bit-exact functional replicas of quantized photonic operations — they reproduce the reference's output exactly (verified N/N), they do not re-derive the physics. This is the same sense in which a CPU emulator reproduces a datapath: exactly the framing of the companion neural-aarch64 units.
• The whole assembled pipeline running on a GPU simulates a photonic computer — it models one, it does not physically become one.

This repository packages the trained models (emulators) and the training + verification process. The interactive 3D demo lives in the companion Space.

---

The models

MZI2.pt and PD.pt are the two models trained here. ADC8.pt is reproduced from the author's neural-aarch64-units so the end-to-end hybrid is runnable in one place; all credit for it is there.

---

What the compute looks like

Forward light-transport renders of optical energy moving through the mesh — produced by step6_demo.py (photonic/visualize.py), visualization only and firewalled from the compute path.

Energy of a single injected beam as it propagates through the interferometer mesh. Each column is a mesh layer (light flows left→right), each row a waveguide mode; brightness is optical intensity. One input mode fans out across many — this spreading is interference performing a matrix multiply, the thing ray optics cannot represent.

The same forward-transport view for the optical core inside the trained hybrid network — the light path that feeds the neural photodetector and, in turn, the neural-CPU readout.

---

Why this exists — the idea

Photonic computing performs a matrix multiply with light: a mesh of Mach-Zehnder interferometers (MZIs) makes beams interfere, and the interference is the arithmetic. The catch is that the computation lives in the phase and amplitude of a coherent field — something geometric ray optics cannot represent. So the core of this project is an honest, complex-valued (wave-optics) model of an MZI mesh, then a path to make it verifiable the way a digital datapath is.

The bridge from "continuous physics" to "verifiable unit" is quantization: discretize the phase/amplitude controls to a finite grid, and the input domain becomes finite and enumerable — the precondition for exhaustive N/N verification.

---

How the units were built (the 6-step process)

Each step ships as a runnable script with its own acceptance tests.

The photodetector unit was added afterwards:

bench.py measures speed (see below). photonic/prism.py is the forward spectral ray-trace used for the dispersion visual.

Reproduce

pip install torch numpy
python step1_demo.py          # ... through step6_demo.py
python step4_train_verify.py  # retrains + verifies MZI2.pt  (256/256)
python train_detector.py      # retrains + verifies PD.pt    (1024/1024)
python bench.py               # speed: sim vs frozen-deploy vs projection

---

Using the models

import torch
from photonic.unit import NeuralPhotonicMZI, bits_of
from photonic.detector import NeuralPhotodetector

mzi = NeuralPhotonicMZI(); mzi.load_state_dict(torch.load("MZI2.pt")["state_dict"]); mzi.eval()
pd  = NeuralPhotodetector(); pd.load_state_dict(torch.load("PD.pt")["state_dict"]); pd.eval()

# MZI2: phase indices (theta=3, phi=10) -> quantized 2x2 interferometer matrix
block = mzi.forward_int(bits_of(3, 10).unsqueeze(0))       # int8 components

# PD: detect a complex field vector -> intensity bytes (learned |.|^2)
field = torch.tensor([0.7+0.2j, 0.1-0.3j], dtype=torch.complex64)
bytes_out = pd.detect(field)

The hybrid pipeline (MZI2 → PD → ADC8) is assembled in photonic/hybrid.py and demonstrated end-to-end in step5_demo.py.

---

Speed — what's real

bench.py, measured on CUDA:

• This is a simulation on a GPU — simulating interference is more work than the matmul it produces, so the sim can never be faster than digital. The "sim" column is that overhead (3,400×–22,000× depending on N).
• Once trained, freeze the mesh to its matrix and it runs at full GPU matmul speed — identical to digital (column ②). This is the shippable path.
• Projected hardware (a model, not measured): a 64×64 MZI mesh does all N² MACs in one optical pass — ~179 ps latency, ~205 T-MAC/s, energy scaling with O(N) modulators rather than O(N²) MACs. The real speedup exists only on silicon photonics.

---

Honesty (the recurring theme)

This project is deliberately built so a nice-looking result can never stand in for a correct one:

• Interference is the compute — modeled with complex fields (phase + amplitude), which ray optics cannot represent.
• Passive light only attenuates — any gain > 1 comes from the electronic half (the neural CPU), never from passive optics. Enforced in Steps 3/5.
• The metric measures the invariant — unitarity caught a bug in Step 1; the N/N curve caught training drift in Step 4; the firewall keeps Step 6's render from ever feeding back into a result.
• Analog ≠ exact — the optical core is analog; N/N verification is only possible after quantization. MZI2 and PD are verified on their quantized, finite domains, at finite resolution (4-bit phases, 5-bit field components).

---

Files

MZI2.pt, PD.pt            trained + verified models
cpu_units/ADC8.pt         adder from neural-aarch64-units (for the hybrid)
photonic/                 mzi, linear, quantize, unit, detector,
                          hybrid, cpu_bridge, visualize, prism
step1..6_demo.py          the build, with acceptance tests
step4_train_verify.py     train + verify MZI2   (256/256)
train_detector.py         train + verify PD     (1024/1024)
bench.py                  speed benchmark
core_energy.svg           forward-transport render: energy per mode/layer
hybrid_core_energy.svg    same, for the hybrid net's optical core

The two SVGs are produced by step6_demo.py (photonic/visualize.py) — a forward light-transport render of optical energy flowing through the mesh, layer by layer. They are visualization only, firewalled from the compute path.

Companion Space: NeuralVerified/neural-photonic-hybrid — live 3D visualization of light → detector → CPU → output. Related: neural-aarch64-units, neural-raytracing.

---

Citation

@misc{byrne2026neuralphotonic,
  title        = {Neural Photonic: Verified Optical Compute Units},
  author       = {Byrne, Dean (Quazim0t0)},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/NeuralVerified/neural-photonic}},
  note         = {Neural networks that emulate photonic-computer operations, exhaustively (N/N) verified}
}

Dean Byrne (Quazim0t0) · 2026

---

<!-- neuralverified-relocation-note -->

Now hosted by NeuralVerified.

This repo was moved into the NeuralVerified organization to help organize my profile. Originally published at Quazim0t0/neural-photonic.