Crosstalk

Engineers spend careers suppressing the signals that leak between neighbouring wires. Two simulated experiments asked whether that leak, or the delay inside a wire, could do a neural network’s job instead.

Contents
  1. tl;dr
  2. Leaky wires
  3. Three tests
  4. Switching off the crosstalk
  5. Against real wires
  6. Weights made of solder
  7. From coax to copper
  8. Counting the cost
  9. Brains and buckets
  10. Method and sources
  11. From the archive
Gold copper art on dark solder mask: a standing figure split down the middle, one half a solid silhouette with veins traced along the arm, the other half dithered machinery and wiring, beside a column of header pins and faint routed traces.

Can a delay line be the neural network?

In the first, a waveform passes through eight coupled wires and a simple classifier reads what comes out. It solves a timing puzzle that defeats the same classifier on the raw signal, with 0.995 accuracy against 0.724, but it keeps solving it after the wires are uncoupled. In the second, a network’s weights become resistors that are either soldered onto a delay line or left off, and a simulated board sorts radio signals with 0.878 accuracy.

Temporal XOR
0.995
Reservoir · raw samples 0.724
Weights as resistors
0.878
8-class modulation task, simulated LC ladder
Tile as first designed
0.17
0.87 once the gain is trimmed
Component tolerance
±0.6 pt
1,000 simulated boards, datasheet tolerances

tl;dr

A neural network learns by adjusting thousands of numbers called weights. This project asks whether the wires on a circuit board could do some of that work themselves.

Part one treats a bundle of eight wires like a pond. A signal dropped in spreads and mixes between neighbouring wires, and a simple program learns to read the ripples. It solves a timing puzzle the program cannot solve alone, and switching the mixing off shows what does the work: a simple squashing step applied to each wire as the signal passes.

Part two treats one long wire like a corridor with listening posts. A signal travels down it, and at each post the circuit adds what it hears, subtracts it, or ignores it. Those choices are the network’s weights, and each one is made by soldering a resistor in place or leaving the spot empty.

part one: wires as a pondsignal8 wiressimple readerpart two: a wirewith listening posts+ / − / nothing= the weights+−·+−Σout
Figure 1Part one is a pond; part two is a corridor with listening posts.

The player runs both experiments side by side, replaying recorded runs and computing the rest in the browser. The cards below it replay four of the results.

Both architectures, running

computed in browser · boardrecorded run · accuracy sweep
y1 1/divf≈ —pp 0.37y2 1/divf≈ —pp 0.04y3 1/divf≈ —pp 0.34y4 1/divf≈ —pp 0.2680 µs/divT startt = 16 µs125 kBdtap 0.96 µsIQ12345678line · 56 sections, a tap every 8+−+−+−+−difference amp → tanh → outputssymbol0.00.51.00246810accuracy against gain trim (dB) · recorded sweep0.17+1: resistor to the + summer−1: resistor to the − summer 0: empty footprint
modulationline Q
output swing max |y| = 0.26
Squashed near zero: the summers assume full drive, and a matched ladder delivers about half. The article measured accuracy 0.17 as designed and 0.87 with the gain trimmed by 8.98 dB. The plot is the recorded sweep; the board is computed here with the trained layer-1 kernels, first four of eight outputs.
Symbols, line and drive scaling are a drawn model (a one-pole low-pass per tap group, seeded random symbols at 8 samples per symbol); the ternary weights are the trained board network’s own, and the accuracy plot is the recorded gain sweep. On the simulated board line the article reports 0.878.

PART ONE · RESERVOIR

Leaky wires

On a circuit board, two copper traces 0.4 mm apart are close enough that a pulse sent down one appears, a little later and a little distorted, on the other: a leak called crosstalk. The first half of this project puts the leak to use. It sends a waveform into a bundle of eight coupled lines, records every line at every moment, and hands the recordings to a simple linear classifier. The approach is called reservoir computing: a fixed, untrained system scrambles a signal into a richer form that a simple readout can learn from.

drivenleakground plane
Figure 2A pulse on the driven trace reappears, smaller and later, on its neighbour.

Eight leaky lines

B field links neighbours · mutual Llaunch · 8 SMAcoupled run · 8 lines, 0.65 mm gapsreceive01 Launchone waveform enters each of eight lines through an SMA edge launch on the left.02 Couplethrough the middle the lines run 0.65 mm apart over a ground plane, and each leaks into its neighbours.03 Receivewhat arrives on the right is a mixture of all eight.
Figure 3Illustrative board · build123d model, isometric, hidden lines removed. Illustration of the physical bundle that the simulated reservoir stands in for; no such board has been built. Each line’s pulse is drawn in its own colour and smears slightly from line to line, which is the effect the reservoir models.

Only the readout learns. To see whether the bundle helps, the same readout is also trained on the raw waveform.

crosstalk, in one pictureC_mL_mdrivenlistenslaterfainterthe neighbour hears it,delayed and smaller
Figure 4Sketch of crosstalk: the coupling between two traces is a mutual capacitance C_m and a mutual inductance L_m.

The bundle in the drawing has not been built, and the software does not simulate a circuit. Its design notes call it “a physical metaphor, not a circuit solver”: a short NumPy loop that imitates delay, loss, leakage between neighbours and a soft ceiling on amplitude. Later sections test how close that imitation comes to real wires.

The simulation advances in steps of 20 nanoseconds, called slots. A waveform of 64 samples is fed in one sample per slot, and after every slot the state of all eight wires is written down, giving 8 × 64 = 512 numbers per waveform. At each step a wire keeps 99.5% of its previous value and adds the incoming sample, scaled by its own fixed gain. It also takes a share of its two neighbours’ values, set by a fixed mask, and passes the total through tanh, which squashes large values towards ±1.

Coupling mask

w0w70163248638 wires × 64 slots = 512 virtual nodes · one slot every 20 ns · 1280 ns round the loop01 Nodeone square is one wire at one tick of the slot clock: a virtual node holding one number.02 Maskdither density is the fixed coupling window sigmoid(m), 0.02 to 0.955. It gates how much each node hears itsneighbours, and never changes between inputs.03 Readoutall 512 states are flattened and handed to one logistic regression. Nothing else is fitted.
Figure 5tensor_8x64 · fixed coupling window, mask seed 0. Squares are sized by sigmoid(m), drawn at unit scale. At the first version’s scale of 0.01 every square would be the same size, because sigmoid(m) = 0.5.

Anatomy of a step

