Skip to content

W976: zero is not an annihilator in the generated MAC — reproduced off the die in 25 microseconds - #685

Merged
gHashTag merged 4 commits into
mainfrom
zero-not-annihilator-w976
Aug 21, 2026
Merged

gHashTag merged 4 commits into
mainfrom
zero-not-annihilator-w976

Conversation

@gHashTag

Copy link
Copy Markdown
Collaborator

Zero is not an annihilator in the generated signed MAC — and the die only had to ask

#684 reported gft_signed_mac answering clauses=0011, ok=0 on silicon. That word decodes exactly against the layout the wrapper documents:

WORD v3: {16'hA5A5, 4'd3, 6'd13, c_zero, c_comm, c_cancel, c_ind, beat, ok}
0xa5a5334e ->  magic A5A5 | v3 | design 13 | c_zero=0 c_comm=0 c_cancel=1 c_ind=1 beat=1 ok=0
clause asserts die simulation
ZERO mac(0, live, 0, live2) == 0 FALSE FALSE — 64/64
COMM mac(live,TWO,live2,ONE) == mac(TWO,live,ONE,live2) FALSE TRUE — not reproduced
CANCEL mac(ONE, live, NEG, live) == 0 TRUE covered by test cancel
IND mac(live, ONE, live2, ONE) != 0 TRUE nearest cover: test pp

ZERO is a logic defect, and a board is not needed to see it

Driving the same generated Verilog in icarus with the wrapper's own operands:

[ZERO]  live=0 live2=0 -> 512    (must be 0)
[ZERO]  live=1 live2=7 -> 516    (must be 0)
[ZERO]  live=2 live2=14 -> 520   (must be 0)
[ZERO]  live=3 live2=21 -> 524   (must be 0)

points=64  ZERO violations=64  COMM violations=0

The result is 512 + 4·live, independent of live2 over the range probed. Multiplying by zero does not produce zero, and the residue grows linearly with one operand. Reproduced in 25 µs of simulated time; the testbench is committed as tb_zero_comm_w976.v.

The die's entire contribution was to ask a question nobody had asked.

COMM is confirmed on silicon and unexplained off it

attempt coverage violations
dense sweep 64 consecutive live, live2 = 7·live 0
diverse probes 32 values: 0, 1, 2ᵏ, spec constants, 0x7FFFFFFF, 0x80000000, 0xFFFFFFFF 0
per-cycle transients 40 cycles after each of 23 operand changes — 960 samples 0, and 0 ready skew

The third attempt tested a specific mechanism: the clause registers are sticky (if (!comm_ok) c_comm <= 1'b0) and the comparison is not gated on the two ready signals, so a single disagreeing cycle would latch the clause false forever. No such cycle occurs, and ready never diverges between the two instances.

Stated as unexplained on purpose. This project has mis-attributed hardware three times in three waves — "Docker is the blocker", "the cable is missing", "the bitstream has no BSCANE2" — and each was a plausible guess. Remaining candidates: a physical effect (against a 4.1× timing margin), or an operand sequence the die reaches over hours that a bounded sweep does not.

The suite covered exactly the clauses that pass

ZERO and COMM: untested. CANCEL and IND: tested, and green on the die. The correspondence is exact in both directions.

And the spec's two tests are weak in a second, independent way — they assert on fixed constants:

test pp     { assert_eq(on_comb(20480, 20480, 86016, 86016), 20992); }
test cancel { assert_eq(on_comb(20480, 20480, 20480, 86016), 0); }

while every die clause drives live operands that change each beat. A test that supplies one operand value cannot see a residue that grows with the operand — which is exactly what the ZERO defect is.

python3 research/arxiv_tnf/verify_numbers.py

293 derived checks, all passing. Related: #683, #684.

🤖 Generated with Claude Code

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant