Photonic Matrix Computing

6.1 Phase Shifter Quantization and Finite Resolution

Phase shifters in photonic meshes are rarely continuous. They are driven by a control voltage or current that maps to a discrete set of phase values, and the phase response is also limited by finite resolution and nonlinearity. In matrix computing, this matters because the mesh implements a target linear transform only when the programmed phases match the required interference conditions closely.

From Ideal Phase Control to Discrete Settings

Start with the ideal model: a phase shifter applies a phase ϕ, so the transfer factor is \(e^{j\phi}\). In a real device, you program an index k, and the hardware produces a phase \(\phi_k\) that is quantized and imperfect. A simple quantization model assumes \(\phi_k = \phi_0 + k\Delta\phi\), where \(\Delta\phi\) is the step size. If the desired phase is \(\phi\), the implemented phase error is \(\epsilon = \phi_k - \phi\), bounded by \(|\epsilon| \le \Delta\phi/2\).

A useful rule of thumb comes from interference. Many mesh elements rely on constructive or destructive interference, where small phase errors turn perfect cancellation into partial leakage. For two paths with equal amplitudes, the output intensity scales like \(I \propto |1 + e^{j(\theta+\epsilon)}|^2\). Near destructive interference, where \(\theta \approx \pi\), the residual intensity grows roughly with \(\epsilon^2\). That quadratic behavior is why even modest phase resolution can be acceptable in some regimes, but not in others.

Quantization Error Propagation Through a Mesh

A mesh contains many phase shifters, and errors compound in a structured way. Each element contributes a small complex error factor \(e^{j(\phi+\epsilon)} = e^{j\phi}(1 + j\epsilon + O(\epsilon^2))\). When you multiply many such factors, the first-order terms can add coherently for some signal paths and incoherently for others. The practical takeaway is that quantization error is not just “more noise”; it changes the implemented matrix entries in a way that can bias certain rows or columns.

To keep this grounded, consider a 2×2 rotation-like block. If the target unitary requires a phase difference of π/2, but your phase shifter has only 8 levels across 2π (\(\Delta\phi=\pi/4\)), you can be off by up to \(\pi/8\). That turns a clean quadrature split into an imbalance that shows up as gain error in one output and leakage in the other.

Finite Resolution Meets Calibration Reality

Quantization is only half the story. Finite resolution also interacts with calibration. Calibration often estimates a mapping from desired phase to control code, but the mapping can be nonlinear and temperature dependent. If you calibrate using a limited set of points, the residual error after quantization is the sum of two components: (1) discretization error from rounding to the nearest code and (2) model mismatch from imperfect phase-code characterization.

A practical best practice is to calibrate with a phase grid fine enough that the quantization step dominates, not the calibration model. If your phase shifter has 6-bit control, the step is already small; spending effort on a coarse calibration grid can waste accuracy because the rounding error will still be driven by the coarse model.

Worked Example with a Quantized Phase Shifter

Assume a phase shifter with 5-bit resolution over 2π, so \(\Delta\phi = 2\pi/32 = \pi/16\). The worst-case phase error is \(|\epsilon| \le \pi/32\). For a destructive interference condition, residual intensity relative to the ideal zero can be approximated as \(I_{res}/I_{max} \approx \sin^2(\epsilon) \approx \epsilon^2\). Numerically, \(\epsilon \approx 0.098\) rad, so \(\epsilon^2 \approx 0.0096\). That means about 1% of the maximum intensity leaks through in the worst case for that interference event.

In a larger mesh, not every element sits at a destructive condition simultaneously, so the effective leakage varies by signal path. Still, this calculation gives a concrete way to connect phase resolution to matrix error magnitude.

Best Practices for Using Quantized Phases

1. Round with intent, not habit. When converting desired phases to control codes, use a consistent rounding rule and keep the phase reference aligned across the mesh. Inconsistent references can turn a small quantization error into a systematic bias.

2. Prefer phase targets that avoid repeated destructive alignment. If your mapping algorithm has freedom (for example, choosing among equivalent decompositions), select a solution that reduces the number of elements that must sit near cancellation for typical inputs.

3. Validate with matrix-level metrics. Instead of only checking phase response curves, measure the implemented transform for representative inputs and compute entrywise or operator-level error. Quantization effects are easiest to see at the matrix output.

4. Use calibration grids that match the resolution. If the phase shifter has step \(\Delta\phi\), calibrate with a phase grid significantly finer than \(\Delta\phi\) so that discretization dominates and the calibration model does not become the bottleneck.

These steps connect the physics of interference to the engineering reality of discrete control, so the mesh behaves predictably when you program it to realize a neural multiplication matrix.

6.2 Crosstalk, Scattering, and Unwanted Coupling Paths

Crosstalk in photonic matrix computing is the gap between what the circuit is supposed to do and what it actually does when light takes extra routes. In waveguide meshes, those extra routes usually come from three sources: unintended coupling between nearby paths, scattering inside components, and parasitic reflections that bounce signals back into the network. The key idea is simple: any optical energy that reaches the wrong output port behaves like an additional term in the implemented matrix, mixing channels that should be independent.

What Crosstalk Means in Matrix Terms

Think of an ideal linear layer as a matrix multiplication y = A x. With crosstalk, the hardware implements y = (A + ΔA) x, where ΔA collects all unwanted couplings. If channel i’s input leaks into channel j’s output, then ΔA[j, i] is nonzero. A practical way to reason about impact is to separate two effects: (1) off-diagonal leakage that mixes features, and (2) diagonal distortion that changes effective gain.

A quick example: suppose you target a 4×4 transform where each input should mostly affect one output. If 1% of each channel leaks into its neighbor, then each output contains a small weighted sum of the wrong inputs. Even if 1% sounds small, repeated layers can accumulate mixing and shift activations.

Unwanted Coupling Paths in Waveguide Layouts

Unwanted coupling happens when two optical modes overlap more than intended. In practice, this can occur through:

• Proximity coupling: two waveguides are close enough that evanescent fields exchange power.
• Layout discontinuities: bends, tapers, and crossings change mode profiles and increase overlap.
• Imperfect isolation: routing that assumes isolation but uses the same substrate or cladding conditions.

A concrete example: in a mesh, adjacent arms may be separated by a nominal gap. If fabrication shrinks the gap by a few tens of nanometers, coupling can rise sharply because evanescent overlap depends strongly on separation. The result is a systematic off-diagonal pattern in ΔA, not random noise.

Scattering Inside Components

Scattering is light redirected by microscopic imperfections: sidewall roughness, material inhomogeneity, and defects in couplers. Scattering can be modeled as loss plus a redistribution term. Some scattered light leaves the guided mode entirely (reducing signal), while some remains guided but changes direction or mode order (creating crosstalk).

A useful mental model: scattering turns a clean mode into a mixture of modes. If the “wrong” mode couples into neighboring paths, you get channel mixing even when the layout is geometrically correct.

Example: a directional coupler designed for a specific splitting ratio may also scatter a small fraction into adjacent waveguides. That fraction appears as a bias in the effective splitting matrix, often with wavelength dependence.

Parasitic Reflections and Back-Propagation

Reflections occur at interfaces, imperfect terminations, and discontinuities. Reflected light can re-enter the mesh, interfere with forward signals, and create oscillatory errors that depend on phase.

A practical example: if a facet reflection sends a small portion of light back into the input region, it can interfere with the next time step or with other paths sharing the same optical phase reference. Even when the reflected power is tiny, interference can make the error non-uniform across outputs.

How Crosstalk Shows Up During Measurement

You can detect crosstalk by exciting one input channel at a time and measuring all outputs. In an ideal system, the response vector has energy concentrated in the intended output(s). With crosstalk, the measured response spreads.

A simple procedure:

1. Set all programmable elements to a known state.
2. Inject a calibrated tone into input i only.
3. Record output powers Pj.
4. Compute leakage ratios Lji = Pj / Σk Pk.

If Lji is consistently larger for certain j near i, the dominant cause is likely proximity coupling. If leakage varies strongly with wavelength or polarization, scattering or mode mismatch is more likely. If leakage shows phase-sensitive oscillations, reflections and interference are suspects.

Mitigation Practices That Actually Map to Physics

Mitigation should target the underlying mechanism rather than just “reduce error.”

• Increase isolation where proximity coupling dominates: adjust waveguide spacing, use better cladding control, and avoid unnecessary parallel runs.
• Improve sidewall and material quality: tighter fabrication tolerances reduce scattering strength and mode mixing.
• Reduce reflections: use angled facets, better termination, and index-matched interfaces so back-propagating light is minimized.
• Use calibration-aware operation: treat the measured transfer matrix as the truth for inference, so ΔA is included in the effective model.

Example: if measurement shows a repeating off-diagonal leakage pattern, you can incorporate it into the calibration matrix rather than trying to “average it out.” Then the network learns or is configured to tolerate the specific mixing structure.

Worked Example: Interpreting a Measured Leakage Pattern

Suppose you inject into input 2 of a 6-channel row and measure normalized output powers:

• Output 2: 0.94
• Output 1 and 3: 0.03 each
• Outputs 0, 4, 5: 0.00–0.005

This concentrated neighbor leakage suggests proximity coupling between adjacent arms, not broad scattering. If you then repeat at two wavelengths and see the neighbor leakage ratio change noticeably, scattering or wavelength-dependent mode overlap is also contributing. If you observe strong dependence on phase settings even when wavelength is fixed, reflections and interference likely play a role.

The practical takeaway is that crosstalk is not a single villain; it is a set of identifiable pathways. Once you map the pattern to the mechanism, you can choose mitigation and calibration steps that match the physics instead of guessing.

6.3 Loss Mechanisms in Waveguides and Couplers

Loss is the quiet tax that turns “ideal matrix multiplication” into “real matrix multiplication.” In photonic meshes, loss matters twice: it reduces optical power before detection, and it changes the effective transfer matrix because different paths lose different amounts.

Core Loss Types in Waveguides

Propagation loss is the attenuation per unit length from absorption and scattering. A simple rule of thumb is exponential decay: if a waveguide has loss coefficient \(\alpha\) (in dB/cm), then power after length \(L\) is reduced by \(\alpha L\) in dB. Example: a 2 cm path with 2 dB/cm loss loses 4 dB, meaning only 40% of the power remains.

Sidewall and surface scattering often dominates in fabricated chips. Roughness at the etched boundary scatters light into radiation modes, which never reach the detectors. This loss scales with wavelength and with how aggressively the waveguide is etched.

Material absorption includes absorption in the core and cladding. Even if the absorption is small, long paths in meshes add up quickly.

Bend loss appears when waveguides curve. Tight bends leak light into the cladding. In meshes, routing constraints can create many bends, so bend loss can become a nontrivial fraction of total loss.

Coupler Loss and Splitting Imperfections

Directional coupler excess loss includes imperfect coupling and fabrication-induced mismatch. Even when the intended split ratio is 50/50, the actual ratio might be 48/52, and some power may be lost to radiation.

Insertion loss in interferometer arms comes from components like multimode interference couplers and beam splitters. Each component adds loss, and meshes contain many components, so the total insertion loss is roughly the sum of per-component losses in dB.

Polarization dependence can create effective loss differences between TE and TM modes. If the input polarization drifts, the “same” matrix setting can yield different detected outputs.

How Loss Distorts the Effective Matrix

A photonic mesh ideally implements a linear transform \(\mathbf{y}=\mathbf{W}\mathbf{x}\). With loss, each internal path has a different attenuation factor, so the implemented transform becomes \(\mathbf{y}=\mathbf{D}*\text{out}\mathbf{W}*\text{eff}\mathbf{D}*\text{in}\mathbf{x}\), where \(\mathbf{D}*\text{in}\) and \(\mathbf{D}_\text{out}\) represent input and output attenuation. Practically, this means:

• Row and column gains become uneven, even if phase settings are correct.
• Calibration that assumes uniform loss can leave systematic bias.
• Noise performance changes because shot noise depends on detected power.

A concrete example: suppose two paths contribute to the same output. If one path has 3 dB more loss, it contributes half the power compared to the other, so interference contrast drops and the effective weight magnitude shrinks.

Worked Example: Estimating Total Loss in a Small Mesh

Consider a simplified 4×4 mesh where each signal path traverses 6 waveguide segments of 1 cm each and 5 coupler/beam splitter components. Assume waveguide propagation loss is 1.5 dB/cm and each component insertion loss is 0.3 dB.

• Waveguide loss: \(6 \times 1.5 = 9\) dB
• Component loss: \(5 \times 0.3 = 1.5\) dB
• Total loss: \(10.5\) dB

A 10.5 dB loss corresponds to about 8.9% power remaining. If you were counting on a certain detected power to keep shot noise low, this loss directly forces you to raise input power or accept reduced accuracy.

Practical Best Practices for Managing Loss

1. Budget loss by path length and component count. Use dB arithmetic early so you know whether detection power will be sufficient.
2. Prefer straighter routing where possible. Fewer bends usually means less bend loss and more predictable calibration.
3. Treat coupler loss as part of the model. When calibrating, measure enough operating points to capture gain nonuniformity, not just phase.
4. Control polarization at the interface. Even if the chip is polarization-tolerant, the input coupling can dominate effective loss.

Loss is not just “less light.” In a matrix machine, it changes how strongly each internal path participates in interference, so it quietly reshapes the computation you thought you programmed.

6.4 Detector Noise and Shot Noise in Photonic Readout

Photonic matrix computing often turns an optical field into an electrical number by measuring light intensity. That measurement is never perfectly repeatable: the detector adds noise, and the light itself arrives in discrete quanta. Two effects dominate in many regimes: shot noise from the quantized arrival of photons, and detector noise from the electronics and device physics.

From Photon Arrivals to Shot Noise

Consider a photodetector receiving an average optical power (P) at wavelength \(\lambda\). The detector converts optical power to an average photocurrent \(\bar{i}\) through responsivity \(R\) (A/W):

\[ \bar{i} = R P. \]

If photons arrive independently, the number of detected photoelectrons in an integration time \(T\) follows a Poisson process. For a Poisson count, the variance equals the mean, which produces a current variance. A standard result is the shot-noise current spectral density:

\[ S_{i,shot} = 2 q \bar{i} \quad (A^2/Hz). \]

Over bandwidth \(B\) (or equivalently an integration time), the shot-noise variance scales with \(\bar{i}\). Practical takeaway: doubling optical power increases signal linearly but shot noise increases only with the square root, so signal-to-noise improves as \(\sqrt{P}\) until other noise sources take over.

Example: Suppose \(\bar{i}=10,\mu A\) and the effective noise bandwidth is \(B=10,kHz\). Then the shot-noise RMS current is \(\sqrt{2 q \bar{i} B}\). You can treat this as the “floor” you cannot remove by better electronics; only increasing \(\bar{i}\) or changing the measurement strategy reduces it.

Detector Noise Sources Beyond Shot Noise

Real detectors add additional noise terms that do not scale with photocurrent in the same way. Common contributors include:

• Dark current shot noise: Even with no light, a detector has a baseline current \(i_d\). Its shot noise adds to the total.
• Thermal noise: Resistors and front-end electronics generate noise roughly independent of optical power.
• Amplifier noise and readout noise: Noise from transimpedance amplifiers, ADC quantization, and clocked sampling.

A useful modeling approach is to treat total noise power as the sum of independent variances. In current terms, a simplified expression is:

\[ \sigma_i^2 \approx 2 q (\bar{i}+i_d)B + \sigma_{th}^2 + \sigma_{amp}^2 + \sigma_{ADC}^2. \]

This is not a universal law, but it is a good engineering first pass because it keeps the scaling behavior clear.

How Noise Maps into Matrix-Compute Error

In a photonic multiply, each output corresponds to a weighted sum of inputs. If the detector measures intensity \(I\) with noise \(\sigma_I\), then the inferred electrical value has uncertainty. When you later apply scaling, normalization, or quantization, the noise can become a bias or a decision error.

A practical rule is to compare noise to the smallest meaningful step in your pipeline. If your system quantizes outputs to \(N\) levels, then the quantization step \(\Delta\) sets a tolerance: when \(\sigma\) is much smaller than \(\Delta\), noise mainly adds harmless jitter; when \(\sigma\) approaches \(\Delta\), it causes frequent sign flips or wrong bin assignments.

Example: If an output is expected to be near zero and you use a threshold to decide whether a neuron is active, then shot noise can directly flip the decision. In contrast, if you use analog values and later apply a smooth nonlinearity, the same noise typically perturbs the value rather than causing a hard error.

Bandwidth, Integration Time, and the Noise Trade

Noise depends on the effective bandwidth. Shorter integration times reduce latency but increase noise variance because fewer photons are collected. Longer integration improves SNR but may conflict with modulation speed or drift.

A concrete way to reason is to connect integration time \(T\) to an equivalent bandwidth \(B\) (often on the order of \(1/(2T)\) depending on filtering). Then shot noise scales with \(\sqrt{\bar{i}B}\), so increasing \(T\) reduces noise roughly as \(1/\sqrt{T}\) for shot-noise-limited detection.

Example: If you halve the integration time, you collect about half the photons, so shot-noise RMS increases by \(\sqrt{2}\). If your detector is already electronics-noise-limited, the improvement may be smaller.

Mind Map of Detector Noise in Photonic Readout

Worked Example with a Noise Budget

Assume an output channel has \(\bar{i}=20,\mu A\), dark current \(i_d=1,\mu A\), and effective bandwidth \(B=5,kHz\). The shot-noise variance is \(2 q (\bar{i}+i_d)B\). If your measured electronics noise RMS current is \(\sigma_{elec}=0.5,\mu A\), then total RMS noise is \(\sqrt{\sigma_{shot}^2+\sigma_{elec}^2}\).

From this, you can compute whether the system is shot-noise-limited or electronics-limited. If shot noise dominates, increasing optical power helps most. If electronics noise dominates, you gain more by improving front-end gain, reducing bandwidth, or optimizing filtering and sampling.

Best Practices for Stable Readout

• Use a noise budget per channel: Estimate shot noise and electronics noise separately so you know which knob matters.
• Match integration time to bandwidth needs: Choose \(T\) so noise is acceptable without violating timing constraints.
• Avoid operating too close to zero when decisions are discrete: Thresholding is fragile under shot noise.
• Calibrate responsivity and dark current: Responsivity errors scale the signal, while dark current errors add a noise floor.

These practices keep detector noise from silently turning a clean optical interference result into a noisy numerical output.

6.5 Practical Mitigation Techniques for Reliable Computation

Reliable photonic matrix multiplication is mostly about managing three things: how accurately the circuit implements the intended linear transform, how consistently the optical signals are measured, and how the system behaves when it drifts. The goal is not perfect optics; it’s predictable computation.

Start with a Measurement-First Error Model

Before choosing mitigation, define what “wrong” means. A practical approach is to treat the implemented transform as the target plus structured error:

• Transform error: the effective matrix differs from the programmed one.
• Readout error: detection noise, offsets, and gain mismatch distort outputs.
• Drift error: parameters change between calibration and inference.

Example: Suppose you program a 4×4 mesh to realize a known matrix. You measure the response to a set of basis inputs (one-hot vectors). If the measured outputs are consistently scaled or phase-shifted, you can correct with gain/offset and calibration updates. If the errors vary strongly by input, you likely have crosstalk or nonideal splitting.

Use Calibration That Matches the Failure Mode

Calibration is effective when it targets the dominant error source.

• Phase alignment calibration corrects systematic phase offsets in interferometers.
• Amplitude calibration corrects uneven coupling and loss differences across paths.
• Transfer-matrix estimation captures the combined effect of multiple imperfections.

Best practice: Calibrate with the same encoding and detection scheme used in inference. If you calibrate using intensity-only tests but infer with complex-field encoding, you’ll “fix” the wrong thing.

Example: If your weight encoding uses phase shifters to set interference, measure a small subset of basis inputs across the mesh and fit a per-path phase correction. Then verify on held-out inputs rather than assuming the fit generalizes.

Add Closed-Loop Tuning for Drift Without Overcorrecting

Drift is usually slow enough to track, but fast enough to matter. Closed-loop tuning should be lightweight and stable.

• Pick a small set of pilot signals that are easy to inject and measure.
• Update only the parameters that most affect the pilot outputs.
• Use conservative step sizes to avoid chasing noise.

Example: Every inference block, inject two pilot patterns that probe the most sensitive interferometers. If the measured pilot outputs deviate beyond a threshold, adjust the corresponding phase shifters. Keep the update frequency tied to observed drift, not a fixed schedule.

Mitigate Crosstalk with Layout-Aware and Signal-Aware Controls

Crosstalk can be reduced by design, but you can also manage it in computation.

• Design-side: reduce unwanted coupling paths using spacing and isolation structures.
• Signal-side: choose input patterns that limit simultaneous excitation of sensitive paths.
• Algorithm-side: incorporate measured crosstalk into the effective matrix used for inference.

Example: If adjacent waveguides leak into each other, one-hot basis measurements will show “ghost” outputs. Build an effective matrix from those measurements and use it during inference so the system compensates for the ghost terms.

Improve Readout Reliability with Gain, Offset, and Noise Handling

Detection errors often dominate when optical power is low.

• Offset subtraction: measure dark frames to remove detector bias.
• Gain normalization: calibrate detector responsivity so outputs are comparable across channels.
• Noise-aware averaging: average repeated measurements when latency allows.

Example: If channel 3 consistently reads 2% higher than others under identical optical input, normalize by a per-channel gain factor. Then confirm that the normalization does not amplify noise by checking variance at low signal levels.

Constrain the Computation to What the Hardware Can Do Consistently

Even with mitigation, some matrices are harder to realize accurately than others.

• Prefer weight representations that avoid extreme phase requirements.
• Use quantization-aware training so the learned weights match the control resolution.
• Apply output scaling so detection stays within a stable dynamic range.

Example: If phase shifters have limited resolution, train with that quantization in the loop. The resulting weights will “fit” the hardware’s stepwise control, reducing systematic mismatch.

Worked Mini-Workflow for a Reliable Layer

1. Measure a small basis set using the same encoding as inference.
2. Estimate an effective matrix that includes crosstalk and amplitude imbalance.
3. Calibrate detector offsets and gains using dark and reference frames.
4. Run inference using the effective matrix and apply output scaling.
5. Insert pilot checks and update only the most sensitive parameters when drift exceeds a threshold.

Example: For a 4×4 layer, basis measurements might require 8–16 patterns depending on symmetry. After building the effective matrix, verify on 4 held-out inputs. If held-out error is stable across time windows, drift mitigation is working; if it degrades quickly, tighten pilot frequency or reduce update aggressiveness.

7.1 Defining Energy per Multiply Accumulate for Photonics

Energy per Multiply Accumulate (MAC) is the unit that lets you compare a photonic matrix engine to a digital baseline without arguing about “speed” in the abstract. For photonics, the tricky part is that a single MAC is not always a single optical event; it is a contribution to an output element produced by interference, propagation loss, detection, and control overhead. A practical definition must therefore separate (1) optical work that scales with the number of MACs and (2) system work that scales with how you operate the chip.

Step 1: Start from the mathematical MAC

A dense layer computes Y = W·X, where each output element y[m] is a sum of products y[m] = Σₙ w[m,n]·x[n]. A “multiply accumulate” corresponds to one term w[m,n]·x[n] contributing to one y[m]. If you implement a block of size M×N, the block contains M·N MACs.

Step 2: Define the Photonic Operation Window

Photonic matrix multiplication is performed by launching optical signals, letting them interfere through a waveguide mesh, and then detecting outputs. Define an operation window with duration T (set by modulation bandwidth, detector integration time, and synchronization). During that window, the chip consumes:

• Optical energy delivered into the photonic input ports.
• Electrical energy for modulating inputs and for setting phase shifters or other programmable elements.
• Electrical energy for detection and readout.

Step 3: Separate Energy That Scales with MAC Count

A clean energy model uses two terms:

1. Per-MAC optical energy: energy that must be present for each MAC contribution.
2. Per-window overhead energy: energy that happens once per operation window, regardless of how many MACs are in that window.

A common way to express this is:

E_MAC = (E_opt + E_ctrl + E_det) / (M·N)

where each E_* is the energy consumed for the M×N block during one operation window.

Step 4: Compute Optical Energy from Launched Power

Optical energy is the easiest to measure and the most directly tied to signal-to-noise. If the total launched optical power into the relevant input ports is P_in and the operation window is T, then:

E_opt = P_in · T

In practice, P_in is chosen to meet a target detection quality. If you scale the matrix size while keeping the same encoding and detection scheme, P_in typically stays tied to the required output signal level, not to M·N directly. That is why dividing by M·N matters: larger blocks amortize the same optical energy across more MACs.

Step 5: Include Control Energy Without Double Counting

Phase shifters and modulators consume electrical energy in two ways:

• Dynamic energy when settings change between windows.
• Static energy if the device draws current continuously.

To avoid double counting, define E_ctrl for one window as the energy actually consumed during that window for the required reconfiguration. If phase settings remain constant across multiple windows, then E_ctrl should be amortized across those windows before dividing by M·N.

Step 6: Model Detection Energy as a Function of Required SNR

Detection energy includes photodiode biasing, transimpedance amplifier operation, and any ADC or readout energy. A useful simplification is to treat E_det as proportional to the number of detected output channels and the integration time:

E_det ≈ (N_out · E_ch) + (N_ADC · E_ADC)

where N_out is the number of output elements produced in the block (often M), and E_ch is the energy per detected channel per window.

Step 7: Work Through a Concrete Example

Suppose a photonic tile computes a block with M=64 outputs and N=64 inputs, so there are 4096 MACs.

• Operation window: T = 10 ns
• Total launched optical power: P_in = 20 mW
• Control energy per window: E_ctrl = 0.5 µJ
• Detection energy per window: E_det = 0.2 µJ

Then:

• E_opt = 0.02 W · 10e-9 s = 2e-10 J = 0.2 nJ
• Total energy per window: E_total = 0.2 nJ + 0.5 µJ + 0.2 µJ ≈ 0.7 µJ
• Energy per MAC: E_MAC = 0.7e-6 J / 4096 ≈ 171 pJ per MAC

Notice the optical term is tiny compared to control and detection here. That outcome is common when phase setting dominates energy, even if optics is efficient. The definition still holds; it just tells you where the energy is really going.

Step 8: Mind the Encoding and Normalization

Energy per MAC depends on how you map numbers to optical signals. If your encoding requires higher optical power to represent the same dynamic range, P_in rises and E_opt rises. If your detection uses more averaging (longer T) to reduce noise, E_det and sometimes E_ctrl rise too. The MAC definition stays the same, but the measured E_* changes with the encoding and detection model.

Step 9: A Checklist for Consistent Measurement

To keep E_MAC comparable across designs, record for each reported number: M, N, T, P_in (or launched energy), whether phase settings change every window, and how many output channels are detected per block. If any of these differ, the MAC count alone will not make the comparison fair.

7.2 Optical Power, Detection Efficiency, and Loss Tradeoffs

Optical matrix computing spends energy in two places: generating enough optical power to overcome noise at the detector, and paying for losses that force you to raise that power. The key tradeoff is simple: higher optical power can improve signal-to-noise, but every dB of loss and every inefficiency in detection increases the required input power for the same output quality.

Power Budget from Field to Photocurrent

Start with the optical field at a detector. If the circuit implements a linear transform, the detected photocurrent is proportional to the optical intensity reaching the photodiode, scaled by responsivity and detection efficiency.

A practical way to reason about it is in stages:

1. Input optical power enters the photonic mesh.
2. Propagation and coupling losses reduce the power reaching each output.
3. Interference and weighting distribute power among outputs according to the programmed transfer matrix.
4. Detector efficiency converts the remaining optical power into electrons.
5. Noise sources set the minimum photocurrent needed for reliable readout.

A best practice is to compute required power at the detector, then back-calculate the needed launch power by dividing by the total efficiency.

Detection Efficiency as a Multiplicative Factor

Detection efficiency is not one thing. It bundles several effects:

• Optical coupling efficiency from chip to photodiode.
• Photodiode quantum efficiency converting photons to electrons.
• Readout chain efficiency including any optical filtering and electrical capture.

If total detection efficiency is \(\eta_{det}\), then photocurrent scales like \(I \propto \eta_{det} P_{out}\). That means a 20% drop in \(\eta_{det}\) is equivalent to a 1.25× increase in required output power to keep the same photocurrent.

Example: Suppose you need 50 µA average photocurrent for a given noise margin. If \(\eta_{det}\) is 0.8 instead of 1.0, you need 1/0.8 = 1.25× more optical power at the detector. If the chip-to-detector coupling is the culprit, improving that coupling can be more energy-effective than increasing launch power.

Loss Tradeoffs Across the Circuit

Losses appear in multiple forms:

• Waveguide propagation loss reduces power with path length.
• Coupler and splitter insertion loss reduces power at each interference stage.
• Phase shifter loss adds attenuation alongside phase control.
• Routing and packaging loss reduces power before detection.

Because losses multiply, the energy penalty grows quickly with depth. A useful rule is to convert losses to a single total efficiency \(\eta_{chip}\) for the path from input encoding to each detector.

Example: If a path has 3 dB chip loss (half the power) and 1 dB packaging loss (about 79% remaining), then \(\eta_{chip} \approx 0.5 \times 0.79 = 0.395\). To get the same detector power, you need about 1/0.395 ≈ 2.53× more launch power.

Noise, Shot Noise, and Why Power Still Matters

At typical optical readout levels, shot noise is often a dominant term because it scales with the square root of the number of detected electrons. Increasing optical power increases both signal and shot noise, but the signal-to-shot-noise ratio improves roughly with the square root of detected power.

A best practice is to set a target minimum detected electron count per measurement window. Then you can compute the required detected optical power and back-calculate launch power using \(\eta_{chip}\) and \(\eta_{det}\).

Example: If you require 10,000 detected electrons per sample to meet a chosen decision threshold, and your photodiode responsivity and wavelength imply that 1 µW yields a certain electron rate, you can translate that into a detector power requirement. After that, losses tell you how much more launch power is needed.

Worked Back-Calculation with a Loss Stack

Assume you target a detector power \(P_{det}=200,\mu W\). Your chip efficiency is \(\eta_{chip}=0.4\) and your detection efficiency is \(\eta_{det}=0.75\). The required launch power is:

\[ P_{launch} = \frac{P_{det}}{\eta_{chip}\eta_{det}} = \frac{200,\mu W}{0.4\times 0.75} \approx 667,\mu W. \]

This calculation is the backbone of energy tradeoffs: it shows how improving either chip loss or detection efficiency reduces launch power linearly in the efficiency term.

Practical Best Practices for Tradeoff Control

1. Use a single efficiency product per path rather than tracking each loss term informally.
2. Set power from detector requirements, not from an arbitrary launch power.
3. Prefer efficiency improvements that reduce required launch power over changes that only redistribute power without increasing detected electrons.
4. Check worst-case outputs in the programmed matrix, since some rows or columns may deliver less optical intensity to certain detectors.

When these steps are followed, the power budget becomes a controlled design variable rather than a last-minute knob you turn after the noise shows up.

7.3 Modulation and Control Energy for Reconfiguration

Photonic matrix computing is often framed as “free” multiplication, but reconfiguration is not. The energy cost shows up when you change the optical transfer matrix: you drive phase shifters, update control voltages, and sometimes run calibration pulses to keep the device aligned. A useful way to reason about this section is to separate optical energy (light used for computation) from control energy (electrical work to set the device state). Control energy matters most when the matrix changes frequently, when you use fine phase resolution, or when the control loop is conservative.

Foundational Model of Control Energy

A waveguide mesh typically uses many tunable elements. Each element can be modeled as a capacitor with some parasitic resistance. When you change a phase, you charge or discharge that effective capacitance through a driver. In the simplest approximation, the energy per update for one element is proportional to the capacitance and the square of the voltage swing:

• Per-element update energy scales like \(E \propto C V^2\).
• Total update energy scales with the number of elements you actually change.
• Driver efficiency and any series resistance add overhead, so real energy is higher than the ideal \(CV^2\) estimate.

This model gives a practical best practice: if you can avoid unnecessary updates, you save energy even when the optical power is unchanged.

What “Reconfiguration” Means in Practice

Reconfiguration can mean different things at different layers of the system:

1. Weight update: you change the programmed phases to represent a new matrix (common in training or adaptive inference).
2. Batch scheduling: you keep weights fixed but change input encoding timing, detection windows, or normalization factors.
3. Calibration refresh: you re-run a short alignment routine to correct drift.

Only the first and third typically require significant modulation energy. The second is mostly timing and gating energy in the digital host.

Control Granularity and Update Policies

If you update every phase shifter every time step, you pay for it. Instead, use policies that reduce the number of elements that move.

• Thresholded updates: only apply a new control voltage when the required phase change exceeds a tolerance. Example: if your phase shifter resolution is 6 bits, you can set a tolerance of one least significant step; smaller changes are ignored and absorbed into the error budget.
• Group updates: when multiple elements share a control line or driver stage, you can update them together to reduce driver wake-ups. Example: if a mesh tile has 64 phase shifters behind one DAC bank, updating once per tile per layer can be cheaper than updating per element.
• State caching: if the same matrix appears repeatedly (common in inference with repeated layers or repeated prompts), store the last programmed voltages and skip reprogramming.

These policies are not just software conveniences; they directly reduce the number of charge/discharge cycles.

Phase Resolution, Quantization, and Energy Tradeoffs

Higher phase resolution often means either more DAC bits or smaller voltage steps with tighter settling criteria. Both can increase control energy.

A concrete example: suppose a phase shifter needs a voltage range \(\Delta V\) to cover \(2\pi\). With \(b\) bits, the step size is \(\Delta V/2^b\). If you increase \(b\), you reduce quantization error, but you may also:

• drive more precise voltages (more frequent small corrections),
• require longer settling time to meet tighter tolerances,
• increase the number of DAC transitions.

Best practice: choose phase resolution based on the system-level error budget, not on the device’s maximum capability. If detector noise and optical loss already dominate, extra control precision may not reduce total error but will still cost energy.

Settling Time and Dynamic Energy

Control energy is not only about charging capacitance; it also includes time-dependent effects. Drivers may dissipate power while the device settles, especially if you use closed-loop verification.

• Open-loop programming: you set voltages and proceed after a fixed delay. Energy is mostly switching plus driver overhead.
• Closed-loop verification: you measure a response and adjust. This can reduce optical power or improve accuracy, but it adds modulation pulses and measurement gating.

Example: during calibration refresh, you might apply a small set of probe phases, read outputs, and compute corrections. If the refresh is triggered every layer, the modulation pulses dominate. If you trigger refresh only when a drift metric crosses a threshold, you reduce both modulation and measurement energy.

Worked Example: Energy-Aware Reconfiguration Schedule

Consider a mesh tile with 256 phase shifters. If you reprogram all phases for every layer, you pay 256 update events per layer. Now apply thresholded updates with a tolerance of one DAC step: if only 30% of phases move enough to matter, you reduce update events to about 77 per layer. If each update event has the same effective \(CV^2\) cost, the control energy drops by roughly 3.3×.

Next, suppose you also run a calibration refresh every 10 layers instead of every layer. Even if the refresh uses a small number of probe pulses, the modulation energy scales with how often you trigger it. The combined effect is multiplicative: fewer phase changes per layer plus fewer calibration cycles.

The key takeaway is simple and operational: control energy is proportional to how many elements you move and how often you move them, with phase precision and settling time determining how expensive each move is.

7.4 System Level Overheads Including I/O and Synchronization

Photonic matrix multiplication is fast at the optical layer, but the system still spends time and energy on moving data, aligning timing, and coordinating control signals. In practice, these overheads can dominate when the optical computation is small, the host interface is slow, or the calibration loop is too chatty.

I/O Pathways and Where Time Goes

A typical accelerator has four I/O stages: input preparation, optical injection, detection readout, and host-side postprocessing. Input preparation includes scaling, quantization, and mapping vectors or batches into the encoding expected by the photonic layer. Optical injection includes modulator settling and ensuring the optical carrier is present during the measurement window. Detection readout includes analog front-end settling, digitization, and transferring samples to the host. Postprocessing includes converting detector outputs into matrix-vector results, applying normalization, and accumulating across tiles.

A practical best practice is to treat the optical layer as a “measurement engine” with a strict integration window. For example, if each multiply uses a 10 µs integration window, then the host should schedule modulator updates and detector reads so that the window starts immediately after the optical field is stable. If the host waits 5 µs before starting the window, you just spent 50% overhead without improving computation.

Synchronization Strategy for Coherent Measurements

Synchronization matters because interference depends on relative phase and because detectors integrate over time. The system must align three clocks: the input modulation timing, the optical path stability, and the detection integration window.

A clean approach is to use a single timing reference from the host controller to trigger both the input modulator sequence and the detector integration. Then, phase-related control updates should occur outside the integration window. For instance, if a phase shifter update takes 1 µs to settle, schedule it right after the previous integration ends, not during the next integration.

When multiple photonic tiles are used, synchronization also includes aligning tile boundaries. Suppose a layer is split into two tiles, each producing partial sums for the same output neurons. The host should either (a) accumulate partial sums immediately after each tile’s readout, or (b) buffer both tiles’ outputs and accumulate once both are complete. Immediate accumulation reduces buffer memory, while buffered accumulation can simplify alignment when tile latencies differ.

Control Signaling and Energy Overhead

Control energy comes from driving phase shifters, modulating inputs, and communicating settings to the photonic chip. Even if optical power is low, frequent reconfiguration can raise control energy and add latency.

A best practice is to batch operations that share the same photonic configuration. For example, if you process a batch of 64 input vectors with the same weight matrix, keep the weight-related phase settings constant and only update the input encoding between vectors. Then you pay the “weight configuration” cost once per batch rather than once per vector.

I/O Bandwidth and Data Movement Costs

The host-to-chip bandwidth depends on how you represent inputs and how often you update them. If you stream raw high-resolution samples, the interface can become the bottleneck. Instead, encode inputs in the smallest representation that preserves the photonic layer’s effective precision. For example, if the optical encoding supports 6-bit amplitude levels, sending 12-bit values wastes bandwidth and may not improve results.

On the chip-to-host side, detection outputs can be large. A practical mitigation is to reduce the number of samples transferred by integrating on-chip when possible, or by reading only the channels needed for the current layer partition. If you only need a subset of output neurons for a sparse activation pattern, avoid digitizing unused channels.

Example: Scheduling a Batch Without Wasting Integration Time

Assume a photonic layer computes one matrix-vector product per integration window of 10 µs. Phase settings for weights take 2 µs to settle after a change. Input encoding updates take 0.5 µs.

For a batch of 32 vectors with fixed weights, do this:

1. At t = 0, set weight phase settings and wait 2 µs.
2. For each vector k, update input encoding in 0.5 µs, then start the 10 µs integration immediately.
3. After integration ends, read detectors and transfer results while the next input encoding is being prepared.

If you instead updated weights for every vector, you would add 2 µs overhead 32 times, which is 64 µs of extra settling. That’s not catastrophic, but it’s unnecessary overhead that also increases the chance that detector reads and integration windows drift out of alignment.

Example: Tile Accumulation with Different Latencies

Suppose tile A readout takes 120 µs and tile B takes 140 µs for the same output partition. If you accumulate immediately, you need a buffer for partial sums from tile A while waiting for tile B. If you buffer both, you delay the final output by the slower tile but simplify accumulation logic. Either way, the host must keep track of which integration window each tile’s data belongs to, so normalization and accumulation use matching windows.

7.5 Worked Example: Energy Budget for a Layer Execution

This worked example estimates energy for one photonic matrix-multiplication layer, focusing on what actually moves the needle: optical power through losses, detection efficiency, and the control energy needed to set the waveguide mesh. We’ll use a concrete, small-but-realistic configuration so every term has a job.

Layer and Hardware Setup

Assume a fully connected layer with:

• Input vector length: 256
• Output vector length: 64
• Matrix size: 64 × 256
• Photonic mesh implements a linear transform per output row.
• Inputs are encoded as optical intensities using a single wavelength (so we avoid extra modulation channels).
• Detection is direct intensity detection.

Assume the photonic tile processes one input vector per inference “shot.” If you batch, you multiply the shot count; the per-shot energy model stays the same.

Step 1: Choose Optical Power at the Chip Input

Let the optical power launched into the chip per input channel be 0.5 mW. With 256 channels, the total launched optical power is:

• P_in,total = 256 × 0.5 mW = 128 mW

This number is not “free.” It must be high enough that after losses and detector inefficiency, the detected photocurrent is above the noise floor.

Step 2: Account for Optical Losses

Let the end-to-end optical transmission from chip input to each detector be 10% (including waveguide propagation loss, coupler loss, and routing loss).

• Transmission η_opt = 0.10

Then the optical power reaching each detector is:

• P_det,per_out = P_in,total × η_opt / 64

Why divide by 64? Because the 64 outputs share the total optical energy distribution at the detection stage in this simplified model.

Compute:

• P_det,per_out = 128 mW × 0.10 / 64 = 0.2 mW

Step 3: Convert Detected Power to Photocurrent and Shot-Noise Scale

Assume a detector responsivity R = 0.8 A/W at the operating wavelength.

• I_photo = R × P_det,per_out = 0.8 × 0.2 mW = 0.16 mA

Shot noise current standard deviation over an integration time τ is:

• i_shot = sqrt(2 q I_photo / τ)

Pick τ = 10 ns, a typical integration window for high-throughput direct detection.

• i_shot ≈ sqrt(2 × 1.6e-19 × 1.6e-4 / 1e-8) A
• i_shot ≈ 2.3e-7 A = 0.23 µA

A practical rule is to design so the signal current is at least ~100× the noise current for comfortable SNR. Here, I_photo / i_shot ≈ 700, which is generous; that means we can later reduce launched power if needed.

Step 4: Optical Energy per Shot

Energy is power times time. Optical energy delivered to the chip per shot:

• E_opt,shot = P_in,total × τ = 128 mW × 10 ns = 1.28 µJ

This is the dominant term if you keep optical power high.

Step 5: Control Energy for Reconfiguration

Waveguide meshes require phase shifters or equivalent tuning elements. Assume:

