Frontiers in Physical AI: Ternary
The multiply is the cost. Three states {−1,0,+1} delete it, and with it the binary tax of multiplier arrays, the data-movement wall, and leading-edge fabs. Backed by information theory, arithmetic, and material science, this course builds the case in code: the trit is the optimal atom, a ternary policy matches full precision, and multiply-free silicon runs on a mature, sovereign node. Ternary is the bridge from the binary world to post–von-Neumann computing, and the only way forward for embodied AI at the edge.
▶ Start the course ← All coursesWhere this sits, and what moves it.
Binding constraint · The multiply, and the data movement it drags behind it. Arithmetic is not the bill; moving operands to the arithmetic is, and a multiply is what forces the movement.
Three-state logic was a 1950s Soviet machine and a footnote. The information-theoretic argument that e -- and so three -- is the optimal radix was known and had nowhere to go, because binary had won the manufacturing base.
A ternary policy matching its full-precision twin is reproducible and sits in this course. What is not established is the end-to-end trit: most demonstrations keep binary somewhere in the loop, and a ternary model on binary silicon collects part of the prize. Saying so plainly is the point -- the case is strong and it is not finished.
It lands when multiply-free logic runs on a mature node with no leading-edge fab in the chain, which is a sovereignty argument as much as a physics one. The number to watch is joules per inference measured at the wall on ternary silicon, not parameter counts or accuracy parity, both of which are already there.
Every hard thing was impossible until the constraint that made it impossible was named. How we read a frontier →
The information case: why three beats two
Prove from information theory and arithmetic that the trit, not the bit, is the optimal atom of computation, and that three states {−1,0,+1} delete the multiply.
- L3Bits, trits, and the best radixWhich integer base is the most economical for representing numbers (radix economy = radix x number-of-digits)?Compute that one trit carries log2(3)=1.585 bits and that base 3 beats base 2 on radix-economy cost averaged over a large range of integers.→
- L3The multiply is the costOn a battery-powered edge policy running inference, where do most of the joules actually go?Given a tiny edge policy, count its MACs and price them with the Horowitz @45nm energy constants to show that multiplies dominate arithmetic energy (~80%) and that a single DRAM read outweighs every add combined.→
- L3Three states delete the multiplyCan you compute Wx with ZERO multiplies and get an answer that is bit-for-bit the same as the full floating-point x@W?Implement a matrix-vector product with ternary weights using only add, subtract, and skip, no multiplies, and prove it is bit-for-bit identical to x@W (max error < 1e-9).→
The model: a ternary policy that matches full precision
Quantize and train a policy whose weights are only {−1,0,+1}, show it matches its FP32 twin, then price the real energy win.
- L3Absmean: rounding a net to three statesIf you round a fully-trained FP32 network's weights straight to {-1,0,+1} with absmean, does its task accuracy survive intact?Ternarize a Gaussian weight matrix with the BitNet b1.58 absmean rule (scale = mean(|W|)) so that every value lands in {-1,0,+1} and the zero fraction, by the rule's scale-invariance, lands inside the 0.2-0.45 band.→
- L4Train for ternary: QAT matches FP32Can a network whose weights are only {-1, 0, +1} ever match its full-precision twin's accuracy on a task a linear model can't solve?Train a 2-H-2 MLP on XOR-quadrants with quantization-aware training and a straight-through estimator so that, evaluated with weights restricted to {-1,0,+1}, it reaches >=90% test accuracy, matching its FP32 twin.→
- L4BitVLA: the trit ships in productionBitVLA reports its ternary VLA policy is 11.0x smaller AND 4.4x faster than full-precision OpenVLA-OFT, with matched task performance. What is the one thing this production result does NOT establish?Given the cited BitVLA record (arXiv:2506.07530: 1.4 GB footprint, 11.0x smaller and 4.4x faster than a full-precision OpenVLA-OFT baseline, matched task performance), show that a memory ratio and a latency ratio cannot be multiplied into one 'total win' number, then count which of the three legs of the ternary+energy+certificate slot BitVLA closes -- and which two remain open.→
- L3the joulesYou just deleted 100% of the multiplies (0 of them remain) and the weights are ~20x smaller. Is the end-to-end energy win therefore around 1000x?Given cited per-operation energies, the learner computes a complete end-to-end joule ledger for a ~1e5-param policy and shows the FP32-to-ternary energy speedup is ~tens x (not ~1000x) because memory movement, not arithmetic, dominates once the multiplies are deleted.→
The frontier: silicon and the end-to-end trit
See why multiply-free logic runs on a mature, sovereign node, and assemble the end-to-end trit, ternary’s bridge from the binary world to post–von-Neumann edge AI.
- L4Why the multiply-free win is a memory winTernary weights pack to 2 bits, 8x smaller than bf16. A first, correct multiply-free decode kernel on a real edge GPU therefore runs about how much faster than bf16?On real edge silicon, show that a naive ternary decode is stalled by a branchy unpack, then replace the select-chain with a branch-free arithmetic decode v=(c^2)-2, bit-identical, and the measured decode kernel jumps from 2.6x to 5.8x faster than bf16.→
- L4Silicon anyone can makeDo you need a leading-edge (e.g. 3 nm) fab to build an efficient edge-AI inference chip?Show by gate count that deleting the multiplier array cuts an 8-bit datapath from ~n^2 to ~n gates (ratio >= 6x), and argue this is what lets a mature node do edge-AI inference.→
- L4The end-to-end trit (capstone)In today's stack, how many times is a ternary value re-encoded to binary and back on its trip from memory, through compute, to the wire?Ship one ternary edge policy end-to-end: QAT-ternarize a trained FP32 policy so its accuracy holds (>=0.85) with zero multiplies at inference, then count the three binary re-encode taxes a naive stack pays and prove the end-to-end trit removes all three.→