sw[t]=tanh⁡(λ sw[t−1] 1+u[t] pw 2+σ(mw,t) k1(sw−1[t−1]+sw+1[t−1]) 3+ε 4) 5s_w[t] = \htmlClass{lk-pen-blue}{\tanh}\htmlClass{lk-pen-blue}{\Big(} \htmlClass{lk-pen-teal}{\lambda\, s_w[t{-}1]\,{}^{\scriptscriptstyle 1}} + \htmlClass{lk-pen-amber}{u[t]\, p_w\,{}^{\scriptscriptstyle 2}} + \htmlClass{lk-pen-pink}{\sigma(m_{w,t})\, k_1 \big( s_{w-1}[t{-}1] + s_{w+1}[t{-}1] \big)\,{}^{\scriptscriptstyle 3}} + \htmlClass{lk-pen-violet}{\varepsilon\,{}^{\scriptscriptstyle 4}} \htmlClass{lk-pen-blue}{\Big)\,{}^{\scriptscriptstyle 5}}
sw[t]=tanh⁡(λ sw[t−1] 1+u[t] pw 2+σ(mw,t) k1(sw−1[t−1]+sw+1[t−1]) 3+ε 4) 5\begin{aligned} s_w[t] &= \htmlClass{lk-pen-blue}{\tanh}\htmlClass{lk-pen-blue}{\Big(} \htmlClass{lk-pen-teal}{\lambda\, s_w[t{-}1]\,{}^{\scriptscriptstyle 1}} + \htmlClass{lk-pen-amber}{u[t]\, p_w\,{}^{\scriptscriptstyle 2}} \\ &\quad + \htmlClass{lk-pen-pink}{\sigma(m_{w,t})\, k_1 \big( s_{w-1}[t{-}1]} \\ &\quad\quad \htmlClass{lk-pen-pink}{+ s_{w+1}[t{-}1] \big)\,{}^{\scriptscriptstyle 3}} \\ &\quad + \htmlClass{lk-pen-violet}{\varepsilon\,{}^{\scriptscriptstyle 4}} \htmlClass{lk-pen-blue}{\Big)\,{}^{\scriptscriptstyle 5}} \end{aligned}
wire w−1wire wwire w+1slot t−1slot tsw−1[t−1]sw[t−1]sw+1[t−1]sw−1[t]sw[t]sw+1[t]1λ = 0.995, memoryu[t]2× p, input profileσ(m)·k1σ(m)·k13crosstalk, gated by the mask4ε ~ N(0, 0.001²)Σ5tanh, limiterλ = 0.995k1 = 0.08pw ∈ [0.2, 1]ε ~ N(0, 0.001²)8 wires × 6 slotstslot t: every wire
Figure 6Reservoir update rule · one wire in one slot; every wire does the same. Every wire is updated the same way in the same slot, in parallel, and each wire hears only its own neighbours (the edge wires have one). The pink crosstalk term and the blue tanh limiter are the two parts that the switch-off tests disable.

The mask decides how loudly each wire hears its neighbours. In the project’s first version it was drawn so narrowly that every entry came out at 0.5, which made every connection identical and the mask pointless. Redrawn properly, its entries range from 0.02 to 0.955, with a mean of 0.496.

Config nameWires × slotsNodesDurationNeighbour coupling k1
tensor_8x648 × 645121,280 ns0.08
tensor_16x12816 × 1282,0482,560 ns0.06 (0.01 between wires two apart)
mnist_8x7848 × 7846,27215,680 ns0.08
Three reservoir configurations. All three share decay 0.995, noise 0.001, mask seed 0 and a single frequency band, and apply tanh both to the wire states and at the readout. In mnist_8x784 each slot takes one pixel of a 28 × 28 digit, read in raster order.

Every test uses the same readout, a standard logistic regression with identical settings and data splits. The only thing that changes is what it reads: the raw samples, or the 512 recorded states.

Three tests

The first test is a sanity check: telling apart six kinds of short waveform, including sine bursts, square bursts, chirps and pulses, with amplitudes matched so that only shape and timing differ. There are 64 examples of each, and a quarter are held back for testing.

Sine or square?

sine burstinw0w7square burstinw0w7chirpinw0w701 Inputone held-out waveform, 64 samples, one per slot.02 Statethe state of each of the eight wires after tanh, one row per wire, each in its own colour.03 Errorssine burst and square burst are the only pair either classifier ever confuses; every chirp, pulse and AM pulse isclassified correctly by both.
Figure 7Held-out examples · seed 1234 · signed state after tanh. Rows are the eight wires, columns the 64 slots. The two bursts drive almost the same pattern; over three seeds the readout tells them apart correctly 56 times in 96 with the reservoir and 52 times with raw samples.
SeedRaw samplesReservoirDifference
12340.8330.844+0.010
12350.8650.885+0.021
12360.8440.854+0.010
Mean ± sd0.847 ± 0.0160.861 ± 0.022+0.014 ± 0.006
Six-way classification · tensor_8x64. Accuracy on held-out waveforms. Chance is 0.167. Each seed trains on 288 waveforms and tests on 96.

The reservoir does better on every run, but never by more than the runs vary among themselves. Both readouts make only one kind of mistake, confusing sine bursts with square bursts; the other four shapes are identified perfectly. Across three runs the reservoir gets four more of those 96 cases right, 56 against 52, a margin the project’s own report describes as modest.

Temporal XOR was chosen because a reservoir should help with it. Each waveform may carry a pulse early, at sample 16, and another late, at sample 48. The answer is yes when exactly one pulse is present, and no when there are two or none. A linear classifier looking at the raw samples cannot express “one or the other but not both”, because it weighs each sample independently.

One pulse or two

a 0 · b 0 → falseaba 0 · b 1 → trueaba 1 · b 0 → trueaba 1 · b 1 → falseab01 Eventsa pulse at sample 16 if a is set, at sample 48 if b is set. The label is a XOR b.02 Mixingthe per-slot tanh bends each wire’s response, so “both” is not the sum of “a” and “b”. A linear readout of rawsamples cannot tell both from neither, and scores 0.724.03 Readoutthe same readout on these 512 states scores 0.995 ± 0.009.
Figure 8Temporal XOR · one example per case. Pulse positions are fixed, so the task is only to tell whether one, both or neither pulse occurred. The wire states differ visibly between the “both” and “neither” cases even where the input is quiet.
Raw samples
0.724
± 0.024 · chance 0.5
Reservoir
0.995
± 0.009
Seeds
1.000 · 1.000 · 0.984
Reservoir accuracy, by seed

On raw samples the classifier reaches 0.724 accuracy, mostly by answering yes when the answer is no (45 of 98 such cases across three runs). With the reservoir it gets 191 of 192 right, and reruns in October reproduced the figures exactly.

MNIST, the standard benchmark of 70,000 handwritten digits, was never designed with a reservoir in mind. Each 28 × 28 pixel image is read row by row as a waveform of 784 samples, one per slot, which gives 6,272 numbers per digit. All 60,000 training and 10,000 test images are used in their standard order, so the result can be compared with published ones.

At 2.8 gigabytes, those numbers would crowd the 8 GB laptop that ran the experiment, so they are streamed from disk and the classifier is trained in batches. A small neural network with one hidden layer, trained on the raw pixels, runs alongside as a reference because, as a comment in the code puts it, without one 0.91 and 0.92 are just two numbers.

Three tasks, two readouts

0.000.250.500.751.00classify · 6 waveformsraw samples0.847reservoir0.861temporal XORraw samples0.724reservoir0.995MNIST · 60,000 / 10,000raw pixels0.914reservoir0.915small MLP0.979dashed tick: chance for the task · whisker: ± 1 sd over three seeds
Figure 9tensor_8x64 and mnist_8x784 · three seeds each. Same linear readout, hyperparameters, split and seeds in both conditions; only the features change. MNIST also shows a one-hidden-layer MLP on raw pixels as a reference point.

Eight times as many numbers buy a tenth of a percentage point: 0.9146 accuracy against 0.9136, a difference smaller than its own uncertainty (+0.0011 ± 0.0014), and on one of the three runs the reservoir does worse. The small neural network scores 6.4 points above both. Digit by digit, the reservoir helps slightly with 2s and 6s and costs 2.2 points on 8s.

Digit by digit

0.850.900.951.000123456789digitrecall per digit, three seeds summedraw pixelsreservoirsmall MLP01 Similarraw pixels and reservoir features score within a point of each other on every digit.02 DifferencesThe reservoir gains 1.7 points on 2s and 1.0 on 6s, and loses 2.2 on 8s.03 Referencea one-hidden-layer MLP of 128 units scores above both on every digit, 6.4 points clear overall.
Figure 10MNIST test set · 10,000 digits × 3 seeds. Blue: raw pixels. Pink: reservoir features. Teal: the MLP. The first two use the same type of readout, 10 epochs and identical batch boundaries.

Switching off the crosstalk

Why does the reservoir solve XOR? Its design notes credit memory: the coupled wires hold on to the first pulse until the second arrives. If that were true, cutting the coupling or shortening the memory should break it. So each was switched off in turn, and so was the tanh, one change at a time with three runs each.

What breaks it

0.500.751.000.00.020.040.080.160.32k1 (tensor_8x64 uses 0.08)coupling between neighbours, k1raw xor 0.724raw classify 0.8470.500.751.000.50.80.90.950.990.995λ (tensor_8x64 uses 0.995)memory per slot, decay λraw xor 0.724raw classify 0.8470.000.250.500.751.00temporal XOR, remove the tanhtanh every slot0.995no tanh (linear)0.531dashed tick: chance for the task · whisker: ± 1 sd over three seeds01 CouplingXOR (pink) is still solved with the neighbours disconnected (k1 = 0), and six-way classification (teal) barelymoves. The hatched bands show each task’s gain over raw samples.02 Memorycutting the decay λ from 0.995 to 0.5, which halves a state every slot, leaves XOR at 1.000.03 Nonlinearityremove the per-slot tanh and XOR falls to 0.531, which is chance level with a wide spread.
Figure 11One knob at a time from tensor_8x64 · three seeds each. Pink: temporal XOR with the reservoir. Teal: six-way classification. Dashed lines: the raw-sample baselines, which do not change. The sweeps were run for this piece and are not in the project’s own results.

With the neighbouring wires disconnected, temporal XOR still scores 1.000. With the tanh removed, it scores 0.531.

Coupling turned out not to matter. With the neighbours disconnected, or with coupling anywhere from 0.02 to 0.32, XOR stayed at 1.000. Shortening the memory so far that a value halves every 20 nanoseconds, and nothing of the first pulse survives to the second, also left it at 1.000. Replacing tanh with a straight line dropped it to 0.531 ± 0.196, no better than guessing. Even reading a single wire instead of all eight barely mattered for XOR (0.990), though it cost four points on the six-waveform test (0.816).

The likely explanation is simpler than memory. Because the pulses always arrive at the same two moments, any fixed nonlinear distortion of the signal lets a linear classifier separate two pulses from none, and the tanh applied at every step supplies exactly that. Varying the pulse times would force the reservoir to remember, and would finally test what the coupling is for. That experiment has not been run.

why the tanh matters+Vin+in−Q1Q2matched NPN pair, width 2V_Tabout 51.7 mVinouttanhstraight linesquashedsquash → mixing becomesnonlinear → XOR possibletemporal XORwithout it: 0.531with it: 0.995
Figure 12Temporal XOR scores: 0.531 without the tanh, 0.995 with it.

The six-waveform test moved a little with coupling, from 0.858 with none to 0.875 at four times the default, but all the results sit within about two standard deviations of one another. A reservoir twice the size, 16 wires by 128 slots, scored the same as the original on both tasks.

Against real wires

A loop in NumPy is not a circuit, so a separate test bench checks that a circuit simulator, ngspice, produces the same numbers. A circuit has no clock stepping through slots, so the bench lays the slots out in space instead, as a chain of stages. Each term of the update becomes a current fed into a 1-ohm resistor, which turns the summed current into a voltage, and a component that behaves like tanh sits after the sum.

R_0_5_59   u0_5_59 0 1                          * 1 Ω: volts = summed amps
Gdc_0_5_59 0 u0_5_59 q0_5_58 0 0.995            * decay × own previous state
Gnl_0_5_59 0 u0_5_59 q0_4_58 0 0.0609           * sigmoid(m) × k1, left neighbour
Gnr_0_5_59 0 u0_5_59 q0_6_58 0 0.0609           * same gain, right neighbour
Gdr_0_5_59 0 u0_5_59 d0_59 0 0.4286             * input × this wire’s profile
B_0_5_59   q0_5_59 0 V=tanh(v(u0_5_59))         * the limiter
Figure 13one stage of the generated netlist · batch 0, wire 5, slot 59

Four waveforms through the 8-wire, 64-slot reservoir become 2,048 stages and 11,953 lines of circuit description, solved in a single pass with tolerances close to the limits of the arithmetic.

Two solvers

1e-171e-161e-15016324863slot (stage of the unrolled netlist)max |ngspice − NumPy| over 4 waveforms × 8 wiresdashed: float64 machine epsilon, 2.2e-16-101wires 0, 3, 7 of waveform 0 · NumPy lines, ngspice squares01 Unrolleach slot becomes a stage of controlled current sources into 1 Ω: 2,048 stages, 11,953 lines of netlist, oneoperating-point solve.02 Comparethe worst disagreement is 5.27e-16, at wire 5, slot 59, one step in the last printed digit.03 No growththe error does not grow along the slots, so rounding does not compound through the recurrence.
Figure 14ngspice 41 against NumPy · 8×64 · batch of 4 · noise off. Top: the largest disagreement at each slot on a log scale. Bottom: three wires from one waveform as NumPy computes them, with ngspice’s values marked as squares on every third slot.

The two programs agree to the last digit a computer can hold. The largest difference anywhere is 5.27e-16 (ngspice +0.162703485466625, NumPy +0.162703485466624), a single rounding step, and it does not grow along the chain. Writing the bench also turned up a bug in how the circuit version applied tanh.

Newer benches model the physical wires the loop stands in for. Three kinds of line, described by their resistance, inductance, capacitance and leakage per unit length, are chopped into short sections, simulated in ngspice, and checked against exact mathematical models and, for the microstrip, against the independent RF library scikit-rf.

+−EHL dxC dx∂V/∂x = −L ∂I/∂t∂I/∂x = −C ∂V/∂tv = 1/√(LC)Z₀ = √(L/C)120 µH, 120 pF → 1 kΩ, 120 ns a section
Figure 15A transmission line in section, with the telegrapher’s equations that describe it.
LineConductorsLengthSectionsDefined by
4-line PCB bus4100 mm64electrical matrices: C tridiagonal, L falling off with distance
Microstrip pair280 mm48geometry: 1.5 mm lines, 0.4 mm gap, 0.8 mm FR-4
LC ladder210 mm4lumped elements: the coarsest case the pipeline has to handle
Simulated line types. Loss is linearised at 1 GHz (skin-effect R, dielectric G = ωC tan δ with tan δ 0.02), which the code notes is accurate only in a band around that point.

A coupled pair, end on

