PAI-240 · Education

Frontiers in Physical AI: Ternary

The multiply is the enemy. 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.

Frontier·3 modules · 10 labs·10 lessons
▶ Start the course ← All courses
Module 1

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.

  1. L3Bits, trits, and the best radixCompute 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.→
  2. L3The multiply is the enemyGiven 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.→
  3. L3Three states delete the multiplyImplement 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).→
Module 2

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, honest energy win.

  1. L3Absmean: rounding a net to three statesTernarize 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.→
  2. L4Train for ternary: QAT matches FP32Train 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.→
  3. L4BitVLA: the trit ships in productionGiven 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.→
  4. L3The honest joulesGiven cited per-operation energies, the learner computes an honest 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.→
Module 3

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.

  1. L4Why the multiply-free win is a memory winOn 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.→
  2. L4Silicon anyone can makeShow 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.→
  3. L4The end-to-end trit (capstone)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.→