Read the paper as a hostile reviewer and close three gaps it found by gHashTag · Pull Request #516 · gHashTag/trinity-fpga

gHashTag · 2026-08-09T08:40:47Z

SUBMISSION.md lists five things a reviewer will push on and where each is answered. Testing that rather than asserting it — checking whether each answer sits in the abstract or the limitations, the two places a sceptic reads first — found three of the five answered only deep in the body.

The worst was the thesis itself

"Three inputs determine the format" is what the paper argues, and it was not in the abstract at all. It is now: the four axes, the three that do not depend on the workload, and the sentence that makes TEF forced rather than designed on one triple and silent off it.

"A ternary fabric does not exist"

Appeared in neither the abstract nor the limitations. It is now the first limitation, and says the uncomfortable version out loud:

the fabric this format is optimal on cannot be bought; every hardware figure here is measured on a binary FPGA; what survives on silicon you can buy is the fixed-field half — no regime codec, no exponential.

"Your regime codecs are models"

Answered only in a table caption, two sections later. The prose now says it where the models are introduced, and says why both belong: the models isolate the variable the taxonomy is about, the published decoders say what that variable is worth against everything else, and the answer moved when we measured the second.

One stale claim fixed on the way

The limitations said four of nine rungs are measured and TEF64 is "within reach". TEF64 has been measured since, at 7,479 LUTs and 48.20 MHz. Five of nine now, with TEF128 named as not converging in routing rather than as pending.

🤖 Generated with Claude Code

SUBMISSION.md lists five things a reviewer will push on and where each is answered. Testing that rather than asserting it -- checking whether each answer sits in the abstract or the limitations, the two places a sceptic reads first -- found three of the five answered only deep in the body. The worst was the thesis itself. "Three inputs determine the format" is what the paper argues, and it was not in the abstract at all. It is now: the four axes, the three that do not depend on the workload, and the sentence that makes TEF forced rather than designed on one triple and silent off it. "A ternary fabric does not exist" appeared in neither the abstract nor the limitations. It is now the first limitation, and it says the uncomfortable version out loud: the fabric this format is optimal on cannot be bought, every hardware figure here is measured on a binary FPGA, and what survives on silicon you can buy is the fixed-field half -- no regime codec, no exponential. The ternary claim is architectural and labelled so. "Your regime codecs are models" was answered only in a table caption two sections later. The prose now says it where the models are introduced, and says why both belong: the models isolate the variable the taxonomy is about, the published decoders say what that variable is worth against everything else, and the answer moved when we measured the second. One stale claim fixed on the way. The limitations said four of nine rungs are measured and TEF64 is "within reach"; TEF64 has been measured since, at 7,479 LUTs and 48.20 MHz. Five of nine now, with TEF128 named as not converging in routing rather than as pending. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

… was written The limitations said TEF64 was 'within reach of a larger part'. It has been measured on this one since, at 7,479 LUTs and 48.20 MHz. TEF128 is now named as not converging in routing rather than as pending, which is the honest status. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

28 catalogued competitors at 8/16/32/64/128 bits, zero survive the one-parameter TNF family. Range is analytic for a fixed field; the boundary check is impossible above E_t~30 (2^1.4e23) and is recorded as a limit of the measurement rather than dropped. Adds the frontier theorem and no-survivors corollary to the paper, with the silicon reconciliation stated inline: dominance in (M_eff, range) is not dominance in LUTs, and the paper says so. Refs #516

The one-parameter TNF family dominates all 28 catalogued competitors across five width classes. That closes the number axis and closes nothing else: silicon puts TNF mid-pack among fixed fields, the block axis (MXFP4) is still uncovered, and a dense family dominates any finite point set for free unless each competitor's shortfall is a theorem. The publication stop rule therefore stands. Also records the killed boundary experiment rather than dropping it, and fixes the stale arxiv_tef path. Refs #516

The no-survivors list becomes a statement about the design space. The family covers (m,b) iff m + log_3(b+1) <= N-1; a uniform format obeys m + log_2(b+1) <= N-1 in its own accounting. Same books, two currencies, and the exchange rate is the whole result: every uniform binary format is covered with slack E*(1 - log_3 2) = 0.3691*E positions, growing linearly in the exponent width it spends. This is stated against T6, which says a packed ternary exponent carries no more per bit and which silicon confirmed (BNF16 vs TNF16, 1% apart). Both hold on different axes: per position the trit spans log2(3) binades, per bit of binary fabric the packing gives it back. The bound is tight -- posit16 sits within 1% -- and not vacuous: the same posit16 scored where a taper is designed to live violates it at 16.30 against 15. So escape needs non-uniformity, and there are exactly two routes: taper, or a scale outside the word. Both are named as frontier, not as territory held. Abstract rewritten to arXiv's 1826/1920 character metadata limit with no TeX-isms, following the motivation/problem/approach/results structure; abstract_arxiv.txt is the submission field verbatim. Refs #516

Three results the no-survivors table needed to stand on. Theorem (optimal member): once a workload's visited range is named, E_t* = ceil(log_3(b+1)) maximises the mantissa uniquely. The rule has no free parameter, so it names a winner before measurement -- which is what makes it falsifiable. Theorem (regret): mis-sizing is asymmetric. Over-sizing costs precision logarithmically on every value; under-sizing costs range linearly on the tail. A wider exponent is not the conservative choice by default. Theorem (composition): transforms and formats act on different arguments, so their order matters -- measured at 2.78x. Recorded because an earlier version of this work reported the levers as nearly multiplicative, computing a ratio against a losing baseline. Related work now states where the block literature is not looking: the 2026 papers vary the transform (learnable block optimisation, format-aware rounding, residual channels) and hold the element at E2M1. That is the variable the width rule speaks to. Six dangling cross-references repointed to their real labels. Refs #516

…eight fp_levels reserved the top exponent code for Inf/NaN as IEEE binary formats do. OCP microscaling element formats reserve nothing -- every E2M1 code is finite -- so the reservation cost the standard the values 4.0 and 6.0 and ran it at 2.58 bits against int4's 3. Uncorrected, the run reads 'uniform int4 beats MXFP4 by 27%'. It does not; the rows had different level counts. Same class as the earlier amax defect: both underfed the competitor and both would have produced a headline in our favour. Adopted rule -- a competitor's cardinality is a specification fact, asserted against the spec in the harness, never derived from a shared helper. Refs #516

The width rule was stated as a rule. It is the solution of a constrained maximisation: maximise M subject to 1+E+M=N and r^E >= b+1. The multipliers come out lambda = mu = 1, so complementary slackness makes the range constraint active -- the exponent is exactly as wide as the range demands and not one position wider. Theorem (optimal member) is now derived, and lambda=1 is the shadow price: one position of exponent costs exactly one of mantissa. Radix economy rho(r)=r/ln r, minimal at e, explains why three and not two -- a 1950s result we claim no credit for. Its use here is the reconciliation of our two axes, which are the two factors of r * log_r(V): the number axis counts positions and ternary wins unconditionally by 0.3691*E; the silicon axis restores the cost per position and charges kappa(3)/kappa(2)=1.68, which is why BNF16 and TNF16 land within 1%. T6 and the slack corollary are one product reported factor by factor, not a contradiction. Least action and conservation of energy are named as resemblances and explicitly not used as arguments: no time, no trajectory, and 1+E+M=N is a designer's budget, not a law of nature. Applied to the block axis the multiplier problem returns E2M1 at the measured 99th-percentile within-block span of 3.04 binades -- the OCP microscaling element, derived rather than beaten. Refs #516

In a ternary layer the weight has no format -- 1.58 bits, no exponent, no mantissa, no multiply. Every published ternary method quantises the weight, so none of them was ever a competitor to a number format; the object a format describes here is the accumulator, and that niche is empty. Law: range visited grows as log2(pK), error after pK roundings as sqrt(pK)*2^-(M+1), so through the KKT solution E* = ceil(log_3 B(K)) and the mantissa side outruns the exponent side. Measured on real ternarised weights: fitted exponent in K is +0.476 and +0.435 against a predicted +0.5. Et=2 fits at +0.207 and that is the range constraint being active, not a refutation -- 9 binades cannot hold an accumulator visiting 13.9, so its curve is saturation-dominated then rounding-dominated. The measured span picks Et=3 by the rule, and the measurement picks Et=3 independently at every fan-in. Two more self-caught defects recorded. The first instrument normalised each value by its own magnitude and returned error identically zero everywhere -- a format that never rounds is not a format. The second built level sets from the position count alone, ignoring that binary fabric addresses only 2^(N-1) magnitudes, and produced a 100x perplexity artefact against our own format. Refs #516

Reframed on what the measurements actually support. A ternary node has three format-bearing sites and only one needs a format: the weight is a code (sign-select, not multiply), the sample is ADC-native, and the accumulator is the only object with a range to spend. We close both halves that need closing -- GFTernary the weight, TNF the accumulator -- and no other pair in the literature does. New theorem: the golden alphabet is unique. Requiring the product of two weights to fall back into the lattice the datapath already adds in means r^2 = r + 1, whose only positive root is phi. Corollary: a k-layer gain is exactly F_k*phi + F_(k-1), two integers, so rescaling between layers is shift-and-add and depth never reintroduces a multiplier. This is what separates the phi alphabet from {-1,0,+1}, which needs a learned real alpha per layer -- and multiplying by alpha puts the DSP back. Comparison split in two by a checkable test: does the word carry the range, or must it be brought from outside? int8, int4, integer accumulators and the bare E2M1 element go in the rejected table -- e=0, no range in the word, and every published sub-8-bit training result using them carries block scales AND a higher-precision master weight. int8's 0.189 MHz/LUT is reported there, not as a competitor: it leads by declining the task. GFTernary stays in the main table despite e=0 because its scale is intrinsic and exact rather than external and learned. Conclusion stated at the strength the measurements carry: for a ternary datapath the pair {GFTernary, TNF} is a reference format -- complete, forced rather than chosen, and predictive. Explicitly not a claim about datapaths that multiply, where the block axis holds the ground. Abstract rewritten to exactly 1920/1920 arXiv metadata characters. Refs #516

MXFP4 21.94 and MXFP6 14.73 beat TNF4 36.72 and TNF6 18.03 on wikitext-2 with the MX spec's own E8M0 scale and a verified baseline. The reason is structural, not tuning: 3^E_t never divides 2^k, so a ternary exponent packed into a binary word always wastes codes, and where the alphabet is short the waste dominates. TNF4 gets 7 of 8 magnitudes against E2M1's 8, and 3 binades against 4 -- strictly worse on both counts at once. At 6 bits the loss reaches 41% of the alphabet. This is T6 carried to its conclusion: on the number axis a trit is a position and wins; in a packed word the codes are counted and it pays. Two things survive. The KKT law returned E2M1 -- a binary exponent -- from the measured within-block span, recommending the industry standard over our own family; a rule that only ever recommends its author is not a rule. And the range constraint is visibly active: TNF6 E_t=2 with 19 magnitudes beats E_t=1 with 25, so fewer levels with more range wins, which is complementary slackness appearing in perplexity. The reference-format claim is bounded accordingly: it is a claim about ternary datapaths without multipliers, not about block-scaled binary ones. The publication stop rule stands -- the block axis was the named condition and the measurement went against us. Refs #516

Radix economy and the case for three are not ours, and saying whose they are makes our contribution smaller and defensible. Fowler's mechanical balanced-ternary machine around 1840; Brusentsov and Sobolev building Setun at Moscow State University in 1958 on paired ferrite cores, ~50 machines 1959-65; Setun-70 in 1970 anticipating RISC arguments and ended administratively; Knuth keeping the idea alive; CNTFET, memristor and photonic ternary devices continuing it. New theorem states the boundary rather than the claim. Written as cost = r x log_r V: where the position is physical, only the second factor is compared and ternary gains 0.3691E positions unconditionally; where the position must be encoded in bits, the format is bounded by 3^E_t * 2^M <= 2^(N-1) and, since 3^E_t never divides a power of two, the remainder is lost -- 25% at 4 bits, 15.6% at 6 and 8, 5.1% at 16. We add no support to 'ternary beats binary' as a general statement. We measured it three times and it went against us each time. What we add is the condition under which the old argument applies, which reads as a prescription: it says what fabric must exist for the advantage to be collected, and that fabric is not the one currently purchasable. Parhami's binary-encoded balanced ternary anticipated the mechanism and is credited; our part is measuring its cost in a live network and in placed-and-routed silicon rather than in operation counts. Refs #516

Audit of every table against its own caption found two defects. tab:carryrange claimed 21 formats and showed six rows with an ellipsis. Now complete: 20 rows with storage, LUTs, Fmax and MHz/LUT, int8 excluded and pointed to the rejected table with the reason. tab:tnet still carried 440 against 895 LUTs at 0.184 MHz/LUT -- the comparison this same paper retracts elsewhere, where TNF received pre-widened fields while the competitors unpacked theirs. Replaced with matched width against matched width on packed words: 3.1x at 16 bits and 5.6x at 32, with the withdrawal stated in the caption rather than buried. The gap belongs to the regime scan, not to the ladder. Closing section sets the two independent lines side by side: the arithmetic one, 68 years old, which stalls because 3^E_t never divides a power of two; and the geometric one, where requiring the product of two weight symbols to fall into the sum the datapath already forms gives r^2 = r + 1, whose single positive root determines the alphabet. Stated as a reading of the results, with every component measured above, and what they amount to together left to the reader. Refs #516

GF8 E=3 and BNF8 E=3 both give perplexity 14.6130 -- the same number, not a close one. The golden-ratio rule E = round((N-1)/phi^2) and the width rule 1+E+M=N were derived independently and for unrelated reasons, and at eight bits on this workload they name the identical format. Neither derivation predicted that. Twelfth self-caught defect, and it falsifies our own prediction: the width rule named BNF8 E=4 and TNF8 E_t=3, and the winners were E=3 and E_t=2 -- both predictions one step too wide. The rule's form survives and is visible in the sweep (single optimum, asymmetric penalty exactly as the regret theorem states: under-sizing gives 4.5 million, over- sizing costs 0.3%). What was wrong is the estimator of the visited range: we measured 0.1st percentile to maximum, crediting a tail that carries almost no energy. Recorded rather than quietly re-tuned. Ternary loses on binary fabric for the third independent time: GF-T8 carries 109 magnitudes against GF8's 129 and pays 15.51 against 14.61. Refs #516