ground planeFR-4 · εr 4.3 · tan δ 0.02w 1.5 mmgap 0.4h 0.8 mmcoupling k0.755Z even / odd137.4 / 19.19 Ωε eff even / odd4.017 / 2.640delay even / odd0.535 / 0.434 nsZ0, one line51.35 Ωthrough, −3 dB at≈ 370 MHz
Figure 16Benched microstrip pair · geometry and derived modal values. The geometry the RF bench uses for its coupled pair. The even-mode and odd-mode impedances (137.4 and 19.19 Ω) differ by a factor of seven, which is how tight coupling shows up in the numbers.

Signal and leak

0-20-40-600123GHzmicrostrip pair · 80 mm · k 0.755throughfar-end crosstalknear-end crosstalk−3 dB ≈ 370 MHz0-20-40-600123GHz4-line PCB bus · 100 mm01 Pairtwo lines 0.4 mm apart on 0.8 mm FR-4. Far-end crosstalk climbs to −3.7 dB, as strong as the through path past a fewhundred MHz.02 Busfour lines with weaker coupling: through loss −1.2 dB at 3 GHz, far-end crosstalk no worse than −37.5 dB.03 Checkngspice matches the analytic sectioned ladder to 1e-11 or better, and the ladder sits within about 1% of the exactdistributed line.
Figure 17ngspice .ac · port 0 driven, others in 50 Ω. Magnitude of the through path and of the leakage into the neighbouring line, at each end, with the dashed line at −3 dB. The coupled pair is the tightly coupled case and the four-line bus the weakly coupled one.

From 10 MHz to 3 GHz, ngspice matches the exact model of the sectioned line to within 1e-11 to 1e-13, and the sectioned line comes within about 1% of a continuous one. The tightly coupled microstrip pair is the extreme case (coupling k = 0.755): by about 370 MHz the driven line has lost half its power (3 dB), and the far end of the neighbouring line picks up a signal only 3.7 dB weaker than the input. As a reservoir that is a lot of mixing; as a bus it is unusable.

A pulse in flight

0.00.51.01.01.52.02.53.03.5nsvolts at the four ends of the pairline A, launch endline A, receive endline B, far endline B, near endflight 464.8 ps · predicted 481.601 Launcha 1 V, 0.5 ns pulse with 0.2 ns edges enters line A at 1 ns.02 Arriveit reaches the far end of the 80 mm line 465 ps later at 0.389 V peak, slightly ahead of the effective-permittivityestimate because the odd mode is faster.03 Leakline B, never driven, sees 0.105 V at its far end.
Figure 18ngspice .tran · 10 ps step · microstrip pair. Voltages at both ends of both lines of the coupled pair, from the transient simulation. The Fourier transform of the same response agrees with the AC sweep to 0.6% of peak on the through path.

A 1-volt pulse takes 464.8 picoseconds to cross the 80 mm pair, a little faster than the 481.6 ps predicted. A coupled pair carries a signal in two modes, and the faster one crosses in 0.434 ns against 0.535 ns for the slower. On the cleaner four-line bus the pulse takes 595 ps against 577.7 ps predicted. Converting the pulse’s journey into frequencies reproduces the frequency sweep to within 0.58% of peak.

For a single line, scikit-rf gives an impedance of 51.12 to 51.17 ohms between 0.1 and 5 GHz, against 51.35 ohms from the textbook formula. Modelling the copper’s 35-micrometre thickness widens the gap from 0.45% to 2%, so thickness accounts for most of it. Loss is 3.64 dB per metre at 1 GHz.

Joining the two halves would mean putting a real line inside the reservoir. A tool for that exists: it fits a compact mathematical model to how a line responds to a pulse, and the reservoir accepts the result as its coupling, provided the model is stable. On synthetic test systems it recovers the answer to 1e-12.

A quick attempt for this article, on the four-line bus, fitted badly (41% error at order 8, 21% at order 16) and gave models just past the stability limit (spectral radius 1.001 to 1.003), which the reservoir would refuse. The timescales also clash: the lines respond in hundreds of picoseconds, while the reservoir’s clock ticks every 20 nanoseconds, about forty times slower.

PART TWO · CROSSTALK

Weights made of solder

A delay line with taps is a 1-D convolution with the multiplications done by wiring.

Crosstalk article draft, November 2026
+0−++0−+delay line · 8 tapstanh
Figure 19Each of eight taps is wired plus, wired minus, or left empty.

Delay lines were among the first computer memories. The EDVAC report of 1945 described them, and the EDSAC computer kept its data in 32 tubes of mercury, each holding 560 bits as pulses of sound travelling from one end to the other, where they were caught and sent round again. A tap partway along such a line reads the signal as it was a fixed time ago. Weighted taps added together make a filter (Kallmann, 1940); learnable weights and a squashing function make one layer of a time-delay neural network (Waibel, 1989).

bits in flightread · re-inject
Figure 20Mercury delay-line memory: bits travel as sound and are re-injected at the start.

Crosstalk, the second half of the project, builds that layer with as little hardware as possible. Each weight can take only three values: a tap wired to the circuit that adds signals counts as +1, a tap wired to the one that subtracts them counts as −1, and an unconnected tap counts as 0. That makes it a ternary network, the restriction used by Microsoft’s BitNet b1.58 language models, and the weights need no memory, because they are the wiring. Each layer is a grid of resistor pads, two for every pairing of tap and output, and training decides which pads receive a resistor.

tapped line = convolutionΣoutLC+10−1try this:+1 = resistor to +−1 = resistor to −0 = leave the footprint emptythe pick-and-place filelists the weights
Figure 21Each tap is wired to the plus summer (+1), to the minus summer (−1), or left unconnected (0).

As a result, the file that tells an assembly machine where to place parts is the trained network. The design uses three boards, called tiles, each with eight delay lines and eight outputs; their placement files list 85, 315 and 316 resistors, and a script checks that these match the trained weights exactly. Each output takes the difference of its two sums and feeds a matched pair of transistors, whose response is itself a tanh, with a width set by physics: 2VT2V_T, about 51.7 mV at room temperature. A track-and-hold circuit then hands the result to the next tile in step with the clock.

+1 · −1 · empty = the model
Figure 22Resistors fitted to the pads are the non-zero weights.
uo[n]=∑i∑k=0K−1Woik  xi[n−kd],Woik∈{−1, 0, +1}u_o[n] = \sum_i \sum_{k=0}^{K-1} W_{oik}\; x_i[n - k d], \qquad W_{oik} \in \{-1,\ 0,\ +1\}yo[n]=gtanh⁡ ⁣(uo[n]+boVsat)y_o[n] = g \tanh\!\left(\frac{u_o[n] + b_o}{V_{\mathrm{sat}}}\right)receptive field=1+∑layersd (K−1)=1+3⋅7=22 samples\text{receptive field} = 1 + \sum_{\text{layers}} d\,(K-1) = 1 + 3 \cdot 7 = 22 \text{ samples}
Figure 23one layer · K = 8 taps, spacing d, weights ternary

Trained networks are usually pictured as grids of shaded squares, one per weight. Here each weight is a resistor that is either present or absent, so the same picture becomes a map of solder pads.

Two ways to store a weight

Float 1-D CNN weightsCrosstalk weights as the board holds themlayer 1 · 8 out × 2 in × 8 taps85 of 128 pads populatedlayer 2 · 8 out × 8 in × 8 taps315 of 512 pads populatedlayer 3 · 8 out × 8 in × 8 taps316 of 512 pads populatedlayer 1 kernels as frozen waveforms · I pink, Q blue · upper: CNN, lower: Crosstalk tapsout 0out 1out 2out 3out 4out 5out 6out 7tap delay 0 to 6.74 µs, 962.5 ns per tap on the designed ladder01 CNNthe usual way to show a trained network: every weight of the floating-point network as a continuous tone. A coarsedot screen means a positive weight and a fine one a negative weight.02 Crosstalkthe same grid for the delay-line network, as the tile would show it: a pink-outlined pad is a resistor to the +summer, a blue one is a resistor to the −, and a dashed pad is left empty. These are the populated resistors in theplacement file, one for one.03 Kernelsa kernel read along its taps is a frozen waveform. The CNN’s is a curve; the delay-line net’s is a row of ±1 stemsat the ladder’s tap spacing.
Figure 24Width 8 · three layers · 1,152 weights each side. Two networks of identical shape trained on the same windows: the float 1-D CNN from the nine-model comparison on the left, the board network on the right. Their kernels are not expected to match one for one. In the CNN a weight is a continuous number; in the board network it is a resistor that is fitted or not.

Training rounds each weight to −1, 0 or +1 on the way forward and lets the gradient pass straight through the rounding on the way back. A microcontroller handles the final steps (pooling, the eight-way readout and the decision), while the delays, the weighted sums and the nonlinearity stay analogue. None of these ideas is new. Pour and Ha (ISCAS 2025) ran an RF recurrent network on a tapped transmission line, Woo, Jung and Mukhopadhyay (2024) built ternary modulation recognition on an FPGA, and Tank and Hopfield used analogue delays in 1987. What the project adds is the whole chain: one set of trained weights carried through four levels of simulation to a routed circuit board, with every gap reported.

The task is recognising how a radio signal is modulated, choosing among eight schemes (OOK, BPSK, QPSK, 8PSK, 16QAM, 2FSK, 4FSK and GMSK) from snippets of 128 samples. The signals are synthetic, 16,000 for training and 4,000 for testing, at signal-to-noise ratios from 0 to 20 dB with random carrier phase. The results rank the project’s models against one another and cannot be compared with published RadioML scores.

Nine models, one task

0.000.250.500.751.001-D CNN0.9091,248 pCrosstalk, board-trained0.8781,275 pCumulant0.875208 pCrosstalk, float readout0.8511,275 pCrosstalk0.8051,275 pMLP, phase-invariant0.783992 pReservoir0.7181,544 pRaw-I/Q MLP, large0.54210,078 pRaw-I/Q MLP, small0.2611,068 p01 Delay linepink: the ternary delay-line network. 0.806 with a ternary readout, 0.851 with a float readout on themicrocontroller, 0.878 when trained for the simulated board line (the LC ladder).02 Higher scoresa float 1-D CNN of the same shape (blue) scores 0.909, and a 208-parameter cumulant classifier (teal) 0.875.03 MLPsMLPs on raw I/Q samples cannot become invariant to the random carrier phase at either size; the dashed line ischance, 0.125.
Figure 258-class modulation · 4,000 test windows · SNR 0 to 20 dB. Accuracy over all SNRs, 4,000 test windows. Wide screens show each model’s parameter count beside its bar. All models were simulated on a CPU.

On accuracy, the delay-line network trails the conventional options. A conventional neural network of the same shape, run in floating point, scores 0.909 against its 0.806, and a classical method built on signal statistics (cumulants), with just 208 parameters and no gradient-descent training, scores 0.875. Giving the delay-line network a floating-point final layer, which costs nothing since that layer runs on the microcontroller anyway, recovers part of the gap (0.851). Small fully connected networks fed raw samples cannot cope with the random phase and stall at 0.261 and 0.542; given phase-independent features, one with 992 parameters reaches 0.783.

QuantityCrosstalk1-D CNN
Adds93,376151,616
Multiplies3,144147,528
tanh evaluations3,0723,072
Arithmetic energy, 45 nm datapath≈ 209 nJ≈ 796 nJ
Board, 216 mA at 5 V for ≈ 150 µs≈ 162 µJ—
STM32G474 running the CNN, lower bound—≥ 84 µJ
Cost of one classification · estimates. All values are estimates; nothing here was measured. Arithmetic energy uses Horowitz (ISSCC 2014): 0.9 pJ per floating-point add and 3.7 pJ per multiply, with each tanh charged as ten multiplies. The board figure is the design current drawn over one classification. The microcontroller figure uses the datasheet’s 173.5 µA/MHz at 170 MHz and one cycle per multiply-accumulate.

Counting only arithmetic, the delay-line network needs about a quarter of the energy. Built as a board full of op-amps, it would use about 774 times that estimate, up to about twice the minimum for a microcontroller running the more accurate network. At this size the analogue board is neither more accurate nor more efficient. Its one advantage is that the weights cost nothing to store.

From coax to copper

The first plan for a physical delay line used coaxial cable, and it could not be built. Each tap needed up to 1.12 microseconds of RG-58 cable, eight lines per layer, losing an estimated 32 dB per microsecond with nothing to boost the signal along the way. One piece of that work survived: a bit-exact simulation of the arithmetic (the E tier, described below) matched a Verilog hardware description across 202,752 values without a single mismatch.

Its replacement is a ladder of ordinary surface-mount inductors and capacitors, 56 sections of 120 µH and 120 pF, so Z0=L/C=1 kΩZ_0 = \sqrt{L/C} = 1\,\mathrm{k\Omega}, 120 ns per section, an ideal cut-off of 2.65 MHz, and a tap every 8 sections. How much signal survives then depends on the inductors’ quality factor, Q. Reaching the last tap at the highest usable frequency costs about 9.6 dB at Q = 10 and about 3.2 dB at Q = 30.

Loss along the line

0-10-20-30-4002505007501000kHz|H| at taps 0 to 7, dB · solid Q 10 · dashed Q 30≤ 250 kHz · twice the symbol rate01 Tapsone LC line of 56 sections, 120 µH and 120 pF each, tapped every 8 sections. Each colour is one tap, nearest first.02 Roll-offevery section is a low-pass filter, so each later tap loses more of the high frequencies: by tap 7 the signal hasaccumulated 7π radians of phase at Nyquist, and each radian costs about 1/(2Q) nepers.03 Loss budgetthe symbol rate of 125 kBd keeps the band that matters (amber) inside a 3 dB loss budget. The network is trained onthis response.
Figure 26ngspice .ac · KiCad-exported tile, layer 2, line 0. Magnitude at each tap relative to the line input. The datasheet gives only a minimum Q for the 120 µH wirewound part, so the Q 30 curves are an assumption.

No inductor on the market met the wish list: 120 µH, shielded, self-resonant above 5 MHz and under 8 ohms. The part chosen is unshielded, with 3.3 ohms of resistance, self-resonance at 3.3 MHz and a guaranteed Q of only 10; the typical Q of 30 is an assumption, because the datasheet gives only the minimum. Symbols arrive at 125,000 a second, eight samples each, and at 250 kHz the simulated loss between first and last tap is 2.26 dB even at the minimum Q. The first job for anyone building it is measuring Q on twenty real parts.