• Number of tunable elements: 4096
• Energy to set one element per shot: 0.5 nJ (includes driver switching and settling)

Then:

• E_ctrl,shot = 4096 × 0.5 nJ = 2.048 µJ

If the layer weights stay constant across many shots (typical for inference), you can amortize control energy by setting once and reusing. For this worked example, we assume weights change every shot to keep the accounting honest.

Step 6: Detection and Readout Overhead

Assume detector front-end and ADC energy per output per shot:

• E_det,per_out = 20 nJ
• Outputs = 64

So:

• E_det,shot = 64 × 20 nJ = 1.28 µJ

Step 7: Total Energy per Layer Execution

Sum the three main contributors:

• E_total,shot = E_opt,shot + E_ctrl,shot + E_det,shot
• E_total,shot = 1.28 µJ + 2.048 µJ + 1.28 µJ = 4.608 µJ

So the energy per layer execution for one input vector is about 4.6 µJ.

Example: Quick Sanity Check and Knob Selection

If you want to reduce energy without breaking the SNR, the first knob is launched power. In this example, SNR was very high (signal current far above shot noise), so you could reduce P_in,total until I_photo is closer to the target SNR margin.

A second knob is optical transmission. Improving η_opt from 0.10 to 0.20 halves the required launched power for the same detected power, cutting E_opt,shot roughly in half.

A third knob is control amortization. If weights are fixed for a batch of 100 input vectors, E_ctrl,shot effectively becomes E_ctrl,shot/100 for that batch, and the total energy becomes dominated by optical and detection terms.

Worked Summary

For the assumed 64 × 256 layer with 10 ns integration, 10% optical transmission, 0.5 mW per input channel, 4096 tunable elements, and 20 nJ per output readout, the energy per layer execution per input vector is approximately 4.6 µJ, with control energy and detection energy each contributing about a third to nearly half of the total depending on how often weights change.

8.1 Encoding Inputs With Optical Intensity and Phase

Photonic matrix multiplication needs a rule for turning real-valued inputs into optical fields that interfere correctly inside the waveguide array. The two most common knobs are optical intensity (how bright) and optical phase (where the wave is in its cycle). A good encoding makes three things easy: (1) linearity with respect to the input, (2) sign handling for negative values, and (3) stable scaling so the detector sees signals in a useful range.

Core Idea: Fields, Not Just Light

Inside a coherent interferometric mesh, the relevant quantity is the complex field \(E\), not the raw power. A typical linear optical transform maps input fields to output fields, and then photodetectors measure intensity \(I\propto |E|^2\). To keep matrix multiplication behavior predictable, the encoding is designed so that the measured intensity (or a differential version of it) becomes proportional to the desired linear combination.

Intensity Encoding for Nonnegative Inputs

If your inputs \(x\) are already nonnegative (for example, after a ReLU-like step), you can encode them as optical power:

• Choose a reference power \(P_0\).
• Map \(x\in[0, x_{max}]\) to \(P = P_0\cdot x/x_{max}\).
• Use a modulator to set the optical intensity accordingly.

Easy example: Suppose \(x=[0, 0.5, 1.0]\) and \(x_{max}=1\). With \(P_0=1,\text{mW}\), you drive \([0, 0.5, 1.0],\text{mW}\). If the photonic layer is configured to implement a linear transform on the encoded amplitudes, the output intensities scale with the input magnitudes.

Best practice: keep \(P\) away from the modulator’s nonlinear region. A simple rule is to reserve headroom, e.g., map \(x_{max}\) to 70–90% of the maximum optical power.

Phase Encoding for Signed Inputs

Negative values are awkward for pure intensity encoding. Phase encoding uses the fact that a phase shift can represent a sign.

A common approach is binary phase sign encoding:

• Normalize \(x\) to \(x_n\in[-1,1]\).
• Use a fixed amplitude \(A\) and set phase to 0 for \(x\ge 0\) and \(\pi\) for \(x<0\).
• Optionally scale amplitude with \(|x|\) for better dynamic range.

Easy example: Let \(x=[-0.25, 0.5]\). Choose \(A=1\) (arbitrary units). Encode as \(E_1 = A,e^{j\pi} = -A\) and \(E_2 = A,e^{j0} = +A\). If the circuit is arranged so that the output field is a weighted sum of input fields, the sign is carried by the phase.

Best practice: if you use only 0/\(\pi\) phase, you must still represent magnitude. A practical hybrid is amplitude scaling times phase sign: \(E = A,|x_n|,e^{j\theta}\) with \(\theta\in{0,\pi}\).

Differential Encoding for Clean Subtraction

When the circuit ultimately measures intensity, sign can be lost because \(|E|^2\) removes phase. Differential encoding fixes this by measuring two complementary channels and subtracting:

• Encode \(+x\) in one path and \(-x\) in another.
• Compute \(I_{diff} = I_{plus} - I_{minus}\).

Easy example: If a neuron needs \(y = w\cdot x\) and \(x\) can be negative, drive two modulators with fields proportional to \(\max(x,0)\) and \(\max(-x,0)\). After detection, subtract the two outputs. The subtraction restores a signed quantity.

Best practice: match the two paths’ gains and offsets. A small mismatch shows up as a bias term that looks like a constant input.

Scaling and Normalization Rules That Actually Help

Optical systems dislike surprise. Use a consistent normalization so that the encoding scale matches the mesh’s expected operating range.

1. Choose an input scale \(s_x\) so that typical values land near the middle of the modulator range.
2. Track the scale through the layer: if you encode \(E\propto x/s_x\), then the effective matrix implemented by the hardware is \(W_{eff} = W\cdot s_x\) (up to any additional gain factors).
3. Use detector-friendly power: ensure the maximum expected output intensity stays below saturation.

Worked Micro-Example: From Real Inputs to Encoded Fields

Assume a neuron input \(x\in[-1,1]\) and you choose hybrid amplitude-phase encoding:

• Normalize \(x_n=x\).
• Set \(E = A,|x_n|,e^{j\theta}\) where \(\theta=0\) if \(x\ge 0\), else \(\theta=\pi\).

If \(x=-0.6\), then \(|x|=0.6\) and \(E=-0.6A\). If \(x=0.8\), then \(E=0.8A\). The mesh then combines these fields linearly at the field level, and your detection strategy (direct intensity with a compatible circuit, or differential intensity) determines whether the final measurement corresponds to a signed multiply.

Practical Takeaway

Pick the encoding that matches your data distribution and your detection method. Nonnegative activations pair naturally with intensity encoding, signed values pair naturally with phase sign and/or differential detection, and scaling rules keep the whole system from quietly turning math into bias.

8.2 Modulation Schemes for Driving Waveguide Arrays

Photonic waveguide arrays need a controllable optical field at each input and a controllable transfer function inside the mesh. Modulation is the practical bridge between digital control signals and optical behavior. The key design choice is where modulation happens: at the source (input encoding), inside the mesh (weight setting), or at the output (readout shaping). A good scheme keeps the optical field stable enough for interference while matching the bandwidth and noise tolerance of the detectors.

Modulation Goals and Constraints

A modulation scheme should satisfy four goals. First, it must represent the intended numerical values (inputs and weights) with a mapping that is physically realizable. Second, it must keep phase relationships consistent across channels so interference produces the correct linear transform. Third, it must minimize energy spent in driving electronics and in optical power required to overcome noise. Fourth, it must fit the timing model of the system: whether you stream many vectors or reuse the same weights across many vectors.

A useful mental model is to separate “field preparation” from “weight programming.” Field preparation sets the complex amplitudes entering the mesh. Weight programming sets the complex transfer matrix implemented by the interferometer network.

Input Modulation for Field Preparation

For many photonic matrix multiplications, you encode the input vector as optical amplitudes across multiple waveguides. Common approaches:

1. Intensity-only encoding: drive each input channel with a nonnegative optical intensity proportional to the value. This is simple but cannot represent sign directly, so you use differential encoding (two channels per value) or a bias term.
2. Complex amplitude encoding: represent each value using both amplitude and phase. This can reduce channel count, but it requires phase-stable sources and careful calibration.
3. Time-multiplexed encoding: represent multiple channels over time using a single modulator or fewer modulators. This reduces hardware but increases latency and demands precise timing.

Easy example: Suppose you want a 2-element input vector \([x_1, x_2]\) and your mesh expects two nonnegative inputs. If your values can be negative, encode \(x_i\) as \((x_i^+, x_i^- )\) where \(x_i^+=\max(x_i,0)\) and \(x_i^-=\max(-x_i,0)\). Drive two input waveguides per element. The mesh output then naturally forms \(x_1 y_1 + x_2 y_2\) using the differential structure.

Weight Modulation for Transfer Function Programming

Inside a waveguide mesh, weights are typically implemented by controlling phase shifts and coupler splitting ratios. The modulation scheme here is about how you translate a desired complex weight into device control signals.

1. Phase-shift modulation: drive phase shifters to set relative phase between paths. This is efficient when the device supports analog tuning.
2. Amplitude modulation via interferometric splitting: use tunable couplers or interferometer sections that convert phase control into effective amplitude scaling.
3. Quantized weight programming: if phase shifters have limited resolution, you map each target weight to the nearest achievable setting.

Easy example: A simple 2×2 interferometer cell can implement a rotation-like transform. If you want a weight proportional to \(\cos\theta\) and \(\sin\theta\), then your modulation problem reduces to setting \(\theta\) with a phase shifter. If the phase shifter has 6-bit resolution, you quantize \(\theta\) to the nearest of 64 steps and accept the resulting approximation error.

Choosing Between Continuous and Discrete Modulation

Continuous modulation (analog tuning) gives fine control but requires stable biasing and careful drift management. Discrete modulation (switching between a small set of states) simplifies control and can reduce calibration overhead, but it increases quantization error.

A practical rule: use discrete modulation when the system tolerates approximation noise and when you can compensate with training or calibration. Use continuous modulation when you need tight linearity across a wide dynamic range.

Bandwidth and Synchronization

Modulation bandwidth determines how quickly you can change inputs or weights. If weights are fixed for many vectors, you can spend most bandwidth on input modulation. If weights change frequently, you must account for settling time and transient interference.

Synchronization matters because interference depends on relative timing. If two channels are modulated with different delays, the effective phase relationship shifts and the implemented matrix deviates.

Easy example: If you time-multiplex two input channels into one modulator, you must ensure the mesh sees the correct channel at the correct time slot. A one-slot misalignment turns a intended dot product into a scrambled sum.

Worked Example: Differential Intensity Encoding with Phase-Stable Weights

Assume a mesh implements a linear transform \(\mathbf{y}=\mathbf{W}\mathbf{x}\). Your input values \(x_i\) can be negative, and your sources are intensity modulators only. Use differential encoding: \(x_i = x_i^+ - x_i^-\) with \(x_i^+, x_i^- \ge 0\). Create an extended input vector \(\tilde{\mathbf{x}}\) by stacking \(x_i^+\) and \(x_i^-\). Then design or calibrate the effective weight matrix \(\tilde{\mathbf{W}}\) so that \(\mathbf{y}=\tilde{\mathbf{W}}\tilde{\mathbf{x}}\). The modulation scheme is straightforward: drive each nonnegative channel with intensity proportional to its encoded value. The subtle part is ensuring the weights are phase-stable so the interferometer’s linear mapping remains consistent while you stream vectors.

8.3 Bandwidth, Latency, and Throughput Considerations

Bandwidth, latency, and throughput are linked by the same physical bottlenecks: how fast you can modulate inputs, how quickly light propagates and is detected, and how much time you spend reconfiguring the photonic mesh. A good rule of thumb is to treat each matrix multiply as a pipeline stage with a measurable service time, then compute how many stages can run in parallel without starving each other.

Bandwidth: What Limits the Input and Output Rates

Optical bandwidth is constrained by three places: the modulator drive bandwidth, the photodetector and transimpedance amplifier bandwidth, and the optical path stability over the symbol interval. If you encode inputs as intensity only, you still need the modulator to follow the symbol rate; if you encode phase or complex fields, you also need phase stability so the interference pattern does not smear across symbols.

A practical way to reason about bandwidth is to compare the symbol period \(T_s\) to the electrical settling time \(T_{settle}\). If \(T_s\) is not comfortably larger than \(T_{settle}\), you will see inter-symbol interference in the electrical domain, which looks like extra noise and effectively reduces usable SNR.

Example: Suppose your modulator settles in 2 ns and your target symbol period is 3 ns. Even before considering optical loss, you are spending most of the symbol window transitioning, so the detected value corresponds to an average of “old” and “new” symbols. Increasing \(T_s\) to 6 ns improves fidelity, but it also reduces throughput. That trade is the core bandwidth-throughput coupling.

Latency: From First Bit to First Valid Output

Latency is the time from when an input symbol is presented to when the corresponding output value is available and usable by the next stage. In photonic matrix computing, latency includes:

1. Input encoding time: time to drive modulators or switch input routing.
2. Optical propagation time: typically small compared to electrical times, but not always negligible for long paths.
3. Detection integration time: how long the photodetector accumulates charge to reach the desired noise level.
4. Post-processing time: scaling, thresholding, or digitization.

A key nuance: detection integration time is often chosen for SNR, not for speed. If you shorten integration, noise rises and you may need more averaging elsewhere, which can cancel out the latency gain.

Example: If you integrate for 10 ns to get acceptable noise, but your system clock expects results every 5 ns, you cannot simply “clock faster.” You either accept higher error, increase optical power (energy cost), or use parallel detectors and sample-and-hold to keep the integration window while meeting timing.

Throughput: How Many Matrix Results per Second

Throughput depends on how many symbols you can process per unit time and how efficiently you reuse hardware. For a matrix multiply, the effective throughput is limited by the slowest of:

• Symbol rate determined by bandwidth and settling.
• Reconfiguration rate of the mesh weights or routing.
• Detection and digitization rate.
• Host-device coordination if weights or activations are streamed.

To compute throughput, model the operation as a schedule. If the mesh weights are static for a layer, you can amortize reconfiguration across many symbols. If weights change frequently (e.g., per token or per micro-batch), reconfiguration becomes a dominant term.

Example: Consider a layer where weights remain constant for 256 input vectors. If reconfiguration takes 1 ms and each vector takes 50 ns of symbol time plus 10 ns detection integration, the reconfiguration overhead per vector is \(1\text{ ms}/256\approx 3.9\text{ µs}\), which dwarfs the per-vector compute time. In that case, throughput is mostly limited by how often you must update the mesh.

Worked Scheduling Example with a Simple Timing Budget

Assume a static mesh for a layer. Let symbol period be \(T_s\), detection integration be \(T_{int}\), and reconfiguration be \(T_{reconf}\) once per layer. For \(N\) input vectors, a reasonable approximation for total time is:

• Total time \(\approx T_{reconf} + N\cdot (T_s + T_{int})\)

Example: \(T_{reconf}=0.5\text{ ms}\), \(T_s=20\text{ ns}\), \(T_{int}=10\text{ ns}\), \(N=10^4\). Compute time per vector is 30 ns, so \(N\cdot 30\text{ ns}=0.3\text{ ms}\). Total time is 0.8 ms, giving throughput \(\approx 10^4/0.8\text{ ms}=12.5\text{ million vectors per second}\). If you instead had to reconfigure per vector, throughput would collapse to \(1/(0.5\text{ ms}+30\text{ ns})\), which is why batching and layer-wise reuse matter.

Finally, remember that “faster” is not always “more accurate.” If you push \(T_s\) below settling time or shorten \(T_{int}\) below the noise requirement, you may increase error so much that downstream layers compensate with extra computation elsewhere. The best throughput is the one that preserves the error budget you already planned for.

8.4 Synchronization of Optical Inputs and Detection Windows

Optical matrix multiplication only looks “instant” on paper. In hardware, the multiplication happens while light is traveling through waveguides, interfering, and then being converted to electrical signals. Synchronization is the discipline that makes those events line up so each detected sample corresponds to the intended input vector and the intended weight configuration.

What Must Be Synchronized

Start with three clocks, even if you never see them as clocks.

1. Optical arrival time: when the encoded light reaches each interferometer path.
2. Weight configuration time: when phase shifters settle after a new setting is applied.
3. Detection window timing: when the photodiode integrates or samples the output.

A practical rule: the detection window must open only after both the optical signal and the weight setting have settled, and it must close before the next input encoding begins.

Path-Length Skew and Group Delay

Even if the source is continuous, different waveguide paths can have different group delays. That means the interference pattern at the output is not a single clean moment; it is a time-smearing of the superposition.

Best practice: treat the circuit like a set of delays and measure the effective impulse response. Then choose an encoding format (pulse width or symbol duration) that is long enough to average out small jitter but short enough to avoid overlap between symbols.

Example: Suppose your symbol duration is 10 ns. If the worst-case differential group delay across the mesh is 1 ns, then a 10 ns symbol gives the interference time to form within the symbol, and the detection window can be placed near the symbol center to reduce sensitivity to edge effects.

Weight Settling and Control Latency

Phase shifters rarely change “in zero time.” They have finite tuning speed and may overshoot or ring before settling.

Best practice: define a settling criterion in terms of output stability, not just driver timing. For instance, repeatedly apply the same weight setting and measure when the output variance drops below a threshold.

Example: If a phase shifter driver nominally updates in 50 ns but the output keeps drifting for another 20 ns, then opening the detection window at 50 ns will mix two weight states. Instead, schedule detection at 70 ns after the command, or use a two-step approach where you pre-load weights and only then start the optical symbol.

Detection Window Placement

Detection windows can be implemented as gated integration (integrate-and-dump) or as synchronous sampling.

Best practice: place the window where the output is least sensitive to transitions. That typically means:

• avoid the first part of the symbol where optical interference is still forming,
• avoid the last part where the next symbol may start,
• align the window center with the measured combined delay of the system.

Example: If you use gated integration over 4 ns within a 10 ns symbol, center the 4 ns gate at the symbol midpoint. If you observe that the output amplitude peaks 0.6 ns after the midpoint, shift the gate center by +0.6 ns.

Coordinating Input Encoding and Output Sampling

A clean workflow is to separate configuration from data.

• Configuration phase: set phase shifters for the current weight matrix tile.
• Data phase: launch the encoded optical input vector.
• Sampling phase: integrate or sample outputs during the stable interval.

Best practice: pipeline these phases across tiles so you don’t waste time waiting for both optical and control systems.

Worked Example with a Simple Timing Budget

Assume:

• Symbol duration: 10 ns
• Worst-case differential group delay: 1 ns
• Phase shifter settling time to stable output: 70 ns after command
• You command weights at time 0 and launch the optical symbol at time 60 ns

Then:

• Optical interference should be largely formed by 60 ns + 1 ns = 61 ns.
• Weight stability is guaranteed only after 70 ns.
• Choose the detection window to start at 70 ns + margin, say 72 ns, and end before the next symbol begins at 70 ns + 10 ns = 80 ns.

Result: a 72–80 ns detection window ensures the detected sample corresponds to one intended input symbol under one stable weight configuration.

Common Failure Modes and Fixes

1. Window opens too early: output looks like a blend of two weight states. Fix by delaying detection or pre-loading weights before launching the optical symbol.
2. Window overlaps symbol boundaries: results vary with input pattern edges. Fix by increasing symbol duration or shrinking the window to the stable interior.
3. Unmodeled skew: different outputs peak at different times, causing row/column imbalance. Fix by using per-channel window offsets or re-optimizing symbol timing.

Synchronization is not a single “timing signal.” It is a set of constraints that you satisfy simultaneously: optical propagation, control settling, and detection timing. When those constraints are met, the math you designed is the math you measure.

8.5 Worked Example: Choosing an Encoding for a Given Throughput Target

Suppose you need to run a neural layer using a photonic matrix tile that produces one output vector per optical “shot.” Your throughput target is T = 50,000 vectors per second. The tile’s optical path settles within t_settle = 2 µs, and your control electronics can update phase shifters at f_ctrl = 200 kHz. You also know your detector integration window must be t_int = 8 µs to keep shot noise manageable.

Step 1: Convert Throughput into Timing Constraints

Throughput implies a shot period of t_shot = 1/T = 20 µs. You must fit settling and integration inside that period:

• Settling: 2 µs
• Integration: 8 µs
• Remaining budget: 10 µs for switching, guard time, and any digital host overhead

Since t_shot = 20 µs, you can run 50 kHz shots. Your control update rate is 200 kHz, so you can update weights every shot without violating f_ctrl. That means the encoding choice should focus on how many optical degrees of freedom you need per vector and how much optical power you must spend per degree.

Step 2: Pick an Encoding Family That Matches the Tile’s Linear Core

Most waveguide meshes implement a linear transform on an optical field. The main question is how you represent the input vector and how you represent signed values.

A practical encoding decision is between:

• Intensity-only encoding: map inputs to optical intensity, then detect intensity at outputs.
• Field encoding with phase: map inputs to complex field amplitude (magnitude and phase), then detect intensity after interference.

For throughput, intensity-only is often simpler because it avoids needing phase-stable modulation for every input element. But it struggles with negative values unless you use extra channels.

Step 3: Enforce Signed Values Without Doubling Everything

Assume your layer weights and activations are quantized to 8-bit signed values. A common approach is two-channel differential encoding:

• Channel A carries the positive part
• Channel B carries the negative part
• Output difference gives the signed result

This doubles the number of optical input channels, which can reduce effective throughput if your tile needs separate shots per channel. Here, you can avoid that by using simultaneous dual-channel injection if your hardware supports two input ports feeding the same mesh.

If your tile supports dual-port injection, you can keep one shot per vector. If it does not, you’d need two shots per vector, which would cut throughput to 25 kHz and miss the target.

Step 4: Choose Between Two Concrete Encodings

Option A: Differential Intensity Encoding

• Encode each input element as nonnegative intensity using:
  • I⁺ = max(x, 0)
  • I⁻ = max(-x, 0)
• Inject I⁺ and I⁻ simultaneously into two ports.
• At each output detector, compute y = y⁺ − y⁻ digitally.

Why it fits throughput: one shot per vector, assuming dual-port injection.

Easy example: if x = -3 (in some normalized units), then I⁺ = 0 and I⁻ = 3. The mesh processes both channels; the detector outputs for the negative channel subtract from the positive channel.

Option B: Phase-Signed Field Encoding

• Encode x into a complex field amplitude with a sign mapped to phase:
  • magnitude ∝ |x|
  • phase = 0 for x ≥ 0, phase = π for x < 0
• Inject a single channel.

Why it can be risky: phase stability and calibration must be tight because a π error turns subtraction into addition. That calibration effort can be manageable, but it increases the chance that your effective throughput drops due to longer integration or more frequent recalibration.

Easy example: if x = +2, send amplitude +2 with phase 0. If x = -2, send amplitude 2 with phase π. After the mesh, the interference pattern at each output detector encodes the signed contribution.

Step 5: Check Power and Noise with a Simple Budget

Let your detector noise be dominated by shot noise, so the signal-to-noise ratio scales roughly with optical energy per shot. Differential intensity encoding splits optical power across two channels, so for the same total power you may reduce per-channel SNR.

A workable rule for choosing between A and B is:

• If your system can afford dual-port injection without extra shots, Option A is usually safer.
• If dual-port injection is impossible and you must use extra shots, Option B may be the only way to meet throughput.

Given our timing constraints, dual-port injection is the deciding factor. If it exists, Option A meets throughput cleanly.

Step 6: Final Selection for This Example

Because t_shot = 20 µs and your control update supports per-shot reconfiguration, the throughput bottleneck is whether the encoding forces extra shots. With dual-port injection available, choose Differential Intensity Encoding (Option A).

You will:

1. Normalize inputs to a nonnegative pair (I⁺, I⁻).
2. Inject both channels simultaneously into the mesh.
3. Integrate detectors for t_int = 8 µs within the 20 µs shot period.
4. Compute signed outputs by subtraction in the digital host.

This choice keeps the shot count at 50,000 per second while avoiding the calibration fragility of phase-sign mapping.

9.1 Partitioning Neural Layers Across Photonic Tiles

Photonic matrix multiplication is fast when the whole layer fits cleanly into one optical fabric. Real neural layers rarely cooperate, so partitioning becomes the practical skill: split the layer into tile-sized subproblems that match the photonic mesh dimensions, optical power budgets, and calibration scope.

Core Idea: Tile the Matrix Multiply

A dense layer computes Y = XW + b. Photonic tiles typically implement a linear transform Y_tile = X_tile W_tile for a fixed input/output dimension range. Partitioning chooses how to split X and W so each tile computes a piece of Y, then the system combines pieces digitally.

A reliable starting point is to decide the tiling axis:

• Output tiling splits rows of W so each tile produces a subset of output channels.
• Input tiling splits columns of W so each tile produces partial sums that must be accumulated.

Output tiling is often simpler because each output element is produced by exactly one tile. Input tiling reduces the required input fan-in per tile but introduces accumulation, which is still straightforward if you keep scaling consistent.

Step 1: Choose Tile Dimensions That Match the Photonic Mesh

Let the photonic tile implement a matrix of size M_out × M_in. For a layer with N_out × N_in weights:

• Pick M_in so X can be chunked into blocks of width M_in.
• Pick M_out so Y can be chunked into blocks of height M_out.

Best practice: choose tile sizes so the remainder blocks are small. If you must handle a large remainder, pad inputs and weights to the next tile boundary and mask outputs in software.

Step 2: Decide Between Output Tiling and Input Tiling

Output tiling

• Split W by rows: W = [W0; W1; …].
• Each tile computes Yk = X Wk.
• Combine by concatenation: Y = [Y0; Y1; …].

Easy example: If N_out = 1024 and M_out = 256, you need 4 output tiles. Each output tile reads the same X block and writes a distinct slice of Y.

Input tiling

• Split W by columns: W = [W0, W1, …].
• Each tile computes a partial output: Yk_partial = Xk Wk.
• Combine by summation: Y = Σk Yk_partial.

Easy example: If N_in = 4096 and M_in = 1024, you need 4 input tiles. Each tile reads a different chunk of X, and the host accumulates the four partial results.

Step 3: Keep Scaling and Bias Handling Consistent

Photonic tiles often include normalization and detection scaling. Treat the tile as producing Y_tile = α (X_tile W_tile) where α is known from calibration.

Best practice: absorb α into the software scaling so that every tile contributes to Y in the same numeric convention.

Bias handling options:

• If bias is per output channel, add it after combining tiles. This avoids duplicating bias across tiles.
• If you must add bias earlier, ensure it is added only once per output element.

Step 4: Manage Data Movement and Reuse

Partitioning is not only about math; it’s about moving the right signals.

• With output tiling, X is reused across tiles, so you can keep X in the photonic input staging path longer.
• With input tiling, W is reused less often because each tile uses different Wk and different Xk.

Best practice: schedule tiles to maximize reuse of whichever operand is more expensive to move in your system. In many setups, weights are stored digitally and streamed, so you may prefer output tiling when X can be staged efficiently.

Step 5: Handle Remainders and Masks Cleanly

If N_out or N_in is not a multiple of tile size, use padding and masking:

• Pad X and W with zeros so the photonic output for padded indices should be near zero.
• Mask padded output channels in software to prevent small residuals from accumulating.

Example: Partitioning a Fully Connected Layer

Assume N_in = 4096, N_out = 1024, and a tile supports M_in = 1024, M_out = 256.

Option A: Output tiling

• Split outputs into 4 tiles: each tile computes 256 outputs.
• Each tile uses the full input X (4096 wide) which must be internally handled by the photonic fabric. If the fabric cannot accept 4096 directly, you still need input tiling inside each output tile.

Option B: Input tiling plus output tiling

• Split inputs into 4 chunks and outputs into 4 chunks.
• Total tiles: 4 × 4 = 16.
• Each tile computes 256 × 1024 partial results.
• Combine by summing across input chunks for each output chunk, then concatenate output chunks.

Best practice: when both dimensions exceed tile limits, use a 2D tiling plan and define a strict combine rule: sum over input tiles, concatenate over output tiles. This keeps the host logic simple and reduces the chance of mixing scaling conventions.

9.2 Interfacing Photonic Accelerators with Digital Hosts

Photonic matrix engines usually sit beside a digital host that handles data movement, scheduling, and training logic. The interface problem is mostly about making timing and numeric conventions unambiguous: the host must know when optical results are ready, how they map to tensor values, and what calibration state the photonic tile is using.

Core Interface Responsibilities

A practical host interface has four jobs.

1. Commanding the optical operation: the host selects which matrix tile to use, sets the weight configuration (phase shifters or equivalent), and starts an optical “compute window.”
2. Providing inputs in the expected encoding: the host must present activations in the form the photonic layer expects, including scaling and sign handling.
3. Collecting outputs with correct alignment: the host reads detector samples and associates them with the right output channels and batch index.
4. Maintaining calibration metadata: the host tracks which calibration parameters were applied so that numeric outputs remain consistent across runs.

A simple rule helps: treat the photonic accelerator as a deterministic function plus a calibration state. The host should always pass a calibration identifier along with each compute request.

Data Path: From Host Tensors to Optical Signals

Most systems use a digital-to-analog path for driving modulators and phase shifters, and an analog-to-digital path for detector readout.

• Inputs: activations are converted to optical modulation settings. If intensity encoding is used, the host scales values into a nonnegative range and applies an offset. If differential encoding is used, the host splits each activation into two channels and later recombines results digitally.
• Weights: weights are mapped to programmable optical parameters. The host typically stores weights in a quantized format that matches the device’s control resolution.
• Outputs: detectors produce analog currents or voltages. The host samples them, applies gain/offset corrections, and converts them into tensor values.

Example: Differential Encoding with Recombination

Suppose an activation \(a\) is represented as two nonnegative values \(a^+\) and \(a^-\) such that \(a = a^+ - a^-\). The photonic layer computes linear transforms on both channels, producing outputs \(y^+\) and \(y^-\). The host then forms \(y = y^+ - y^-\). This keeps the optical path nonnegative while preserving signed arithmetic in software.

Timing and Synchronization

Optical compute windows are short compared to digital control cycles, so the interface must define when “start” and “stop” mean.

• Triggering: the host issues a start command, then waits for a hardware trigger that marks the beginning of the optical window.
• Sampling: detector ADC sampling is synchronized to that trigger so each output corresponds to the correct input symbol.
• Latency accounting: the host records the fixed pipeline latency of the photonic tile and uses it to align outputs with subsequent digital stages.

A robust best practice is to include a monotonically increasing sequence number in each request. The photonic controller echoes it with the readout-ready signal, preventing mismatches when multiple tiles operate concurrently.

Numeric Conventions and Scaling

Photonic outputs often require scaling because optical power, detector gain, and any normalization factors are not identical to the software’s tensor conventions.

• Define a single “tensor contract”: specify the mapping from detector units to tensor units, including any global gain and per-layer normalization.
• Keep scaling near the host: apply final scaling and bias correction in digital logic so device-to-device variations don’t leak into model semantics.
• Use calibration-aware transforms: if the device transfer function is represented as a measured matrix, the host applies the inverse or a correction model consistently.

Example: Output Scaling Contract

If the photonic layer outputs a measured value \(\hat{y}\) proportional to the desired \(y\) by \(\hat{y} = k,y\), then the host computes \(y = \hat{y}/k\). Store \(k\) per calibration state, not as a hardcoded constant.

Control Plane: Weight Updates and Compute Scheduling

The host must decide when to update weights versus when to compute.

• Weight staging: preload weight parameters into the photonic controller so compute windows start quickly.
• Batching: reuse the same weight configuration across multiple input batches when possible, reducing control overhead.
• Tiling: for large matrices, the host schedules multiple tiles and accumulates partial sums digitally.

Example: Tiled Accumulation

For a matrix split into two column blocks, the photonic engine computes partial outputs \(y_1\) and \(y_2\). The host accumulates \(y = y_1 + y_2\) after both tiles complete. This keeps the photonic hardware focused on linear transforms while the host handles accumulation order and numeric precision.

Minimal Interface Checklist

• A request includes: tile ID, input batch index, weight configuration ID, calibration ID, and sequence number.
• A response includes: sequence number, output tensor shape, and detector sample statistics needed for scaling.
• The host applies: encoding recombination (if differential), gain/offset correction, and final tensor scaling.

When these pieces are explicit, the photonic accelerator becomes a predictable compute element rather than a mysterious analog side quest. The interface then supports both inference and training-time calibration loops without changing the core contract.

9.3 Memory Movement Strategies for Weights and Activations

Photonic matrix tiles are fast at the multiply part, but the system can still stall if weights and activations arrive late or are moved inefficiently. The goal is simple: keep the photonic mesh fed while minimizing transfers, conversions, and reformatting. In practice, you treat memory movement as a schedule problem with constraints from tiling, encoding, and calibration.

Core Principle: Move Less, Move Smarter

Weights are reused across many activations, while activations are streamed through layers. A good strategy therefore:

• Stores weights in a form that matches the photonic tile’s expected parameterization.
• Streams activations in a layout that avoids repeated packing and unpacking.
• Uses tiling so each weight block is loaded once per set of activations.

A quick mental model: if a tile computes Y = W·X, then for a fixed W you want to reuse W across multiple X blocks before evicting it. For a fixed X, you want to reuse X across multiple output tiles before reformatting it.

Weight Residency and Tiling

Photonic meshes typically map to a fixed matrix shape per tile. Suppose a tile computes an output block of size M×K from an input block of size K×N. Then you can tile the full layer as:

• Split outputs into M-sized row blocks.
• Split inputs into K-sized column blocks.
• Split activations into N-sized column blocks.

Best practice: keep a K×M weight submatrix resident on the host or accelerator memory until all N activation columns that need it are processed. That reduces weight reloads.

Example: If you process a batch of activations in chunks of N=64 columns, load each weight block once, run 64 columns through the tile, then move to the next weight block. If you instead reload weights for every smaller activation slice, you pay extra transfer cost and add synchronization overhead.

Activation Streaming and Layout

Activations often dominate bandwidth because they change every inference step. You want a streaming layout that matches how the photonic tile consumes inputs.

Two practical choices:

1. Column-major streaming: stream activation columns so each tile sees contiguous K elements for each output column.
2. Row-major streaming with packing: stream rows but pack K-sized segments into a tile-friendly buffer.

Best practice: prefer the layout that minimizes packing. Packing is not free; it costs cycles and can require temporary buffers that increase memory traffic.

Example: If your tile expects K inputs per run and your activations are already stored as contiguous K segments, you can DMA directly into the input buffer. If not, you pack once per activation chunk and reuse the packed buffer across all output tiles that share the same activation chunk.

Double Buffering for Overlap

Even with good tiling, transfers and computation must be overlapped. Double buffering uses two sets of buffers so one is being filled while the other is being used.

A simple schedule for one layer:

• Buffer A holds weights and activations for tile run i.
• Buffer B holds weights and activations for tile run i+1.
• While the photonic tile computes with Buffer A, the host transfers the next data into Buffer B.

This works best when the compute time is long enough to hide transfer latency. If compute is too short, you increase the chunk size (larger N or larger K blocks) so each run does more work per transfer.

Example: Scheduling a Tiled Layer Run

Consider a layer with W of shape (M_total×K_total) and X of shape (K_total×N_total). Choose tile sizes M=128, K=64, N=32.

1. For each output row block m0 in steps of 128:

   • For each input column block k0 in steps of 64:
     • Load W[m0:m0+128, k0:k0+64] into the weight buffer.
     • For each activation column block n0 in steps of 32:
       • Stream X[k0:k0+64, n0:n0+32] into the input buffer.
       • Run the photonic tile to accumulate partial outputs for Y[m0:m0+128, n0:n0+32].

2. After finishing all k0 blocks, finalize Y for that m0 and n0.

Best practice: accumulate partial sums in a digital accumulator buffer sized for the output tile. That avoids trying to store intermediate optical results and keeps the photonic part focused on the linear multiply.

Data Format Matching to Avoid Hidden Costs

Memory movement includes more than bytes. If weights must be converted into phase/amplitude control parameters, do it in a way that aligns with residency.

Best practice: precompute and store the photonic control parameters for each weight tile block, not for every activation chunk. Then each run only transfers control parameters already in the correct format.

Example: If quantization maps weights to discrete phase steps, store the phase-step indices per tile. During inference, you transfer indices and let the photonic control layer apply them directly, rather than recomputing quantization per activation batch.

Summary Checklist

• Load each weight tile block once per set of activation columns.
• Stream activations in a layout that avoids repeated packing.
• Use double buffering to overlap transfers with photonic compute.
• Accumulate partial outputs digitally per output tile.
• Match stored data formats to the photonic control interface to prevent conversion overhead.

9.4 Scheduling and Data Reuse to Reduce Energy Use

Photonic matrix multiplication is fast, but energy is still spent on moving data, keeping optical paths aligned, and driving control elements. Scheduling decides when each tile runs, and data reuse decides how many times you pay those costs for the same values.

Core Idea: Separate Compute Order from Data Movement

Treat the photonic accelerator as a set of linear operators that consume encoded inputs and produce detected outputs. The digital host handles packing, quantization, and buffering. A good schedule keeps the photonic tiles busy while minimizing re-encoding and reloading.

A practical rule: if a value is reused across multiple output rows or columns, keep it in the host buffer long enough to feed several photonic runs. If a tile’s configuration changes, batch work that uses the same configuration.

Step 1: Partition Work into Reuse-Friendly Blocks

For a layer with output Y = A·W, split W into column blocks W0, W1, … and split A into row blocks A0, A1, … so that each photonic run computes a partial product. A typical block computes Y_block = A_i · W_j.

Reuse comes from choosing block sizes so that either A_i stays resident while you sweep across multiple W_j, or W_j stays resident while you sweep across multiple A_i. Which is better depends on where the bottleneck is:

• If weights are large and change slowly, keep W_j in the host buffer and stream A_i.
• If activations are large and change quickly, keep A_i and stream W_j.

Example: Suppose A has shape [M, K] and W has shape [K, N]. If N is big and you can afford to buffer a few activation blocks, compute Y in column blocks so each activation block A_i feeds several W_j blocks before you evict it.

Step 2: Use Accumulation to Avoid Recomputing

When you tile along K, each output block needs a sum of partial products:

\(Y[:, j] = Σ_i (A_i · W_i,j)\)

Scheduling should compute all K-tiles for a given output block before moving on, so you accumulate partial sums in host memory (or in a small on-chip buffer) rather than re-running earlier tiles.

Easy example: If K is split into two halves, run the photonic tile twice for the same output columns, then add the two detected results digitally. This costs two optical executions, but it avoids recomputing the same A half with the same W half in a different order.

Step 3: Batch Configuration Changes

Photonic meshes often require phase settings that correspond to a particular weight block. If your host reprograms phase shifters for every tiny block, control energy and setup latency rise.

A simple batching strategy:

1. Fix a weight block W_j.
2. Sweep multiple activation blocks A_i through the same configured mesh.
3. Only then reconfigure for the next \(W_{j+1}\).

Example: For a mesh that maps K inputs to B outputs, configure it once for W_j that targets those B outputs. Then run A_0, A_1, A_2 sequentially, accumulating or stacking outputs as required.

Step 4: Overlap Transfers with Compute Using Double Buffering

Energy is wasted when the photonic tile waits for data. Double buffering lets you overlap:

• While the photonic tile computes on buffer 0, the host prepares buffer 1 (packing, quantizing, and encoding parameters).
• When compute finishes, swap buffers.

Concrete example: If packing A_i into the encoding format takes time T_pack and photonic execution takes T_phot, you want T_pack ≤ T_phot so the tile rarely idles. If T_pack is larger, increase block size so each packing step feeds more compute.

Step 5: Keep Optical Power Where It Belongs

Scheduling affects required optical power because noise and loss determine detection quality. If you run many small blocks, you may need higher power to keep signal-to-noise acceptable, which increases optical and detection energy.

So, prefer blocks that:

• Use enough optical signal to stay above detector noise without saturating.
• Avoid excessive reconfiguration that forces conservative margins.

Example: If your detector saturates at high intensity, you can reduce optical power by using a slightly larger block that averages better across multiple contributions, rather than shrinking blocks and compensating with more power.

Step 6: A Minimal Scheduling Template

Use a loop order that maximizes reuse and minimizes reconfiguration:

• Outer loop over weight column blocks W_j.
• Middle loop over activation row blocks A_i.
• Inner loop over K-tiles if needed for accumulation.

Within each (i, j), compute partial products for all K-tiles, accumulate detected outputs, then proceed.

This template is simple, but it captures the main energy levers: fewer reprogramming events, fewer redundant encodings, and less idle time waiting for data.

9.5 Worked Example: Mapping a Convolutional Layer to Photonic Operations

We map a small convolutional layer onto a photonic matrix-multiplication pipeline by turning the convolution into a structured matrix multiply. The key idea is to use the same photonic hardware primitive—linear transforms implemented by an interference mesh—while handling convolution-specific structure through input layout and output reshaping.

Step 1: Choose a Concrete Convolution

Assume input tensor shape (C_in=3, H=5, W=5), kernel size (K=3), stride s=1, padding p=1, and output channels C_out=4. With padding, output spatial size is H_out=W_out=5. A single output pixel y[n, i, j] is a dot product between a 27-element patch (3 channels × 3×3) and the corresponding 27 weights for output channel n.

Best practice: keep the patch size small enough that the photonic matrix dimension is manageable. Here, 27 is friendly because it maps cleanly to a 32-wide padded vector.

Step 2: Convert Convolution to Matrix Multiply

Use an im2col-style layout. Flatten each 3×3×3 patch into a vector x_p of length 27. For each output channel n, weights w_n form a vector of length 27. Then each output pixel is:

\(y[n, i, j] = \sum_{k=0}^{26} w_n[k] · x_p[k]\)

Stack all output channels into a matrix W of shape (C_out=4) × (27). For each spatial location (i, j), the photonic device computes y_vec = W · x_p.

To process the whole feature map, you repeat this for all 25 spatial locations. You can do it sequentially (25 shots) or in parallel by batching multiple patches into separate optical channels.

Step 3: Define Photonic Matrix Dimensions and Padding

Photonic meshes often prefer square or near-square transforms. Choose a mesh that implements a (M_out × M_in) linear map. Here, set M_in=32 and M_out=4 (or pad outputs to 8 if your mesh is more symmetric).

Pad x_p from length 27 to 32 by appending four zeros. Pad W from (4×27) to (4×32) by appending four zero weight columns. This keeps the optical transform linear and avoids special-case logic.

Best practice: zero padding is safer than trying to “compress” dimensions, because the photonic mesh is already an analog linear operator.

Step 4: Map to a Photonic Linear Transform

A typical photonic matrix multiply uses an interference mesh to realize a complex linear transform. Since neural weights and activations are real, you implement real multiplication using one of two common strategies:

1. Single-rail with signed encoding: represent positive and negative values using two nonnegative optical channels (difference encoding).
2. Two-rail complex-to-real: use quadrature components so that the detected intensity difference corresponds to a real dot product.

For clarity, use difference encoding.

• Encode each input vector element x_p[k] as two nonnegative values: x⁺[k]=max(x_p[k],0), x⁻[k]=max(-x_p[k],0).
• Encode weights similarly or incorporate sign into the weight programming.
• The photonic outputs compute dot products for the positive and negative parts, then you subtract electronically.

Step 5: Worked Numerical Example for One Pixel

Pick one output channel n=0. Suppose the 27-element patch x_p contains values (after normalization) and the 27 weights w_0 are known. Create x_p⁺ and x_p⁻ arrays.

Let the photonic mesh compute:

• \(a = Σ_k w_0[k] · x⁺[k]\)
• \(b = Σ_k w_0[k] · x⁻[k]\)

Then y[0, i, j] = a − b.

If your mesh supports M_in=32, you include four extra columns of zeros in the programmed weight matrix so those padded inputs contribute nothing.

Step 6: Layout for All Spatial Locations

You have 25 patches. A practical mapping is:

• Run the photonic multiply for one patch at a time, producing a 4-element output vector.
• Store the 4 outputs into the output tensor at indices (n, i, j).

If throughput is critical, batch multiple patches by using different optical wavelengths or time slots, then demultiplex at detection. The matrix multiply remains the same; only the input scheduling changes.

Step 7: Reshaping and Bias

After computing y_vec for each (i, j), reshape into (C_out, H_out, W_out). Add bias b[n] electronically after detection:

y[n, i, j] ← y[n, i, j] + b[n]

Bias addition is cheap and avoids forcing the photonic mesh to represent affine transforms.

Step 8: Practical Checklist for This Mapping

• Confirm padding and patch extraction match the convolution definition.
• Ensure the photonic programmed matrix includes zero columns for padded inputs.
• Use difference encoding consistently so subtraction happens after detection.
• Keep bias and any activation function outside the photonic linear stage.
• Validate with a single pixel first, then scale to all (i, j) locations.

This approach turns the convolution’s local connectivity into repeated structured dot products, letting the photonic mesh do what it does best: fast linear mixing with minimal digital arithmetic.

10.1 Calibration Objectives and Measurement Setup Requirements

Calibration is the process of turning a physical photonic mesh into a predictable linear operator. In practice, you are estimating how the device maps known optical inputs to measured outputs, then using that estimate to correct or compensate errors during inference.

Calibration Objectives

Objective 1: Measure the implemented transfer matrix. The core deliverable is an estimate of the complex linear transform from input waveguide fields to output fields. For intensity-only readout, you still need a model that connects your chosen encoding to the detected signals.

Objective 2: Identify systematic errors versus random noise. Phase shifter offsets, coupling imbalance, and waveguide loss are systematic. Detector noise and laser intensity fluctuations are random. Separating them determines whether you should average, re-calibrate, or adjust the model.

Objective 3: Ensure repeatability across operating conditions. Even if the mesh is stable, the measurement chain may not be. You want to confirm that the calibration remains valid when you change input power within the linear regime and when you repeat the same settings.

Objective 4: Provide a usable correction workflow. Calibration is not just measurement; it must feed into an inference-time procedure. That might mean updating a stored transfer matrix, fitting a correction model, or generating per-output scaling and phase compensation.

Measurement Setup Requirements

A good setup makes the calibration problem well-posed. That means you can control inputs, measure outputs with sufficient signal-to-noise ratio, and keep the device in the same state during the entire calibration run.

Laser coherence and wavelength control. Interference-based calibration assumes stable phase relationships. Use a narrow linewidth source or a configuration that maintains coherence over the relevant optical path differences. Keep wavelength fixed during a run; if you must tune, treat it as a separate calibration condition.

Input preparation and switching. You need a way to excite specific input channels one at a time (or in controlled groups) with known relative phases. Typical approaches include:

• A fiber-to-chip coupling stage with controllable input routing.
• On-chip or external optical switches that select which input waveguide receives light.

Output detection and synchronization. Measure each output channel with a detector chain that has known gain and stable bandwidth. If you use time-multiplexing or scanning, ensure that the detector integration window matches the modulation or switching cadence.

Reference channels and normalization. Include at least one reference measurement to track laser power drift and coupling changes. Normalize each output by the corresponding reference so the calibration captures device behavior rather than measurement chain fluctuations.

Dynamic range and linearity checks. Before collecting calibration data, verify that detectors remain in their linear region for the chosen optical power. If you saturate, your estimated transfer matrix will be biased in a way that no amount of averaging can fix.

Thermal and mechanical stability. Phase shifters and couplers are sensitive to temperature and stress. Let the system reach a steady operating point, then minimize mechanical disturbances. During a calibration run, avoid changing anything that could move the optical alignment.

Systematic Measurement Plan

A practical plan starts with a small sanity test, then scales up.

1. Single-channel characterization. Excite each input channel individually and record the output intensity vector. This reveals gross routing issues, dead channels, and extreme loss.
2. Phase-sensitive calibration using controlled settings. For each input, apply a small set of phase-shifter configurations that allow you to infer complex response. A common pattern is to use phase steps that produce distinct interference fringes at each output.
3. Repeatability measurement. Re-run a subset of configurations at the end of the run. If results drift beyond your noise floor, you need tighter stabilization or shorter measurement bursts.
4. Model fitting and validation. Fit the transfer matrix (or a structured approximation) and validate by predicting outputs for held-out input patterns.

Example: Minimal Setup Verification Before Full Calibration

Suppose you have 4 input channels and 4 output channels, and you plan to estimate a transfer matrix using phase-stepped interferometry.

• First, excite input 1 alone at a moderate power and record all outputs. Repeat for inputs 2–4. If any output is consistently near zero while others are not, flag a routing or coupling issue.
• Next, for input 1, apply two phase settings that should produce different interference outcomes at a chosen output. If the measured output does not change beyond detector noise, either the phase shifter is not affecting the optical path as expected or the encoding-to-detection model is mismatched.
• Finally, repeat the same input 1 measurement at the end of the run. If the normalized output differs significantly, you likely have drift in alignment, temperature, or reference normalization.

These checks are small, fast, and they prevent you from spending hours collecting data that cannot be trusted.

10.2 Estimating Transfer Matrices From Measured Responses

A photonic mesh implements a linear transform between input optical channels and output channels. In practice, you estimate the transform by measuring how known input patterns map to measured outputs, then fitting a matrix that best explains the data. The goal is not just “a matrix,” but a matrix with a clear error model and a repeatable procedure.

Core Setup and Notation

Assume there are N inputs and M outputs. Let the unknown transfer matrix be W (M×N). For an input vector x, the ideal complex field at outputs is y = W x. Your measurement produces samples of y for multiple known x patterns.

Because detectors usually measure intensity, you often work with a calibration scheme that yields complex field estimates or an equivalent linearized measurement. If you can only measure intensity directly, you still estimate W by using phase-stepping or interferometric reference channels so that the resulting equations become linear in the unknown parameters.

Measurement Plan That Makes Fitting Well-Behaved

You choose a set of K input patterns {x₁,…,x_K} and record corresponding outputs {y₁,…,y_K}. Stack them into matrices:

• X = [x₁ x₂ … x_K] (N×K)
• Y = [y₁ y₂ … y_K] (M×K) Then the linear model becomes Y ≈ W X.

A good plan ensures X has enough independent excitation. If X is rank-deficient, multiple W values explain the same data, and your estimate becomes unstable. A simple rule: use at least K ≥ N patterns for each output row, and prefer K > N when noise is present.

Estimation Methods from Linear Algebra

If you have complex-valued y samples and X has full column rank, the least-squares estimate is:
Ŵ = Y Xᵀ (X Xᵀ)⁻¹
More generally, use the pseudoinverse:
Ŵ = Y X⁺
This automatically handles overcomplete measurements (K > N) and reduces sensitivity to noise.

In practice, you also weight measurements. If some outputs have higher noise (for example, lower optical power), weighted least squares improves accuracy by giving those samples less influence.

Example: Estimating a 3×3 Transfer Matrix

Suppose N = M = 3. You choose K = 6 input patterns to improve robustness. Let X be 3×6 and Y be 3×6.

1. Generate patterns: x₁ = [1,0,0]ᵀ, x₂ = [0,1,0]ᵀ, x₃ = [0,0,1]ᵀ, and three additional patterns with known phase offsets, such as x₄ = [1,1,0]ᵀ/√2, x₅ = [1,0,1]ᵀ/√2, x₆ = [0,1,1]ᵀ/√2.
2. Measure y₁…y₆ at the outputs using your interferometric scheme to obtain complex estimates.
3. Form X and Y and compute Ŵ = Y X⁺.
4. Validate: for each k, compute residual r_k = y_k − Ŵ x_k. If residuals are large for specific patterns, it usually indicates either a measurement issue (wrong phase reference) or a model mismatch (for example, saturation or nonlinear detector response).

A practical best practice is to normalize each input pattern to the same total optical power. Otherwise, the fit may “learn” power differences as if they were transfer differences.

Handling Intensity-Only Measurements Without Losing Your Mind

If you only measure intensities, y_k is not linearly related to W. A common approach is to introduce a reference path and perform phase stepping so that the measured intensity varies sinusoidally with the phase. From those samples, you reconstruct the complex field at each output for each input pattern.

The key is to keep the phase stepping consistent across outputs. If the phase reference drifts during the sequence, the reconstructed complex values become biased, and the least-squares fit will compensate incorrectly.

Regularization and Conditioning Checks

Even with K ≥ N, X can be poorly conditioned when patterns are nearly collinear. Regularization adds a penalty that discourages extreme matrix entries. A simple approach is ridge regression:
Ŵ = Y Xᵀ (X Xᵀ + λ I)⁻¹
Choose λ small enough that it reduces noise amplification without washing out real structure. You can select λ by monitoring how residual error trades off against coefficient magnitude.

Validation Metrics That Actually Matter

Use at least three checks:

1. Residual norm: ||Y − Ŵ X||
2. Per-output error: statistics of ||y_k − Ŵ x_k|| across k
3. Column-wise consistency: if you excite one input at a time, the corresponding columns of Ŵ should match those single-input measurements within expected noise.

When these checks disagree, the fix is usually procedural: inconsistent normalization, phase reference errors, or detector nonlinearity. The math is rarely the culprit.

Worked Micro-Workflow for Repeatability

• Fix a channel ordering and stick to it.
• Normalize each x_k to a known power.
• Measure a small calibration set first and compute a quick Ŵ.
• Inspect residuals per output; re-measure only the worst channels.
• Refit using the updated dataset and record the residual statistics.

This workflow turns transfer matrix estimation from a one-off calculation into a controlled measurement step, which is exactly what you want when later stages depend on the accuracy of Ŵ.

10.3 Closed Loop Tuning for Phase and Amplitude Alignment

Closed-loop tuning is the practical step that turns an ideal photonic mesh into something that behaves like the matrix you asked for. The goal is simple: adjust each controllable element so the measured transfer matches the target within an error budget, while keeping the procedure stable and repeatable.

Core Idea and What You Measure

A photonic mesh implements a linear transform from input optical fields to output fields. In practice, you do not directly measure fields; you measure detected intensities (and sometimes interferometric quadratures). That means the loop must be built around measurable quantities.

Start by defining a calibration target for each output channel. For example, if you want output row i to represent a specific set of weights, you can inject a known basis input (one input waveguide excited at a time) and record the resulting output detector responses. The measured response vector becomes your “observed transfer” for that basis.

Best practice: choose a tuning metric that matches your downstream use. If inference only needs relative scaling, normalize each measured response by a reference detector. If sign matters via differential detection, tune using the differential metric rather than raw intensity.

Loop Structure from Basics to Control

A robust closed loop has four stages: excite, measure, estimate, update.

1. Excite: Apply a small set of basis patterns. Keep them consistent across iterations so the loop does not chase changing illumination.

2. Measure: Record detector outputs with fixed integration time and stable optical power. If you vary power, your loop will “correct” power drift as if it were phase error.

3. Estimate: Compute how far the current mesh response is from the target. A common approach is least-squares fitting of the effective transfer parameters.

4. Update: Adjust phase shifters and amplitude controls using a step rule that avoids overshooting.

Best practice: use incremental updates. If you change many actuators at once with large steps, you can create nonlinearity that breaks the linear assumption behind your estimator.

Phase Alignment and Amplitude Alignment Together

Phase and amplitude errors often trade off. A phase shifter error can look like an amplitude error after detection, especially when you use intensity-only readout. To keep the loop from mixing them blindly, separate the tasks.

A practical strategy is two-stage tuning:

• Stage A: Phase alignment using an interferometric metric that is sensitive to phase. For instance, measure two outputs that form a differential pair and tune to maximize the expected contrast.
• Stage B: Amplitude alignment using a metric on total detected power (or normalized power) once phase is roughly correct.

Best practice: after each stage, run a quick verification basis set. If phase alignment is poor, amplitude tuning will compensate incorrectly and increase error elsewhere.

Example: Tuning a Two-by-Two Interferometer Block

Consider a simple 2×2 block with one tunable phase in each arm and a controllable coupling ratio. You want it to approximate a target matrix that performs a rotation.

1. Inject basis input [1, 0] and measure both outputs: you get detector readings D1 and D2.
2. Inject basis input [0, 1] and measure outputs again: you get D3 and D4.
3. Compute an error vector comparing normalized measured responses to the target responses.
4. Update actuators in small steps:
   • If the differential contrast between the two outputs is too low, adjust the phase shifters first.
   • Once contrast matches, adjust the coupling ratio to match the relative magnitudes.

Best practice: use a step schedule. Start with larger steps to escape gross mismatch, then reduce step size when the error metric decreases slowly. This prevents the loop from “buzzing” around a solution.

Example: Linearized Update Using Finite Differences

When the relationship between actuator settings and measured responses is locally smooth, you can estimate sensitivities by probing small actuator perturbations.

• Pick one actuator k.
• Measure the response at the current setting.
• Apply a small delta to actuator k.
• Measure again.
• The difference approximates the local gradient of the response with respect to actuator k.

Then solve a small linear system to choose actuator updates that reduce the error metric.

Best practice: reuse measured sensitivities for a few iterations if the operating point stays close. Recomputing gradients every time is expensive and can inject measurement noise into the loop.

Convergence and Stopping Criteria That Actually Work

Stopping is not just “error below threshold.” Use a combination:

• Metric threshold: the main error metric falls below a target.
• Stability check: the error does not improve for a fixed number of iterations.
• Actuator sanity: updates become small compared to actuator resolution.

Best practice: log per-output residuals. If only a subset of outputs stays wrong, you likely have a localized issue such as a stuck phase shifter or a detector channel with abnormal gain.

Practical Checklist for Repeatable Tuning

• Keep optical power and integration time fixed across iterations.
• Use normalized metrics when absolute power is uncertain.
• Tune phase before amplitude when using intensity-only detection.
• Update actuators incrementally and in sensible groups.
• Verify with a held-out basis set, not only the basis used for fitting.
• Stop based on both error and update magnitude.

A good closed loop behaves like a careful editor: it makes small corrections, checks the result, and stops when the remaining mistakes are within the margin you can tolerate.

10.4 Verification Metrics for Matrix Accuracy and Stability

Photonic matrix verification has two jobs: confirm that the implemented transform matches the target matrix, and confirm that it keeps matching after time, temperature, and repeated use. The tricky part is that “accuracy” and “stability” are not the same metric, and you need both to avoid fooling yourself.

What You Measure First

Start with a simple, repeatable measurement protocol.

• Define the target transform: the matrix you intended the mesh to realize, including any scaling conventions used by your encoder and detector model.
• Choose the verification stimulus set: use a small set that still exercises all degrees of freedom. A common baseline is one-hot inputs (basis vectors) plus a few random vectors.
• Fix the evaluation pipeline: the same preprocessing and postprocessing must be used for both calibration and verification, including normalization and sign handling.

Easy example: If your layer is 4×4, measure responses for four one-hot inputs. Each output vector gives you one column of the realized matrix (up to a global scaling factor). Then compare the assembled realized matrix to the target.

Matrix Accuracy Metrics

Accuracy metrics should separate “direction” errors from “magnitude” errors and should work for complex-valued optical transforms.

• Column-wise relative error: for each input basis vector \( e_j \), compare the measured output (y_j) to the expected output (A e_j). Use a relative norm ratio so that one large column doesn’t dominate.
• Normalized mean squared error: compute \(\text{NMSE} = |A_{real}-A_{target}|*F^2 / |A*{target}|_F^2\). This is a single number that’s easy to track across firmware or calibration changes.
• Cosine similarity per column: compare the output vectors after normalizing their norms. This highlights phase and interference errors even when overall gain drifts.
• Singular value mismatch: compare the singular values of realized and target matrices. If singular values shift, you may see systematic changes in how the layer amplifies or attenuates features.

Easy example: Suppose your target column vectors have the right phase pattern but your measured outputs are consistently 5% too large. NMSE will reflect both phase and magnitude, while cosine similarity per column will stay high, telling you the interference is mostly correct.

Stability Metrics over Time and Reconfiguration

Stability is about how metrics change between measurements.

• Session-to-session drift: measure the same stimulus set at multiple times and compute the variance of NMSE and cosine similarity.
• Intra-session repeatability: repeat the same measurement without changing settings to estimate noise-limited variability.
• Reconfiguration sensitivity: if you update weights, verify that the accuracy change is consistent with the intended update rather than random wandering.
• Transfer-matrix consistency: if you estimate a realized matrix at time \( t_1 \) and again at (t_2), compute \(|A(t_2)-A(t_1)|_F\) after aligning any global scaling.

Easy example: If NMSE jumps after weight updates but returns after a short recalibration, the issue is likely control settling rather than optical instability.

Alignment and Normalization Rules

Most verification mistakes come from inconsistent scaling.

• Global gain alignment: if your detection model includes an unknown gain, estimate a single scalar \(\alpha\) that minimizes \(|\alpha A_{real}-A_{target}|_F\) before computing accuracy metrics.
• Per-column gain alignment: use only if your system intentionally allows column-dependent gain. Otherwise, it can hide real errors.
• Phase reference handling: if the optical phase reference is arbitrary, compare using metrics that are invariant to a global phase, or explicitly align phase using a reference output.

Worked Example with Practical Thresholds

Assume you measured a 4×4 realized matrix and computed NMSE and cosine similarity per column.

• Step 1: Align global gain using a scalar \(\alpha\).
• Step 2: Compute NMSE for the aligned matrices.
• Step 3: Compute cosine similarity per column to identify which inputs suffer interference errors.
• Step 4: Repeat after 30 minutes and compute the same metrics.

A useful reporting pattern is a small table per layer:

• NMSE mean and standard deviation across time
• Minimum cosine similarity across columns
• Worst-case column-wise relative error

If NMSE stays flat but cosine similarity drops for one or two columns, you likely have localized phase drift or a calibration mismatch affecting specific paths. If both NMSE and cosine similarity degrade together, the problem is more global, such as gain drift or detector scaling changes.

Verification Checklist That Prevents Common Failures

• Use the same preprocessing and normalization for target and measured outputs.
• Align global gain and phase consistently before computing accuracy.
• Separate noise-limited repeatability from true drift.
• Report both a global metric (NMSE) and a structure-sensitive metric (cosine similarity or singular values).
• Track stability after the exact operations you perform in the workflow, including weight updates and any settling delays.

10.5 Worked Example: Calibration Workflow for a Small Mesh

This example calibrates a 4×4 programmable photonic mesh that implements a target linear transform. The goal is to estimate the mesh’s effective transfer matrix, then tune phase shifters so the measured response matches the target within a chosen error tolerance.

Step 1: Define the Target and the Error Metric

Pick a target matrix \(T\) with real-valued entries for simplicity, such as a 4×4 block that mixes inputs with a mild pattern:

• Row 1: [0.5, 0.5, 0, 0]
• Row 2: [0.5, -0.5, 0, 0]
• Row 3: [0, 0, 0.5, 0.5]
• Row 4: [0, 0, 0.5, -0.5]

Use an error metric that matches your detection model. A common choice is normalized mean squared error on the complex field transfer (if you can measure phase) or on the detected intensities (if you only measure power). For this workflow, assume you can measure complex outputs using a phase-referenced method, so you calibrate the complex transfer matrix \(\hat{T}\).

Step 2: Choose Calibration Inputs That Make the System Identifiable

For a mesh with (N=4) inputs, you need enough independent measurements to solve for the effective transfer. A practical approach is to inject one input at a time while keeping others off, then repeat with a small set of known input phase offsets.

Example input set:

• For each input \( j\in{1,2,3,4} \), inject a unit amplitude into \(j\) and measure all four outputs.
• Repeat for two input phase offsets: 0 and \(\pi/2\).

This yields 4 inputs × 2 phase conditions × 4 outputs = 32 complex samples, which is plenty to estimate a 4×4 complex transfer.

Step 3: Establish a Measurement Baseline and Data Hygiene

Before tuning, record a baseline with the mesh set to a known configuration, such as all phase shifters at their midpoints. Then:

• Verify detector linearity by checking that output scales proportionally with input power.
• Remove obvious outliers caused by saturation or misalignment.
• Store raw complex samples and the exact phase reference used.

A small but important best practice: keep the same optical alignment and reference path for every calibration run. If the reference drifts, your “error” becomes a measurement artifact.

Step 4: Estimate the Effective Transfer Matrix

From the measured outputs, build \(\hat{T}\) column-by-column. Each column corresponds to the response when a single input is excited.

If you measured complex fields, the column for input \(j\) is:

• \(\hat{T}_{:,j}\) = measured complex output vector for that input.

If you measured only intensities, you would need a different reconstruction method, but the rest of the workflow still applies: compare predicted outputs to measured outputs under the same excitation set.

Step 5: Compute a Tuning Direction for Phase Shifters

Let the mesh parameters be phase shifter settings \(\theta\). The tuning objective is: \[ \min_{\theta}\ |\hat{T}(\theta)-T|_F^2 \]

A practical method is iterative coordinate descent or gradient-free search when gradients are unreliable. For a small mesh, coordinate descent works well:

1. Pick one phase shifter.
2. Sweep it over a small range around the current value.
3. Choose the value that reduces the error metric.
4. Repeat for the next shifter.

Keep the sweep range small enough to avoid jumping between multiple local minima. If your phase shifters are quantized, sweep over the discrete levels only.

Step 6: Run a Closed-Loop Calibration Cycle

Perform cycles until the error stops improving.

• After each full pass over all phase shifters, re-measure the calibration inputs.
• Track the Frobenius norm error \(E_k=|\hat{T}_k-T|_F\).
• Stop when \(E_k\) decreases by less than a small threshold over two cycles.

A best practice that saves time: after the first cycle, identify which outputs are consistently wrong. If only two output rows show large error, you can focus tuning effort on the subnetwork that feeds those rows.

Step 7: Verify with Independent Test Vectors

Calibration inputs are not the same as verification inputs. Test with:

• Two random complex input vectors with known phases.
• One sparse input vector that excites only two inputs.

For each test vector \(x\), compare predicted output \(\hat{y}=\hat{T}x\) to measured output \(y\). Use relative error per output channel to see whether the mismatch is global scaling or a structural mixing error.

Worked Example: What You Should See in Practice

Suppose after the baseline, the measured transfer \(\hat{T}_0\) has correct magnitudes but wrong signs in the second and fourth rows. After one tuning cycle, the error drops sharply because the coordinate sweeps adjust phase relationships that control interference. After two cycles, the remaining error is mostly uniform across all entries in a row, which usually indicates a gain or normalization mismatch rather than incorrect mixing. You can then correct scaling in the detection model or input normalization, and re-run verification without further phase tuning.

Example: Minimal Implementation Checklist

• Confirm reference stability before any calibration run.
• Use one-hot inputs with at least two phase conditions.
• Estimate \(\hat{T}\) directly from measured complex outputs.
• Tune phase shifters with small discrete sweeps.
• Verify using independent random and sparse vectors.
• Stop when error improvement becomes negligible.

11.1 Case Study: Interference Based Multiply for a Fully Connected Layer

This case study implements one fully connected layer using an interference-based photonic multiply. The goal is to compute Y = XW + b where X is a batch of input vectors and W is a weight matrix. We focus on the linear multiply XW, then show how bias and scaling fit without breaking the optical model.

System Setup and Assumptions

We choose a small, concrete layer: X has shape [B, N], W has shape [N, M], and Y has shape [B, M]. The optical core realizes a linear transform from N input channels to M output channels.

A practical interference-based approach uses a programmable linear optical network that implements an M×N transfer matrix T. In the ideal case, T ≈ W up to known scaling and sign handling. In the real case, T is complex-valued, so we map real weights into optical degrees of freedom.

Encoding Inputs and Weights

Input encoding. For each input feature x_i, we drive an optical mode with a nonnegative intensity proportional to x_i after preprocessing. If inputs can be negative, we use a two-channel split: \(x_i = x_i^+ − x_i^-\), where both parts are nonnegative.

Weight encoding. Interference networks naturally produce complex amplitudes. To represent real weights, we use a common trick: represent each real weight w_ij as a difference of two nonnegative contributions, or use a calibration map that assigns a phase setting and amplitude scaling so that the detected intensity corresponds to the signed weight.

Detection model. Photodetectors measure intensity. To keep the computation linear in x, the architecture is arranged so that the detected signal for each output channel is proportional to a weighted sum of input intensities with a calibrated proportionality constant.

Worked Example with a Tiny Layer

Let N=3, M=2, and B=1 for clarity.

Choose:

• X = [1, 2, 0]
• W = [[1, -1], [0.5, 1], [2, 0]]
• b = [0.1, -0.2]

Reference multiply:

• Y0 = 1·1 + 2·0.5 + 0·2 + 0.1 = 2.1
• Y1 = 1·(-1) + 2·1 + 0·0 − 0.2 = 0.8

Optical realization:

1. Split signed weights or inputs so all optical drives are nonnegative.
2. Program the network so that each output channel’s calibrated response implements the corresponding column of W.
3. Measure detector outputs ŷ = k·(XW) where k is a known scale from calibration.
4. Apply digital scaling: Y = ŷ/k + b.

A key best practice is to keep k stable by using the same optical power range during calibration and inference. If you change the drive range, the detector response can become nonlinear, and the multiply stops behaving like a multiply.

Calibration and Verification Loop

Calibration estimates the effective transfer matrix T_eff that the network produces after programming. A systematic workflow:

• Inject basis inputs where one feature channel is “on” and others are “off”.
• Record output intensities for each basis input.
• Fit a linear model mapping programmed settings to effective weights.
• Reprogram using the inverse of that mapping so the realized transform matches the target W as closely as possible.

Verification uses a small set of random test vectors X_test. Compute Y_reference = X_test W + b digitally and compare to Y_optical after scaling. Track error per output channel and also the worst-case error across the test set.

Practical Mind Map: What Can Go Wrong

Best Practices Embedded in the Case

• Use a consistent normalization convention for both calibration and inference so the scale factor k is not a moving target.
• Prefer basis-based calibration for small to medium meshes because it directly measures the effective transform rather than relying on ideal component models.
• Validate with signed test vectors even if your training data is mostly positive; sign handling is where “it looks fine” often hides a real error.
• Add bias digitally after detection. Bias is constant per output channel, so doing it in software avoids forcing the optical network to represent an extra affine term.

This small example generalizes: once you can reliably map basis inputs to calibrated outputs, the interference network behaves like a programmable matrix multiplier, and the rest is careful bookkeeping—scales, signs, and verification.