Name the oracle's divergence from the spec, and gate it - #519
Open
gHashTag wants to merge 147 commits into
Open
Conversation
… 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>
…p 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>
…ose 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>
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>
…c 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>
…ns 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>
…t 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>
…ontrol 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>
…ine 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>
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>
…ery 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>
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>
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>
…lies 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>
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>
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
Qwen agrees with SmolLM2 in direction at both widths: geometric 13.6401 against E4M3 13.7636 at seven bits, 13.6910 against 13.7636 at eight. The margin does not transfer -- 5.3-8.8% on the smaller model against 0.5-0.9% on the larger -- which is the pattern every result tonight has followed. One reading is model-dependent and is not made: on SmolLM2 a geometric grid at 4.25 bits per weight beats the NVFP4-like configuration at 4.50, cheaper and better; on Qwen it is cheaper and worse. So 'geometric beats float at equal bits' replicates and 'geometric at lower cost dominates NVFP4' does not.
The hierarchy was reported by algebraic degree with the cost given as
the minimal ratio available at each degree, and that framing hid the
result. The family r^d = r + 1 has two non-zero coefficients at every
degree, so its companion map is ONE addition regardless of d:
(x_0..x_{d-1}) -> (x_{d-1}, x_0+x_{d-1}, x_1..x_{d-2}), verified exact
at d=5 and d=8.
The roots converge to 2^(1/d) from above, so any granularity a
logarithmic subdivision offers is reachable multiply-free at the cost
of registers alone.
Silicon, same harness, 16-bit: phi 149 LUT / 307.69 MHz / 23.607% level
error; r^5=r^3+1 164 / 306.56 / 10.575%; r^8=r+1 225 / 815.66 / 4.625%.
A fivefold refinement costs 51% more LUTs and no frequency at all -- the
eight-register step measured 2.65x the frequency, its single adder
sitting on one of eight parallel paths rather than one of two.
And in the practical width the approximation to the optimal geometric
ratio is 0.06% at four to six bits, so 'the optimal grid needs a
multiplier' is true in general and false where a block scale lives.
Corrects the earlier claim that the hierarchy stops being cheap at
degree four; that was about the minimal ratio at that degree.
r^d = r + 1 has two non-zero coefficients at every degree, so its companion map is one addition regardless of d, and the roots converge to 2^(1/d) from above. Any granularity a logarithmic subdivision offers is reachable without a multiplier, at the cost of registers alone. Measured: phi 149 LUT / 307.69 MHz / 23.607% level error against r^8=r+1 at 225 / 815.66 / 4.625%. A fivefold refinement costs 51% more LUTs and no frequency. This resolves what Theorem thm:geoscale left open. The optimal grid needs a multiplier in general; where a block scale actually lives -- 8.32 to 9.12 binades, four to six bits -- the nearest multiply-free ratio matches it to within 0.06%.
… ours T38 says r^d = r+1 costs one addition at every degree; T37 says a geometric scale grid beats a float one. Together they predict the geometric advantage should be available without a multiplier, and it is: on both models at both widths the one-adder ratio measures at least as well as the geometric ratio beside it. And a correction. The rows labelled 'geometric' used 9.5 binades for the scale range where the measured values are 8.32 and 9.12 -- a rounding of the larger applied to both. With the measured value the six-bit optimum is 1.095860, not 1.110180, and r^8 = r+1 sits 1.12% from it. So the multiply-free ratio did not beat the optimum; it sat near the optimum while the row we labelled 'optimum' did not. The uncorrected reading is impossible and would have been caught by a referee rather than by us. Replicates: multiply-free costs nothing in accuracy. Does not: that the six-bit multiply-free scale beats E4M3 at eight bits while cheaper -- true on SmolLM2, false on Qwen.
We reported a gap at the eight-bit block-scale optimum -- target
1.026159, nearest available 1.049852, 88% error. That was the edge of
an enumeration stopped at degree 8, reported as a property of the
spectrum.
Extended: {0,±1} at degree 9 reaches 1.036380 (0.99%), at degree 10
reaches 1.027738 (0.15%), and {0,±1,±2} at degree 9 reaches 1.026129
(0.003%) with 734,533 roots enumerated. A coefficient of ±2 is a shift,
so the map remains addition and wiring.
What IS a real limit is the one-adder family: at the same target the
best one-adder ratio is 1.0850702 under {0,±1} and 1.0510545 under
{0,±1,±2}, 5.6% and 2.4%. Any ratio is reachable multiply-free if you
spend adders; only a coarser set is reachable with one.
The methodological point: a search bound was reported as a property of
the object. Nothing in the output said 'degree <= 8'. A silent search
bound reads as exhaustiveness, exactly as a silent exclusion reads as
coverage.
The eight-bit gap was our search bound reported as a property of the
spectrum. Degree 9 reaches 1.036380 and degree 10 reaches 1.027738 with
{0,±1}; {0,±1,±2} at degree 9 reaches 1.026129, within 0.003%, from
734,533 enumerated roots. A coefficient of ±2 is a shift, so the map
stays addition and wiring.
The real limit is the one-adder family: 5.6% and 2.4% at the same
target, not improving with degree.
And the one-adder ratio matches the geometric ratio beside it as a
block scale on both networks at both widths, so the geometric grid's
advantage is available with no multiplier.
LaTeX resolves a duplicate \label in favour of the last definition and
emits nothing. The paper had four: sec:optimal, tab:ladder, thm:floor
and thm:wobble, each an old label colliding with one added in a recent
session.
Nine references reading 'Theorem~\ref{thm:floor}' in sentences about
tapers, Kraft's inequality and asymptotic optimality resolved to a
theorem about normalisation cascades added yesterday. Two references to
'precision wobble' resolved to 'a wobble admits no crossover'. One
reference to the decoder table resolved to the ladder-law table. The
build reported zero errors and zero undefined references throughout.
The later label of each pair is renamed, which restores every earlier
reference, and the one reference that did mean the newer table is
repointed. Also converts two markdown emphasis spans that would have
rendered as literal asterisks.
tools/check_latex_hygiene.py catches all three classes; both new checks
negative-tested.
An earlier submission package carries two references whose labels live in a file this checker does not see. Baselined rather than fixed -- repointing another paper's cross-references without understanding its structure risks making it worse -- so the gate fails only on new defects. Negative-tested after ratcheting.
A \ref can exist, be unique and still be wrong. The paper said
'Appendix~\ref{sec:limits}' in a document with no appendix, and
'Section~\ref{sec:blockrelated}' inside the section labelled
sec:blockrelated -- a section pointing at itself. LaTeX resolves both
silently and correctly by its own rules; the sentence is what is wrong,
and the sentence names the kind.
The gate records the environment each label sits in and checks every
reference whose preceding word declares one. 193 such references in the
paper; both defects are fixed and all three failure classes are
negative-tested.
Also applies four prose fixes found by the same audit: a section
opening as a caption now says what it is for, and a subsection that
announced a strong statement now makes it.
…ion fails
A Pisot number is a real algebraic integer above one whose conjugates
all lie strictly inside the unit circle. Our scales are real algebraic
integers with coefficients in {0,±1}, so the question was immediate and
we had not asked it.
phi, the plastic number, the supergolden ratio and the tribonacci
constant are all Pisot. The one-adder family r^d = r + 1 is Pisot only
at d = 2 and 3; every member from degree four up has a conjugate
outside the unit circle -- 1.0633 at d=4, 1.0837 at d=8. The two
members our datapath actually uses are exactly the Pisot ones, reached
without knowing why they were special.
And a prediction of ours fails. A conjugate above one seemed to imply
register growth, so a non-Pisot scale should cost width. Iterating the
companion map sixty times, the coordinates track r^k in both cases and
the non-Pisot member is no worse. Withdrawn: the map is exact integer
arithmetic from an integer start and the dominant eigenvalue is r, so
nothing is ever perturbed into the conjugate direction.
Where the property should matter is encoding a real into coordinates,
where the classical beta-expansion results live. Recorded as not yet
looked at rather than as closed.
The law was measured over degrees 1-3 because those were the rungs we had. Along the one-adder family the rungs go much further and cost the same single addition, and the law holds over all of them: phi at four bits, r^5=r^3+1 at five, r^6=r+1 at six. At six bits the one-adder ladder reaches 14.8882 against an fp32 baseline of 14.3607 -- 3.7% -- with a six-bit element and one adder. The failures are as instructive: at four bits r^8=r+1 spans 1.7x and measures 2,710,365. Fineness without span is not precision. This needed T38 first. Read by degree with each degree's cost taken as its minimal ratio, degree 4 and above looked expensive; along the family the adder count never grows and the winning rungs cost what phi costs. The result was available all along and the framing hid it.
Applying a ladder weight r^-j costs j steps. As a block scale that amortises over 32 weights; as an element it is paid per weight and a six-bit ladder needs j up to 31, so the element form is a coordinate table rather than an iteration. A ladder's cost is a property of the ladder in a ROLE, not of the ladder. Measured, same harness as every other silicon number: phi 4-bit 89 LUT at 621.89 MHz, r^5 5-bit 95 at 482.39, r^6 6-bit 122 at 612.00. Against perplexity 24.4280, 15.9242, 14.8882 on an fp32 baseline of 14.3607. Thirty-three more LUTs -- 37% -- move the error from 70% to 3.7% at no cost in frequency, with one addition per scale application and no DSP. The chain is now measured at every link: theorem, scale step on the fabric, element table, network.
Applying a ladder weight r^-j costs j steps, amortised over 32 weights as a block scale and paid per weight as an element, so the element form is a coordinate table. Priced: phi 4-bit 89 LUT / 621.89 MHz / 24.4280; r^5 5-bit 95 / 482.39 / 15.9242; r^6 6-bit 122 / 612.00 / 14.8882 against an fp32 baseline of 14.3607. Thirty-three more LUTs move the error from 70% to 3.7% at no cost in frequency, with one addition per scale application and no DSP.
…s single-seed An audit found two paragraphs about one measurement eighteen lines apart. The first said an int8 datapath scores 0.189 MHz/LUT above GFTernary's 0.177 'and that number is real'; the second withdrew exactly those figures as a single placement run, the audited five-seed medians being 0.180 and 0.181, indistinguishable inside a 16% spread. The duplicate paragraph is deleted and the live use 1300 lines earlier now points at the discussion rather than the withdrawn number. Correcting my own first fix: I changed the abstract's 0.177 to 0.181, which was wrong. What the passage withdraws is the CLAIM OF A 7% LEAD over int8, not the 0.177 measurement. Reverted, and the abstract is consistent with its table again. What the gate did find is larger than one number. Table tab:carryrange -- twenty formats -- is a single placement run per format, while every other silicon table in the paper reports the median of five seeds. Its caption now says so and names the three adjacent pairs that a 16% seed spread cannot resolve, which should be read as ties. tools/check_withdrawn_live.py finds numeric literals inside a withdrawal passage that are also used outside one. The traceability gate could not catch this: it asks whether a number appears in a data file, and a withdrawn number does -- it was measured, once. Also reconciles a quantity printed as both 478 and 479 in four places.
Pointing at Section~\ref{sec:rejected} named a label that does not
exist; the discussion lives in Table~\ref{tab:rejected}. Caught by the
hygiene gate within a minute of being introduced, which is what it is
for.
The withdrawn-number baseline is now keyed on the value and its
surrounding words rather than the line number, since a line-keyed
baseline rots on every edit above it -- three of my own edits today
invalidated it.
…ms are corrected A literature pass placed our scales in the mathematics. Siegel (1944) proved the smallest Pisot number at any degree with any integer coefficients is 1.3247179572, the root of r^3 = r + 1 -- which is the degree-3 member of our own one-adder family. So the family is Pisot at d=2 and d=3 and provably at no higher degree, and the finest scale that is both applicable by one addition and Pisot is the plastic number. Our computed conjugate moduli agree exactly: 0.6180, 0.8688, then 1.0633 and above. That scopes what may be built on a rung. Normalisation in base theta is finite-automaton realisable exactly when theta is Pisot (Berend and Frougny 1994), and for n >= 4 the root of x^n = x + 1 is not even a Parry number, its shift being non-sofic (Akiyama 2016). Our datapath never normalises -- coordinates are carried as integers and never reduced to a canonical digit string -- which is why the d=8 step closes at 815.66 MHz. Stated because a reader assuming a normaliser would be assuming something the mathematics forbids. Two corrections. The E8M0 over-provisioning observation is not ours to claim: it appears in arXiv:2509.23202, and we now claim only the quantification and what the freed bits buy. And our description of FQP was unfair in our favour -- by Binet, F_n = round(phi^n / sqrt 5) exactly for n >= 1, verified to n = 25, so a Fibonacci ladder IS a phi-power ladder up to a constant. What does not follow is closure: F_i F_j leaves the set and phi(a+b phi) does not. The schemes agree on the ladder and differ on the ring.
… format's
Every silicon number so far measured a piece. This is the assembled
thing: fan-in N, weights from {-phi,0,+phi}, accumulator in Z[phi],
8-bit samples. Harness subtracted, median of five seeds:
N=8 660 LUT 82.5 LUT/weight 109.35 MHz 0 DSP
N=16 1393 LUT 87.1 LUT/weight 91.43 MHz 0 DSP
N=32 3809 LUT 119.0 LUT/weight 66.53 MHz 0 DSP
Two defects of ours found while measuring. The N=32 row was invalid on
the first pass -- 32 eight-bit samples need 256 bits of stimulus and the
harness offered a 128-bit register. And a comment claimed a balanced
tree over what was written as a ripple chain; replacing it with a real
tree moved the measurement by 5 LUT, because the synthesiser was
already balancing it. The suspicion was reasonable and the check
disproved it.
The figure is above a hand-count and the reason is ours: a lane should
be near 24 LUT and is near 82 because -x is computed per lane as a full
two's-complement subtract rather than folded into the tree as a
carry-in. So 82.5 LUT per weight prices this implementation, not the
format, and is reported as such. Quoting it as the format's cost would
be the same error as quoting a single-seed table as a median.
Independent of the implementation: zero DSP at every fan-in, and a
weight application containing no arithmetic at all.
…r weight The first complete-node measurement reported 82.5 LUT per weight and said the figure priced the implementation, not the format, because -x was a full two's complement per lane. Two's complement is (~x)+1 and the +1 of every lane is one bit, so the fold is an XOR with the sign plus a narrow second tree for the carries, added once at the root. Equivalence first: 0 mismatches in 400 random vectors, in simulation, before any synthesis. fan-in 8 82.5 -> 28.0 LUT/weight 109.35 -> 87.29 MHz fan-in 16 87.1 -> 33.1 91.43 -> 73.42 fan-in 32 119.0 -> 33.2 66.53 -> 58.22 Zero DSP throughout. Area falls 2.9x to 3.6x and lands on the hand-count of 24 to 30 per lane, which is what confirms the negation was the whole gap. Frequency falls about 20%, real rather than seed noise, since the carry tree's root addition sits after the main one; on throughput per area the trade is worth 2.35x to 2.87x. So the quotable figure is 28 LUT per weight at fan-in 8 with zero DSP. The previous number is not deleted: it was published with a caveat, the caveat named the cause, and the cause turned out to be the whole of it.
…ated
A literature pass reported that for base phi the minimal digit alphabet
permitting parallel addition is 'exactly {-1,0,+1}'. An adversarial
check found the minimality is of CARDINALITY, not of the particular
set: three digits are necessary and three suffice, and a working
{0,1,2} parallel adder for base phi was constructed during the check,
refuting 'exactly' directly.
So the statement that goes in the paper is: parallel addition in base
phi requires three digits and admits three. Ternary is forced; the
particular letters are not. Weaker than the report, stronger than
nothing, and it does say that no two-letter alphabet can be made to
work at any window size.
The constant is not small either: their Algorithm III is 21-local, with
memory 10 and anticipation 10. 'Constant time' taken as 'cheap' would
be wrong by an order of magnitude.
Scope stated because it limits us: the theorem is about the digit
alphabet of a positional representation, and our accumulator is a pair
of integers never reduced to a canonical digit string. What transfers
is the impossibility for two letters; what does not is any claim that
our alphabet is unique.
And on Lind-Boyd: the exceptional degrees are exactly d = 5, 9, 11, 15,
reproducing Wu (2010) Table 1 for d = 13..24 -- but the fineness gain is
NOT free, the exceptional winners costing more than the family's single
adder. 'Disproved' also overstates the history, Lind's conjecture
having been private correspondence.
…ilent section
Three findings had stayed in the research record. The assembled node is
the figure asked from outside and was the largest omission: a ternary
neuron costs 28 LUT per weight at fan-in 8 with no DSP at any fan-in,
after folding the negation into the accumulation tree. Both columns are
given, unfolded and folded, because the first was published with a
caveat naming the negation as the likely cause and the cause turned out
to be the whole of it.
The alphabet result is stated at the strength it actually has. Parallel
addition in base phi requires three digits and admits one; the
minimality is of cardinality, not of the set -- {0,1,2} works as well as
{-1,0,1}, verified by construction. Ternary is forced, the particular
letters are not, and the theorem is about a digit alphabet while our
accumulator is never reduced to a digit string. The 21-local window is
stated too, since 'constant time' read as 'cheap' is wrong by an order
of magnitude.
And the last section that opened without saying what it was for now
says it.
…the literature imposes
The abstract predated the campaign's main results and named none of
them. Rewritten to carry the argument as it now stands: closure removes
the multiplier, enumeration singles out phi, the one-adder family
reaches any granularity, a ternary neuron costs 28 LUT per weight at
zero DSP, the rung follows from the budget, and the block axis is
closed on the element and open on the scale. 1926 characters against
the arXiv cap, synchronised with abstract_arxiv.txt.
A summary table now collects the multiply-free scales in one place --
polynomial, root, registers, adders, level error and silicon -- which
the argument had been carrying in prose across four sections.
And three qualifications the literature imposes are recorded rather
than left for a referee. The alphabet minimality is of CARDINALITY, and
{0,1,2} is minimal too -- a working {0,1,2} parallel adder for phi was
implemented and tested -- and the bound constrains a digit alphabet of a
positional representation, not the weight alphabet of a dot product, so
it does not transfer to ours. Not every rung is Perron: the degree-4
and degree-6 minima have conjugates of modulus 1.5129 and 1.3069
against roots of 1.1787 and 1.0863, which costs 0.36 guard bits per
composed step at degree 4. And the Lind-Boyd exceptional minimisers are
finer but cost three to fifteen adders where the family costs one, with
gains under 0.8% beyond d=5.
0.125 named a bit width in a withdrawal passage and a storage cost three sections later, and matching on the digits alone conflated them. Values that are simple dyadic fractions are skipped; a real withdrawn figure is still caught, negative-tested.
The gate reported OK under an injected withdrawn figure and looked blind. It was not: the string replacement's target was absent, so nothing was injected, and a no-op patch is indistinguishable in the output from a blind gate. Verified with an assertion that the file changed -- the gate catches the figure. The discipline is now written into the file it applies to, since the mistake was made twice while building it.
…ns off the page A display equation stuck 57.5pt past the right margin and seven paragraphs and table rows did the same, while the build reported zero errors and zero undefined references throughout. LaTeX calls an overfull box a warning, prints it among hundreds of lines of engine chatter, and typesets the page anyway -- but to a reader it is text they cannot see. The equation is broken across two lines and the offending table cells are shortened. Float separations are set once globally rather than nudged per table, since the tables were also sitting flush against the text above them. tools/check_overfull.py builds the paper and fails on any overfull box over 2pt -- below that the overhang is inside the margin's own slack. Negative-tested with an injected 88-character unbreakable token, and the injection asserted to have applied.
Section 18 held eighteen subsections -- more than every other section combined -- because each iteration appended to the section it was working in. The paper's opening roadmap pointed at Sections 18.3 through 18.7 for its main claims, which is what accretion looks like structurally. Split at the boundaries of the argument, without reordering anything, so no cross-reference moves: the alphabet and closure stay as section 18; which rung to use, the block axis, the one-adder family and the silicon cost each become their own section. Eighteen subsections become five sections. Found by reading the rendered pages rather than the source. Every gate here reads the source and none looks at the output, which is how a 57.5pt overfull equation and a section with eighteen subsections both survived.
Reading the rendered pages found what nine gates could not: Figure 4 titled 'TEF multiplier on XC7A200T' with axis labels TEF4 through TEF64, Figure 5 'TEF16 multiplier', and Figure 3's legend reading 'GF-T16 (ours)'. Every sentence had said TNF for weeks. Two of the six figures had NO GENERATOR. The PDFs sat in the tree and the code that drew them did not, which is why they were never renamed: a file nobody regenerates is a file nobody renames. Both now derive from the tables they illustrate -- tab:field and tab:ladderacc -- so a figure that disagrees with its table is one build away from being seen. tools/check_figure_names.py extracts each figure's text layer and fails on a superseded name. Negative-tested by substituting a figure titled 'TEF16 multiplier'. Eleven gates now.
The generator I wrote an hour ago placed the legend where the annotation already was, and clipped the annotation's last word. Legend moved to the lower left, y-limits bounded so the empty decades above 10^2 stop stretching the axis, and the annotation reworded to say what the shading means.
Two of the paper's six figures had no producer, and they were the only
two still carrying the format's name from two renames ago. The two
facts are one fact: a file nobody regenerates is a file nobody renames.
tools/check_orphan_artefacts.py looks for figures, measured data and
netlists that no script, makefile or documented command names as an
output. It matches f-string shapes as well as literals, since a script
writing f'scale_frontier_{TAG}.json' never contains the literal name
and the whole parameterised family would otherwise read as orphaned --
that correction took the count from 22 to 6.
Of the six, ladder_acc.json was the live one: data behind a paper
figure, read by nobody, produced by nobody, and still labelled GF-T. It
is now written by gen_figures.py from the same table the figure draws,
so it is both produced and current. The remaining five are July
benchmark artefacts from a different era and are baselined.
Negative-tested. Twelve gates now.
The owner flagged it: there are four formats, not one with old names. Two rules fix an exponent budget -- the golden-ratio rule E = round((N-1)/phi^2) and the width rule 1+E+M=N -- and two radices encode it, binary or balanced ternary. GF, GF-T, BNF and TNF are the four corners, each distinct. The paper had lost this. 'Four families' appeared nowhere, GF8 and BNF8 appeared nowhere, and GF-T survived in a single sentence as 'the historical GF-T ladder'. Restored as its own section with the measurement: SmolLM2-135M, 40 windows, predictions printed before the perplexities. The result worth keeping is that GF8 at E=3 and BNF8 at E=3 return 14.6130 -- the same number, not a close one -- because two derivations made for unrelated reasons select the identical layout at eight bits. Reported with the prediction that failed alongside it: the width rule named E=4 and E_t=3 and the winners were E=3 and E_t=2, one step narrower each, because the estimator of the visited range credited a tail carrying no energy. The rule's form survives; its input was wrong. And the figure-name gate is corrected. It listed GF-T as a superseded name and would have failed the paper for naming its own format. TEF is superseded; GF-T is not.
A conformance run put gf16_mul.v against this estate's own vector pack and got 110 mismatches out of 994. Three independently stored copies of the RTL -- tri-net/fpga/gf16, trinity-s3ai/docs/hardware/rtl, t27/chips/phi/src -- each produced exactly 110. Identical counts across separate copies is the shape of a convention difference, not a bug, so the RTL was not the thing to fix. specs/numeric/gf16.t27 settles it, twice over: line 37: GF16_NAN : u16 = 0xFE01 // Sign + all exp + mantissa != 0 line 107: subnormals flushed to zero The RTL follows both. The oracle follows neither: gf_ref.py builds a quiet NaN family-generically as (exp_max << mant_bits) | 1 = 0x7E01, sign clear, and uses gradual underflow — the latter deliberately, with a comment calling the spec "old". Neither choice appeared in the pack. Its note said only "exact Fraction decode/mul/encode, round-ties-even", so anyone checking a spec-conformant design against these vectors would have read 110 failures as 110 defects. Classified: 55 NaN sign, 13 flushed subnormals, 4 one-LSB, 38 other. The expected values are NOT changed here. They are what the oracle produces, and rewriting them would invalidate every conformance figure already published against them. What changes is that the divergence is now stated, in the eight gf16 packs and in a gate. tools/check_oracle_vs_spec.py reads the constants out of the .t27 spec and compares them with what the oracle produces. Divergence is allowed but must be declared with its reason, so it is a decision on the record instead of a surprise in somebody's report. Proven red on the real failure, not a planted one: with the declaration present it exits 0; with ALLOWED emptied it exits 1 naming gf16.quiet_nan; restored, 0. conformance/conformance_run.py is the harness that found it — it simulates a design against a pack and prints, alongside the mismatch count, the bound that count buys under Duran & Ntafos 1984, so N is never mistaken for exhaustiveness.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
1 participant
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
A conformance run put
gf16_mul.vagainst this estate's own vector pack: 110 mismatches out of 994. Three independently stored copies of the RTL —tri-net/fpga/gf16,trinity-s3ai/docs/hardware/rtl,t27/chips/phi/src— each produced exactly 110. Identical counts across separate copies is the shape of a convention difference, not a bug.specs/numeric/gf16.t27settles it, twice:0xFE01(sign set, line 37)0x7E01(family-generic, sign clear)0xFE01The RTL follows the spec. The oracle follows neither — the second deliberately, with a comment calling the spec "old". Neither choice appeared in the pack, whose note said only "exact Fraction decode/mul/encode, round-ties-even". Anyone checking a spec-conformant design against these vectors would have read 110 failures as 110 defects.
Classified: 55 NaN sign · 13 flushed subnormals · 4 one-LSB · 38 other.
Expected values are not changed. They are what the oracle produces; rewriting them would invalidate every conformance figure already published against them. What changes is that the divergence is stated — in the eight gf16 packs, and in a gate.
tools/check_oracle_vs_spec.pyreads constants from the.t27spec and compares them to the oracle. Divergence is allowed but must be declared with its reason. Proven red on the real failure, not a planted one: declaration present → exit 0;ALLOWEDemptied → exit 1 naminggf16.quiet_nan; restored → 0.conformance/conformance_run.pyis the harness that found it: it prints, next to the mismatch count, the bound that count buys under Duran & Ntafos 1984, so N is never mistaken for exhaustiveness.