TierWhat is simulatedNot modelledResult for the board-trained network
V · virtualideal-arithmetic NumPy, with the FIR filter response of the ngspice-simulated ladder as the “board line” referenceevery physical effect except the line response0.878 board line · 0.655 ideal line
E · emulated8-bit fixed point, bit-for-bit against Verilog RTLall analog effectsearlier phase-1 networks only, not the board-trained one: 198,144 values, 0 mismatches
C · circuitngspice on the KiCad-exported tile netlist, two fixes appliedlayout, crosstalk, noise0.8505 at Q 10 · 0.8588 at Q 30 (calibrated model)
P · parasiticsscikit-rf cascade of ABCD matrices with parasitics and mutual inductance; Monte Carlo over 1,000 simulated boardselectromagnetic field effects and layout0.8705 at Q 10 · 0.872 at Q 30
Simulation tiers. V, E, C and P are the project’s labels for the four tiers. The C figures come from running 4,000 examples through a behavioural model calibrated against ngspice; the full transient simulation covers 64 examples a layer. The exported schematic needed two fixes, a line termination and feedback resistors about 2.9× larger. On the board line, P scores 0.75 points below V, with 0.948 top-1 agreement between them.

A ladder of real components is an imperfect delay: it rings, it loses signal, and its delay varies with frequency. So the network is trained on the line it will actually sit on. A single pulse sent through the simulated ladder and sampled at each tap gives a short filter for every tap, and every training pass mixes the responses for Q = 10 and Q = 30 and shifts each tap’s timing by up to 14% of a symbol. Through this realistic line, the network trained on an ideal one falls from 0.806 to 0.772. The network trained on the ladder itself scores 0.878, holds that across both values of Q and the timing errors, and drops to 0.655 if moved onto an ideal line.

Its first version scored 0.797 and never once recognised QPSK. That scheme and 8PSK had merged into a single output, and gains on 8PSK hid the loss in the average. Choosing models by their worst class instead (every class at least 0.35 on held-out training data at both values of Q), and training the final layer with focal loss, which concentrates on hard examples, separated them in two runs out of three. They remain the hardest pair, at 0.690 and 0.664 with the floating-point readout. All of this rests on three runs on one dataset, with no independent replication.

Simulated with realistic board effects, the first tile design scores 0.17, little better than guessing among eight classes. The amplifiers that add up the taps were designed as if each tap delivered the full signal, but a ladder terminated at both ends delivers about half, so every tap arrives about 6 dB short and the shortfall compounds through three layers until the output is noise. The network needs its signal within about 2 dB of the level it was trained at, 8.98 dB, and a simple fixed 6 dB boost falls short (0.45). The fix is to make the amplifiers’ feedback and bias resistors about 2.9 times larger.

gain bugfull½summerexpectsladderdeliversR_fb~2.9× largerladder delivers ½ the drivethe summer expects →turn up feedback ~2.9×
Figure 27Sketch of the gain error: the summer expects full drive and the ladder delivers half.

Gain and coupling

0.00.51.00246810gain trim on the summers, dBas designed 0.17trimmed ≈ 0.840.00.51.000.0030.0070.0140.0270.050inductor coupling k, nearest neighbourflat from 0 to 0.0501 Gainthe summing amplifiers were sized as if each tap carried the full drive, but a matched ladder delivers about half.As designed, accuracy is 0.1675 on the full test set; the network needs its level within about 2 dB of the trained8.98 dB.02 Crosstalkmagnetic coupling between neighbouring unshielded inductors, swept to beyond the k = 0.027 point-dipole estimate,moves accuracy by about a point, inside the subset’s noise.
Figure 28P (parasitics) tier · simulated tile · stratified test subsets. Same trained weights, same simulated board, one setting changed at a time. The dashed line is chance. Neither sweep includes layout or electromagnetic field effects.

Coupling between neighbouring inductors on the board, the same crosstalk effect part one tried to exploit, moved accuracy by about a point.

The plan called for 40 dB of isolation between neighbouring inductors, which are unshielded. A rough estimate puts their coupling at k = 0.027 when they sit side by side 3 mm apart, short of that target, but the network barely notices: across four layouts accuracy stays between 0.849 and 0.859, within the noise of the test. The estimate is not a full field simulation, and the real coupling has not been measured. The layout spaces the inductors 4.2 mm apart and turns alternate rows at right angles anyway.

A thousand boards

0960.840.850.860.870.88accuracy on the 800-example subsetboards, of 1,000mean 0.856 · sd 0.6 ptp5 0.847501 Variationeach component value is drawn independently within datasheet tolerance, with added clock error, transistor mismatchand track-and-hold phase error.02 Spreadworst board 0.841, best 0.874. Tolerances at these values cost about half a point; the subset’s own standard erroris about 1.1 points.
Figure 29P (parasitics) tier · 1,000 simulated boards · 800 examples each. Each simulated board has independently drawn component values. Pink: mean. Amber: 5th percentile.

Ordinary component tolerances cost almost nothing. Across 1,000 simulated boards built from parts drawn at random within their datasheet tolerances, accuracy averages 0.856 with a spread of 0.6 points; the biggest single contributors, amplifier gain and transistor mismatch, account for about 0.4 points each. Every board passes the project’s bar, but the bar is low: five points below the network’s score on an ideal line (0.605), where it happens to do poorly.

Counting the cost

Two kinds of board were designed: the tiles, and a carrier for the NUCLEO-G474RE microcontroller module. Scripts generated both, from schematic to placement and routing, and checked them against KiCad 9’s electrical and design rules. One tile design serves every layer; the first layer uses only two of its eight lines, for the signal’s in-phase and quadrature channels.

TILE-8, layer-1 variant, top side
Figure 30TILE-8, layer-1 variant, top side. KiCad render. Upper left: two delay lines of 56 inductors each, buffers either side. Lower left: the crossbar footprint grid, populated pads in gold. Right: summers, differential pairs and track-and-holds. 180.1 × 142.1 mm, routed, with 0 design-rule (DRC) violations.
Carrier for the NUCLEO-G474RE, bottom side
Figure 31Carrier for the NUCLEO-G474RE, bottom side. KiCad render of the 134.1 × 90.1 mm four-layer carrier. The figure is artwork in exposed ENIG (gold) finish, supplied by the project owner: a copper island with a solder-mask opening and no electrical net, with 0 DRC violations. With a HASL finish it would come out silver.

Inside the board

Exploded: four copper layersF.Cusignal traces2,301 segments · 1,748 padsIn1.Cuground planenet GND, outline onlyIn2.Cu+5VA planenet +5VA, outline onlyB.Cusignal traces1,095 segments · 109 padsvias: 1 in 6 of 787Flat: top and bottom copper, true proportionCrossbar of resistor pads, enlarged■ F.Cu ■ B.Cu · pads outlined · circles in the enlargement are vias
Figure 32KiCad 9 board file · TILE-8 layer-1 variant · 180.1 × 142.1 mm · four copper layers. Above, the tile’s four copper layers are pulled apart. The outer two carry the traces, pink on top and blue underneath; the two inner layers are planes, a ground plane and a +5VA plane, drawn as hatched outlines because each is a solid sheet of copper. Short ink lines join the layers where a via runs through the board; one via in six is drawn, of 787. Below, the top and bottom copper overlaid at true proportion with the board outline. The boxed corner is enlarged at right: the crossbar of resistor pads, where the weights go as resistors, with the traces that reach them. Pads are outlined, and the figure draws copper only, not solder mask or parts.
BoardStateChecks
Carrier, with gold artworkrouted0 DRC violations
TILE-8 layer 1, 2 of 8 linesrouted0 DRC violations, 0 unrouted
TILE-8 layer 2, 8 linesplaced, not routed499 unconnected items
TILE-8 layer 3, 8 linesplaced, not routedsame as layer 2
Board status. The full tiles carry 448 inductors and about 2,200 placements each.
Crosstalk, width 8 × 31-D CNN on the carrier’s microcontrollerCrosstalk, width 32 × 4
Parts$191 (three tiles, carrier)——
Circuit boards$52——
Assembly$129——
Microcontroller, cables, supply$34$34$34
Total, estimated$406 · $507–549 with 25% contingency$34≈ $4,135
Tiles3052
Inductors1,008021,952
Solder joints, tiles7,811——
Weights1,152 ternary, held as 716 fitted resistors1,248 parameters, float, in flashternary, held as resistors
Accuracy, simulated0.878 board line · 0.8705 parasitics tier0.9090.931 virtual
Energy per classification≈ 162 µJ, design current≥ 84 µJ, lower bound—
Changing the weightsa new assembly orderreflash, secondsa new assembly order
Statedesigned, not builtnot run on hardware heresimulated only
Estimated bill of materials, three designs side by side. Prices are single readings of JLCPCB part pages on 3 November 2026, not quotes, with board and assembly prices from published area rates. The microcontroller is the NUCLEO-G474RE already on the carrier, so the conventional CNN adds only the shared part of the bill (microcontroller, cables and supply). The width 32 × 4 column uses the scaling rule of about $79 a tile plus $50.

A full tile costs about $75.89 in parts, $44.49 of it inductors. Five things still need checking before anyone orders one: the microcontroller header’s geometry, the assembler’s rotation offsets, how the inductors are oriented and coupled, a firm quote, and the 3.3 V bias network, which so far has passed only an automated electrical check.

Scaling up is expensive. Every input channel needs its own delay line, and each tile carries eight lines and eight outputs, so a layer of width W needs (W/8)2(W/8)^2 tiles. A network of depth D needs this many inductors: 448 (D−1) (W/8)2+112 (W/8)448\,(D-1)\,(W/8)^2 + 112\,(W/8).

Width × depthTilesInductorsAccuracy (V tier)
8 × 3 (demonstrator)31,0080.806
16 × 4145,600—
32 × 45221,9520.931
64 × 6328144,256—
Scaling with network width. Accuracy is from the virtual (V) tier. At width 32 the ternary network scores 0.931 against 0.929 for its floating-point twin, so restricting weights to three values costs nothing measurable there. Its 52 tiles would cover about 8,320 cm² and cost about $4,135. Tile power is set by the roughly 106 op-amps on each tile, not by the taps.

Stacked up

01 · Crosstalk · 202636 mmteacup1,152 weights → 3 tiles≈ $406shorter than a teacup02 · LeNet-5 · 19981.45 melephant, 3.2 m61,706 weights → 121 tiles≈ $9,555about half an elephantscale ÷3403 · GPT-2 small · 20192.9 kmBurj Khalifa, 828 m124 million weights → 242,188 tiles≈ $19 million3.5 Burj Khalifasscale ÷90804 · BitNet b1.58 2B4T · 202546.9 kmEverest, 8.8 km2.00 billion weights → 3.9 million tiles≈ $307 millionfive Everests, already ternaryscale ÷1605 · Llama 3.1 8B · 2024188 kmedge of space, 100 km8.03 billion weights → 16 million tiles≈ $1.2 billionthrough the edge of spacescale ÷406 · Llama 3.1 405B · 20249,492 kmEarth, 12,742 km across405 billion weights → 791 million tiles≈ $62.1 billionmost of the way through the Earthscale ÷68
Figure 33Weights as stacked tiles · 512 to a tile · 12 mm apart. The figure counts resistor footprints. It does not claim that these models would run on the boards, since a transformer’s weights are not taps on a delay line. Each panel is drawn at its own scale. Stack heights assume 12 mm per tile, and costs use the project’s scaling rule of about $79 a tile. Parameter counts are the publishers’ own. BitNet b1.58 is the one model here whose weights are already ternary.
Established

A ternary network whose weights are entries in a pick-and-place file, carried from training to a routed tile, with a design error found in simulation before any order was placed.

Not established

Any accuracy or energy advantage over conventional models at this size: the floating-point CNN and a 208-parameter classifier both do better.

Open

Running the C (circuit) tier end to end, routing the full tiles, and any measurement on hardware. Measuring twenty inductors on a Q meter would be a start.

Brains and buckets

The question behind part one, whether signals leaking between neighbours can do useful work, is also being asked of brains. Neurons are joined by synapses, but the electric field their activity creates also spills onto their neighbours. In slices of rat cortex, Anastassiou, Perin, Markram and Koch found that such fields shifted a neuron’s membrane voltage by less than 0.5 mV, yet still pulled the timing of its spikes, most strongly for rhythms slower than about 8 Hz. Neuroscientists call this ephaptic coupling; on a circuit board it would be called crosstalk.

ephaptic couplingno synapse< 0.5 mVactiveneighbourpulls spike timingstrongest below ~8 Hz= crosstalk, in a brain
Figure 34Sketch of ephaptic coupling: the active neuron’s field shifts its neighbour’s membrane voltage by under 0.5 mV and pulls the timing of its spikes.

At a larger scale, activity sweeps across the cortex as travelling waves. Recording directly from the brains of epilepsy patients during memory tasks, Das, Zabeh, Ermentrout and Jacobs found oscillations at theta, alpha and beta frequencies moving as flat fronts, as spirals, and as rings spreading from a source or closing on a sink. A small neural network reading the wave patterns could tell when a person was memorising rather than recalling, and could tell some remembered letters apart. The authors propose that the waves coordinate distant parts of the brain, possibly helped by electric fields that carry across the folds of the cortex.

Waves on the cortex

PlanarSpiralSourceSinkfour pattern types, drawn at one instantSame idea, two mediaPart one: 8 wires × slotsCortex: 8 × 8 electrode gridtrained readouttrained readoutfixed medium → trained readout01 Phaseeach square is one electrode. Its arrow points along the phase of the oscillation there, and the tone follows thephase.02 Patternsplanar fronts, spirals, and rings spreading from a source or closing on a sink. The figure steps through them inturn.03 Readouta small network trained on the wave patterns could tell memorising from recalling: the same arrangement as part one,a fixed medium with a trained readout on top.
Figure 35Schematic of the pattern types · phase on an 8 × 8 electrode grid · after Das, Zabeh, Ermentrout and Jacobs, bioRxiv 2024. Schematic of the four pattern types that Das, Zabeh, Ermentrout and Jacobs describe in human cortex; it is not data from their paper. Each square is one electrode on an 8 × 8 grid, with an arrow pointing along the phase of the oscillation there and a tone that follows the phase. The patterns come from simple formulas: planar phase grows along one direction, spiral phase is the angle around a centre, and source and sink phase is the distance from a centre, with the rings moving outward in one and inward in the other. The figure steps through the four in turn. Below, part one’s reservoir, eight wires by slots with a column sweeping it, sits beside a cortex grid; in both a medium is fixed and only a readout is trained. The wires-by-slots field here is a schematic too.

That is close to part one’s set-up: a fixed medium full of travelling, interfering signals, with a trained readout on top. It also inherits part one’s caution. Decoding a state from a wave shows that the information is present in the wave, and says nothing about whether the wave did the work. Part one’s readout scored 0.995 on temporal XOR, yet the coupling turned out to be idle once it was switched off. In a living brain that switch is much harder to throw, so whether travelling waves and field effects compute, or only accompany computation, remains open.

Engineers have tried the idea in other media. Fernando and Sojakka drove a tank of water with motors, filmed the ripples, and trained a perceptron on the footage to solve XOR, the same timing puzzle tested in part one. Hughes, Williamson, Minkov and Fan showed that the equations of a wave travelling through a material can be written as a recurrent neural network, then trained the material’s own structure to sort vowel sounds as they scattered through it, a step between part one’s fixed bundle and part two’s trained taps. Appeltant and colleagues built a reservoir from a single nonlinear element and a delay loop, letting time stand in for many neurons, much as a single tanh carried part one.

bucket of watermotorsripplescameraperceptronXORripples → camera → perceptron
Figure 36A tank of water as a reservoir: motors make ripples, a camera films them, and a perceptron reads the footage to solve XOR.

The experiment part one never ran, XOR with pulses at unpredictable times, needs what these waves are claimed to provide: a record of the recent past. Keller, Muller, Sejnowski and Welling gave an ordinary recurrent network hidden states that travel as waves, and found that it learned memory tasks faster and more accurately than the same network without them; a wave moving across a network is, in effect, a delay line. Izhikevich argued that the brain’s conduction delays, measured at 0.1 to 44 ms between cortical neurons, are part of the computation, because they let spikes from different sources arrive at a target together.

Method and sources

RefSourceWhereAs ofAccessUse
CLclassify · six-way synthetic waveforms, tensor_8x64, three seedsresults/20261104-142853-tensor_8x64-classify/2026-11-04internalmeasured
XRxor · temporal XOR, tensor_8x64, three seedsresults/20261104-142857-tensor_8x64-xor/2026-11-04internalmeasured
MNmnist · raw pixels, reservoir features and MLP, mnist_8x784, three seedsresults/20261104-144850-mnist_8x784-mnist/2026-11-04internalmeasured
ABAblation sweeps · coupling, decay, readout, nonlinearity, mask mode, size; one knob per run, run for this piecedriver over packages/delay-tensor, tensor_8x64 base2026-11-04internalmeasured
EQEquivalence bench · update rule unrolled to 2,048 stages, ngspice operating point against NumPybenches/netlist.py, benches/01-equivalence.ipynb2026-11-04internalmeasured
RFRF bench · RLCG topologies, ngspice AC and transient, analytic chain matrix, scikit-rf referee, state-space extractionbenches/topologies.py, rf_netlist.py, transient.py, rf_char.py, extract.py2026-11-04internalmeasured
DNDesign notes and tooling surveypackages/delay-tensor/docs/design.md, docs/tools.md2026-10-10internalcontext
ARphase-lattice (dllm) · the original PyTorch prototype, five commits, one recorded resultarchive/2026-06-11internalcontext
DACrosstalk arena · nine models on 8-class synthetic modulation recognition, 16,000 / 4,000 windowspaper package, docs/artifacts/data/arena_models.json2026-11-04internalmeasured
DPCrosstalk P (parasitics) tier · parasitics model, gain-trim and crosstalk sweeps, 1,000-board Monte Carlopaper package, docs/artifacts/data/p_tier.json, p_tier/2026-11-04internalmeasured
DSCrosstalk ladder tap response · ngspice .ac of the KiCad-exported tile, Q 10 and Q 30paper package, docs/artifacts/data/spice/tap_response.json2026-11-04internalmeasured
DBCrosstalk boards · KiCad 9 carrier and TILE-8 tiles, ERC/DRC reports, renders, BOM and cost modelpaper package, docs/artifacts/board/, data/board_cost.json, data/scale_story.json2026-11-04internalmeasured
DDCrosstalk article draft and claim list · source of the prior-art survey and the energy references (Horowitz, ISSCC 2014; STM32G474 DS12288 Rev 2)paper package, docs/artifacts/article/article.md, data/claims.json2026-11-04internalcontext
BDBoard drawing · build123d model, isometric projection, hidden lines removedcomponents/labs/crosstalkBoard.ts2026-11-04internalillustrative

From the archive

Delay lines began as radar equipment. Tubes of mercury held one sweep of echoes so that only moving targets showed on the screen, and the first stored-program computers borrowed the trick, keeping their working memory as sound circulating through mercury or coiled wire, readable only at one end.

Radar technician at a radar display
Figure 37Radar technician at a radar display, 1940s. Mercury delay lines were first built for wartime radar, to cancel echoes that had not moved. Computer History Museum, catalogue 500004583. © Computer History Museum.
Technician with mercury delay lines
Figure 38Technician with mercury delay lines, about 1951. A technician checks mercury delay-line memory for the UNIVAC I. Computer History Museum, catalogue 102722391. © Computer History Museum.
UNIVAC I delay-line memory, central support
Figure 39UNIVAC I delay-line memory, central support, 1951. A set of these gave the UNIVAC I about 1.5 KB of memory. Filled with mercury, each tank weighed nearly 800 lb. Computer History Museum, catalogue 102677540. © Computer History Museum.
Mercury memory
Figure 40Mercury memory, 1950s. Mercury delay-line memory of the kind used in the UNIVAC I. Wikimedia Commons, File:Mercury_memory.jpg. CC BY-SA 3.0.
UNIVAC I recirculation chassis
Figure 41UNIVAC I recirculation chassis, 1951. The vacuum-tube board that re-amplified and re-timed the bits leaving a tank and sent them round again. 24 inches long. Mark Greenia, Wikimedia Commons. CC BY-SA 4.0.
UNIVAC I dedication, US Census Bureau
Figure 42UNIVAC I dedication, US Census Bureau, 14 June 1951. The first UNIVAC I, dedicated at the Eckert-Mauchly plant in Philadelphia for the Census Bureau. US Census Bureau, via Wikimedia Commons. Public domain.
Ferranti Sirius magnetostrictive delay line
Figure 43Ferranti Sirius magnetostrictive delay line, 1959. The same circulating memory without mercury: a strip of special metal rolled into a coil, with a transducer at each end. Computer History Museum, catalogue XD230.80. © Computer History Museum.

Delay-line memory · seven photographs, colour-graded. Reproduced for non-commercial research commentary, with credit, under each holder’s terms. Computer History Museum images remain © Computer History Museum and are not licensed for reuse from this page. The Wikimedia images keep their licences, CC BY-SA 3.0 (creativecommons.org/licenses/by-sa/3.0) and CC BY-SA 4.0 (creativecommons.org/licenses/by-sa/4.0), and the colour-graded versions here are released under the same; the Census Bureau photograph is public domain. All seven were colour-graded, cropped and given film grain by d/rksci; none is otherwise altered.

  • Reservoir Computing
  • Ternary Networks
  • Signal Integrity
  • SPICE
  • PCB Design
  • Machine Learning
  • Methods