fix(jit): ARM64 bundle and tail encodings; v_random honours its seed (Refs #989)

[dmitrii-f-t27]

S12 of #988 (Refs #989). While probing the capability cards' acceptance commands for the capability index, the VM example printed this for cos(v0, unbind(bind(v0, v1), v1)):

Result: f0 = -1.0000 (expected ~1.0)

Two defects were behind it, and the tests had been bent around both.

1. Two ARM64 encodings in src/jit_arm64.zig

encoder	emitted	is	effect
cmgt_16b_zero	0x4E20A800	CMLT #0 (opcode 01010)	the SIMD bundle returns 0 for every positive sum: 371 of 1024 trits wrong on random input
ldrsbReg	0x38E06800	LDRSB Wt, which zeroes bits 63:32	the scalar tails do 64-bit MUL/ADD/CMP/SCVTF on it, so a −1 trit past the last full 16 becomes 4294967295

The second one broke the fused cosine for every vector with a negative trit in its tail. Since 59049 % 16 = 9, that means every MAX_TRITS vector, and it is why the VM's v_cosine called two identical vectors −1.0. It also broke the bundle tail.

The fixes are 0x4E208800 (CMGT) and 0x38A06800 (LDRSB Xt). SMULL, which the dot products use, reads the same low 32 bits, so nothing that already worked can change.

The existing tests used all-ones vectors or one fixed vector, and the bundle test checked no result at all ("to be verified via integration tests"). Each JIT file now has a differential test against a scalar reference, over random trits and ten dimensions (1 to 59049, with and without a tail):

• src/jit_arm64.zig: dot (scalar, SIMD, hybrid), hamming, fused cosine, bind (direct, SIMD), bundle. It fails with either encoding restored.
• src/jit_x86_64.zig and src/jit.zig: dot, bind, bundle. Every x86-64 kernel already agreed; the test fails on a planted setg/setl swap.

Off its own architecture each test skips (error.SkipZigTest) instead of returning early as a pass.

2. v_random ignored its seed

execVRandom had _ = seed; // TODO: actually use seed and drew seed 0. So v_random 111 and v_random 222 were the same vector, and every bind/unbind program bound a vector with itself. It now uses the seed.

The tests that had been bent around both

where	workaround	now
src/vm.zig, two tests	vm.jit_enabled = false; // Disable JIT (has bug in cosineSimilarity)	JIT on
src/e2e_test.zig, VM roundtrip	@abs(f0) > 0.3 ("JIT engine may return negative cosine (known sign issue)")	f0 > 0.7. The expected value is √(2/3) ≈ 0.82, because v1 is zero on a third of its trits
src/e2e_test.zig, VERDICT check 4	@abs(f0) > 0.99	f0 > 0.99
examples/vm.zig	"expected ~1.0"	"expected ~0.82"; it prints 0.8155

src/vsa_jit.zig: for a zero vector the fused kernel computes 0/0 = NaN, the only way it can produce NaN. It now returns 0, as the three-dot fallback and vsa.cosineSimilarity do.

The gate

What skips now depends on the machine, so specs/reproduce/headless.t27 sets its floors per architecture:

	passed	skipped at most
x86_64	2773	3
aarch64	2763	13

The judge picks the floors by the record's host and refuses to judge another architecture (ARCH); the self-check plants both architectures and a third.

reproduce.yml now runs the headless profile on both architectures, aarch64 on ubuntu-24.04-arm, with one artifact each. With x86_64 alone, no runner could execute the ARM64 kernels; this is how both encodings survived.

Measured: Linux aarch64 in a container with empty caches gives build 94/94 with 46/46 installs, and test 135/135 steps with 2763/2776 passed and 13 skipped, no violation. x86_64 is this PR's CI.

{
  "version": 1,
  "head_sha": "acaad5eeef91846f921eea84eaff50198231830d",
  "summary": "The ARM64 JIT computed wrong bundles and cosines and the VM drew one random vector for every seed; both are fixed, the tests that had been bent around them assert the right values again, and the profile now runs on aarch64 as well as x86_64.",
  "changes": [
    "Fixed two encodings in src/jit_arm64.zig: CMGT #0 was emitted as CMLT #0, and LDRSB loaded into W under 64-bit tail arithmetic.",
    "Added differential tests against a scalar reference to src/jit_arm64.zig, src/jit_x86_64.zig and src/jit.zig, over random trits and dimensions with and without a tail; each skips off its own architecture.",
    "Made v_random use its seed, mapped the fused cosine's 0/0 to 0, and restored the VM and e2e assertions that had disabled the JIT or taken the absolute value of the cosine.",
    "Made the headless floors per architecture and ran the profile on ubuntu-24.04-arm as well as ubuntu-latest."
  ],
  "tests": [
    {
      "command": "zig test src/jit_arm64.zig on Linux aarch64",
      "status": "passed",
      "result": "25 of 25 tests, including the differential test; with CMLT restored it reports bundle_simd wrong at every dimension, with LDRSB Wt restored it reports cosine and bundle tails wrong.",
      "evidence": "Ubuntu 24.04 aarch64 container, Zig 0.15.2, run locally before the commit"
    },
    {
      "command": "zig test src/jit_x86_64.zig and src/jit.zig -target x86_64-linux-gnu, run in an amd64 container",
      "status": "passed",
      "result": "6 of 6 and 7 of 7 tests; a planted setg/setl swap in jit.zig makes the differential test report bundle wrong at nine dimensions.",
      "evidence": "Run locally under emulation before the commit"
    },
    {
      "command": "python3 tools/reproduce.py headless --zig zig-0.15.2 in ubuntu:24.04 aarch64 with empty caches",
      "status": "passed",
      "result": "Build 94/94 with 46/46 installs; test 135/135 steps, 2763/2776 passed and 13 skipped, 66 run steps with tests and one empty, no compile failure, both commands exit 0; no violation against the aarch64 floors.",
      "evidence": "Linux aarch64 container, head acaad5eeef91846f921eea84eaff50198231830d, fresh zig caches, 2 min 36 s"
    }
  ],
  "limitations": [
    "The x86_64 floors (2773 passed, 3 skipped) are derived from the counts of the added tests and the previous x86_64 run; this PR's x86_64 job measures them.",
    "Most older tests in src/jit_arm64.zig and src/jit_x86_64.zig still return early off their architecture and count as passed; the new differential tests skip instead.",
    "The aarch64 leg depends on GitHub's ubuntu-24.04-arm runners."
  ],
  "tags": [
    "Engineering",
    "Verification",
    "CI"
  ],
  "blog": {
    "title": "One opcode bit made two identical vectors look opposite",
    "summary": "An ARM64 CMLT where a CMGT was meant, a 32-bit load under 64-bit arithmetic, and a random instruction that ignored its seed, hidden for months by tests bent around them.",
    "outline": [
      "The symptom: the VM said cos(v, v) = -1.0, and the tests had been relaxed to accept it.",
      "The causes: two ARM64 encodings and a seed that was never read, found by testing every kernel against a scalar reference.",
      "The gate: differential tests that skip off their architecture, floors per architecture, and an ARM64 runner."
    ]
  }
}

Dmitrii Fedorov (@dmitrii-f-t27)