diff --git a/research/r420-compensation-rank80/CLAIM.md b/research/r420-compensation-rank80/CLAIM.md
new file mode 100644
index 0000000000..73a4825f21
--- /dev/null
+++ b/research/r420-compensation-rank80/CLAIM.md
@@ -0,0 +1,59 @@
+# Local sprint claim
+
+- Track: independent verification (assignment seed **80**, drawn with
+  `secrets.randbelow(100)` from OS randomness on 2026-10-13).
+- Exact base: `66849e1475c930fd7732b1a0067ffee7e1e95f60`.
+- Claimed at 2026-10-13 04:45 UTC; expected finish by 05:05 UTC.
+- Object: the 120-by-420 dirty-helper correction map of the accepted PR543
+  R420 bit word, consumed unchanged by selected PR626.
+- Method: independently propagate target observables backward through
+  A/scatter/B (transpose circuit, rather than forward register expressions).
+  Compare the resulting helper coefficients with D; certify rank by an
+  explicit invertible minor and derive the entire right kernel. Seed 80
+  rotates the helper-column pivot order and selects control targets.
+- Deliverable: source-pinned standard-library verifier, exact certificate,
+  rejecting controls, and a scoped linear-summary dimension consequence.
+  No new circuit, runtime saving, kappa, or full multiplication theorem.
+
+Three candidates considered: selected cold-wrapper identities (overlaps
+#702 and our #712), selected moment inequalities (overlaps #678/#706),
+and this correction-map rank/kernel certificate (chosen). Existing PR543
+`xcheck.py` already verifies K=D by forward symbolic propagation; this run
+adds a different propagation direction and explicit full-rank/kernel evidence.
+The recent #686/#694 helper-basis and #713/#716 target-basis constructions
+optimize D but do not claim this certificate. #612 formalizes boundaries/B;
+its D compensation equality remains open. None of those pending patches is
+consumed here. The fixed-frame search #661 does not exclude circuit changes.
+
+The refreshed open-PR queue included #716. There were no pinned issues and
+Discussions was disabled; no separate reservation issue was opened. No
+workers were delegated. Scope is a fixed finite object, not a search for a
+stronger bound. Stop after exact rank/kernel and control checks are complete.
+The first 20% is reserved for selection and the final 25% for verification
+and handoff.
+
+## Result — 2026-10-13 04:58 UTC
+
+Completed and submitted as
+[PR #731](https://github.com/CrocSwap/integer-mult-bounds/pull/731).
+The correction has rank 120, nullity 300, and minimum nonzero kernel weight
+4, with exactly 18 weight-four vectors. The latter follows from the complete
+87,990-pair census on the same fixed map, not an expanded supplier search.
+The package supplies an inverse minor, all kernel directions by a compact
+formula, 120 isolated target-error inputs, ten rejecting controls and seven
+independent obligation tests. Normal/optimized runs, a minimal clean export,
+the original frame/scalar/interface checker, selected-record integrity and
+ledger checks pass; see VALIDATION.json. No new kappa is claimed.
+
+The final pre-submission refresh covered 547 open PRs through #728, with main
+still at the exact base. Two arrivals were checked immediately after posting:
+#729 (`deaed262cebc50bdb0c27c6ba132b8f8289b3eef`) checks complex helper frame
+lifetimes; #730 (`d222e348179cc02a54d6d26dbd2838944f62c6e5`) optimizes ordered
+dirty echoes. Neither overlaps this fixed bit correction matrix. No pinned
+sprint issue was available, so this is the single local result update.
+
+Implementation/certificate commit:
+`0e10ed667c0cc435eb0f69c71a1d542599cad170`; the follow-up changes only this
+claim. Verification and packaging occupied the final part of the run, and
+the contribution finished before the recorded deadline. No workers were
+delegated and no selected-frontier or upstream files changed.
diff --git a/research/r420-compensation-rank80/EXPECTED.json b/research/r420-compensation-rank80/EXPECTED.json
new file mode 100644
index 0000000000..6a6856c6b5
--- /dev/null
+++ b/research/r420-compensation-rank80/EXPECTED.json
@@ -0,0 +1,814 @@
+{
+  "K_rows_hex": [
+    "0xd1c00c60a60c5053000d08220c1c100518a16a007329c041d15bd08ce04b130608a27377f3968f8050348402e35a4c7081c79f959",
+    "0xa6000210e102118c007400d64c3ba109dca2406409395791f7798fa2f08f86c9ec38db95075ccc4175b20360301a14dc238922f28",
+    "0x10d00e21a20e4757400d2456071c3341d830c06429191248361ea2ecd7e5994c8ff7019df04d5921ffcebc2aa9339cce00010ef00",
+    "0xe1000050a5005090007508220e1b900518a1ea04530884501b141e780f0380a2ab6da97f04871ae1d8c4080c6e272127ea5ebd1db",
+    "0x96c00e20820e554f000c04564d1c2141dcb1e41408091455ec56214836a8af84a68a66d3a22772dddaf0bf1b0930e43e43892ed0c",
+    "0xe1000050a5005090007508220c1b900518a0ca6472180041d15c9ddce66c3a4b48bb0724b5d6ac48bf763879de2559d7a9f59f9d9",
+    "0xd1c00c60a60c5053000d08220e1c100518a04a65523884501b1353280924a9efeb74dd2c42c739283786b47753583480ce7cfd1d9",
+    "0x20100210a1025b94407520d6063bb309d8236414282951c42d310c0611c2b001c545bcdb5536e7bd508c005190186c2c60010ad2c",
+    "0x41e003e806e201640518415420962512c22969a40a99142089c7a8fae7a6cd45c1d070757fb975ab8e2efbb9591eeed7430522c00",
+    "0x78201e18019e00a78062083e0211a083e021a10d09288000024c5edd27c01000754bbb71902268f1c4413c598c715e97bc3083080",
+    "0x48e0122802920064801a083e00162083e021210c29080411c8039029c88883a4d68461396733fd914cb1b057010c33c0dbb9e1881",
+    "0x71212e5c0d8f01a7006082541251a922c125e9a42ab95803c588f42284d5b65be21faa7d88a8e0cb03ba266eb493df0ca30122c00",
+    "0x48e0122802920064801a083e02162083e0200160481b8000024b138d21e7394d3552cf22d6624b392b038022b10e4b30901283041",
+    "0x71202e5c0d8f01a7116042542051a522c2244bc42a2d54200fc077866181e4088a238a3388e0e0c7214c47c26491a7fce00522c00",
+    "0x41e403e806e201640018815412962912c128cbc40a0d1c01838f2b5e02f29f16a9ec503b7ff175a7acf89a15891c9627018102c00",
+    "0x78201e18019e00a78062083e0011a083e0208164683ac411c804dd79ceafaae9969d152a2173de59a3f30c2c3c732667fb8ba10c3",
+    "0xc8440860a40851d2825d0918081e909060a170b21c380ee2ab74f321834907443fb775d9fe8e59c7993f8b026890f400938008308",
+    "0x81c21b62a63a5456040f0c260e1c304598a8823209284250eed7929099a9ad6cc4de522ae3bc47b5dd8eb6576bda3ca983080c308",
+    "0xe0413820a21851d00849005a0c54900118a520141949eae3a8d2d1fcaf688b278bf7facae39c5575d3f4880e51b264368301e3b08",
+    "0xc8408a26aa0a55d2904d084e0f1cb1e5b8b0caf41221a240281309633a4f312e72df5239f269116c2485b835e37825b61001cfb08",
+    "0xd0413a20a21851d308cf10560e5cf101d8a409743a19eef262da5258577818044ff146116a58e7ff21507d4a81b01ce6c089cbb08",
+    "0x80408a26aa0a55d6104d065c0d1cb10498b1aab42339a651e65b8ac7d98a354a079b65e2ea8fbbd6dd1ad31383fa4dce5389efb08",
+    "0xc9640860a68850f2826d09398e1d909278e0405239080af3613f788464ae4f114c6777e8ca9f9de6d2ece3ac199a8cf0c00828308",
+    "0x81021b62a63a549604470c260e98b04598b1821220284641249f303079a9be6dc58f141bb5bca4549eaa73579bd8c459c0802c308",
+    "0x516414e816d481e5025a08520236811b4022c1d41809ea337a4baade50ae9f81a8e950b76e48637faa2cc760d13ebe460009e3a10",
+    "0x28212818118980a2886008ba0071808b602069723b384a23b4c0ccf5966e2e8a5933ba468448e0cd6d793e7904b1060a330020210",
+    "0x79621e68068601e7845e0046009ea087e02962140129a601136e8357a698328f51c1f8447fbd27665e65795bdbd056965081e3a20",
+    "0x61a09a78019a012610320a04061320269821ab32221802001c49f992c84ac4f2d25a9db5997afebf210b2382007af46a800000200",
+    "0x28e1281811898062882808ba0015008b6027695212384e327f886e55766f3d8b5862fc77f248032c2e5dfb79f4b3f6fa308800210",
+    "0x196414e816d481e1825a0140003681826023a1942911ee22b403a96ab36b9bc5ddad676c76aec9c553b3ac46b1bcc6364381c3a10",
+    "0x60809a10009a000610020a258010202480609bd207280611d61076772fad8ca7a18a9f84ad6b3a9e6ad84b2c72708c9af38820200",
+    "0x49620268068601e484d8104a0296c18720284b742279a210d9a200b36e88a1ac95c7449ff67995ecacc18c1f03d02e541309c3a00",
+    "0xd080060660060988151483220129481302028600b0005f9b36a3b86236848007093b975a02368d1c6c5098243328e30c18c28020",
+    "0x71401e30031e0157007a080c0007a004c0010ba0320000004622173f4ca2982e8835448e46c4a3c8b3d8400e83c04848b20000000",
+    "0x44001800601861920047085a40189105142060c008100dfa73ae8793ac622e297287058cb1322c400e7d034c5bd014b4300828020",
+    "0x7ac05e30031e0147a038804e10173185b12122803110002183e6f753ffbfddfd986077775b12bd32c0c38ee8bbd2d4f6b3c010000",
+    "0x3cc018306318615200bb0008401751803421d0e00d304dfa70d7ed098a010724101a50b5d3014391c93dbf156bbac600700828020",
+    "0x4a00400000000184a0410042101099857120a26038004021814820ac6998b4a0dbbfa94ea803cad30fc1121780d28c7403c010000",
+    "0x3dc80c60660c605b811948324016148130618020083845f9b513d03c856c694f361851a64ff67d9bba8bb5f95398cc08c18c28020",
+    "0x4140124804920094004a082d0214a006d021eac0237040004e8c92dc9b85b263cc3fe85dcb009142ccaa7875b8f07c8a830000000",
+    "0xe1f8007987801b60012e00522c1d07034aa14900231046b5a89fadf9d34f454d0642c513cbf78f2afd429bb57bb8e646718c2030c",
+    "0xd9300c49848c1823801428100e0a0282388181a018400aa7adbd59de5121288831cc9c082df444bbb31d440028a87aca83800030c",
+    "0xb9200648048601a7c05008460412a183e8203b801620400049c4e03c84cf92c29ca537e821d71e5834f7f428e892ac04020000000",
+    "0x20e0521801920064603e882e0e1f2807c9a0eb40330804304431353748c28b34896a61f3cb138fa2c0f8a11100d88c48f04830000",
+    "0xe8f0003183001800802428310c19028028a160c009304aa7a513dc3d870610c175c630dba0307631cc4f7c7b93984e08b3800030c",
+    "0xd1381e49849e1ba30156405e2c1aa1038aa0c9e02a0006b5aa317a0641682c00059d9b2a38e6f8cb3200074e40b8bec4c18c2030c",
+    "0x10205e18019e00a76076882e0e1ba807c8614300303044304248fe8deef6ae78cfe1892024c69ae8bcbe1f6a0072ce70f04830000",
+    "0xb9e0067807860164c0ac0014041d6106c8218ba0130000004abd8aa6a22cbbcffe3862d143e47189f3b7c873d8f87eb0420000000",
+    "0x1880140020144111800300420010118570206a7463000411c98c20bc6c4814e35fb6ae49b99ab68ec147074ed8d0ac740b98200c1",
+    "0x50800600200641150001005c02103100902188b45a004afb6d220447357eaa8997b3ddb3aa4b681fadfd353953106c3e7818283c1",
+    "0x60400a30230a41d60079005c0017b100902108b47a200eeaad131c4d308d8383ec7c17b3555afd7d28a8c06033186e3ebb90083c1",
+    "0x28401830231841d2807b0042021791857020eb3443084000046a45e31e6e6abe587974424e0f23e65fe95cb90372148e3810000c1",
+    "0x51a00648248640350001102c02103002502182b4402380000300134c3baf1ca5297c130a10e30c3429107e24b0304c32800283000",
+    "0x79c01e60261e4057800b083606103081b821e2745807cafb68ae39d2168b2589531732f98998f50b0d51df5f3b30e602800aab300",
+    "0x79c01e60261e4057805b08368207f081b040627478278eeaa29f73c4508f17c550db24f1fd89616b81b38720fb088802c3828b300",
+    "0x28401830231841d2807b086800179184102102b46003c411cbe6d733c64db58d9bf3cb02e7d29d74adc5bb39fb526444738aa3000",
+    "0xe0200018818010a0007c082a0819c00740a12f746283c3001bf53763794c266f86d532ea6924b13edd267775585af4f2b00283320",
+    "0xc9a0184884981122801600400c1a018668a0e7d440300711dc00d148fc5a0062718cabea7cae39c69a4b014e0070247ecb98203e1",
+    "0xb0400630830610c5006c087c0c1da10088a1c9a45b238ea6a09f9d9decac1f234dbddb19735f6f51f164c66cdb185ef4b3828330c",
+    "0x81a00a48848a11260014005e0e1a210388a1035458104ea6a9bdc8b6a1a8fe58c0c49f1f3d5d4cafbe32139788986e344b90003cd",
+    "0xc9a0184884981122801610340e1a008728a149a47b03cab7687959e2114eb60bff720211944cf22175b10371907a7682c00aa330c",
+    "0xb1600678878611e5006c005e0c1da10388a1821478180ab7645bade9d38e8005c70b4515cac8d9c7209c4860533ad6ce78182034d",
+    "0xe0200018818010a00014082a8c0b800748c0af7442a38711d1c47d753f489423851820e21d35265e51c42f0a98629ab2f38aa3320",
+    "0xf9601478879411e1806e00400e1d818668a067d4601043001c31c942f9a92968024761ea83bfaca41f1ef4176078267e0810003e1",
+    "0x18401430231441d1807b001e00179185b021c8983b1900000aae76a32b6f0ba6104d56085615e7ed5c35b9356b50f4b0b83102c80",
+    "0x100126026124090001708280600300458018a3803890eeaa1ae99ce9b6c88e3a196cbbdab279a1ed70638755b604a028bb10af80",
+    "0x50401430231441d5007b005c021791009020a05039188000002245537388d0d4e92d674e56e5ebd7d4125c9783b014f6300181800",
+    "0x28800a00200a41128001004200103185702042f021088afb6e22f647fb9914e726d7deaeb2ede02df71a7e17b370ac7ef009a8b00",
+    "0x60801800201841160003005c00101100902020701968c411cdc4200c01aeae89eef2bd46a9347ebf5abc07605812ac0c0389a1800",
+    "0x18400630230641d1807900420217b1857020e2f00f28ceeaae13ee4dfe6a3ded551824e641fc754d724f8b4ed378ae7e338189b00",
+    "0x61a00a48248a40360001187602103001302148981b394411c248b2dcd68da28ea0828e00b125728dd8e07c283032dcc6cbb922c80",
+    "0x100126026124090007308288216b00450600a3823a94afb639fd3d8dd68baafa25851b51f360c7e5be4600a9b582442c8392af80",
+    "0xb1a01448849411250016005e0e1a010388a189901638c711df00234832bdbe0cc8ec88bf600831f4c0ac4a60e010e43e4389a1b20",
+    "0x98e00c18818c1067806c0834080d0082a0814738390d0711d2f5977ff4ab0b05745743aecb9bdf2b0771905f380a58f2bbb922fa0",
+    "0x98e00c18818c1067803008348c1e0082a8e0c738192d430018c4dd69b2af39497798dda63f8a4a4b8b93c820f83236b2f83102fa0",
+    "0x81601878879811e6006e005e0c1d810388a12990381883001f313b42374e9706bb2372f79319a49455f9bf398018e63e800181b20",
+    "0xc9600a78878a11e2806c00400c1da18668a1cb300238cab76013ad59be683a6f765f560ada6a11f2ab67484ed3f8d6b67009a1b0c",
+    "0xf9a01448849411218016184e0e1a008768a1838820190ea6a931f872fc6c0820748c9e1b35a980888441017d0078e2768bb102f8c",
+    "0x80400a30830a10c6006c002a0c1da10208a1038800394ab761d73c0d018ea108c4034713c2bb1dd80094c4604b1ace00f83922f8c",
+    "0xf9a0064884861121801400400e1a218668a14b1022488ea6adf5c806cc4e443271808c022dfb849a25c913b9085a6e4c438181b0c",
+    "0x58c014306314615c80bb084442175180f420bae5562809fb3ad7ee3d8eaa2b2e583a60c2d3c503983f79cc5d0bbaae043e00280e1",
+    "0x2c8123003120140013b405020173100522148a54308481302aec6e79e04a364811240314ff4178a7c32ac3b0bb04c067e0c200c1",
+    "0x45c040606600605c2019882c02161804d120ea44d33989dafa1352280d89a53dca2860f34fd43d8a7380975b73583480c3d9fb863",
+    "0x8c0123003120000803208120213208120200184d819c010cd6a749763221c45114003001c2248338a0d4b009392bcf8f3d9e3843",
+    "0x32080c00000c01830140005c2010b5009220c8454a180813000011180023ca09c2cf9e08bce5606bb370308430b01484ce0c200c1",
+    "0x580014006014619f8047001642189105d4210ac5530849fb39ae84a7a84902233aa735fbb1f66c49f83970063bd07cb07e08280e1",
+    "0x39001e48049e002380020833000020833000e0e4c9698010c5c4f174b505244c554aafd391e67ab9f55f737b28a2883ac399e3843",
+    "0x75004c60660c609f2051882c42129804d8214204d001c9dafc6a9992abbd8c708ca38820a00120c00fca2a2063f276b8c3d9fb863",
+    "0xa0600049848019a4005c280e0c1e8207d8a08b84f259cab726f53a767fa18ca3a8b9db867712af408ac84f0e38fa8e7ac219e3b4f",
+    "0x99f04c79878c1b67a02c004c1c1d0986a9a1232551080e8729d79c4db2f43bc45f327255df11259241f3b962cbda7eb6bc40103cd",
+    "0x68281218019200a0c17648302c1ba48228a02964eb3188130d485c996603660933d1b87524e4d2f975bd3fc830b236f8f21de3843",
+    "0x11e00a78078a016200ac0858061d61060820e1a54818440100bd8992a6078745b61852a64320318005f3bb28b8f816b40c00000c1",
+    "0x58e81e18019e0063c13e48300c1f248220218124e809c8130b319723c0274b47755a50a6cb31c79309ff80b3301874c0f21de3843",
+    "0x69200a48048a01a20050000a0612a183282151854d38040103c4e3088064be48c485079f21135e51c2b307718892c4004c00000c1",
+    "0x90600c31830c1867006c282f0e0d8205c8806ae4e3298ab72e5bbf95a886a6eeecb37755fad69dcaf5ba775503cabab8f219e3b4f",
+    "0xa930524984921ba4a05680401c1a838669a0a3c558184e872b794bb22cd352b95cedac6c2e0052738ef125d9f0da26340c40103cd",
+    "0xa8421520a21451d484cd00440c9cd084f8a9623461510ae3a9db60e8429f354e328175447a7aafceeb078a20e591fcc343102834b",
+    "0x80840a92a14a5516023505500d1b310458b040d4581902402514640f328fa60dc8648fbf1d9e6eb791a06f643ed79c9d30100c34b",
+    "0xb0408464a60451d5106d0a068c1d902588e12a9462208af36c1ed099ee49b16fb6c7469fea68d1ff28cb880ef1463178dc08283c9",
+    "0xc9c13a52a51b5452883f0c380c5f30c078a168145b10864125d0edf89269294b3e60ff64424b792de81bcd0236a5c90a2c802c3c9",
+    "0xc8840a92a14a5512823500020f1b315178b1209469010651eb5ce7abd14aa249bd20b8640578c40d683f04425e55e4e173982c34b",
+    "0x98421720a21451d7844b10480e94b18438a84b5442010ef263d2e34cba8fa66df687c99ff3be1d4419a37f643593841300980834b",
+    "0xc9013a52a51b549288770c380e0bb0c078b5683472108250ef984f5872683a4a3f31b955144b9accab3f0802c6a779fa6f080c3c9",
+    "0xb1608464a48450f5105d0a270a1e902790a01a7447108ee2a6555b3c09aef93ac51744aede7915de6318e0a0894c49888f80083c9",
+    "0x6022092812a880a6045008a40232800e8029835469008e327dc7b39d9daeaaada38d170825bfde5558ec472c59cef3a99c88002d1",
+    "0x19a0945c1d9481219022024c00310182a0224bf452314a33774c47a2586e08a212528d3181bf1ca41f0910310c91176d201820253",
+    "0x19a416d8009601218202091a821020937061f1145c008611db11da6aa54a72d95b2aaef38d9c768790ff208e90a83112ef88202c1",
+    "0x31611e68068a01e308da00580056e0020025203479314401122232036b6f8ce6e8b777cae65bdddd66967b7563f2ce70909020243",
+    "0x188416b0019600018232093b041320916820c1f479308200114851cf42ad3a8c28faacc2b98db2a6db2c4820e2a249e29c00002c1",
+    "0x1610268068a01e0085c1054025e8102c02409545a614210d8eeb1e7a37f1fc52cb1cb116f9f6f5794328e31bbf2b6b2d31800243",
+    "0x60e2092812a88066041808a40086000e8023837440008a23b48f113d7dafb9aca2dc513973bf3db41bc8802ca9cc4b599f00202d1",
+    "0x51a0945c1d9481251022001e023101af80232bb463294e22b904c416bbab0ce66716baea9959b61ee6967b976c137f11639000253",
+    "0xecd00221b2025358800d20c84e3c338c3ca28e401301caf6be56e24cfa4f23e6168a5697a2ab32d80037bc352970ac7e09febf398",
+    "0xa0c01124aa305154000f42562c9c1521daa96a802a25805097d7cbe7a0e5cbc48ea27164fbf2cf872b7e8ce26b9a551f5bbeaf198",
+    "0x90003c90a15d5197207781561e5b9911d9a5ea800a05c4715b98973fc196b0daad6dab6c0ce35ae7a6ca5134861764c4ba7a9f198",
+    "0x5a000e10a10e1183c0740448051ba1c438300e4033218fa37f31cf03dd253c6375458c9f55baa7b88a4b037fb058246c2a76933b8",
+    "0x90053c90a15d5197007741562c5b9511daa448e00a91c450d1d0149b24c2e289c5518b220cab5aeb843c309956151c34f93e8f198",
+    "0xdc100e10e10e5b9b807524484f1bb3c43cb12a30123189f6a5794ca61c680aab5c38ebd107d08c44af75004e105a5c9c69febb1bc",
+    "0x6ac0022092024140c00c00c8043c218c3823aa303211ccef641e61e81b02152e3ff731d9f0c119242509bf048972d48e4a769f194",
+    "0xa0c01124aa305154340f82561e9c1921d9a8c8e02ab18471dd9f484347b19997e69e512afbbacf8b0988ed4ebb982def197a9f198"
+  ],
+  "complete_endpoint_columns": 660,
+  "controls": {
+    "corrupt_inverse": "M inverse product",
+    "corrupt_kernel": "kernel annihilation",
+    "dependent_kernel_basis": "kernel free-coordinate identity",
+    "duplicate_column": "weight-two kernel vector",
+    "omit_D": "dirty block K differs from D",
+    "omit_one_D_operand": "dirty block K differs from D",
+    "omitted_D_dirty_witnesses": 120,
+    "swap_D_rows_preserves_rank": "dirty block K differs from D",
+    "three_column_dependency": "weight-three kernel vector",
+    "wrong_traversal": "different dirty map",
+    "zero_column": "weight-one kernel vector"
+  },
+  "isolated_target_80_dirty_input_hex": "0x80000023813394841112d6c013800000000000000000000",
+  "kernel_basis_sha256": "04dc252fcd1f328c62e788508e6faabe9591390fe5a95a98d5461fe0f3e2db36",
+  "kernel_distance": {
+    "minimum_weight": 4,
+    "pairs_checked": 87990,
+    "selected_weight_four_helpers_absolute": [
+      284,
+      296,
+      521,
+      623
+    ],
+    "weight_four_supports_absolute": [
+      [
+        240,
+        246,
+        378,
+        385
+      ],
+      [
+        248,
+        471,
+        608,
+        609
+      ],
+      [
+        256,
+        266,
+        325,
+        410
+      ],
+      [
+        267,
+        467,
+        590,
+        644
+      ],
+      [
+        276,
+        302,
+        612,
+        617
+      ],
+      [
+        277,
+        280,
+        293,
+        459
+      ],
+      [
+        277,
+        454,
+        638,
+        639
+      ],
+      [
+        284,
+        294,
+        623,
+        635
+      ],
+      [
+        284,
+        296,
+        521,
+        623
+      ],
+      [
+        285,
+        456,
+        632,
+        633
+      ],
+      [
+        294,
+        296,
+        521,
+        635
+      ],
+      [
+        310,
+        375,
+        494,
+        541
+      ],
+      [
+        317,
+        414,
+        445,
+        461
+      ],
+      [
+        319,
+        406,
+        649,
+        652
+      ],
+      [
+        337,
+        341,
+        362,
+        367
+      ],
+      [
+        344,
+        380,
+        529,
+        532
+      ],
+      [
+        432,
+        459,
+        637,
+        640
+      ],
+      [
+        465,
+        475,
+        606,
+        611
+      ]
+    ],
+    "weight_four_words": 18
+  },
+  "kernel_free_helpers_absolute": [
+    240,
+    241,
+    242,
+    243,
+    244,
+    245,
+    246,
+    247,
+    248,
+    249,
+    250,
+    251,
+    252,
+    253,
+    254,
+    255,
+    256,
+    257,
+    258,
+    259,
+    260,
+    261,
+    262,
+    263,
+    264,
+    265,
+    266,
+    267,
+    269,
+    270,
+    271,
+    272,
+    273,
+    274,
+    276,
+    277,
+    278,
+    279,
+    280,
+    281,
+    282,
+    283,
+    284,
+    285,
+    286,
+    287,
+    288,
+    289,
+    290,
+    291,
+    292,
+    293,
+    294,
+    295,
+    296,
+    297,
+    298,
+    299,
+    301,
+    302,
+    303,
+    304,
+    305,
+    306,
+    307,
+    308,
+    309,
+    310,
+    311,
+    312,
+    313,
+    314,
+    315,
+    316,
+    317,
+    318,
+    319,
+    367,
+    399,
+    402,
+    408,
+    412,
+    414,
+    415,
+    418,
+    421,
+    422,
+    423,
+    424,
+    425,
+    426,
+    428,
+    430,
+    431,
+    435,
+    437,
+    439,
+    441,
+    443,
+    444,
+    445,
+    447,
+    448,
+    449,
+    450,
+    455,
+    456,
+    457,
+    458,
+    459,
+    462,
+    463,
+    464,
+    465,
+    468,
+    469,
+    472,
+    473,
+    474,
+    475,
+    476,
+    478,
+    479,
+    480,
+    481,
+    483,
+    485,
+    486,
+    487,
+    488,
+    489,
+    490,
+    491,
+    492,
+    493,
+    494,
+    495,
+    496,
+    497,
+    498,
+    499,
+    500,
+    501,
+    502,
+    503,
+    504,
+    505,
+    506,
+    507,
+    508,
+    509,
+    510,
+    511,
+    512,
+    513,
+    514,
+    515,
+    516,
+    517,
+    518,
+    519,
+    520,
+    521,
+    522,
+    523,
+    524,
+    525,
+    526,
+    527,
+    528,
+    529,
+    530,
+    531,
+    532,
+    533,
+    535,
+    536,
+    537,
+    538,
+    539,
+    540,
+    541,
+    542,
+    543,
+    544,
+    545,
+    546,
+    547,
+    548,
+    549,
+    550,
+    551,
+    552,
+    553,
+    554,
+    555,
+    556,
+    557,
+    558,
+    559,
+    560,
+    561,
+    562,
+    563,
+    564,
+    565,
+    566,
+    567,
+    568,
+    569,
+    570,
+    571,
+    572,
+    573,
+    574,
+    575,
+    576,
+    577,
+    578,
+    579,
+    580,
+    581,
+    582,
+    583,
+    584,
+    585,
+    586,
+    587,
+    588,
+    589,
+    590,
+    591,
+    592,
+    593,
+    594,
+    595,
+    596,
+    597,
+    598,
+    599,
+    600,
+    601,
+    602,
+    603,
+    604,
+    605,
+    606,
+    607,
+    608,
+    609,
+    610,
+    611,
+    612,
+    613,
+    614,
+    615,
+    616,
+    617,
+    618,
+    619,
+    620,
+    621,
+    622,
+    623,
+    624,
+    625,
+    626,
+    627,
+    628,
+    629,
+    630,
+    631,
+    632,
+    633,
+    634,
+    635,
+    636,
+    637,
+    638,
+    639,
+    640,
+    641,
+    642,
+    643,
+    644,
+    645,
+    646,
+    647,
+    648,
+    649,
+    650,
+    651,
+    652,
+    653,
+    654,
+    655,
+    656,
+    657,
+    658,
+    659
+  ],
+  "minor_inverse_rows_hex": [
+    "0x4bdb61481000000000a2002b2cd016",
+    "0x9657724330000000009228a63838e5",
+    "0x96a226411000411080122b2a5e8075",
+    "0x2100000000840000000000",
+    "0xdd3e152f91404010809014e4a6c0e7",
+    "0xa6766d4f19000000002e420fe42242",
+    "0x5c246d0610404010800040086ce091",
+    "0x113c1c040040401080400086cac251",
+    "0xd7594447d140401080060006ebaa27",
+    "0x840000000000000000000000002100",
+    "0x202021000000000200820200000",
+    "0x5ae765480000000000a220ae4c9066",
+    "0x872c6047d0000000000a400cbcd080",
+    "0x9f7959412040401080d201008f3873",
+    "0x554b600060000000001004a204aaa5",
+    "0x8e53414100000000001214a6057803",
+    "0x9280000000000000000",
+    "0xfab6590d9062ff0208c87327003014",
+    "0x7f295b0c91c101a208be02431c3087",
+    "0x5f75409f183ebb08a0e28cdeaaab1",
+    "0x9009",
+    "0xbf281e0b6101419282903fc4377202",
+    "0xea36e01415019a8001e328abb7a57",
+    "0xc7d3250e4012822000e0334b7468b7",
+    "0x970f220121c2923c0000674d98f094",
+    "0x108000000000404000000000",
+    "0xa0b95d4c7100904808c20f624a7a26",
+    "0x78bb4c474104924808f2070e3fa0e2",
+    "0x13ef1f4600404250e08424efd9e2a1",
+    "0x34bb6f49b1a0d268003450a1d5faa6",
+    "0x20010410000000000000",
+    "0x40400000000080100000000",
+    "0x56cb5505e1c6936840a6586704c2d5",
+    "0xa2743c41f020835080a2008752b2a0",
+    "0xd036300fd040681282800028a3e2ce",
+    "0xcff4794b20c3bba800f47d8e180031",
+    "0xc77c184241200104004c6ba2f562d0",
+    "0x8b362849a0c00034081201aa577066",
+    "0x14077d43f009719880144ecdd79a67",
+    "0xac29554d80b0708a082c0e0f78e8b5",
+    "0x8b595703d1a2d22c909027e56ba8e3",
+    "0x1a8722034000011480586aa9f91257",
+    "0x90140000000000000000",
+    "0x4355540eb0a070aa08406144936081",
+    "0xdae3514dc0a0c02008745f89da6065",
+    "0x202820000000000002820200000",
+    "0x47d1704571c283200a8c28e92dfa81",
+    "0x2e42b013020001000c86a4b81f8e2",
+    "0x4008000000000000000010020000",
+    "0x2804020000000000000",
+    "0xac1b4c4403e41078c00470612b30f1",
+    "0x2809000000000000",
+    "0x15f3014f60128200087233cb246295",
+    "0xa52551088143b38a0af632e69e0a17",
+    "0x8e99094db082db3884f47d04ba12f2",
+    "0xb7793a03a172fb2a01400f4ee7f077",
+    "0x7a19510a3070309a80be0e8f9352c2",
+    "0x660",
+    "0xc48c0402c183eb30881e28e3ce32a5",
+    "0x81c64408f502931c88d04d001e7886",
+    "0x86350605a1c2922c800067ab1db090",
+    "0xac134b051084c37088c65fc6883802",
+    "0x34b16a08b0c2032008d77f2656f255",
+    "0x70dc674041c3daba8064424a2f7233",
+    "0x6bc0043e182eb308a8c28638fee22",
+    "0xf1a94e8bf02203508000208d673003",
+    "0x202021000000000012020200000",
+    "0x8b473b0aa160510848762b88842005",
+    "0x20200000000202000000000",
+    "0x8206000000000000",
+    "0x400c2f43a0c3d23882da302d6d30a6",
+    "0x1f47c0c9082dbb088667d06f3f8f2",
+    "0x85581d4ab010499880944e2f93fa17",
+    "0x859c475680404110001a6a05a912c1",
+    "0xde74070731c2d22c000027b5b66096",
+    "0x17c664691a2d32c809267ef73ca25",
+    "0x400474057120401000de2becdd88f3",
+    "0xd5036d0af0e0692a00c62f0fafa057",
+    "0xd463402000000000008014260032a7",
+    "0x30766d08c1404010802e42875f0a56",
+    "0x1430200680444211c0000804bb6234",
+    "0x4d187106900000000000418ea622c0",
+    "0x5c246d0290404010800800086ce091",
+    "0x176b4449600000000010002240f894",
+    "0x8ed1634fc04001000092290cb15243",
+    "0x202000000000000000020200000",
+    "0x4800000000120000000000",
+    "0xd463400020000000000004260032a7",
+    "0x47080400600000000082000440eb33",
+    "0xd463400800000000008000260032a7",
+    "0x14000000000100200000000",
+    "0x4020140000000000000",
+    "0x48000000000000000000820000",
+    "0x2100000000001400000000",
+    "0x120000000000000000000000004800",
+    "0x2020000000000000000004040000",
+    "0x600000000000000000000000000006",
+    "0xc6347000000000000000006443003",
+    "0x480000000000000000000000000084",
+    "0x551d140000404010800000824872d7",
+    "0x8212000000000000000000000000",
+    "0x1004000000000000000008400000",
+    "0x404000000000000000040400000",
+    "0x8010000000000000000001080000",
+    "0x21000000000000000000140000",
+    "0x1484000000000000000000000000",
+    "0x603024000000000000000088500006",
+    "0x4040000000000000000002020000",
+    "0x108000000000000000002020000",
+    "0x140000000000000000000000002800",
+    "0x900000410000000000008200006000",
+    "0x410000000000000000000000000014",
+    "0x96",
+    "0x2800000000000000000084000000",
+    "0x1221",
+    "0x8241",
+    "0x210000000000000000020080000",
+    "0x410000000000008200000000",
+    "0x40401080000000000000",
+    "0x84000000000000000000410000"
+  ],
+  "nullity": 300,
+  "pivot_helpers_absolute": [
+    320,
+    321,
+    322,
+    323,
+    324,
+    325,
+    326,
+    327,
+    328,
+    329,
+    330,
+    331,
+    332,
+    333,
+    334,
+    335,
+    336,
+    337,
+    338,
+    339,
+    340,
+    341,
+    342,
+    343,
+    344,
+    345,
+    346,
+    347,
+    348,
+    349,
+    350,
+    351,
+    352,
+    353,
+    354,
+    355,
+    356,
+    357,
+    358,
+    359,
+    360,
+    361,
+    362,
+    363,
+    364,
+    365,
+    366,
+    368,
+    369,
+    370,
+    371,
+    372,
+    373,
+    374,
+    375,
+    376,
+    377,
+    378,
+    379,
+    380,
+    381,
+    382,
+    383,
+    384,
+    385,
+    386,
+    387,
+    388,
+    389,
+    390,
+    391,
+    392,
+    393,
+    394,
+    395,
+    396,
+    397,
+    398,
+    400,
+    401,
+    403,
+    404,
+    405,
+    406,
+    407,
+    409,
+    410,
+    411,
+    413,
+    416,
+    417,
+    419,
+    420,
+    427,
+    429,
+    432,
+    433,
+    434,
+    436,
+    438,
+    440,
+    442,
+    446,
+    451,
+    452,
+    453,
+    454,
+    460,
+    461,
+    466,
+    467,
+    470,
+    471,
+    477,
+    482,
+    484,
+    534,
+    268,
+    275,
+    300
+  ],
+  "rank": 120,
+  "raw_binary_additions": 4021,
+  "raw_gates": 3021,
+  "right_inverse_columns_sha256": "ca1eb79ae1766eb91bdce1bd914ac9132f102b3eacf524533b84b30f4891a3b5",
+  "schema": "r420-dirty-rank/1",
+  "seed": 80
+}
diff --git a/research/r420-compensation-rank80/OVERLAP.json b/research/r420-compensation-rank80/OVERLAP.json
new file mode 100644
index 0000000000..7a7d2024fb
--- /dev/null
+++ b/research/r420-compensation-rank80/OVERLAP.json
@@ -0,0 +1,81 @@
+{
+  "additional_arrivals_checked": [
+    719,
+    720,
+    721,
+    722,
+    723,
+    724,
+    725,
+    726,
+    727,
+    728
+  ],
+  "consumed_pending_code": false,
+  "newest_pr": 728,
+  "open_pr_count": 547,
+  "pinned_sprint_issue": null,
+  "related_prs": [
+    {
+      "headRefOid": "688258f863410419d10e34b0b3014b91cdce632c",
+      "number": 718,
+      "title": "Scoped negative result: R420 split target reads cannot lower the paid moment"
+    },
+    {
+      "headRefOid": "67e9e846d9e8814b2dd01133251bb83fafa8f5b6",
+      "number": 717,
+      "title": "Format limits part 2 (no \u03ba claim): erratum to #595, exact invoice prices, frontier-word censuses, decoder floors, spec requirements, centre and fragmentation walls"
+    },
+    {
+      "headRefOid": "afeb452f58ff0cbf109172335e2ba282aac3dcde",
+      "number": 716,
+      "title": "Research: optimal disjoint R420 target pairs save 3,250 XORs (no new kappa)"
+    },
+    {
+      "headRefOid": "1a19af5c5ddb6de9797a6d085e5df0b90ed6d58b",
+      "number": 713,
+      "title": "Research: save 3,150 R420 XORs with a restored target basis"
+    },
+    {
+      "headRefOid": "4773b879a1087540f5919c726ec8c670dadfa0c5",
+      "number": 712,
+      "title": "Independent verification: quadratic-phase certificate for a selected cold wrapper"
+    },
+    {
+      "headRefOid": "0f7dbb54948775c010b5e5bc8ab3cf92a52a9b25",
+      "number": 706,
+      "title": "Independent verification: selected complex moments via integer root bounds"
+    },
+    {
+      "headRefOid": "27db45ac6befa99d6c06be920a93845023e81937",
+      "number": 702,
+      "title": "Research audit: verify all selected cold-wrapper amplitudes (no new kappa)"
+    },
+    {
+      "headRefOid": "9732ac127dd4bef98a846aaa904c20b5a84e72c1",
+      "number": 694,
+      "title": "Research: save 6,934 R420 XORs with a restored helper basis"
+    },
+    {
+      "headRefOid": "23dcb610c2b156b76b9d599ea296c3cbde224b2d",
+      "number": 686,
+      "title": "Research: save 108 R420 XORs with restored frame-zero sharing (no new kappa)"
+    },
+    {
+      "headRefOid": "bdc9317efd6d928a0f050159670d1316ba5f4c5b",
+      "number": 678,
+      "title": "Independent verification of the #543 bit moment using binomial enclosures"
+    },
+    {
+      "headRefOid": "9ca7aa3ab0a3260a2f36ac86b9911a31fd88bd89",
+      "number": 661,
+      "title": "Scoped negative result: R420 phase-B frames are moment-optimal at fixed gate order"
+    },
+    {
+      "headRefOid": "ce37f3ce35ba8891771e01492b3a21978763bebb",
+      "number": 612,
+      "title": "[Lean] Verify current R420 boundaries and B-XOR interfaces"
+    }
+  ],
+  "snapshot_utc": "2026-10-13 04:55:31 UTC"
+}
diff --git a/research/r420-compensation-rank80/README.md b/research/r420-compensation-rank80/README.md
new file mode 100644
index 0000000000..f642af9d50
--- /dev/null
+++ b/research/r420-compensation-rank80/README.md
@@ -0,0 +1,166 @@
+# Exact rank and minimum-weight kernel of R420 dirty compensation
+
+**Independent verification; no new kappa or circuit.** The selected PR543
+R420 word has a dirty-helper correction matrix `K` of size 120 by 420 over
+F2. This package certifies **rank(K) = 120**, **nullity(K) = 300**, and
+**minimum nonzero kernel weight 4**. There are exactly **18** weight-four
+kernel vectors. All 420 columns are distinct and nonzero.
+
+The source is eumemic's PR543 at
+`2065fe4f72a914d907f1046603f5a36f17018535`, unchanged in base
+`66849e1475c930fd7732b1a0067ffee7e1e95f60`. The selected construction is
+PR626 (`660de893d27bb7abd1d5b01b1640207528a5c851`) with PR543,
+conditional kappa `51110230636731/31250000000000000`.
+[SOURCES.json](SOURCES.json) records archive/payload SHA-256, Git blob IDs,
+and the selected record, manifest, construction, checker and review pins.
+
+From the repository root, with Python 3.10+ and no external dependencies:
+
+```sh
+python3 -I -B research/r420-compensation-rank80/verify.py
+```
+
+Expected:
+
+```text
+PASS_R420_DIRTY_RANK rank=120 nullity=300 distance=4 pairs=87990 isolated_errors=120 controls=10
+```
+
+The additional independent scalar tests run with:
+
+```sh
+python3 -I -O -B research/r420-compensation-rank80/test_verify.py
+```
+
+Expected: seven tests pass. `verify.py --write /tmp/new-certificate.json`
+reconstructs the complete certificate and refuses to overwrite an existing
+file. Normal and optimized Python execute the same explicit checks.
+[VALIDATION.json](VALIDATION.json) records the Linux checks, including a
+minimal clean export containing only this package and its pinned inputs.
+
+## What is checked
+
+Registers 0–119 are sources `x`, 120–239 are targets `y`, and 240–659 are
+arbitrary helper inputs `s`. For `W0 = A; scatter; B`, the existing PR543
+interface states
+
+`W0(x,s,y) = (U(x,s), y + Jx + Ks)`.
+
+The original `xcheck.py` already checks `J=I`, `V=I`, and `K=D` by forward
+symbolic register propagation. That identity is predecessor work. This
+implementation imports no supplier code: it **pulls target observables
+backward** through the actual gate order. For a gate `r_d += sum r_s`, a
+covector changes by `q_s += q_d` for each source, with `q_d` unchanged.
+This is its exact transpose action, since
+
+`q · G r = (G^T q) · r`.
+
+Reversing all 3,021 A/scatter/B gates (4,021 binary additions) yields all
+120 target observables simultaneously. Their source and target blocks are
+each the identity, and their helper block equals the literal frame-zero D
+matrix. The retained-total scatter is read directly from `ret` and
+`scatter`; its retained registers are never modified during scatter.
+
+A separate backward pass through D/A/scatter/B/C verifies the entire
+660-column scalar endpoint: `x` and arbitrary `s` are restored, and
+`y -> y+x`. This is a scalar obligation; it does not recheck physical frame
+transport or the COPY/ERASE realization of scatter.
+
+## Rank, diagnostic inputs, and a complete kernel basis
+
+[EXPECTED.json](EXPECTED.json) contains every row of K, 120 selected helper
+indices, and the exact inverse of their 120-by-120 column minor `M`.
+Bit j of a hexadecimal integer denotes coordinate j; K rows use
+helper-relative indices 0–419, while lists explicitly marked `absolute`
+use registers 240–659. Inverse row j corresponds to pivot position j.
+
+The verifier checks **both** `M M^-1 = I` and `M^-1 M = I` by exact products.
+Nomination and Gaussian elimination are not accepted as rank evidence on
+their own. Embedding the rows of `M^-1` in the chosen helper positions gives
+a 420-by-120 right inverse `H` with `KH=I`. In particular, helper input
+`H e_t` causes exactly target error `e_t` if D is omitted. These **120
+isolated-error inputs** are reproducible diagnostics for future correction
+circuits. They distinguish every target error direction, whereas testing
+only clean helpers cannot detect an omitted D at all.
+
+For each nonpivot helper coordinate f, define
+
+`n_f = e_f + H K e_f`.
+
+Then `K n_f = 0`. Each of the 300 vectors has a unique unit coordinate
+among the free positions, so they are independent. Rank-nullity proves
+they span the full kernel. The verifier checks annihilation and the entire
+free-coordinate identity. The exact minor plus this formula is the compact
+kernel certificate; hashes of the generated kernel and H columns are also
+recorded. The 120 H columns together with these 300 kernel vectors form a
+basis of all helper inputs. A separate ordinary Boolean interpreter tests
+all 420 directions through both the raw and complete circuits.
+
+**Scoped consequence.** Any linear factorization `K = A B` with
+`B : F2^420 -> F2^r` needs `r >= 120`. Thus this fixed correction cannot
+factor through fewer than 120 linear summaries. This is not a lower bound
+on simultaneous physical scratch, XOR count, recursive cost, or an altered
+supplier. Summaries can be produced sequentially; the recent basis-changing
+circuits are fully compatible with this rank.
+
+## Exact minimum weight and a concrete cancellation
+
+A kernel vector of weight one would be a zero column of K; a weight-two
+vector would be two equal columns. Neither exists. A weight-three vector
+would satisfy `K_a + K_b = K_c`. All **87,990 unordered column pairs** are
+checked against the complete column set, excluding that possibility.
+
+Equal XORs of two disjoint pairs yield weight-four vectors. The census
+retains all pairs per XOR value, not just one representative, and deduplicates
+sorted supports. Every weight-four vector has three such pair partitions,
+so this exhausts the domain. All 18 supports are in the certificate.
+Seed `80 % 18` selects the example
+
+**absolute helper registers `{284, 296, 521, 623}`**.
+
+Setting those four helper bits to one and all other inputs to zero gives no
+target error in W0. Each of their 14 nonempty proper subsets gives a nonzero
+target error. The separate scalar interpreter checks all 15 subsets for all
+18 supports. Together with the exhaustive lower-weight exclusions this
+establishes minimum weight exactly 4 for this finite linear map. In coding
+notation its kernel is a binary `[420,300,4]` code. This does not identify
+removable helper registers: each individual helper affects the correction.
+
+## Controls, scope, and provenance
+
+Ten controls cover omitted D, one missing D operand, swapped D rows
+(**rank preserved but compensation wrong**), incorrect backward order,
+corrupted inverse, corrupted kernel vector, dependent kernel basis, and
+injected dependencies of weights one, two and three. Additional tests check
+the adjoint identity on all 16 inputs and 16 observables for each of 40
+seeded four-register circuits, both dense inverse products, cleanup damage
+with K unchanged, corrupted source/certificate rejection, and gzip
+recompression acceptance. All proof-relevant input bytes are pinned;
+recompressed containers are compared by their complete decoded payload.
+
+This is a complete finite calculation on the pinned word, not an empirical
+search for a stronger bound or a formal proof in a proof assistant. Pivot
+nomination uses helper order 80–419, then 0–79, and stops at 120 independent
+columns. The distance census completes all 87,990 pairs and retains every
+collision. No solver, probabilistic acceptance or floating arithmetic is
+used. All-size/compiler, common-label/mutable-basis, physical/hosting,
+precision/tape and analytic obligations remain inherited. No new invoice,
+hosted construction, supplier optimum or full multiplication theorem follows.
+
+The reviewed PR543 checker and interleaved-interface argument belong to
+**eumemic**, with their Anthropic Claude disclosure retained in the
+[original notice](../e8-bit-r420/NOTICE.md). Credit also remains with the
+PR493/370/425/472/510 lineage identified there and in the pinned README.
+The current construction/review credit remains with Jeremy Kothe, Chafik
+Boukhalfa and the full selected dependency chain.
+
+Concurrent #686/#694 optimize helper columns, #713/#716 optimize target
+rows, and #612 supplies scoped Lean boundary/B facts. This package imports
+none of those changes and does not certify their implementations; it adds a
+transpose-based check and explicit rank/kernel evidence for their common
+accepted baseline. [CLAIM.md](CLAIM.md) records task selection and overlap.
+
+Prepared by **Joshua Snider**, with substantial **OpenAI Codex assistance**
+in research, mathematics, implementation, testing and writing. Independent
+implementation does not mean independent human review. New material is
+under the repository's [Apache-2.0 license](../../LICENSE).
diff --git a/research/r420-compensation-rank80/SOURCES.json b/research/r420-compensation-rank80/SOURCES.json
new file mode 100644
index 0000000000..0fabbd9da7
--- /dev/null
+++ b/research/r420-compensation-rank80/SOURCES.json
@@ -0,0 +1,38 @@
+{
+  "base": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "bit_pr543": "2065fe4f72a914d907f1046603f5a36f17018535",
+  "files": {
+    "certificates/selected-result.json": {
+      "base_git_blob": "92a10096dee76479af88a897714b3818d8263141",
+      "sha256": "b3bf402f31a69bde0629936a9b569bed48281568d7b16d5fba120b5311ea1f53"
+    },
+    "docs/research/community-k492-review.md": {
+      "base_git_blob": "11efcd07ae2b9d93d355c6adaf773dca70dbce91",
+      "sha256": "3b731d30e80010b15408a289b0b32192700885474c8b36d48ee3320a7a8c5c47"
+    },
+    "research/community-k492-audit/SELECTED-SOURCE.json": {
+      "base_git_blob": "5f8725175afc095ff2da92e38af6ef4476c266da",
+      "sha256": "36e9e421230c4cb7b6a537d76a4bdfb6f667730d383e56062d4e45957484ab9e"
+    },
+    "research/e8-bit-r420/NOTICE.md": {
+      "base_git_blob": "cb68783d7d76c3fc13faa571429e9b067a0db3f7",
+      "sha256": "12ba6e0845f222e9940b00f6c60d261db104246a8d3143da267682973479f811"
+    },
+    "research/e8-bit-r420/README.md": {
+      "base_git_blob": "6751eba6f617292fc919e58d5a9f9f06ab037391",
+      "sha256": "9807be57c6adf26b30e4f54e2f8160075bbc05091f1a6d157e43d2a4620c1c9f"
+    },
+    "research/e8-bit-r420/code/xcheck.py": {
+      "base_git_blob": "fbff8607e4c61e18481f696b99dd38a32444e90d",
+      "sha256": "5737d18a7826fd51e131035f2d7bebba2e2868af91dd7672a5f11208b036d424"
+    },
+    "research/e8-bit-r420/data/bitE8mut-r420.json.gz": {
+      "base_git_blob": "0c63ca62759dc63d302be6552aeeee1ede70350f",
+      "payload_sha256": "e597e3885c0a8daa262afa5985ee2930443329126aece76d33159d81882bdcc2",
+      "pr543_git_blob": "0c63ca62759dc63d302be6552aeeee1ede70350f",
+      "sha256": "9721a3819efd68307f66f00d84a952eb28eb7c3ad2ce79653ce295c98a764784"
+    }
+  },
+  "runtime_dependencies": "Python 3.10+ standard library only; no predecessor code imported",
+  "selected_pr626": "660de893d27bb7abd1d5b01b1640207528a5c851"
+}
diff --git a/research/r420-compensation-rank80/VALIDATION.json b/research/r420-compensation-rank80/VALIDATION.json
new file mode 100644
index 0000000000..00c503c430
--- /dev/null
+++ b/research/r420-compensation-rank80/VALIDATION.json
@@ -0,0 +1,58 @@
+{
+  "base": "66849e1475c930fd7732b1a0067ffee7e1e95f60",
+  "checks": [
+    {
+      "command": "python3 -I -B research/r420-compensation-rank80/verify.py",
+      "result": "PASS: exact rank 120, nullity 300, minimum weight 4, 18 minimum-weight vectors, 87990 pairs, 10 controls"
+    },
+    {
+      "command": "python3 -I -O -B research/r420-compensation-rank80/verify.py --write /tmp/new-certificate.json",
+      "result": "PASS: byte-identical to EXPECTED.json"
+    },
+    {
+      "command": "python3 -I -B research/r420-compensation-rank80/test_verify.py",
+      "result": "PASS: all 7 tests, including direct literal scalar interpretation of 420 helper-basis directions"
+    },
+    {
+      "command": "python3 -I -O -B research/r420-compensation-rank80/test_verify.py",
+      "result": "PASS: all 7 tests"
+    },
+    {
+      "command": "minimal git checkout-index export; run both entry points with python3 -I -O -B from /tmp",
+      "result": "PASS: no undeclared repository import or input dependency"
+    },
+    {
+      "command": "python3 -I -B research/e8-bit-r420/code/xcheck.py research/e8-bit-r420/data/bitE8mut-r420.json.gz --json /tmp/source-xcheck.json",
+      "result": "PASS: 120 labels, 672 closed frames, all 660 scalar input columns, H1-H5 and U/J/K/C conclusions"
+    },
+    {
+      "command": "make selected-record-check",
+      "result": "PASS"
+    },
+    {
+      "command": "python3 scripts/verify_pr_reconciliation.py",
+      "result": "PASS: 528 PRs with attributed heads and evidence pins"
+    },
+    {
+      "command": "git diff --cached --check",
+      "result": "PASS"
+    }
+  ],
+  "date_utc": "2026-10-13",
+  "not_run": [
+    "repository-wide make verify",
+    "full frontier626 cold replay",
+    "native multi-stage or hosted-parent rebuild",
+    "Lean",
+    "remote CI"
+  ],
+  "platform": "Linux x86_64",
+  "python": "3.12.3 (main, Aug 31 2026, 10:18:26) [GCC 13.3.0]",
+  "scope": "Standalone finite verification on the unchanged selected bit word; no selected construction or generator changes. No all-size or physical realization theorem is claimed.",
+  "tested_sha256": {
+    "EXPECTED.json": "1e9471993b22bc374adbd863debb1ad7d06e060a87613665fe4ee9ecf1b7418a",
+    "SOURCES.json": "25d1bf97798a4bdb43b6801d94929de85300f0edc1eafca46f1c2619250bf00f",
+    "test_verify.py": "b1c2a7cde082d71d89bf71343f8e76bcb39f940a853885b4aa88dfe834bd1b50",
+    "verify.py": "f8e582eafe8e8d9cc31e81a58035dc679c06f8206da9dc1f1b6f3ede8674f2b2"
+  }
+}
diff --git a/research/r420-compensation-rank80/test_verify.py b/research/r420-compensation-rank80/test_verify.py
new file mode 100644
index 0000000000..4405a25f1c
--- /dev/null
+++ b/research/r420-compensation-rank80/test_verify.py
@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""Independent scalar controls for the transpose/rank certificate (Apache-2.0)."""
+import copy
+import gzip
+import importlib.util
+import json
+from pathlib import Path
+import random
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+HERE = Path(__file__).resolve().parent
+spec = importlib.util.spec_from_file_location("rank80", HERE / "verify.py")
+v = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(v)
+
+
+def scalar(gates, initial):
+    """Ordinary Boolean execution, independent of packed covector arithmetic."""
+    state = initial[:]
+    for dest, sources in gates:
+        value = state[dest]
+        for source in sources:
+            value = value != state[source]
+        state[dest] = value
+    return state
+
+
+def literal_scalar(word, sections, initial):
+    """Read the source JSON directly, without the verifier's stream adapter."""
+    state = initial[:]
+    for section in sections:
+        if section == "scatter":
+            copied = [state[register] for register in word["ret"]]
+            for target, row in enumerate(word["scatter"]):
+                for index in row:
+                    state[120 + target] = state[120 + target] != copied[index]
+        else:
+            for _, dest, sources in word[section]:
+                for source in sources:
+                    state[dest] = state[dest] != state[source]
+    return state
+
+
+class Evidence(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.word = v.load_word()
+        cls.cert = json.loads((HERE / "EXPECTED.json").read_text())
+        cls.cols = v.extract(cls.word)
+        cls.pivots = [p - 240 for p in cls.cert["pivot_helpers_absolute"]]
+        cls.inv = [int(r, 16) for r in cls.cert["minor_inverse_rows_hex"]]
+        cls.free = [j for j in range(420) if j not in cls.pivots]
+        cls.right = []
+        for t in range(120):
+            cls.right.append(sum(((r >> t) & 1) << p for p, r in zip(cls.pivots, cls.inv)))
+        cls.kernel = []
+        for f in cls.free:
+            # Set symmetric difference implements linear combinations separately.
+            support = {f}
+            for t in range(120):
+                if (cls.cols[f] >> t) & 1:
+                    support.symmetric_difference_update(j for j in range(420) if (cls.right[t] >> j) & 1)
+            cls.kernel.append(sum(1 << j for j in support))
+
+    def test_literal_certificate_dense_inverse_products(self):
+        # Check both products using lists of bits, no inverse/elimination routine.
+        matrix = [[(self.cols[p] >> i) & 1 for p in self.pivots] for i in range(120)]
+        inv = [[(row >> j) & 1 for j in range(120)] for row in self.inv]
+        for a, b in ((matrix, inv), (inv, matrix)):
+            for i in range(120):
+                for j in range(120):
+                    self.assertEqual(sum(a[i][k] * b[k][j] for k in range(120)) % 2, int(i == j))
+
+    def test_all_dirty_witnesses_and_kernel_directions_by_scalar_execution(self):
+        # 120 right-inverse + 300 kernel vectors form a basis of all helper dirt.
+        for index, bits in enumerate(self.right + self.kernel):
+            initial = [False] * 240 + [bool((bits >> j) & 1) for j in range(420)]
+            out = literal_scalar(self.word, ("A", "scatter", "B"), initial)
+            expected = [j == index for j in range(120)] if index < 120 else [False] * 120
+            self.assertEqual(out[120:240], expected)
+            self.assertEqual(literal_scalar(self.word, ("D", "A", "scatter", "B", "C"), initial), initial)
+
+    def test_adjoint_identity_exhaustive_small_circuits(self):
+        rng = random.Random(80)
+        # Exhaust all 16 inputs x 16 observables for each of 40 tiny circuits.
+        for _ in range(40):
+            gates = []
+            for _ in range(9):
+                d = rng.randrange(4)
+                gates.append((d, tuple(s for s in range(4) if s != d and rng.randrange(2))))
+            back = v.pullback(gates, range(4))[:4]
+            for x in range(16):
+                out = scalar(gates, [bool((x >> i) & 1) for i in range(4)])
+                for q in range(16):
+                    lhs = sum(out[i] * ((q >> i) & 1) for i in range(4)) % 2
+                    rhs = sum(((x >> i) & 1) * ((back[i] & q).bit_count() % 2) for i in range(4)) % 2
+                    self.assertEqual(lhs, rhs)
+
+    def test_all_minimum_weight_words_in_literal_circuit(self):
+        supports = self.cert["kernel_distance"]["weight_four_supports_absolute"]
+        self.assertEqual(len(supports), 18)
+        for support in supports:
+            for subset in range(1, 16):
+                state = [False] * 660
+                for i, register in enumerate(support):
+                    state[register] = bool((subset >> i) & 1)
+                error = literal_scalar(self.word, ("A", "scatter", "B"), state)[120:240]
+                self.assertEqual(not any(error), subset == 15)
+
+    def test_full_endpoint_catches_cleanup_damage(self):
+        broken = copy.deepcopy(self.word)
+        broken["C"].pop(80)
+        # K and its rank are unchanged, but restoration is a separate obligation.
+        self.assertEqual(v.extract(broken), self.cols)
+        with self.assertRaisesRegex(v.Reject, "complete scalar endpoint"):
+            v.build(broken)
+
+    def test_source_pins_and_recompression(self):
+        pins = json.loads((HERE / "SOURCES.json").read_text())
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            for path in pins["files"]:
+                dst = root / path
+                dst.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copyfile(v.ROOT / path, dst)
+            path = root / v.WORD
+            payload = gzip.decompress(path.read_bytes())
+            path.write_bytes(gzip.compress(payload, compresslevel=1, mtime=80))
+            self.assertEqual(v.load_word(root), self.word)
+            bad = json.loads(payload)
+            bad["D"][80][2].pop()
+            path.write_bytes(gzip.compress(json.dumps(bad).encode(), mtime=80))
+            with self.assertRaisesRegex(v.Reject, "source pin"):
+                v.load_word(root)
+
+    def test_cli_rejects_changed_certificate_under_optimization(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "bad.json"
+            bad = copy.deepcopy(self.cert)
+            bad["nullity"] = 299
+            path.write_text(json.dumps(bad))
+            result = subprocess.run([sys.executable, "-I", "-O", "-B", str(HERE / "verify.py"), "--check", str(path)], capture_output=True, text=True)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("certificate mismatch", result.stderr)
+            self.assertNotIn("PASS_R420", result.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)
diff --git a/research/r420-compensation-rank80/verify.py b/research/r420-compensation-rank80/verify.py
new file mode 100644
index 0000000000..58d9ae81bc
--- /dev/null
+++ b/research/r420-compensation-rank80/verify.py
@@ -0,0 +1,302 @@
+#!/usr/bin/env python3
+"""Independent transpose-circuit and exact GF(2) rank certificate. Apache-2.0.
+
+Joshua Snider, with substantial OpenAI Codex assistance. No supplier imports.
+Bit j of an integer represents coordinate j; all arithmetic here is over F2.
+"""
+import argparse
+import copy
+import gzip
+import hashlib
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+SEED, V, R, N = 80, 120, 420, 660
+WORD = "research/e8-bit-r420/data/bitE8mut-r420.json.gz"
+
+
+class Reject(ValueError):
+    pass
+
+
+def need(ok, message):
+    if not ok:
+        raise Reject(message)
+
+
+def digest(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+def canonical(value):
+    return json.dumps(value, sort_keys=True, separators=(",", ":")).encode()
+
+
+def load_word(root=ROOT):
+    pins = json.loads((HERE / "SOURCES.json").read_text())
+    for path, pin in pins["files"].items():
+        data = (root / path).read_bytes()
+        # The immutable archive hash is recorded, but proof equality uses payload.
+        if path == WORD:
+            data = gzip.decompress(data)
+            expected = pin["payload_sha256"]
+        else:
+            expected = pin["sha256"]
+        need(digest(data) == expected, "source pin: " + path)
+    return json.loads(gzip.decompress((root / WORD).read_bytes()))
+
+
+def stream(w, sections=("A", "scatter", "B")):
+    need((w["v"], w["R"], w["h"]) == (V, R, 8), "word dimensions")
+    need(w["format"] == "bitE8/1+mut", "word format")
+    gates = []
+    for section in sections:
+        if section == "scatter":
+            need(len(w["scatter"]) == V, "scatter length")
+            need(all(240 <= q < N for q in w["ret"]), "retained helper")
+            for t, indices in enumerate(w["scatter"]):
+                need(all(0 <= k < len(w["ret"]) for k in indices), "scatter index")
+                gates.append((V + t, tuple(w["ret"][k] for k in indices)))
+        else:
+            for frame, dest, sources in w[section]:
+                need(0 <= frame < len(w["frames"]), "frame index")
+                gates.append((dest, tuple(sources)))
+    for dest, sources in gates:
+        need(0 <= dest < N and all(0 <= s < N for s in sources), "register index")
+        need(dest not in sources and len(set(sources)) == len(sources), "transvection operands")
+    return gates
+
+
+def pullback(gates, outputs):
+    """Pull output covectors backward; never propagates register expressions."""
+    columns = [0] * N
+    for bit, register in enumerate(outputs):
+        columns[register] = 1 << bit
+    for dest, sources in reversed(gates):
+        weight = columns[dest]
+        for source in sources:
+            columns[source] ^= weight
+    return columns
+
+
+def literal_d(w):
+    cols = [0] * R
+    for frame, dest, sources in w["D"]:
+        need(not w["frames"][frame], "D frame is not zero")
+        need(V <= dest < 2 * V, "D target")
+        for source in sources:
+            need(2 * V <= source < N, "D helper")
+            cols[source - 2 * V] ^= 1 << (dest - V)
+    return cols
+
+
+def extract(w):
+    cols = pullback(stream(w), range(V, 2 * V))
+    need(cols[:V] == [1 << j for j in range(V)], "source block J differs from I")
+    need(cols[V:2 * V] == [1 << j for j in range(V)], "target block V differs from I")
+    need(cols[2 * V:] == literal_d(w), "dirty block K differs from D")
+    return cols[2 * V:]
+
+
+def apply_columns(columns, vector):
+    out = 0
+    while vector:
+        bit = vector & -vector
+        out ^= columns[bit.bit_length() - 1]
+        vector ^= bit
+    return out
+
+
+def apply_rows(rows, vector):
+    return sum(((row & vector).bit_count() % 2) << i for i, row in enumerate(rows))
+
+
+def transpose(columns, height):
+    return [sum(((c >> i) & 1) << j for j, c in enumerate(columns)) for i in range(height)]
+
+
+def nominate_columns(columns):
+    """Discovery only: the returned minor is subsequently checked by products."""
+    basis, chosen = {}, []
+    for j in list(range(SEED, R)) + list(range(SEED)):
+        value = columns[j]
+        while value:
+            pivot = value.bit_length() - 1
+            if pivot in basis:
+                value ^= basis[pivot]
+            else:
+                basis[pivot] = value
+                chosen.append(j)
+                break
+        if len(chosen) == V:
+            return chosen
+    raise Reject("no full-rank minor found")
+
+
+def inverse(rows):
+    n = len(rows)
+    work = [r | (1 << (n + i)) for i, r in enumerate(rows)]
+    for j in range(n):
+        pivot = next((k for k in range(j, n) if (work[k] >> j) & 1), None)
+        need(pivot is not None, "singular minor")
+        work[j], work[pivot] = work[pivot], work[j]
+        for k in range(n):
+            if k != j and ((work[k] >> j) & 1):
+                work[k] ^= work[j]
+    need([x & ((1 << n) - 1) for x in work] == [1 << i for i in range(n)], "inverse elimination")
+    return [x >> n for x in work]
+
+
+def check_certificate(columns, pivots, inv, kernel):
+    need(len(columns) == R and all(0 <= c < (1 << V) for c in columns), "K dimensions")
+    need(len(pivots) == V and len(set(pivots)) == V and all(0 <= p < R for p in pivots), "pivot indices")
+    need(len(inv) == V and all(0 <= r < (1 << V) for r in inv), "inverse dimensions")
+    minor = [columns[p] for p in pivots]
+    right = []
+    for t in range(V):
+        coefficients = apply_rows(inv, 1 << t)
+        need(apply_columns(minor, coefficients) == 1 << t, "M inverse product")
+        need(apply_rows(inv, minor[t]) == 1 << t, "inverse M product")
+        right.append(sum(((coefficients >> j) & 1) << p for j, p in enumerate(pivots)))
+    free = [j for j in range(R) if j not in set(pivots)]
+    need(len(kernel) == R - V, "kernel count")
+    for f, vector in zip(free, kernel):
+        need(0 <= vector < (1 << R), "kernel dimensions")
+        need(apply_columns(columns, vector) == 0, "kernel annihilation")
+        need([j for j in free if (vector >> j) & 1] == [f], "kernel free-coordinate identity")
+    return right
+
+
+def distance_four(columns):
+    """Exhaust weight <= 3 via column equality/XOR; exhibit weight four."""
+    need(all(columns), "weight-one kernel vector")
+    need(len(set(columns)) == len(columns), "weight-two kernel vector")
+    lookup = set(columns)
+    pairs, quads = {}, set()
+    count = 0
+    for a in range(len(columns)):
+        for b in range(a + 1, len(columns)):
+            count += 1
+            value = columns[a] ^ columns[b]
+            need(value not in lookup, "weight-three kernel vector")
+            for c, d in pairs.get(value, []):
+                need(len({a, b, c, d}) == 4, "overlapping equal pairs")
+                quads.add(tuple(sorted((a, b, c, d))))
+            pairs.setdefault(value, []).append((a, b))
+    need(quads, "no weight-four witness")
+    # Every weight-four word is encountered through its three pair partitions.
+    ordered = sorted(quads)
+    witness = ordered[SEED % len(ordered)]
+    need(apply_columns(columns, sum(1 << j for j in witness)) == 0, "weight-four witness")
+    return {"minimum_weight": 4, "pairs_checked": count,
+            "weight_four_words": len(ordered),
+            "weight_four_supports_absolute": [[j + 240 for j in q] for q in ordered],
+            "selected_weight_four_helpers_absolute": [j + 240 for j in witness]}
+
+
+def rejects(action, expected):
+    try:
+        action()
+    except Reject as error:
+        need(str(error) == expected, "wrong rejection: " + str(error))
+        return expected
+    raise Reject("control accepted: " + expected)
+
+
+def controls(w, columns, pivots, inv, kernel, right):
+    result = {}
+    broken = copy.deepcopy(w)
+    broken["D"] = []
+    result["omit_D"] = rejects(lambda: extract(broken), "dirty block K differs from D")
+    broken = copy.deepcopy(w)
+    broken["D"][SEED][2].pop()
+    result["omit_one_D_operand"] = rejects(lambda: extract(broken), "dirty block K differs from D")
+    broken = copy.deepcopy(w)
+    broken["D"][SEED][2], broken["D"][SEED + 1][2] = broken["D"][SEED + 1][2], broken["D"][SEED][2]
+    # This mutation preserves full rank. Rank alone does not establish K=D.
+    wrong_columns = literal_d(broken)
+    wrong_pivots = nominate_columns(wrong_columns)
+    inverse(transpose([wrong_columns[p] for p in wrong_pivots], V))
+    result["swap_D_rows_preserves_rank"] = rejects(lambda: extract(broken), "dirty block K differs from D")
+    # A backward pull in forward gate order is not the adjoint of the stream.
+    wrong = pullback(list(reversed(stream(w))), range(V, 2 * V))
+    need(wrong[2 * V:] != columns, "wrong traversal escaped")
+    result["wrong_traversal"] = "different dirty map"
+    wrong_inv = inv[:]
+    wrong_inv[SEED] ^= 1
+    result["corrupt_inverse"] = rejects(lambda: check_certificate(columns, pivots, wrong_inv, kernel), "M inverse product")
+    wrong_kernel = kernel[:]
+    wrong_kernel[SEED] ^= 1 << pivots[0]
+    result["corrupt_kernel"] = rejects(lambda: check_certificate(columns, pivots, inv, wrong_kernel), "kernel annihilation")
+    wrong_kernel = kernel[:]
+    wrong_kernel[SEED] = wrong_kernel[SEED + 1]
+    result["dependent_kernel_basis"] = rejects(lambda: check_certificate(columns, pivots, inv, wrong_kernel), "kernel free-coordinate identity")
+    # Omitting all D is invisible on clean helpers, but these 120 witnesses
+    # independently isolate each target error, one for each basis direction.
+    need(apply_columns(columns, 0) == 0, "clean-helper control")
+    isolated = [apply_columns(columns, s) for s in right]
+    need(isolated == [1 << t for t in range(V)], "isolated dirty witnesses")
+    result["omitted_D_dirty_witnesses"] = len(isolated)
+    for name, value, reason in (
+        ("zero_column", 0, "weight-one kernel vector"),
+        ("duplicate_column", columns[SEED + 1], "weight-two kernel vector"),
+        ("three_column_dependency", columns[SEED + 1] ^ columns[SEED + 2], "weight-three kernel vector"),
+    ):
+        wrong = columns[:]
+        wrong[SEED] = value
+        result[name] = rejects(lambda: distance_four(wrong), reason)
+    return result
+
+
+def build(w):
+    columns = extract(w)
+    pivots = nominate_columns(columns)
+    inv = inverse(transpose([columns[p] for p in pivots], V))
+    free = [j for j in range(R) if j not in set(pivots)]
+    kernel = []
+    for f in free:
+        coefficients = apply_rows(inv, columns[f])
+        kernel.append((1 << f) | sum(((coefficients >> j) & 1) << p for j, p in enumerate(pivots)))
+    right = check_certificate(columns, pivots, inv, kernel)
+    # A second transpose pull checks the complete scalar endpoint, including
+    # cleanup and every arbitrary helper/source/target input.
+    full = pullback(stream(w, ("D", "A", "scatter", "B", "C")), range(N))
+    expected = [(1 << j) ^ ((1 << (V + j)) if j < V else 0) for j in range(N)]
+    need(full == expected, "complete scalar endpoint")
+    fmt = lambda values: [hex(x) for x in values]
+    return {
+        "schema": "r420-dirty-rank/1", "seed": SEED,
+        "rank": V, "nullity": R - V, "raw_gates": len(stream(w)),
+        "raw_binary_additions": sum(len(s) for _, s in stream(w)),
+        "K_rows_hex": fmt(transpose(columns, V)),
+        "pivot_helpers_absolute": [p + 2 * V for p in pivots],
+        "minor_inverse_rows_hex": fmt(inv),
+        "kernel_free_helpers_absolute": [f + 2 * V for f in free],
+        "kernel_basis_sha256": digest(canonical(fmt(kernel))),
+        "right_inverse_columns_sha256": digest(canonical(fmt(right))),
+        "isolated_target_80_dirty_input_hex": hex(right[SEED]),
+        "kernel_distance": distance_four(columns),
+        "complete_endpoint_columns": len(full),
+        "controls": controls(w, columns, pivots, inv, kernel, right),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--write", type=Path, help="write a new certificate; refuses overwrite")
+    parser.add_argument("--check", type=Path, default=HERE / "EXPECTED.json")
+    args = parser.parse_args()
+    result = build(load_word())
+    if args.write:
+        with args.write.open("x") as output:
+            json.dump(result, output, indent=2, sort_keys=True)
+            output.write("\n")
+    else:
+        need(result == json.loads(args.check.read_text()), "certificate mismatch")
+    print("PASS_R420_DIRTY_RANK rank=120 nullity=300 distance=4 pairs=87990 isolated_errors=120 controls=10")
+
+
+if __name__ == "__main__":
+    main()