Applying a phi weight to an integer pair (a,b) representing a + b*phi is (a,b) -> (b, a+b): the Fibonacci recurrence, one integer addition, no shift. Z[phi] is a ring and the alphabet lies inside it, so for inputs in Z[phi] the entire linear part of a ternary network -- every weight application and every accumulation, to arbitrary fan-in and depth -- stays in Z[phi] and is computed with no rounding error at all. This is a different kind of claim from the rest of the paper. Elsewhere we compare error magnitudes between formats; here there is no error to compare. Measured at fan-in 512 the integer pair reproduces the real sum to the precision of the checker, not of the datapath. Components grow logarithmically, eight bits over those 512 terms, and the cost is two integer accumulators instead of one float. The base is a minimum rather than a choice: closure needs r^2 = pr + q with integer p,q, and any p > 1 adds a shift to the addition. p=q=1 gives phi. 1+sqrt(2) satisfies r^2=2r+1 and pays the shift; sqrt(2) has r^2=2 and loses the scale out of the lattice. Scope stated so the claim does not overreach: this is arithmetic in a lattice. It covers the linear algebra that dominates a network's work and its DSP cost, and says nothing about control flow or addressing. Refs #516

…tiplier BitNet stores ternary weights plus a real per-layer scale alpha = mean|W|, and multiplying by that alpha puts the multiplier back at the layer boundary. Snapping the scale to a grid removes it. The phi grid is denser than powers of two by log(2)/log(phi) = 1.440 at the same cost class, so the prediction made before measuring was that its excess error over the unreachable exact alpha would be about half. Measured over 210 layers: exact 0.476781, phi^k 0.488424 (+2.4420%), 2^k 0.499943 (+4.8579%). Ratio of excesses 0.501 against a predicted 0.500. phi wins 163 of 210 layers -- not all, since a layer whose optimum lands near a power of two is better served by the coarser grid. Together with dot_exact this closes the multiplier out of the entire layer: weights, accumulation, and now the scale. Defect #13 recorded rather than reported as a result. The first attempt asked this through perplexity, where post-hoc ternarisation destroys a model not trained for it: every arm including BitNet's exact alpha landed at ppl ~2.2e7 against a baseline of 14.49. Read naively that says phi is refuted by 2x. It says nothing -- the tell was that the control arm was destroyed too, and a comparison whose control fails is not a comparison. Refs #516

BitNet's per-layer alpha = mean|W| is a real number, so applying it is a genuine multiply -- the multiplier the ternary weights removed comes back at the layer boundary. Carrying the value as an integer pair makes the scale phi^k into k Fibonacci steps, one adder each. Synthesised through yosys synth_xilinx: the multiplier arm costs 2 DSP48 blocks, or 1215 LUTs with DSP inference off. The phi arm costs 171 LUTs and zero DSP, and is DSP-invariant -- identical numbers with and without, because there is no multiply to map. Costs stated rather than omitted: 4x the registers (135 FF against 33), k cycles instead of 1 (about 8 for a typical alpha, so ~1.6% of a fan-in-512 layer), no Fmax because nextpnr-xilinx is not on this machine, and only k >= 0 -- the inverse step is (a,b) -> (b-a, a) since phi^-1 = phi - 1, one subtraction, not yet built. Area reported only after correctness: 200 randomised cases against a golden model computed independently in the testbench, 0 errors, with a negative control confirming the bench can detect a mismatch. A circuit that computes the wrong thing is smaller still. Refs #516

…ours Two of our own claims are withdrawn or bounded, both by measuring a competitor properly rather than by a new experiment. The phi^k grid does beat 2^k by exactly the predicted density ratio, and that reproduces. It was the wrong baseline. The deployed state of the art for multiplier-free scales is APoT -- sums of power-of-two terms, ICLR 2020. On the same 210 layers: APoT-2 costs 0.1651% excess against exact alpha where ours costs 2.4420%, and it does so in one cycle against our k. APoT-3 costs 0.0054%. Ours wins 17 layers of 210 against APoT-2. The claim that ours is the right grid for a multiplier-free scale is withdrawn. dot_exact is machine-checked and remains true, but the significance attached to it does not survive. An APoT scale is a dyadic rational, and the dyadic rationals are also a ring closed under the datapath's operations: checked in exact arithmetic, a fan-in-512 layer with an APoT-2 scale and Q8 inputs lands on a denominator of 2^15, exact in ordinary fixed point. Binary has had this since fixed point existed. What remains unique to phi is term-count non-growth -- a Z[phi] value stays a two-component pair through any depth, while APoT-2 squared has four terms and the count compounds. Stated as a conjecture; it needs an experiment, not an assertion. Also lands the deployable signed scale path, closing the hole named in the previous iteration: both directions, since real layer scales give k about -8. 360 randomised cases including a multiply-then-divide round-trip identity, 0 errors. Costs two LUTs over the forward-only version, 173 against 171, still zero DSP and still DSP-invariant. Refs #516

Measuring area rather than only accuracy shows the scale applier was never a one-dimensional question. phi^k costs 173 LUTs, APoT-2 costs 384, the multiplier 1215 or 2 DSP48. Ratio phi to APoT is 2.22x at d=0, 3.81x at d=1, 7.03x at d=2. The reason is not the one predicted. Term-count non-growth is the second effect; the first is that APoT's shift is by a runtime value, so it is a barrel shifter at 192 LUTs each on 32 bits. We had been calling APoT shift-add and treating that as free. A constant shift is free; a variable one is a barrel, and a scale serving any layer is variable by construction. Four theorems: term growth n^(d+1) against a constant pair; shifter cost Theta(W log W) against zero for a fixed permutation; a crossover depth d* = 2 at which APoT costs what it was introduced to avoid, measured at 1217 against the multiplier's 1215; and no domination in (area, latency, error), all three being vertices. The accuracy withdrawal stands. APoT-2 remains 15x more accurate at one cycle against k, and anyone bound by accuracy or latency should use it. The honest output is a hybrid rule rather than a winner -- the previous two iterations each defended a single answer and each was wrong in a different direction. Refs #516

Records both corrections in place rather than quietly restating the position. Withdrawn: that the phi^k grid is the right one for a multiplier-free scale. The 0.501 density ratio reproduces and is correct, but the baseline was wrong -- APoT is what the field deploys, and it costs 0.1651% against our 2.4420%, in one cycle against k. Bounded: dot_exact is machine-checked and true, but an APoT scale is a dyadic rational and Z[1/2] is also a closed ring, so a fan-in-512 layer with an APoT-2 scale and Q8 inputs is already exact in ordinary fixed point. Binary has had this since fixed point existed. Four new theorems from measuring area rather than accuracy: term growth n^(d+1) against a constant pair; shifter cost Theta(W log W) against zero, which is the effect we missed and is larger than the one we predicted -- APoT's shift is by a runtime value, so it is a barrel at 192 LUTs each on 32 bits, while a Fibonacci step has no shifter at all; a crossover at d* = 2 where APoT costs what it was introduced to avoid; and no domination in (area, latency, error). Output is a rule, not a winner: phi^k where the path is area-bound or composed without requantisation, APoT where it is latency- or accuracy-bound. Stated that way because the two previous iterations each defended a single answer and each was wrong differently. Refs #516

…ng one Two attacks on our own area claim, both successful. Freeze the scale and APoT's shifts become compile-time constants -- wiring, not logic. Measured: APoT-2 at 26 LUTs against an unrolled phi^k at 64, 128, 256 for K = 2, 4, 8. An unrolled recurrence is linear in K at about 32 LUTs a step; a constant-shift applier is one adder regardless. The lines never cross, not even at K = 1. Then the barrel. Our regime-2 advantage used a 5-bit shift field, but across 210 layers the scales span only 3.15 octaves, so two bits suffice. At SW=2 APoT costs 130 LUTs against our 199. The 2.22x advantage was an artefact of giving the competitor a wider field than it needs, and it is withdrawn. Instrument limitation recorded: the APoT sweep is non-monotonic (130, 380, 230, 384) with the parameter demonstrably applied and yosys deterministic, so this is abc mapping heuristics. LUT counts from yosys alone are not reliable at this granularity -- a claim resting on 30% between two such points is unsafe; one resting on regime 1's 10x is. Three theorems: an unrolled recurrence is Theta(KW) against Theta(W) for constant shifts, so it loses at every K; the ordering inverts with compile-time versus runtime scale, so neither family is better and the architecture decides; and a barrel is priced by the workload's range, not by a convenient field width. What survives is narrower: phi^k is the only applier whose area is independent of composition depth, which is real but uncommon. The alphabet uniqueness and Z[phi] closure are machine-checked and were never area claims. Refs #516

Three theorems and one withdrawal. An unrolled recurrence is Theta(KW) where a constant-shift additive applier is Theta(W), so with a frozen scale the recurrence loses at every K -- measured 26 LUTs against 64, 128, 256 at K = 2, 4, 8. The ordering therefore inverts with regime and is a property of neither family. And a barrel is priced by the workload's range: 3.15 octaves across 210 layers means two bits, where APoT costs 130 against our 199, so the 2.22x was an artefact of a five-bit field. Instrument limitation stated rather than smoothed: the APoT sweep is non-monotonic with the parameter applied and the tool deterministic, so logic-synthesis LUT counts are not reliable at this granularity. What survives is term-growth independence alone, in a regime that is real but uncommon. The alphabet uniqueness and Z[phi] closure are untouched, having never been area claims. Refs #516

Z[phi] is the only one of three systems cheap under BOTH operations. LNS makes multiplication free and pays for addition with a log(1+2^x) table -- our own takum32_decode measurement, 10,967 LUT and 84 RAMB36. Fixed point and APoT make addition cheap and pay for scale multiplication unless the scale is frozen. Z[phi] costs one adder for multiplication by a power of phi and 64 LUTs for componentwise addition. The price is that its free multiplication is restricted to powers of phi. Four theorems say why that is not a restriction here: in a datapath where weights are codes applied by sign-select and the scale is a power of the base, the required multiplication set is exactly {base^k}; a ring closed under addition and under multiplication by generator powers is sufficient; LNS is over-provisioned and fixed point under-provisioned for that profile; and compile-time composition is free, so term growth occurs only where d or the scales are runtime quantities. That last theorem removes three of the four depth cases we had claimed: low-rank W=UV, folded conv+BN and residual branch scalars are all known after training, so the product is precomputed and no composition happens in hardware. One survives -- accumulation along a mesh route, where the hop count is runtime. That is the tri-net datapath, not the network. States its own boundary rather than waiting to be asked: not an area win, not an accuracy win, and nothing to beat where the scale is frozen. A claim about which system matches a datapath's operation profile. Refs #516

An accounting. Every phi claim about silicon was tested tonight, mostly by us, and none survived. Withdrawal 6: our LNS row cited takum32_decode at 10,967 LUT. That is a format decoder, not an adder. An honest LNS-32 adder with a 4096-entry table costs 275 LUT -- we were off by two orders of magnitude, and the over-provisioning theorem shrinks from 170x to 8.6x at matched storage. Withdrawal 7: the mesh case, the last place a depth advantage could live. Matched combinational comparison gives APoT requantisation 103 LUT against a Fibonacci step at 128 -- phi loses by 25%. Reached first through an unmatched comparison reading 0.60x against us, because our side carried a controller the other did not. Same defect as the six wins before it, pointed the other way. A loss deserves the same audit as a win. What survives: the machine-checked mathematics, untouched and never a hardware claim; the LNS comparison rebuilt honestly, where Z[phi] addition is 32 LUT against 275 and LNS additionally cannot represent zero while a ternary alphabet is 46% zeros; the number-axis frontier; and zero DSP, which belongs to ternary weights rather than to phi. Closing theorem: the terms of a comparison are part of its result. Seven times a ratio changed sign or magnitude when the competitor was rebuilt as its own advocate would build it. The measurements were never wrong; the comparisons were. Refs #516

…its artefact The claim that 28 catalogued formats are dominated with slack 0.3691*E counts positions. A format is stored in bits, and a realisable member obeys 3^Et * 2^M <= 2^(N-1). Substituting the minimal Et gives m + log2(b+1) <= N-1, identically the uniform binary budget, since log2(3) log3(x) = log2(x). The slack vanishes exactly, for every E. Measured at equal storage: 6 of 17 dominated, not 28 of 28. Uniform binary formats that spend all their bits tie exactly -- binary32 at 31.10 against 31, binary64 at 63.27 against 63. Those dominated are wasting budget: posit32 by 5.12, posit64 by 14.24, takum32 by 0.82, cray_float by 0.65, and our own gf8 by 0.70. Several tapered formats escape outright -- posit16 by 2.37, takum16 by 1.53 -- which is consistent with our own corollary that escape requires non-uniformity. Corrected statement: at equal storage the family ties every uniform binary format spending all its bits, dominates those wasting budget, and is escaped by tapers measured where they concentrate precision. The same defect was recorded twice yesterday, as T6 and as the level table where TNF4 with Et=2 does not exist in four bits. Both were treated as local facts about packing and neither was carried back to the headline. Rule adopted: a correction that invalidates a comparison must be applied to every claim resting on the same quantity, not only where it surfaced. Refs #516

The abstract claimed 28 catalogued formats dominated with slack 0.3691*E. That counts positions. A realisable member is stored in bits and obeys 3^Et * 2^M <= 2^(N-1); substituting the minimal Et collapses the condition to m + log2(b+1) <= N-1, identically the uniform binary budget, since log2(3) log3(x) = log2(x). Abstract rewritten to state both counts and which one holds. New theorem and corollary in place, with the measured outcome: 6 of 17 dominated, uniform binary formats spending all their bits tie exactly, and tapers escape -- consistent with our own corollary that escape requires non-uniformity. Also records why it went unseen: the same packing defect appears twice elsewhere in the paper, as the no-free-range theorem and as TNF4 with Et=2 not existing in four bits, and neither was carried back to the result resting on the same quantity. Refs #516

Found by applying withdrawal 8's rule systematically rather than locally, and it is the deepest of the nine. The SSOT specifies each ternary rung as 1 + Et + M = N with Et in trits and M in bits, and declares storage=uN. The oracle stores the exponent offset as an integer in [0, 3^Et - 1], so the word is 1 + ceil(Et log2 3) + M bits. GF-T16 encodes into 20 bits, GF-T32 into 40, GF-T64 into 79. Confirmed by running the encoder. All nine ternary rows carry a wrong storage field. The RTL agrees with the oracle -- tnet_tef #(MW=25, OW=10) is 36 bits for what is labelled TNF32 -- so the measurements are valid for the formats built. Those formats are wider than their names. Theorem: a position specification stored in binary exceeds its declared width by ceil(Et log2 3) - Et, about 0.585 Et, reaching 15 bits at Et = 24. Any comparison at equal N with one side in positions hands that side 0.585 Et bits. The honestly packed ladder loses 59 mantissa bits overall, and at 32 and 64 bits nearly half the code space is unreachable. Invalidates every at-equal-N comparison involving a ternary rung, including the four-families table. Leaves standing the measurements themselves, the binary GF and BNF families, the machine-checked phi mathematics, and the LNS comparison. Refs #516

Withdrawal 10. The oracle and the RTL implement different formats under the name TNF16: Et=6, M=9 in a 20-bit word against Et=4, M=8 in a 16-bit one. The paper's accuracy figures describe the first and its silicon figures the second, presented as one row. The RTL is correct -- its comment says four trits packed into seven bits, so packing was applied there and not in the oracle. The same file asserts the ternary field has the same capacity as its binary sibling. It does not: 81 exponent values against 128, 36.7% less, 47 of 128 codes unreachable. So BNF16 and TNF16 landing within 1% of one another compared fields of unequal capability, and the reading reverses -- matching area at 36.7% less range is TNF paying capacity for that area, not evidence the encodings cost the same. New gate compares declared parameters ACROSS artefacts, which is the only place this shows: every existing check verifies an artefact against itself. It reports 12 disagreements -- nine catalogue rows with wrong widths, two parameter divergences, one capacity mismatch. Negative-tested before being trusted: correcting GF-T16's width to 20 removes exactly that line and the catalogue is restored byte-identical. Parametric families and GFTernary are exempted explicitly rather than passing by accident, and the RTL-to-catalogue name mapping is written out because the TNF rename changed names but not ids -- a silent lookup miss would have made the gate report nothing. Refs #516

Withdrawal 11. Withdrawal 10 showed the oracle and RTL disagree about TNF16. This asks which the SSOT contains, and the answer is neither: the oracle's Et=6 M=9 needs 20 bits and cannot be built at 16, and the RTL's Et=4 M=8 matches no catalogue row at all. Both sides of the paper's TNF16 row are objects that do not exist as specified. Theorem: an artefact that synthesises and measures but has no row in the source of truth is checked by nothing -- specification gates do not see it, instrument checks confirm only that it does what it does, and its numbers enter a report with the same weight as verified ones. Scope measured rather than assumed before calling it systemic: 161 RTL decoders swept, 52 with explicit input widths, 44 matched to catalogue rows, two width mismatches and both are parametric families that legitimately declare width 0. The divergence is specific to the ternary rungs. That bound is stated as plainly as the defect. Gate gains a fourth class and now reports 13 items. Negative-tested: inserting a catalogue row with the RTL's actual parameters removes the orphan line, and the catalogue is restored byte-identical. Refs #516

… halving check_harness.py scans for a design output driving a narrower observed port without a full reduction between. It reports 83 across the tree, including the files written one iteration earlier to correct this exact defect -- withdrawal 14's 'full observation' harness folded four nibbles into the LED port, sixteen of thirty-two bits. Re-measured with all thirty-two observed: phi_step against apot_requant is APoT 1.63x smaller and phi_step 2.50x faster, 1.79x on throughput per area against 2.2x at half observation. zphi_add against lns32 is 2.62x on area and 2.66x on frequency, 5.5x on throughput per area. The trend is the finding. The LNS advantage has been claimed at 8.6x from synthesis area, 14x post-route at 4-bit observation, 11.5x at 16-bit, and 5.5x at 32-bit. Every confound removed has moved it the same way. A quantity that only falls as the instrument improves is not converged, so 5.5x is an upper bound and the result should be quoted as 'several times' rather than as a figure. Theorem: a monotone response to instrument improvement is a warning. If successive corrections all move a result one way, the remaining confounds likely do too. Refs #516

…build The trend theorem said the LNS number was still descending and the remaining confounds probably pushed the same way. Applied to our own result it found a third harness defect and the number fell again. Replacing the shared LFSR with four independent ones gave apot_requant 191 LUT against a 176-LUT harness -- fifteen LUTs for two priority encoders and a subtractor, which is impossible. apot_requant consumes only r0, so the other three LFSRs have no path to an output and are removed. The harness in that build is one LFSR, not four, and the subtraction was against a harness the build never contained. Theorem: net-of-harness figures are valid only if the harness is present in full in every build, since a design consuming fewer harness outputs prunes the rest and the subtrahend varies with the design. Fixed by folding unused sources into the observed reduction. Re-measured with the harness invariant: zphi_add against lns32 is 2.58x on area and 2.47x on frequency, 4.4x on throughput per area. phi_step against apot_requant is APoT 1.71x smaller and phi_step 2.18x faster. The trend now reads 8.6x, 14x, 11.5x, 5.5x, 4.4x across five instruments -- four corrections, four moves the same way, decelerating but not converged. What survives every correction is the sign, not any figure. Theorem: a claim's sign can converge while its magnitude does not. An ordering established across several instruments is stronger evidence than a magnitude measured once on the best of them, and the two should be reported separately. Refs #516

Three harness confounds in three iterations, none visible in any number. The gate scans for a design output driving a narrower observed port without a full reduction between, and reports 83 across the tree, most of them one-off experiment files. Runs as a ratchet like the artefact-agreement gate: the known set is recorded and the job fails only on new entries, or when a baseline entry stops reproducing so the file cannot rot into a permanent excuse. Refs #516

Fifteen withdrawals, two later withdrawn in turn, three classes of harness confound, six theorems about measurement, two gates in CI. The method proved worth more than any number it produced and existed only as a trail of commits. Includes a register of which claim rests on which instrument and which still needs re-measurement -- the 21-format table is on partial observation and is the largest outstanding item. The withdrawals are grouped by cause rather than by date: wrong baseline, wrong units, wrong regime, wrong artefact quoted, divergent artefacts, wrong instrument, and three separate harness confounds. Each had a correct measurement inside a wrong comparison. Refs #516

Eighteen formats plus a baseline, measured on the only harness that passes the observation gate: isolated decoder, every output bit folded into the observed reduction, median of five placement seeds. All fourteen fixed fields sit above all three tapers on frequency, the worst fixed leading the best taper by 1.43x. On area they overlap -- posit8 at 214 LUT against IBM hexadecimal's 243. The asymmetry is the result: a taper's decode is a scan, a serial dependency costing critical path directly and area only incidentally, while a radix-heavy fixed format costs a wide shift that is area-heavy and shallow. The overlap is predicted rather than excused. GFTernary against posit32 is 7.8x on area and 19.9x on frequency. GFTernary costs 66 LUT where a bare wire costs 112. Area-frequency correlation is -0.60 here against -0.90 on the combined harness, so the axes are reported separately and no ratio of them appears in the table. Refs #516

The session's longest-running open number, resolved by finding it had no value to converge to. Five corrections moved it down, 8.6x to 14x to 11.5x to 5.5x to 4.4x; the sixth moved it back up to 5.8x. The trend stopped being monotone because that correction was not a confound removal but a change of which property is held equal. Z[phi] has range linear in width and exact precision; LNS has range exponential in its integer field and relative precision. Matching bits gives 5.8x in our favour. Matching range would need Z[phi] components of 128 bits, 256 bits of state against LNS-32's 32, and it would lose. Matching precision is impossible the other way, since the logarithm of a sum is irrational. Theorem: a system with exact ring arithmetic and one with approximate logarithmic arithmetic cannot be compared at equal bit count, and the area ratio moves in both directions with the choice of what to hold equal. Corollary: a quantity depending on an unstated choice has no limit, so it was never going to converge -- the five corrections were all correct while the thing they corrected did not exist. Withdrawn: every numerical form of 'Z[phi] addition is N times cheaper than an LNS adder'. Retained: that Z[phi] is cheap under both operations where LNS is cheap under one, and that LNS has no representation for zero while a ternary alphabet is 46% zeros. Both are structural and independent of how widths are matched. Lesson: before chasing a number's stability, check that the comparison producing it is well-posed. Refs #516

T7 said a quantity depending on an unstated choice has no limit. It cost six iterations to discover on the LNS ratio. Applied on purpose to the remaining claims it partitions them in one pass. M_eff was measured for each format over its own range, so participants were measured on different domains. For fixed fields this does not matter -- measured across a 14-fold change of domain, TNF16 at three exponent widths moves by 0.04 to 0.11 bits, exactly as the precision law predicts. Those comparisons are well-posed. For a taper it matters by construction and there is no neutral domain. We knew the symptom, since posit16 exceeds the uniform budget when scored where it concentrates precision, but had not named it a problem of posing. So the 28-format frontier mixes two cases: fourteen fixed formats compared soundly, ten tapered ones needing a different form -- 42% of the claim. The well-posed replacement is a crossover rather than a verdict. posit16 loses 0.25 bits per binade from near 12 at unity; TNF16 holds 9.03 everywhere; they meet at 12 binades. Below that posit16 is more accurate, above it TNF16 is and the gap grows linearly, and past 112 binades posit16 does not represent at all. T8: if one system's figure of merit is constant in a parameter and another's varies in it, no single-number comparison is well-posed. The well-posed form is the crossover plus the direction on each side. A domination claim between such systems is not made true by choosing a domain, it is made meaningless. Refs #516

T8 said a fixed field against a taper needs a crossover rather than a verdict. Measured from peaks and slopes rather than from the 2^-es the specifications quote. TNF's M_eff is constant across binades as the precision law requires: 3.81, 9.17, 24.85, 52.09 at 8, 16, 32, 64 bits. Crossovers run from -5 to 54 binades. posit64's slope is under half the others' so it holds to 54; takum8 and tekum8 peak below TNF8 and never lead. Against the measured workload: within a block, 3.04 binades, a taper wins at every width above 8; on a whole weight or the accumulator, 13.4 and 13.9 binades, TNF wins at 16 and 32 and a taper at 64. Both answers occur in the same network. T9: for a taper with peak p and slope s against a fixed field of constant m, the crossover is (p-m)/s + 1 and the taper is preferable exactly when the workload span is narrower. A verdict of the form 'fixed beats tapered' is an assertion about the workload, not the formats. The frontier is now fully partitioned: fourteen fixed rows unchanged, eleven tapers each replaced by a crossover and a workload condition. Our own headline narrows accordingly -- for quantising an element inside an MX-style block a taper is the better choice at every width above 8 bits, and we say so. Refs #516

Assembles nine iterations of narrowing into the form a practitioner can use: for each object quantised, the accuracy winner from the T9 crossover, its threshold, and its measured decode cost. Where the axes agree the rows are unambiguous -- TNF at 8 bits, and for whole weights, accumulators and gradients at 16 and 32. Where they disagree the honest output is both numbers. For an element inside a block at 16 bits posit16 is 1.76 bits more accurate on this workload and costs 3.0x the area and 6.5x the delay to decode. Which matters depends on what is scarce in the datapath, and this work does not know that for someone else's design. Gaps named: 64-bit decode was never measured, so there is no recommendation at 64 bits despite posit64 leading on accuracy to 54 binades; TNF32 decode is likewise absent; gradient span is estimated rather than measured. T10: a selection needs both axes and their exchange rate, and a recommendation is well-founded only when the scarce resource is known. Fourth time this session a single-number answer was the wrong shape for the question -- ratios hide choices, crossovers name them, and pairs of costs name what is still unknown. Refs #516

… flips No TNF32 or TNF64 decoder existed in the tree, so those rows of the selection table had accuracy figures with no decode cost against them. Both written here following tnf16_decode's layout and respecting the packing constraint, both emitting fp32 like every other decoder so the harness is identical. Measured: posit64 costs 2629 LUT at 6.78 MHz, the most expensive decoder in the comparison by a factor of five over the next. TNF64 costs 128 LUT at 416.67 MHz. T11: a taper's decode contains a scan of length O(N) and its area grows as N^1.16 across four widths, while reading fixed fields grows as N^0.17 -- effectively flat, since fields are read by wires. From 32 to 64 bits posit gains 5.09x area and loses 7.2x frequency; TNF gains 1.23x and loses no frequency at all. The row that had no answer now has one. posit64 leads accuracy by 6.1 bits to 54 binades, covering every workload measured here, and costs 20.5x area and 61.5x delay -- 0.30 bits per multiple of area. The recommendation is TNF64 with the price named. At 16 bits the same trade is 1.76 bits against 3.0x and is a judgement call; at 64 bits it is not. Corollary: because the scan is superlinear and field reading flat, the trade degrades for the taper as width grows and there exists a width beyond which no accuracy advantage justifies it, lying between 16 and 64 bits. Refs #516

…is measured Two results. The first is a correction applied to a plan rather than to a finished claim: the previous iteration proposed finding the width beyond which a taper is not justified, and T7 applied to that proposal shows it requires an unstated exchange rate between bits and area. No single width exists. First time tonight the method was used prospectively -- it prevented a measurement instead of correcting one. The well-posed form is the exchange rate by width: 0.589, 0.485, 0.297 bits per area multiple at 16, 32, 64. T12: the rate is monotone, because the gain grows roughly linearly while the cost multiple grows as N^0.99. Every project with its own K has its own break-even width, and the absence of a single answer is a property of the question. The last estimated number in the selection table is now measured. One backward pass on the same model, 211 layers: gradient span is 17.29 binades median per layer against the literature's ~40, so the estimate was 2.3x too high. It flips no row, since 17.29 still exceeds the 8 and 10 crossovers, but the table now contains no estimated quantities. The gap between 17.29 per layer and 30.70 across the whole model is a design statement in itself, worth about two exponent bits. Refs #516

…sweep Applying T7 to the last two untouched claims. The E2M1 derivation depended on an unstated percentile. Protecting the median of blocks returns E1M2; the 90th percentile and above return E2M1. The claim that the MX element is derived held only at one unjustified choice. Corrected in the paper to a threshold: the width rule returns the MX element for any design protecting the 90th percentile or more, and a different element below that. Which is right is a question about how many blocks may saturate, not one settled from first principles. The accumulator law holds -- TNF against TNF so the domain is irrelevant, measured in Python so no harness confound, level sets built packed. One caveat made explicit: the Et=2 fit gave +0.207 because that configuration saturates inside the measured range, so the fit ran outside the model's domain. T13: a power-law fit is valid only where the model is defined. Saturating points must be excluded before fitting, not explained afterwards. Thirteen theorems, sweep complete. No open numbers remain in the selection table, and no claim is stated in a form a different choice of domain, percentile, baseline, regime or instrument would reverse. Refs #516

Thirteen theorems derived from our own defects and validated on our own data is weak evidence. Applied to four published claims from other groups, chosen for having concrete numbers. Claim A, posit64 up to four orders of magnitude better than doubles: checked with our measured slope, the crossover is 52 binades against binary64's 2046-binade range, so the advantage holds on 5.1% of the range and reverses on 94.9%. A verdict where T8 requires a threshold. Claim B, 10.8% area increase without impacting frequency: our measured seed-noise floor is 11.4%, so the claim is unresolvable as reported and needs a median over five seeds. Claim C, 46.8% LUT reduction: passes T2 comfortably, open under T1 on whether the baseline was built as its own advocate would -- our record is seven sign or magnitude changes when a competitor's side was rebuilt. Claim D, posit adders costing more LUTs than IEEE: independently agrees with T11 and is a counter-finding in the authors' own work. Two defects found in work we did not produce, both of classes we had already paid for. First evidence the theorems describe measurement rather than our own history with it. Stated limit: four abstracts is a small sample and abstracts compress; a real test reads the papers in full. Refs #516

The previous iteration ran the checklist over four abstracts and reported two defects. Applying the standard demanded of every number here means checking that against the papers. arXiv:2505.19096 in full: frequency is a 125 MHz constraint, not a measured Fmax; the pipeline is unchanged and the authors say the modifications do not affect the critical path; ASIC timing is post-synthesis delay. They never claimed an Fmax difference, so our T3 flag was too strong -- meeting a fixed constraint is a binary outcome and seed noise does not apply to it as it does to an achieved maximum. The measurement is sound; the wording overstates. T14: a constraint met is not a maximum measured. Designs with 1% and 80% slack file identical reports. T15: a defect found in an abstract is a hypothesis, not a finding. Abstracts compress and compression is indistinguishable from omission, so an abstract-level run overstates the defect count. Restated: of two claimed defects one survives, in a smaller form, and three claims are unchecked. Weaker than the previous iteration reported, and it is the result. The method's first application was itself subject to the defect it exists to catch. Refs #516

Both claimed external defects checked against sources. Neither survives. Defect A was misattributed: the four-orders claim is Big-PERCIVAL's, not the paper I checked, and the source carries both qualifications I said were missing -- 'depending on the benchmark' and 'the trend in every benchmark is a significantly lower error'. The abstract also carries the authors' own counter-findings on quire ordering and hardware cost. Our T9 crossover agrees with their result rather than against it: their benchmarks operate near unity, inside the 52-binade window. Defect B is a wording matter under T14 with the measurement sound. T16: a search summary is not a source. Aggregated output may combine claims from several papers into wording present in none and drop the qualifications each original carried. Both flags raised here came from aggregated output and both dissolved on contact with the papers. The method transfers in the weak sense that it can be applied externally. It has not been shown to find real defects there. What it has demonstrated twice in two iterations is that it catches its own author. Two papers read, two of our own errors found, none of theirs. Refs #516

…nce supports Sixteen theorems from thirty-three iterations, written up as what they are: a procedure for catching your own errors, not an audit tool for other people's. The framing is evidenced. Applied to our own claims the checklist produced sixteen withdrawals; applied to two external papers read in full it produced none, and both times it instead caught our reading of them. That is the honest character of the thing and it is stated first. Grouped by what they check -- what is being compared, the instrument, the harness, and sources -- with the three ratcheted gates that mechanise part of it, and a seven-step order of use. Limits stated: it finds no defects in others' work, it replaces no domain knowledge since every theorem was learned by having a specific number turn out wrong, and it comes from one campaign in one field so its generality is a conjecture with a sample of one. Refs #516

Sixteen claims were withdrawn during this work, two later withdrawn in turn, and in almost every case the measurement was correct while the comparison around it was not. The regularities are stated in the paper because they generalise past the subject and because a reader is entitled to know what kind of errors the work has already made. Grouped as in the accompanying note: what is being compared, the instrument, the harness, and sources. Includes the numbers that make each concrete -- seven sign or magnitude changes on rebuilding a competitor, an 11.4% seed-noise floor, a Spearman 0.961 between throughput-per-area and inverse area, 27 LUTs surviving of 179 under partial observation. Framed by what the evidence supports: sixteen retractions applied to our own claims, none to two external papers read in full, and on both of those the procedure caught our reading rather than theirs. Refs #516

Refs #516

Every figure produced by running the thing rather than reading a note about it. Three gates green, paper building with zero errors and zero dangling references, 64 theorems across 23 sections, arXiv abstract at exactly 1920 characters. Records which repository is where, which two pull requests are open and precisely why each is red -- in both cases on checks that also fail on main for files the PR does not touch, plus a signature gate that needs the owner's key. Names the three modified files left alone because they are the owner's, and separates what is durable from what dies with the session. Refs #516

…dent Three gates guard this tree and each was found by tripping over it. Enumerating every pair of artefacts that must agree shows all three are code-against-code and occupy one region: catalogue-oracle, oracle-RTL, RTL-script, design-harness. Every pair with a document on either side is unguarded -- cases.yaml against its directory, the paper against its measurements, the skill against the repo, README against code, METHOD against what was done. Five unguarded pairs, which is why the three finds felt accidental. The class: a document that quotes a measurement carries no link back to it, and a withdrawn claim's number does not remove itself from a paper. check_paper_numbers.py extracts distinctive literals and asks whether each appears in any data file. Two false-positive classes are excluded rather than tolerated: 60 derived constants stated beside the formula producing them, and rounding, where a data literal extending the paper's digits counts as its source. Of 450 literals, 19 carry a unit, have no source and are not rounding. Several are visibly from superseded tables -- the posit16 row at 774 LUT and 36.30 MHz against the isolated decoder's 302 and 62.39, TNF64 and TNF128 frequencies from an earlier synthesis, area-law fit points, and posit slopes superseded by the measured 0.261 and 0.260. T17: consistency checks get written between artefacts a tool already reads together. Documents are read only by people, so their pairs go unchecked by construction, and that is where withdrawn numbers persist. Refs #516

Of 451 distinctive literals in the paper, 444 trace to a file under research/, fpga/ or conformance/. Seven do not, and they are listed in a new subsection rather than deleted -- a figure that cannot be traced is not thereby shown to be wrong. Two of the seven have a directly measured replacement elsewhere in this same paper and disagree with it, which is the pattern the check exists to surface. The posit slopes stated analytically as 0.2497 and 0.2505 are replaced by the measured 0.261 and 0.260. The check excludes two classes rather than tolerating them: sixty constants stated beside the formula producing them, correctly absent from any data file, and rounding, where a data literal extending the printed digits counts as the source. Figures attributed to someone else's paper are also excluded -- they are that author's measurement, not ours. New theorem in the paper: a document is an artefact and its pairs need guarding. Consistency checks get written between artefacts a tool already reads together, so documents go unchecked by construction. Gate added to CI. Refs #516

Re-measuring the seven untraceable figures confirmed three and exposed something larger about four. The extended-format figures were never stale, only unrecorded: double-double 106.46 against the paper's 106.68, quad-double 216.10 against 215.90, x87 62.93 against 63.04, all inside the sampling noise of a 60-draw probe. TNF16's by-band row is confirmed constant as the precision law requires. The taper slopes are not single numbers. Fitting M_eff by binade over windows 1..9 and 1..20 gives posit16 0.2610 and 0.2458, posit32 0.2600 and 0.2544, takum16 0.2410 and 0.1605 against the paper's 0.113. A taper's M_eff is not strictly linear in |e|, so its slope is defined only with the window it was fitted over, and the crossovers in this work were stated as single numbers with no window named. T18: a slope is a property of the window, not of the curve. Quoting one without its window is the same defect as quoting a ratio without saying what is held equal. posit16 and posit32 survive -- their crossovers move 5% across windows, inside every other uncertainty here. takum16 does not: 4.9 to 9.3 binades, a factor of 1.9 on window choice alone. Standard adopted: every slope quoted with its window, every crossover carrying its range across windows 1..9 and 1..20, and reported as a range wherever those differ by more than 10%. Refs #516

Refs #516

Applying T18's window standard to all eleven crossovers exposed a pattern that removes the problem for six of them. Every posit is robust across fitting windows at 1.00x to 1.09x; every takum and tekum is not, at 1.39x to 1.72x. That splits exactly by staircase form, which this paper already classifies. posit's taper is arithmetic -- constant bits per binade, so M_eff is linear in |e| and a line is the right model. takum's and tekum's is geometric -- one bit per doubling, so M_eff is linear in log|e| and no line fits it, which is why their slopes are properties of the window alone. For a geometric taper the crossover is closed-form and needs no window: setting p - log2(x) = m gives x = 2^(p-m). Recomputed, takum32 moves from a 5.9-10.2 range to an exact 2.6 and tekum16 from 4.2-6.5 to 2.1. The straight-line fit had been overstating every geometric taper's reach. T19: a crossover depends on the fitting window if and only if the taper's form is not arithmetic. Corollary: the staircase taxonomy introduced here to describe formats also prescribes how they must be compared -- a classification that only labelled would not do that. Refs #516

… label New theorem and corollary. A crossover depends on the fitting window if and only if the taper's staircase form is not arithmetic: an arithmetic taper's M_eff is linear in |e| and its slope is well-defined, while a geometric taper's is linear in log|e|, no line fits it, and the apparent slope belongs to the window. Measured across windows 1-9 and 1-20 the split is exact -- posit at 1.08x, 1.00x, 1.09x; every takum and tekum at 1.39x to 1.72x. For a geometric taper the crossover is closed-form, x = 2^(p-m), with no window needed. Six figures previously reported as ranges were computed by the wrong model: takum32 from 5.9-10.2 to an exact 2.6, tekum16 from 4.2-6.5 to 2.1. The straight-line fit had overstated every geometric taper's reach. The point is not the arithmetic. A taxonomy introduced to label formats turns out to prescribe how they must be compared, and we had used it only to label for most of this work. Refs #516

T19 closed two of the four staircase forms. Asking the remaining two closes the rest. The wobble form measured on IBM hexadecimal 32: amplitude 3.07 bits, period 4 binades, exactly log2(16) as the radix requires -- the textbook hexadecimal wobble recovered from measurement rather than assumed. Against TNF32 at 25.08 the whole band sits below and the answer is a plain verdict, but against packed TNF32 at 21.32, inside the band [19.94, 23.11], the winner alternates with period 4 at a 50/50 duty cycle and no binade separates them. T20: if M_eff is periodic in |e| and a constant competitor's m lies inside the band, no crossover exists. The well-posed statistic is the duty cycle together with the period. Corollary: each of the four forms determines the shape of a well-posed comparison -- a difference, a linear crossover, an exponential crossover, or a duty cycle. Every comparison of number formats we have read reports a verdict or a ratio, and for two of the four forms that shape is wrong. Refs #516

Claimed that every comparison of number formats we had read reports a verdict or a ratio. Hunhold's takum paper, read in full at 145,000 extracted characters, reports by regime with numeric thresholds: posit's efficiency diminishing with deviation from unity, takum's accuracy exceeding posit near unity and aligning for slightly larger exponents, posits superior in the realm of small values, takum staying at 8 bits until number 30. The paper also states its own logarithmic nature, which is the property T19 says forces the closed form. Withdrawn. What survives is narrower and is a contribution about method rather than a criticism: the staircase form determines the shape of a well-posed comparison, and that mapping is stated here, while the takum literature reports by regime without deriving the closed form and we have found no treatment of the wobble case. The pattern is the real finding. Three external checks -- posit64's four orders, the frequency claim, and this -- and three times our flag was too strong, with none surviving contact with the source. T21: a checklist tuned on one's own errors over-flags others'. It acquires the priors of the mistakes it was derived from and fires on the shapes it was trained on, which are how we went wrong rather than how anyone else did. Its false-positive rate outward is high and its true-positive rate unmeasured at three attempts, zero confirmed. Corollary: the instrument's demonstrated value is entirely inward, which is not small -- sixteen of our own claims fell to it -- but it should never be described as an audit tool, and any flag it raises on someone else's work is a question to ask them, not a finding. Refs #516

An earlier version said published comparisons give verdicts or ratios. Checked against Hunhold's takum paper it is false -- that paper reports by regime with numeric thresholds. Withdrawn in place, with what survives stated: we have not found the closed form for a geometric taper against a constant competitor, nor any treatment of the wobble case, and the contribution is the mapping itself. Refs #516

Enumerating the pairs that must agree showed every existing gate is code against code and every pair with a document on one side was unguarded. The paper-against-measurements pair was closed earlier; this closes the rest. A document naming a file makes a checkable claim about the tree, and a path in prose does not update itself when the tree moves. 1510 path references across 808 documents; 250 are dangling and baselined as historical debt, and the job fails only on new ones. Three exclusion classes are explicit rather than tolerated: temporary paths, which are expected to be gone; sibling-repository paths, which are real references into t27, trinity-s3ai and claim-audit-lab; and files a document names precisely to record that they are absent, since flagging those would flag the finding. One real error of our own was fixed: a document referred to METHOD.md where the file is METHOD_2026-08-10.md. Our own documents now carry zero dangling references. Refs #516

* Measure the actual frontier: four levers against MXFP4, and what each is worth The goal is a format that leads the world, so the measurement has to happen where the leader stands. That is not where this project's map is. MX puts the exponent outside the number -- one per block of 32 -- and MXFP4 runs natively on Blackwell and MI355X. It is a fifth axis, and our own classifier had already said so: five of six MX formats landed in "range < 6, unclassifiable", which I read as a limit of the instrument rather than as the instrument telling me these formats are not in its domain. Four levers, block 32, NRMSE, three workloads: finer shared scale than e8m0 1.05-1.09x, and 0.82x on outliers other minifloat shapes 0.27-1.11x uniform int4 1.05-1.12x Lloyd-Max levels on the data 1.51-1.74x, but 0.82x on activations dropping the sign on ReLU data 2.35x The control matters more than the largest number: the same unsigned format on weights collapses to 0.22x, as it must. Without that, 2.35x would mean nothing. What the numbers say is uncomfortable. At four bits the format is close to saturated -- MXFP4 sits within 1.5x of the MSE-optimal quantiser -- and every remaining gain is workload-specific: the level set that wins on weights loses on activations. The largest lever found, 2.35x, is not a new format at all. It is dropping the sign bit on one-sided data, which is standard quantisation practice. MX carries a sign because it is a general format, not because that is optimal for post-ReLU tensors. So the measurement confirms this project's own corollary from the other side: formats cannot be ranked without naming a workload. The universal 4-bit format is saturated. What is left is not a better format but a rule for choosing one per tensor, and whether that composes end to end is the next experiment rather than a claim. One wrong result was caught and is recorded: the first version had int4 beating MXFP4 by 3.5x, which is nonsense. I had normalised by amax, putting every value in [0,1] and denying the element format its entire upper range. The committed script fits Lloyd-Max in the element's own normalised domain and asserts all three findings, including the control. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * Seven measurements at the frontier, and the honest verdict they add up to The goal is a format that leads the world, so the measurement has to happen where the leader stands: MX, block-scaled, hardware-native on Blackwell and MI355X. Seven levers measured. Finer shared scale: 1.05-1.09x, and 0.82x on outliers. Other minifloat shapes: at most 1.12x. Dropping the sign on one-sided data: 2.35x, with the control confirming it collapses to 0.22x on weights as it must. Block size from 8 to 128: a straight exchange, 1.18x of accuracy for 1.18x of bits, so the standard's 32 sits on a flat part of the curve. A per-tensor selector: 1.73x across a mixed network, with fitted levels transferring to held-out data at 98-99% and never below 1.26x cross-distribution. Two findings are structural rather than numerical. The levers do not compose. On every workload exactly one wins and the combination is always worse than the better single lever: weights 0.22x / 1.50x / 0.21x, activations 2.38x / 0.78x / 1.91x, Laplace 0.31x / 1.74x / 0.31x. The cause is that both fix the same thing -- the mismatch between the level set and the distribution's support -- so fixing it twice can only hurt. A selector is therefore a classifier, not an accumulator, and its ceiling is the maximum over levers rather than their product. And the sign lever exceeds any choice inside the signed family. On post-ReLU activations the best signed minifloat among e1m2 / e2m1 / e3m0 is e2m1 itself at 1.00x, while unsigned uint4 gives 2.35x. That matters because the selector idea is already published and active -- BlockDialect picks a per-block format from a formatbook, MixFP4 switches between E2M1 and E1M2 per block, dMX learns a per-layer assignment. Experiment 6 rediscovered known work, and the file says so. What those methods appear not to touch is the sign axis, which is where the largest measured lever lives. That is recorded as a claim requiring verification by reading the papers, not as a result. The verdict is that no claim to a leading format follows from these numbers. At four bits the universal format is saturated, and the largest remaining lever is standard quantisation practice rather than a new format. Two of my own wrong results are recorded in the file: int4 beating MXFP4 by 3.5x, caused by normalising away the element format's upper range, and a "levers are almost multiplicative" verdict computed against a lever that was losing. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * Read BlockDialect, measure the sign lever on real activations, and close the question Two things needed checking before the sign lever could be called a gap: whether published selectors already use it, and whether it survives on activations that real networks produce. The first says no, the second says the lever does not survive. BlockDialect, section 3.1 and Figure 4, read rather than inferred: sixteen dialects, each a set of magnitudes {7.5, 5.5, 3, 2, 1.5, 1, 0.5, 0}, stored as "1-bit sign and 3-bit index". Every dialect is signed. The formatbook varies magnitudes, not signedness, so the sign axis is genuinely untouched. That stops being an opportunity at experiment 8. Measured against real activation functions, unsigned gives 2.35x on ReLU, 1.32x on GELU, and 0.26x on SiLU/SwiGLU — and 0.21x on post-LayerNorm tensors. BlockDialect's own profiling quantises attn_input and mlp_input, which are post-normalisation and symmetric by construction, and modern LLMs use SwiGLU. The lever is negative exactly where MXFP4 matters. An asymmetric 12/3 allocation recovers GELU to 1.97x but still loses on SwiGLU at 0.43x. So the search for a leading format through the element format is closed: the universal 4-bit format sits within 1.5x of the MSE optimum, block size is a straight exchange, minifloat shape is exhausted, the selector idea is published, and the largest lever found does not transfer to the architectures that use MXFP4. One structural result stands on its own. The levers partition rather than compose: a quantiser's error comes from one source, the mismatch between its level set and the distribution's support, and every lever addresses that same mismatch, so two cannot compose and the better dominates. Measured on three workloads, the combination is always worse than the best single lever. The consequence is that a format selector is a classifier and not an accumulator, and its ceiling is the maximum over levers rather than their product — an upper bound on the whole BlockDialect / MixFP4 / dMX family that I have not found stated anywhere. What is not done is stated too: perplexity was never measured. Everything here is NRMSE on synthetic tensors passed through real activation functions, and no claim about network quality is defensible without quantising a live model. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * Energy asymmetry: the unclaimed ceiling sits on GELU and SwiGLU One-sidedness is a property of a tensor's energy, not of how many of its values are negative. GELU sends half its values below zero and 1.8% of its energy; SwiGLU 6.2%. A format that splits its levels evenly by sign spends eight of sixteen codes on 1.8% of the work, and an unsigned format discards that 1.8% entirely. Both are wrong, differently. Measuring the ceiling makes the consequence visible. With D* the distortion floor over all 16-point quantisers, existing levers saturate it on symmetric tensors -- weights 1.50x against a 1.51x ceiling, post-LayerNorm 1.35x against 1.38x -- and leave 29-33% unclaimed on exactly the two activations modern LLMs use: GELU 1.74x against 2.60x, SwiGLU 2.02x against 2.85x. The optimum's shape says why. Free Lloyd-Max on 16 levels spends 5 of them below zero on GELU, reaching only -0.65 while the positive side runs to +5.13; on SwiGLU 6 levels to -1.83 against +5.26. Neither symmetric nor one-sided: a narrow dense lobe down, a long sparse ladder up. A one-integer family captures it. With k levels down to the block minimum and 16-k up, SwiGLU reaches 2.56x at k=4 -- 90% of the codebook optimum and 1.27x better than the best existing lever -- and GELU 2.01x at k=4 against 1.74x. ReLU takes k=1 at 2.21x. Why this is not in the published methods, read rather than assumed: BlockDialect's sixteen dialects are each a set of magnitudes stored as "1-bit sign and 3-bit index" (section 3.1, Figure 4). Every dialect is symmetric in sign. The formatbook varies magnitudes, not how levels are distributed between the two sides, so an asymmetric allocation is not expressible in their representation. MixFP4 switches between E2M1 and E1M2, both signed and symmetric. The shared-ceiling theorem is now checked numerically on five workloads: no lever and no combination exceeded D(F0)/D*. Its corollary bounds the whole selector family -- a selector is a classifier, not an accumulator, and its ceiling is the maximum over levers rather than their product. One error found on the way and recorded. The first version had silu(x) = x/(1+exp(-(-x))), a doubled negation that mirrored the function. It surfaced because the optimum showed ten negative levels reaching -5.24, which SiLU cannot produce -- it is bounded below by -0.2785. The number contradicted theory and the bug was mine, not a discovery. Every SwiGLU row is recomputed. Perplexity is still not measured, and the hardware cost of an asymmetric level allocation is not estimated -- BlockDialect chose symmetric dialects to keep MAC arithmetic integer, and asymmetry may break that. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * An asymmetric dialect beats DialectFP4 on activations at no arithmetic cost Head to head against the real formatbook from Figure 4 of arXiv:2501.01144, on their 0.5 grid, block 32, their scale rule floor(log2 max) - 2, with the best dialect chosen per block by exhaustive MSE — which is the upper bound of their approach, above their own two-stage heuristic, so the comparison is generous to them: GELU 1.80x -> 2.11x (1.17x) SiLU/SwiGLU 2.51x -> 3.02x (1.20x) ReLU 1.64x -> 2.39x (1.46x) weights 1.59x -> 1.49x (0.94x) The reason is the energy asymmetry. GELU sends half its values below zero and 1.8% of its energy; SwiGLU 6.2%. All sixteen DialectFP4 dialects are symmetric — eight magnitudes stored as "1-bit sign and 3-bit index" — so eight of sixteen codes go to 1.8% of the work. The asymmetric variant spends k levels down and 16-k up with the depth taken from the block: one integer, chosen by the same mechanism that already chooses a dialect. The hardware cost is zero by their own argument. DialectFP4 keeps every magnitude a multiple of 0.5 so the index maps to an integer 0..15 and the multiply stays 4-bit integer. The asymmetric shape stays on that grid — what changes is which integers, not that they are integers. Rounding to the grid costs 6% on SwiGLU and ReLU, 14% on GELU, and the formatbook grows by five entries against the sixteen it has. Asymmetry helps on asymmetric tensors and mildly hurts on symmetric ones, so the selector picks symmetric for weights and asymmetric for activations on a cheap feature: the fraction of energy below zero. That matches the shared-ceiling theorem — levers do not compose, exactly one wins, and the selector's job is to say which. What this is not: a leading format. It is a one-parameter extension to someone else's formatbook worth 1.17-1.46x on activations, measured as NRMSE on Gaussian inputs passed through real activation functions. Perplexity is still unmeasured, real activations carry heavy tails and per-channel outliers that will move both the optimal k and the size of the gain, and a claim this size needs a live model before it is a result. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * Real trained tensors: the criterion predicts correctly, the format wins once Every earlier measurement fed x ~ N(0,1) through an activation function, which assumes the distribution rather than observing it and cannot produce the per-channel outliers training creates. This trains a small SwiGLU transformer to convergence and captures what an inference engine actually quantises. Local models were no use: ollama and LM Studio hold only GGUF, already quantised to 4 bits, so measuring 4-bit quantisation error on them is circular. The energy asymmetry survives training -- 3.4% of energy below zero on the SiLU gate against 6.2% on synthetic, the same order. But it lives only there. The gate multiplied by w3(x) restores symmetry, so swiglu_hidden is 50.4%, as are both post-LayerNorm tensors and the weights. Head to head on those tensors, the asymmetric format wins on exactly one: silu_gate 2.77x against BlockDialect's 2.32x. Elsewhere BlockDialect wins -- attn_input 1.64 vs 1.44, mlp_input 1.61 vs 1.44, swiglu_hidden 2.01 vs 1.63 -- and weights are a tie at 1.49 vs 1.41. That is a validated theory with a narrow application. The energy criterion correctly picked the one tensor where asymmetry pays and correctly predicted the loss on the other four. But the SiLU gate is an intermediate tensor that many implementations fuse and never materialise in low precision, so a 1.19x on it may apply to nothing. It also corrects my own synthetic result. The 1.20x I reported for "SwiGLU" was measured on the SiLU output, not on the SwiGLU block output. On the real block output the asymmetric format loses, 1.63x against 2.01x. One finding recorded but not pursued: swiglu_hidden carries a per-channel outlier ratio of 188x between maximum and median, against 2x for weights and 5-7x for the post-LayerNorm tensors. That is the known 4-bit problem and it is concentrated in one MLP tensor. Of eight levers tried, one reached real data, and it wins on one tensor of five. What stands is the shared-ceiling theorem and the energy-asymmetry criterion as a predictor. What does not exist is a leading format, and perplexity is still unmeasured. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * Transforms move the ceiling that formats share -- and can destroy what a format exploits The shared-ceiling theorem says format levers compete for a fixed budget D*(b,p) and therefore do not compose. An orthogonal transform changes p itself, so it changes D*. That predicts transforms and formats should compose where format levers do not, and the prediction is testable on real trained tensors. A Hadamard rotation over groups of 32, as QuaRot does, on swiglu_hidden: the outlier ratio falls 157x to 10x, MXFP4's error falls 0.216 to 0.125 -- a 1.72x gain with the format untouched -- and the ceiling falls with it, 1.72x to 1.35x. The rotation takes the gain the format levers were competing for and leaves less behind. That is a quantitative account of why the field went to rotations rather than formats. They do compose, but only sometimes, and the exception is the finding. swiglu_hidden format 1.72x rotation 1.72x together 2.33x 79% of product silu_gate format 2.68x rotation 1.33x together 2.06x 58%, and WORSE than format alone attn_input format 1.40x rotation 1.02x together 1.38x nothing to remove On silu_gate the combination is worse than the format by itself. Rotation removes outliers, a property of the tail; the asymmetric format exploits one-sided energy, a property of the support. On swiglu_hidden the structure was outliers, rotation removed them, and a symmetric tail still needed the format -- so they compose. On silu_gate the format lived on asymmetry and rotation symmetrises the distribution, destroying exactly what the format was earning from. The practical consequence: applying QuaRot and then optimising the format is not the same as optimising the format on the original data. The order changes which format is optimal and can cancel the gain the format was chosen for. I have not found this stated anywhere. Refined statement: transforms and formats compose if and only if they address different structure -- a transform that reduces the statistic a format exploits anti-composes with it. Measured at 79% of the product where the structures differ and 58% where they collide. Caveats stand: the rotation is applied along a vector in groups of 32 rather than along the hidden dimension with weight compensation as QuaRot does, perplexity is still unmeasured, and the model is small with a synthetic task. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * Order of operations changes the result by up to 2.78x, with a clean control The composition condition says a transform and a format compose iff they address different structure. That has a directly testable consequence: the order of "fit the format" and "rotate" should matter, and should not matter where the rotation has nothing to remove. swiglu_hidden format-then-rotate 1.82x rotate-then-format 2.33x 1.28x silu_gate format-then-rotate 0.74x rotate-then-format 2.06x 2.78x attn_input 1.40x / 1.38x 0.99x mlp_input 1.36x / 1.36x 1.00x The control is clean: on the two tensors where rotation removes nothing, the ratio is 0.99 and 1.00, so the effect is not noise. And the worst case says the most -- on silu_gate a format fitted before rotation gives 0.74x, worse than doing nothing at all, because it was tuned to an asymmetry the rotation then destroyed. Stated as non-commutativity: the distortion of F(p) applied to T(p) differs from that of F(T(p)) applied to T(p), with the gap growing in how much T changes the statistic F exploits, and equality iff T leaves that statistic alone. The practical consequence is that quantisation pipelines treat rotation and format selection as independent stages, and they are not. A format chosen from the original tensor's statistics -- including any selector from BlockDialect, MixFP4 or dMX calibrated before rotation -- can end up worse than the baseline once rotation changes the distribution. Transform first, then select. Obvious in hindsight, but it follows from the theorem rather than from intuition, and the size of the effect is not obvious at all. Caveats: the rotation is applied in groups of 32 along a vector rather than along the hidden dimension with weight compensation as QuaRot does, the model is small with a synthetic task, and the "format fitted on original data" is free Lloyd-Max on 16 levels, the strongest available -- a weaker selector would suffer less because it has less to lose. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * Perplexity on a task that can degrade, and the summary of what this line produced The first perplexity attempt was useless and the fault was mine: the model learned the task to loss 0.0000, and a task with zero error has infinite margin, so quantisation either breaks the argmax or does not. That is a binary, not a quality measure. Adding 30% random labels gives the task an irreducible floor of 1.913 and makes degradation graded. fp32 loss 2.3350 ppl 10.330 MXFP4 on all weights loss 4.5092 ppl 90.849 8.79x Lloyd-16 on all weights loss 2.3239 ppl 10.215 0.99x Fitting levels to the distribution takes essentially all of it. The absolute numbers do not transfer to real LLMs, which have redundancy and calibration pipelines, but the ordering does and that is what is claimed. SUMMARY.md consolidates the line. No leading format was found, and the measurements say why: of eight format levers, one reached real data and wins on one tensor of five -- an intermediate gate many implementations never materialise. What stands is three statements, all verified, all about boundaries rather than about a format. The shared ceiling: format levers compete for D*(b,p) and do not compose, so a selector is a classifier and not an accumulator. That bounds BlockDialect, MixFP4 and dMX from above. The energy criterion: one-sidedness is a property of energy, not of the count of negatives, and it predicted the winner on all five real tensors. The composition condition and its non-commutativity: a transform moves D* while a format divides it, so the two compose iff they address different structure -- Hadamard rotation composes with format on outliers (2.33x from 1.72x and 1.72x) and anti-composes on asymmetry (2.06x against the format's own 2.68x). Order therefore matters, by 2.78x in the worst case, and a format fitted before rotation can give 0.74x, worse than doing nothing. The control on two flat tensors returns exactly 1.00. Six errors caught along the way are listed rather than buried, each in the file where it happened. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * The ternary-network datapath, measured as one design rather than summed In a ternary network the weight is in {-1, 0, +1}, so w*a is a select, a negate or a zero -- not a multiply. The multiplier disappears for every format at once, and the denominator the decoder is compared against stops being thousands of LUTs of multiplier and becomes hundreds of LUTs of adder. What was overhead in an ordinary network becomes the body of the datapath here. Synthesised as one design on XC7A200T, no DSP, differing in exactly one block -- posit needs a regime decode before the add, TEF reads its fields directly: TEF 440 LUT 80.73 MHz 0.184 MHz/LUT posit 895 LUT 31.81 MHz 0.036 MHz/LUT 2.03x in area, 2.54x in frequency, 5.16x in throughput per LUT. Measured end to end rather than assembled from separate decoder and adder figures. The decomposition explains the size: the decoder is 20% of an ordinary datapath for posit and 54% of a ternary one, and 85% against 97% for takum, which also brings 84 block-RAM tiles. Three things this does not claim, stated in the README because each would be found in minutes otherwise. It is not a format without multiplications -- TEF pays the significand multiply like everyone else when one is needed, and the quadratic term of its own area law is that multiplier; what vanishes in a ternary network vanishes for the network, not for the format. It is not best-for-FPGA in general -- the exponent decode of TEF and of an ordinary binary fixed field measure identically at 32 LUTs each, so the advantage is over tapered formats and not over fixed-field ones. And it is not a measurement on a ternary fabric, which does not exist to buy; everything here is a binary FPGA where our own theorem says the ternary encoding earns nothing, and it does not need to -- the gain comes from the absent decoder. The posit decoder is taken from an open verification suite and brought to the same fields through fp32, which is structurally fair but is not an optimised posit adder datapath. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * The full matrix: one ternary neuron across formats, scored against every theorem Seven formats through one synthesised datapath on XC7A200T, differing in exactly one block -- the activation decode. Adder, weight application and accumulator are identical. TEF 440 LUT 0 BRAM 80.73 MHz 0.183 MHz/LUT binary32 479 0 78.23 0.163 binary16 552 0 62.69 0.114 posit8 560 0 43.55 0.078 takum16 817 57 64.16 0.079 posit16 774 0 36.30 0.047 posit32 955 0 28.33 0.030 The ordering is set by one column, scan-at-decode, and one property, the value law, and the group boundaries fall exactly where the theorems put them. No scan and a linear value law: TEF, binary32, binary16, spread 9-25% apart, which is field widths rather than format. With a scan: posit at every width, 2.35x to 6.10x behind in throughput per LUT, which is Theorem 14 -- decode cost is set by the scan, not by the staircase. Logarithmic value law: takum has no scan but brings 57 block-RAM tiles to evaluate 2^f, which is Theorem 20. The 9% between TEF and binary32 is Theorem 6 in action, and stating it is what keeps the claim honest: on a binary fabric a packed ternary exponent never carries more values per bit, so it earns nothing here and should not. The gap comes from the absent decoder, not from ternarity. The defensible sentence is therefore not "TEF is the best format" but "a fixed field beats a tapered one by 2.4-6.1x on a ternary network, and TEF is the best of the fixed fields". Where ternarity starts to pay is the last column, and it is computed rather than synthesised because no such FPGA exists: on a fabric whose positions hold trits, a binary exponent field is either dense and unaddable without a radix conversion, or addable at one bit per trit and 25-50% wasted. TEF pays neither. Twelve more formats are still routing. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * Eighteen formats through one ternary neuron, including the GF ladder The matrix now covers every family in the catalogue that has RTL: the GF ladder from arXiv:2606.05017 (GF10, GF14, GF+8, GFTernary), IEEE, VAX, fp8, minifloat, int8, posit at three widths, takum, LNS and IBM hexadecimal. One synthesised datapath, XC7A200T, no DSP, differing in exactly one block. Ranked by throughput per LUT, the boundaries fall where the theorems put them and not where a favourite would put them: int8 448 LUT 84.86 MHz 0.189 no exponent field at all TEF 440 80.73 0.183 GFTernary 466 82.51 0.177 binary32 479 78.23 0.163 ... fixed fields cluster 0.109-0.183 ... takum16 817 + 57 BRAM 64.16 0.079 logarithmic value law posit8 560 43.55 0.078 regime scan IBM hex32 683 49.71 0.073 radix 16 LNS16 659 43.11 0.065 posit16 774 36.30 0.047 regime scan posit32 955 28.33 0.030 regime scan int8 leads TEF by 3%, and the file says so first. It has no exponent field: its decode is a sign extension and its entire dynamic range lives in the block scale. That is a different trade, not a better format, and the defensible sentence is that TEF leads among formats that carry an exponent. The group boundaries are the finding. Fixed fields span 1.7x among themselves; regime-scanning formats sit 2.4x to 6.4x behind; logarithmic value laws pay in memory as well as logic. That is Theorem 14 and Theorem 20 measured on eighteen points rather than argued on three. Skills updated with the matrix and with three things not to say: not "TEF is the best format" (int8 is 3% ahead), not "no multiplications" (the network removes them, not the format), not "best for FPGA" (TEF and a binary fixed field measure identically at 32 LUTs on the exponent decode). Two synthesis traps recorded: takum's 64K tables route for hours and belong last, and posit8_es2_decode instantiates posit16_decode, so yosys fails without both. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * The TEF ladder in the matrix, and the unfair comparison it exposed Adding TEF4/8/16/32 through the same datapath as every other format made my own headline collapse, and the cause is a mistake in how I set the comparison up. The first tnet_tef received a_off and a_mant already widened to the accumulator's fields. It never decoded a packed word at all. Every competitor received a packed word and decoded it. TEF was running a shortcut nobody else had, and the 440 LUT against posit's 895 was not apples to apples. Through the same fp32 path the ladder measures 469, 487, 495 and 499 LUTs for TEF4/8/16/32, at 0.167, 0.147, 0.145 and 0.151 MHz per LUT. That puts TEF in the MIDDLE of the fixed-field group, not at its head: int8 0.189, GFTernary 0.177, TEF4 0.167, binary32 0.163, TEF32 0.151, TEF16 0.145. The spread inside the group is 1.7x and it tracks field widths rather than family. So "TEF is the best fixed field" does not survive a fair comparison, and the file now says so where the claim used to be. What survives intact is the group separation, which was always the actual finding: fixed fields 0.109-0.189, regime-scanning formats 0.030-0.078, logarithmic value laws paying in memory as well as logic. That is Theorem 14 and Theorem 20, and neither depends on whose format leads within a group. This is the seventh error of my own that a measurement has caught in this campaign and the most consequential, because it was in the headline rather than in a footnote. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * The BNF/TNF control in silicon, and the frontier across all four families BNF exists to measure what the ternary encoding is worth rather than to assert it, and the pair differs in exactly one thing: the radix the exponent field is encoded in. Through one datapath on XC7A200T, no DSP: BNF16 at 519 LUTs and 71.05 MHz against TNF16 at 514 and 74.37. One percent in area, under five in frequency -- routing noise. That is what the no-free-range theorem requires. A ternary exponent packed into bits never carries more values per bit than a binary one, so on a binary fabric the pair must tie. It ties, in silicon rather than only in arithmetic, and the 1.00x was computed before the synthesis rather than after. The frontier across all four families is measured too, and the effective mantissa matches the declared M within 0.15 on both axes, so the precision law holds on the phi axis as well as the theorem axis. One clean result falls out of it. GF and GF-T carry the SAME mantissa at every rung -- 4 at 8 bits, 9 at 16, 19 at 32, 39 at 64 -- because both take round((N-1)/phi^2) positions for the exponent. But GF-T's positions are trits, so it spans 728 binades at 16 bits against GF's 62, and 531440 at 32 bits against 4094. On a ternary fabric, where a trit is a position, GF-T strictly dominates GF: same width, same precision, 11.4x the range at 16 bits and 130x at 32. That is the ternary encoding's payoff with no trade at all, and it lives on the phi axis rather than on ours. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * The frontier and the silicon, which contradict each other only apart Two results that read as opposed until they are put side by side, because they answer different questions. By the numbers, TNF is not a format at all. It is a one-parameter family: the width rule 1 + E_t + M = N, swept over E_t, gives a chain of points every one of which lands exactly with no position unspent. At 16 bits that is twelve points from (13.06, 8) to (2.13, 1594322), and all seven catalogued competitors are strictly dominated -- binary16, gf16, posit16, bfloat16, afp, tekum16, takum16, no exceptions. At 8 bits the same, seven competitors, none surviving. That is not a trick of density. Each competitor leaves something on the table for one of three reasons: a taper, which measures below its declared mantissa; unspent positions, which the historical GF-T had at 2, 4 and 6 and the width rule reclaims; or a binary exponent at equal position count, where a trit carries log2(3) bits against a bit's one. Every competitor loses on at least one. The family loses on none. The wide classes needed the probe's ceiling removed -- a binary search rather than a linear scan to 400 -- and TNF then holds the top-precision point at every width: 11.20 at 16 bits, 25.13 at 32, 55.82 at 64 against binary64's 52.27, 119.12 at 128 against binary128's 111.98. GF-T's ranges at 64 and 128 still saturate the probe and are marked as such. By the silicon, TNF sits mid-pack. Through one ternary-neuron datapath across 21 formats it measures 0.145 to 0.167 MHz per LUT against int8's 0.189 and binary32's 0.163. The two do not conflict. The frontier asks what a word of a given width carries, which is a property of the number, and there the family dominates because it wastes nothing. The silicon asks what it costs to unpack that word, which is a property of the decoder, and there every fixed field is nearly equal because they all decode by reading fields. The gap in silicon runs between fixed and tapered, 2.4x to 6.4x, and it is Theorem 14 and Theorem 20 rather than anything about us. So the honest position is that we win on the axis of the number and do not win on the axis of the decoder, because on that axis there is nothing to win -- and the file says both, along with what may not be claimed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> * docs(research): dominance verified across all five width classes 28 catalogued competitors at 8/16/32/64/128 bits, zero survive the one-parameter TNF family. Range is analytic for a fixed field; the boundary check is impossible above E_t~30 (2^1.4e23) and is recorded as a limit of the measurement rather than dropped. Adds the frontier theorem and no-survivors corollary to the paper, with the silicon reconciliation stated inline: dominance in (M_eff, range) is not dominance in LUTs, and the paper says so. Refs #516 * docs(skills): record what the frontier result does and does not close The one-parameter TNF family dominates all 28 catalogued competitors across five width classes. That closes the number axis and closes nothing else: silicon puts TNF mid-pack among fixed fields, the block axis (MXFP4) is still uncovered, and a dense family dominates any finite point set for free unless each competitor's shortfall is a theorem. The publication stop rule therefore stands. Also records the killed boundary experiment rather than dropping it, and fixes the stale arxiv_tef path. Refs #516 * paper: retitle to Ternary Network Floats and prove the trit is the slack The no-survivors list becomes a statement about the design space. The family covers (m,b) iff m + log_3(b+1) <= N-1; a uniform format obeys m + log_2(b+1) <= N-1 in its own accounting. Same books, two currencies, and the exchange rate is the whole result: every uniform binary format is covered with slack E*(1 - log_3 2) = 0.3691*E positions, growing linearly in the exponent width it spends. This is stated against T6, which says a packed ternary exponent carries no more per bit and which silicon confirmed (BNF16 vs TNF16, 1% apart). Both hold on different axes: per position the trit spans log2(3) binades, per bit of binary fabric the packing gives it back. The bound is tight -- posit16 sits within 1% -- and not vacuous: the same posit16 scored where a taper is designed to live violates it at 16.30 against 15. So escape needs non-uniformity, and there are exactly two routes: taper, or a scale outside the word. Both are named as frontier, not as territory held. Abstract rewritten to arXiv's 1826/1920 character metadata limit with no TeX-isms, following the motivation/problem/approach/results structure; abstract_arxiv.txt is the submission field verbatim. Refs #516 * paper: width-rule optimality, regret, composition, and the block gap Three results the no-survivors table needed to stand on. Theorem (optimal member): once a workload's visited range is named, E_t* = ceil(log_3(b+1)) maximises the mantissa uniquely. The rule has no free parameter, so it names a winner before measurement -- which is what makes it falsifiable. Theorem (regret): mis-sizing is asymmetric. Over-sizing costs precision logarithmically on every value; under-sizing costs range linearly on the tail. A wider exponent is not the conservative choice by default. Theorem (composition): transforms and formats act on different arguments, so their order matters -- measured at 2.78x. Recorded because an earlier version of this work reported the levers as nearly multiplicative, computing a ratio against a losing baseline. Related work now states where the block literature is not looking: the 2026 papers vary the transform (learnable block optimisation, format-aware rounding, residual channels) and hold the element at E2M1. That is the variable the width rule speaks to. Six dangling cross-references repointed to their real labels. Refs #516 * research(block): MXFP4 was given six magnitudes where the spec gives eight fp_levels reserved the top exponent code for Inf/NaN as IEEE binary formats do. OCP microscaling element formats reserve nothing -- every E2M1 code is finite -- so the reservation cost the standard the values 4.0 and 6.0 and ran it at 2.58 bits against int4's 3. Uncorrected, the run reads 'uniform int4 beats MXFP4 by 27%'. It does not; the rows had different level counts. Same class as the earlier amax defect: both underfed the competitor and both would have produced a headline in our favour. Adopted rule -- a competitor's cardinality is a specification fact, asserted against the spec in the harness, never derived from a shared helper. Refs #516 * paper: name the first principles -- KKT, radix economy, Kraft The width rule was stated as a rule. It is the solution of a constrained maximisation: maximise M subject to 1+E+M=N and r^E >= b+1. The multipliers come out lambda = mu = 1, so complementary slackness makes the range constraint active -- the exponent is exactly as wide as the range demands and not one position wider. Theorem (optimal member) is now derived, and lambda=1 is the shadow price: one position of exponent costs exactly one of mantissa. Radix economy rho(r)=r/ln r, minimal at e, explains why three and not two -- a 1950s result we claim no credit for. Its use here is the reconciliation of our two axes, which are the two factors of r * log_r(V): the number axis counts positions and ternary wins unconditionally by 0.3691*E; the silicon axis restores the cost per position and charges kappa(3)/kappa(2)=1.68, which is why BNF16 and TNF16 land within 1%. T6 and the slack corollary are one product reported factor by factor, not a contradiction. Least action and conservation of energy are named as resemblances and explicitly not used as arguments: no time, no trajectory, and 1+E+M=N is a designer's budget, not a law of nature. Applied to the block axis the multiplier problem returns E2M1 at the measured 99th-percentile within-block span of 3.04 binades -- the OCP microscaling element, derived rather than beaten. Refs #516 * research(ternary): the accumulator law, derived and measured In a ternary layer the weight has no format -- 1.58 bits, no exponent, no mantissa, no multiply. Every published ternary method quantises the weight, so none of them was ever a competitor to a number format; the object a format describes here is the accumulator, and that niche is empty. Law: range visited grows as log2(pK), error after pK roundings as sqrt(pK)*2^-(M+1), so through the KKT solution E* = ceil(log_3 B(K)) and the mantissa side outruns the exponent side. Measured on real ternarised weights: fitted exponent in K is +0.476 and +0.435 against a predicted +0.5. Et=2 fits at +0.207 and that is the range constraint being active, not a refutation -- 9 binades cannot hold an accumulator visiting 13.9, so its curve is saturation-dominated then rounding-dominated. The measured span picks Et=3 by the rule, and the measurement picks Et=3 independently at every fan-in. Two more self-caught defects recorded. The first instrument normalised each value by its own magnitude and returned error identically zero everywhere -- a format that never rounds is not a format. The second built level sets from the position count alone, ignoring that binary fabric addresses only 2^(N-1) magnitudes, and produced a 100x perplexity artefact against our own format. Refs #516 * paper: lead with the datapath, and split trainable from rejected Reframed on what the measurements actually support. A ternary node has three format-bearing sites and only one needs a format: the weight is a code (sign-select, not multiply), the sample is ADC-native, and the accumulator is the only object with a range to spend. We close both halves that need closing -- GFTernary the weight, TNF the accumulator -- and no other pair in the literature does. New theorem: the golden alphabet is unique. Requiring the product of two weights to fall back into the lattice the datapath already adds in means r^2 = r + 1, whose only positive root is phi. Corollary: a k-layer gain is exactly F_k*phi + F_(k-1), two integers, so rescaling between layers is shift-and-add and depth never reintroduces a multiplier. This is what separates the phi alphabet from {-1,0,+1}, which needs a learned real alpha per layer -- and multiplying by alpha puts the DSP back. Comparison split in two by a checkable test: does the word carry the range, or must it be brought from outside? int8, int4, integer accumulators and the bare E2M1 element go in the rejected table -- e=0, no range in the word, and every published sub-8-bit training result using them carries block scales AND a higher-precision master weight. int8's 0.189 MHz/LUT is reported there, not as a competitor: it leads by declining the task. GFTernary stays in the main table despite e=0 because its scale is intrinsic and exact rather than external and learned. Conclusion stated at the strength the measurements carry: for a ternary datapath the pair {GFTernary, TNF} is a reference format -- complete, forced rather than chosen, and predictive. Explicitly not a claim about datapaths that multiply, where the block axis holds the ground. Abstract rewritten to exactly 1920/1920 arXiv metadata characters. Refs #516 * research(block): the block axis is decided, against us MXFP4 21.94 and MXFP6 14.73 beat TNF4 36.72 and TNF6 18.03 on wikitext-2 with the MX spec's own E8M0 scale and a verified baseline. The reason is structural, not tuning: 3^E_t never divides 2^k, so a ternary exponent packed into a binary word always wastes codes, and where the alphabet is short the waste dominates. TNF4 gets 7 of 8 magnitudes against E2M1's 8, and 3 binades against 4 -- strictly worse on both counts at once. At 6 bits the loss reaches 41% of the alphabet. This is T6 carried to its conclusion: on the number axis a trit is a position and wins; in a packed word the codes are counted and it pays. Two things survive. The KKT law returned E2M1 -- a binary exponent -- from the measured within-block span, recommending the industry standard over our own family; a rule that only ever recommends its author is not a rule. And the range constraint is visibly active: TNF6 E_t=2 with 19 magnitudes beats E_t=1 with 25, so fewer levels with more range wins, which is complementary slackness appearing in perplexity. The reference-format claim is bounded accordingly: it is a claim about ternary datapaths without multipliers, not about block-scaled binary ones. The publication stop rule stands -- the block axis was the named condition and the measurement went against us. Refs #516 * paper: place the work inside a sixty-eight-year argument Radix economy and the case for three are not ours, and saying whose they are makes our contribution smaller and defensible. Fowler's mechanical balanced-ternary machine around 1840; Brusentsov and Sobolev building Setun at Moscow State University in 1958 on paired ferrite cores, ~50 machines 1959-65; Setun-70 in 1970 anticipating RISC arguments and ended administratively; Knuth keeping the idea alive; CNTFET, memristor and photonic ternary devices continuing it. New theorem states the boundary rather than the claim. Written as cost = r x log_r V: where the position is physical, only the second factor is compared and ternary gains 0.3691E positions unconditionally; where the position must be encoded in bits, the format is bounded by 3^E_t * 2^M <= 2^(N-1) and, since 3^E_t never divides a power of two, the remainder is lost -- 25% at 4 bits, 15.6% at 6 and 8, 5.1% at 16. We add no support to 'ternary beats binary' as a general statement. We measured it three times and it went against us each time. What we add is the condition under which the old argument applies, which reads as a prescription: it says what fabric must exist for the advantage to be collected, and that fabric is not the one currently purchasable. Parhami's binary-encoded balanced ternary anticipated the mechanism and is credited; our part is measuring its cost in a live network and in placed-and-routed silicon rather than in operation counts. Refs #516 * paper: complete the truncated table and withdraw stale headline numbers Audit of every table against its own caption found two defects. tab:carryrange claimed 21 formats and showed six rows with an ellipsis. Now complete: 20 rows with storage, LUTs, Fmax and MHz/LUT, int8 excluded and pointed to the rejected table with the reason. tab:tnet still carried 440 against 895 LUTs at 0.184 MHz/LUT -- the comparison this same paper retracts elsewhere, where TNF received pre-widened fields while the competitors unpacked theirs. Replaced with matched width against matched width on packed words: 3.1x at 16 bits and 5.6x at 32, with the withdrawal stated in the caption rather than buried. The gap belongs to the regime scan, not to the ladder. Closing section sets the two independent lines side by side: the arithmetic one, 68 years old, which stalls because 3^E_t never divides a power of two; and the geometric one, where requiring the product of two weight symbols to fall into the sum the datapath already forms gives r^2 = r + 1, whose single positive root determines the alphabet. Stated as a reading of the results, with every component measured above, and what they amount to together left to the reader. Refs #516 * research(families): the two axes return the same format, measured GF8 E=3 and BNF8 E=3 both give perplexity 14.6130 -- the same number, not a close one. The golden-ratio rule E = round((N-1)/phi^2) and the width rule 1+E+M=N were derived independently and for unrelated reasons, and at eight bits on this workload they name the identical format. Neither derivation predicted that. Twelfth self-caught defect, and it falsifies our own prediction: the width rule named BNF8 E=4 and TNF8 E_t=3, and the winners were E=3 and E_t=2 -- both predictions one step too wide. The rule's form survives and is visible in the sweep (single optimum, asymmetric penalty exactly as the regret theorem states: under-sizing gives 4.5 million, over- sizing costs 0.3%). What was wrong is the estimator of the visited range: we measured 0.1st percentile to maximum, crediting a tail that carries almost no energy. Recorded rather than quietly re-tuned. Ternary loses on binary fabric for the third independent time: GF-T8 carries 109 magnitudes against GF8's 129 and pays 15.51 against 14.61. Refs #516 * paper: the multiply-free path is not merely cheap, it is exact Applying a phi weight to an integer pair (a,b) representing a + b*phi is (a,b) -> (b, a+b): the Fibonacci recurrence, one integer addition, no shift. Z[phi] is a ring and the alphabet lies inside it, so for inputs in Z[phi] the entire linear part of a ternary network -- every weight application and every accumulation, to arbitrary fan-in and depth -- stays in Z[phi] and is computed with no rounding error at all. This is a different kind of claim from the rest of the paper. Elsewhere we compare error magnitudes between formats; here there is no error to compare. Measured at fan-in 512 the integer pair reproduces the real sum to the precision of the checker, not of the datapath. Components grow logarithmically, eight bits over those 512 terms, and the cost is two integer accumulators instead of one float. The base is a minimum rather than a choice: closure needs r^2 = pr + q with integer p,q, and any p > 1 adds a shift to the addition. p=q=1 gives phi. 1+sqrt(2) satisfies r^2=2r+1 and pays the shift; sqrt(2) has r^2=2 and loses the scale out of the lattice. Scope stated so the claim does not overreach: this is arithmetic in a lattice. It covers the linear algebra that dominates a network's work and its DSP cost, and says nothing about control flow or addressing. Refs #516 * research(phi): the phi scale grid halves the cost of removing the multiplier BitNet stores ternary weights plus a real per-layer scale alpha = mean|W|, and multiplying by that alpha puts the multiplier back at the layer boundary. Snapping the scale to a grid removes it. The phi grid is denser than powers of two by log(2)/log(phi) = 1.440 at the same cost class, so the prediction made before measuring was that its excess error over the unreachable exact alpha would be about half. Measured over 210 layers: exact 0.476781, phi^k 0.488424 (+2.4420%), 2^k 0.499943 (+4.8579%). Ratio of excesses 0.501 against a predicted 0.500. phi wins 163 of 210 layers -- not all, since a layer whose optimum lands near a power of two is better served by the coarser grid. Together with dot_exact this closes the multiplier out of the entire layer: weights, accumulation, and now the scale. Defect #13 recorded rather than reported as a result. The first attempt asked this through perplexity, where post-hoc ternarisation destroys a model not trained for it: every arm including BitNet's exact alpha landed at ppl ~2.2e7 against a baseline of 14.49. Read naively that says phi is refuted by 2x. It says nothing -- the tell was that the control arm was destroyed too, and a comparison whose control fails is not a comparison. Refs #516 * fpga(phiscale): what the layer scale costs with and without a multiplier BitNet's per-layer alpha = mean|W| is a real number, so applying it is a genuine multiply -- the multiplier the ternary weights removed comes back at the layer boundary. Carrying the value as an integer pair makes the scale phi^k into k Fibonacci steps, one adder each. Synthesised through yosys synth_xilinx: the multiplier arm costs 2 DSP48 blocks, or 1215 LUTs with DSP inference off. The phi arm costs 171 LUTs and zero DSP, and is DSP-invariant -- identical numbers with and without, because there is no multiply to map. Costs stated rather than omitted: 4x the registers (135 FF against 33), k cycles instead of 1 (about 8 for a typical alpha, so ~1.6% of a fan-in-512 layer), no Fmax because nextpnr-xilinx is not on this machine, and only k >= 0 -- the inverse step is (a,b) -> (b-a, a) since phi^-1 = phi - 1, one subtraction, not yet built. Area reported only after correctness: 200 randomised cases against a golden model computed independently in the testbench, 0 errors, with a negative control confirming the bench can detect a mismatch. A circuit that computes the wrong thing is smaller still. Refs #516 * fpga(phiscale): name which direction was actually built Real layer scales are below one -- alpha = mean|W| ~ 0.02 gives k ~ -8 -- so a deployed layer needs the inverse Fibonacci step (a,b) -> (b-a, a), from phi^-1 = phi - 1. That is one subtraction where the built circuit does one addition, so the area transfers and the count stands, but the forward direction is what was synthesised and simulated. Recorded because a reader would otherwise take the measured circuit for the deployable one. * research: APoT refutes our scale-grid claim, and exactness was never ours Two of our own claims are withdrawn or bounded, both by measuring a competitor properly rather than by a new experiment. The phi^k grid does beat 2^k by exactly the predicted density ratio, and that reproduces. It was the wrong baseline. The deployed state of the art for multiplier-free scales is APoT -- sums of power-of-two terms, ICLR 2020. On the same 210 layers: APoT-2 costs 0.1651% excess against exact alpha where ours costs 2.4420%, and it does so in one cycle against our k. APoT-3 costs 0.0054%. Ours wins 17 layers of 210 against APoT-2. The claim that ours is the right grid for a multiplier-free scale is withdrawn. dot_exact is machine-checked and remains true, but the significance attached to it does not survive. An APoT scale is a dyadic rational, and the dyadic rationals are also a ring closed under the datapath's operations: checked in exact arithmetic, a fan-in-512 layer with an APoT-2 scale and Q8 inputs lands on a denominator of 2^15, exact in ordinary fixed point. Binary has had this since fixed point existed. What remains unique to phi is term-count non-growth -- a Z[phi] value stays a two-component pair through any depth, while APoT-2 squared has four terms and the count compounds. Stated as a conjecture; it needs an experiment, not an assertion. Also lands the deployable signed scale path, closing the hole named in the previous iteration: both directions, since real layer scales give k about -8. 360 randomised cases including a multiply-then-divide round-trip identity, 0 errors. Costs two LUTs over the forward-only version, 173 against 171, still zero DSP and still DSP-invariant. Refs #516 * research(scale): three vertices, no winner, and the shifter we ignored Measuring area rather than only accuracy shows the scale applier was never a one-dimensional question. phi^k costs 173 LUTs, APoT-2 costs 384, the multiplier 1215 or 2 DSP48. Ratio phi to APoT is 2.22x at d=0, 3.81x at d=1, 7.03x at d=2. The reason is not the one predicted. Term-count non-growth is the second effect; the first is that APoT's shift is by a runtime value, so it is a barrel shifter at 192 LUTs each on 32 bits. We had been calling APoT shift-add and treating that as free. A constant shift is free; a variable one is a barrel, and a scale serving any layer is variable by construction. Four theorems: term growth n^(d+1) against a constant pair; shifter cost Theta(W log W) against zero for a fixed permutation; a crossover depth d* = 2 at which APoT costs what it was introduced to avoid, measured at 1217 against the multiplier's 1215; and no domination in (area, latency, error), all three being vertices. The accuracy withdrawal stands. APoT-2 remains 15x more accurate at one cycle against k, and anyone bound by accuracy or latency should use it. The honest output is a hybrid rule rather than a winner -- the previous two iterations each defended a single answer and each was wrong in a different direction. Refs #516 * paper: the scale applier has three vertices, and two of our claims move Records both corrections in place rather than quietly restating the position. Withdrawn: that the phi^k grid is the right one for a multiplier-free scale. The 0.501 density ratio reproduces and is correct, but the baseline was wrong -- APoT is what the field deploys, and it costs 0.1651% against our 2.4420%, in one cycle against k. Bounded: dot_exact is machine-checked and true, but an APoT scale is a dyadic rational and Z[1/2] is also a closed ring, so a fan-in-512 layer with an APoT-2 scale and Q8 inputs is already exact in ordinary fixed point. Binary has had this since fixed point existed. Four new theorems from measuring area rather than accuracy: term growth n^(d+1) against a constant pair; shifter cost Theta(W log W) against zero, which is the effect we missed and is larger than the one we predicted -- APoT's shift is by a runtime value, so it is a barrel at 192 LUTs each on 32 bits, while a Fibonacci step has no shifter at all; a crossover at d* = 2 where APoT costs what it was introduced to avoid; and no domination in (area, latency, error). Output is a rule, not a winner: phi^k where the path is area-bound or composed without requantisation, APoT where it is latency- or accuracy-bound. Stated that way because the two previous iterations each defended a single answer and each was wrong differently. Refs #516 * research: the area ordering inverts with regime, and ours was the wrong one Two attacks on our own area claim, both successful. Freeze the scale and APoT's shifts become compile-time constants -- wiring, not logic. Measured: APoT-2 at 26 LUTs against an unrolled phi^k at 64, 128, 256 for K = 2, 4, 8. An unrolled recurrence is linear in K at about 32 LUTs a step; a constant-shift applier is one adder regardless. The lines never cross, not even at K = 1. Then the barrel. Our regime-2 advantage used a 5-bit shift field, but across 210 layers the scales span only 3.15 octaves, so two bits suffice. At SW=2 APoT costs 130 LUTs against our 199. The 2.22x advantage was an artefact of giving the competitor a wider field than it needs, and it is withdrawn. Instrument limitation recorded: the APoT sweep is non-monotonic (130, 380, 230, 384) with the parameter demonstrably applied and yosys deterministic, so this is abc mapping heuristics. LUT counts from yosys alone are not reliable at this granularity -- a claim resting on 30% between two such points is unsafe; one resting on regime 1's 10x is. Three theorems: an unrolled recurrence is Theta(KW) against Theta(W) for constant shifts, so it loses at every K; the ordering inverts with compile-time versus runtime scale, so neither family is better and the architecture decides; and a barrel is priced by the workload's range, not by a convenient field width. What survives is narrower: phi^k is the only applier whose area is independent of composition depth, which is real but uncommon. The alphabet uniqueness and Z[phi] closure are machine-checked and were never area claims. Refs #516 * paper: withdraw the area advantage as well, by our own attack Three theorems and one withdrawal. An unrolled recurrence is Theta(KW) where a constant-shift additive applier is Theta(W), so with a frozen scale the recurrence loses at every K -- measured 26 LUTs against 64, 128, 256 at K = 2, 4, 8. The ordering therefore inverts with regime and is a property of neither family. And a barrel is priced by the workload's range: 3.15 octaves across 210 layers means two bits, where APoT costs 130 against our 199, so the 2.22x was an artefact of a five-bit field. Instrument limitation stated rather than smoothed: the APoT sweep is non-monotonic with the parameter applied and the tool deterministic, so logic-synthesis LUT counts are not reliable at this granularity. What survives is term-growth independence alone, in a regime that is real but uncommon. The alphabet uniqueness and Z[phi] closure are untouched, having never been area claims. Refs #516 * research: the operating point, which is what survives five withdrawals Z[phi] is the only one of three systems cheap under BOTH operations. LNS makes multiplication free and pays for addition with a log(1+2^x) table -- our own takum32_decode measurement, 10,967 LUT and 84 RAMB36. Fixed point and APoT make addition cheap and pay for scale multiplication unless the scale is frozen. Z[phi] costs one adder for multiplication by a power of phi and 64 LUTs for componentwise addition. The price is that its free multiplication is restricted to powers of phi. Four theorems say why that is not a restriction here: in a datapath where weights are codes applied by sign-select and the scale is a power of the base, the required multiplication set is exactly {base^k}; a ring closed under addition and under multiplication by generator powers is sufficient; LNS is over-provisioned and fixed point under-provisioned for that profile; and compile-time composition is free, so term growth occurs only where d or the scales are runtime quantities. That last theorem removes three of the four depth cases we had claimed: low-rank W=UV, folded conv+BN and residual branch scalars are all known after training, so the product is precomputed and no composition happens in hardware. One survives -- accumulation along a mesh route, where the hop count is runtime. That is the tri-net datapath, not the network. States its own boundary rather than waiting to be asked: not an area win, not an accuracy win, and nothing to beat where the scale is frozen. A claim about which system matches a datapath's operation profile. Refs #516 * paper: the operating point, and four theorems that bound it Z[phi] is the only one of three systems cheap under both operations. LNS buys free multiplication and pays for addition with a log(1+2^x) table -- our own takum32_decode figure, 10,967 LUT and 84 RAMB36. Fixed point and APoT buy cheap addition and pay for scale multiplication unless frozen. Four results say why the restriction to powers of phi costs nothing here: the required multiplication set of a sign-select datapath is exactly {base^k}; a ring closed under addition and generator-power multiplication suffices; LNS is over-provisioned and fixed point under-provisioned for that profile; and compile-time composition is free, which removes three of the four depth cases we had claimed and leaves only mesh-route accumulation, where the hop count is runtime. Boundaries stated in the section rather than extracted later: not an area win, not an accuracy win, and nothing to win where the scale is frozen. * research: seven iterations, seven withdrawals, and what is left An accounting. Every phi claim about silicon was tested tonight, mostly by us, and none survived. Withdrawal 6: our LNS row cited takum32_decode at 10,967 LUT. That is a format decoder, not an adder. An honest LNS-32 adder with a 4096-entry table costs 275 LUT -- we were off by two orders of magnitude, and the over-provisioning theorem shrinks from 170x to 8.6x at matched storage. Withdrawal 7: the mesh case, the last place a depth advantage could live. Matched combinational comparison gives APoT requantisation 103 LUT against a Fibonacci step at 128 -- phi loses by 25%. Reached first through an unmatched comparison reading 0.60x against us, because our side carried a controller the other did not. Same defect as the six wins before it, pointed the other way. A loss deserves the same audit as a win. What survives: the machine-checked mathematics, untouched and never a hardware claim; the LNS comparison rebuilt honestly, where Z[phi] addition is 32 LUT against 275 and LNS additionally cannot represent zero while a ternary alphabet is 46% zeros; the number-axis frontier; and zero DSP, which belongs to ternary weights rather than to phi. Closing theorem: the terms of a comparison are part of its result. Seven times a ratio changed sign or magnitude when the competitor was rebuilt as its own advocate would build it. The measurements were never wrong; the comparisons were. Refs #516 * research(frontier): withdrawal 8 -- the headline was a positions-vs-bits artefact The claim that 28 catalogued formats are dominated with slack 0.3691*E counts positions. A format is stored in bits, and a realisable member obeys 3^Et * 2^M <= 2^(N-1). Substituting the minimal Et gives m + log2(b+1) <= N-1, identically the uniform binary budget, since log2(3) log3(x) = log2(x). The slack vanishes exactly, for every E. Measured at equal storage: 6 of 17 dominated, not 28 of 28. Uniform binary formats that spend all their bits tie exactly -- binary32 at 31.10 against 31, binary64 at 63.27 against 63. Those dominated are wasting budget: posit32 by 5.12, posit64 by 14.24, takum32 by 0.82, cray_float by 0.65, and our own gf8 by 0.70. Several tapered formats escape outright -- posit16 by 2.37, takum16 by 1.53 -- which is consistent with our own corollary that escape requires non-uniformity. Corrected statement: at equal storage the family ties every uniform binary format spending all its bits, dominates those wasting budget, and is escaped by tapers measured where they concentrate precision. The same defect was recorded twice yesterday, as T6 and as the level table where TNF4 with Et=2 does not exist in four bits. Both were treated as local facts about packing and neither was carried back to the headline. Rule adopted: a correction that invalidates a comparison must be applied to every claim resting on the same quantity, not only where it surfaced. Refs #516 * paper: correct the headline -- the frontier at equal storage The abstract claimed 28 catalogued formats dominated with slack 0.3691*E. That counts positions. A realisable member is stored in bits and obeys 3^Et * 2^M <= 2^(N-1); substituting the minimal Et collapses the condition to m + log2(b+1) <= N-1, identically the uniform binary budget, since log2(3) log3(x) = log2(x). Abstract rewritten to state both counts and which one holds. New theorem and corollary in place, with the measured outcome: 6 of 17 dominated, uniform binary formats spending all their bits tie exactly, and tapers escape -- consistent with our own corollary that escape requires non-uniformity. Also records why it went unseen: the same packing defect appears twice elsewhere in the paper, as the no-free-range theorem and as TNF4 with Et=2 not existing in four bits, and neither was carried back to the result resting on the same quantity. Refs #516 * research: withdrawal 9 -- the ternary rungs are wider than their names Found by applying withdrawal 8's rule systematically rather than locally, and it is the deepest of the nine. The SSOT specifies each ternary rung as 1 + Et + M = N with Et in trits and M in bits, and declares storage=uN. The oracle stores the exponent offset as an integer in [0, 3^Et - 1], so the word is 1 + ceil(Et log2 3) + M bits. GF-T16 encodes into 20 bits, GF-T32 into 40, GF-T64 into 79. Confirmed by running the encoder. All nine ternary rows carry a wrong storage field. The RTL agrees with the oracle -- tnet_tef #(MW=25, OW=10) is 36 bits for what …

gHashTag and others added 2 commits August 9, 2026 15:29

gHashTag merged commit 231d470 into main Aug 9, 2026
30 checks passed

gHashTag added a commit that referenced this pull request Aug 10, 2026

paper: rebuild after the self-check section

912407f

Refs #516

gHashTag added a commit that referenced this pull request Aug 10, 2026

docs: the re-measurement gives four of the seven figures a source

8b6cd3b

Refs #516

Navigation Menu

Read the paper as a hostile reviewer and close three gaps it found - #516

Read the paper as a hostile reviewer and close three gaps it found#516
gHashTag merged 2 commits into
mainfrom
fix/reviewer-gaps

gHashTag commented Aug 9, 2026

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

gHashTag commented Aug 9, 2026

The worst was the thesis itself

"A ternary fabric does not exist"

"Your regime codecs are models"

One stale claim fixed on the way

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant