diff --git a/research/p112-boundary24-seed39/CERTIFICATE.json b/research/p112-boundary24-seed39/CERTIFICATE.json
new file mode 100644
index 0000000000..6e8ea762c8
--- /dev/null
+++ b/research/p112-boundary24-seed39/CERTIFICATE.json
@@ -0,0 +1,3093 @@
+{
+  "controls": [
+    "source digest mutation",
+    "missing proof-relevant source",
+    "false extension of predecessor span premise",
+    "nonfree singleton column",
+    "inverse used without transpose",
+    "conjugate instead of ordinary transpose",
+    "omitted compensation term behind apparent 15-cost pair",
+    "singular factor change",
+    "corrupted finite-premise receipt"
+  ],
+  "finite_premises": {
+    "boundary": [
+      27,
+      28,
+      31,
+      32,
+      69,
+      70,
+      73,
+      74,
+      77,
+      78,
+      81,
+      82,
+      85,
+      86,
+      89,
+      90,
+      93,
+      94,
+      97,
+      98,
+      103,
+      104,
+      107,
+      108
+    ],
+    "boundary_spans": {
+      "after": 7,
+      "before": 8
+    },
+    "common_odd_neighbors": [
+      0
+    ],
+    "coordinate_costs": [
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8,
+      8
+    ],
+    "coordinate_pair": [
+      0,
+      1
+    ],
+    "full_deletion_ranks": [
+      [
+        7,
+        7,
+        7,
+        7,
+        7
+      ],
+      [
+        8,
+        8,
+        8,
+        8,
+        8
+      ],
+      [
+        8,
+        8,
+        9,
+        9,
+        9
+      ],
+      [
+        8,
+        8,
+        9,
+        9,
+        9
+      ],
+      [
+        8,
+        8,
+        9,
+        9,
+        9
+      ]
+    ],
+    "original_ranks": [
+      [
+        8,
+        8,
+        8,
+        8,
+        8
+      ],
+      [
+        8,
+        8,
+        8,
+        8,
+        8
+      ],
+      [
+        8,
+        8,
+        9,
+        9,
+        9
+      ],
+      [
+        8,
+        8,
+        9,
+        9,
+        9
+      ],
+      [
+        8,
+        8,
+        9,
+        9,
+        9
+      ]
+    ],
+    "proper_deletions": [
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 27
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 28
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 31
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 32
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 69
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 70
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 73
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 74
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 77
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 78
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 81
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 82
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 85
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 86
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 89
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 90
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 93
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 94
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 97
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 98
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 103
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 104
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 107
+      },
+      {
+        "ranks": [
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            8,
+            8,
+            8
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ],
+          [
+            8,
+            8,
+            9,
+            9,
+            9
+          ]
+        ],
+        "restored_index": 108
+      }
+    ],
+    "pure_correction_ranks": [
+      7,
+      7,
+      7,
+      7,
+      7
+    ],
+    "right_survivors": [
+      [
+        24,
+        25,
+        26,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111
+      ],
+      [
+        24,
+        25,
+        26,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111
+      ],
+      [
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111
+      ],
+      [
+        24,
+        25,
+        26,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99
+      ],
+      [
+        24,
+        25,
+        26,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111
+      ]
+    ],
+    "root_order": "lexicographic positive-first doubled E8 roots",
+    "roots": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        2,
+        -2,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        2,
+        0,
+        -2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        2,
+        0,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        2,
+        2,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        2,
+        0,
+        -2,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        2,
+        0,
+        0,
+        -2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        2,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        2,
+        0,
+        2,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        2,
+        -2,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        2,
+        0,
+        -2,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        2,
+        0,
+        0,
+        -2,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        2,
+        0,
+        0,
+        0,
+        -2
+      ],
+      [
+        0,
+        0,
+        0,
+        2,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        0,
+        0,
+        2,
+        0,
+        0,
+        2,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        2,
+        0,
+        2,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        2,
+        2,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        2,
+        0,
+        -2,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        2,
+        0,
+        0,
+        -2,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        2,
+        0,
+        0,
+        0,
+        -2,
+        0
+      ],
+      [
+        0,
+        0,
+        2,
+        0,
+        0,
+        0,
+        0,
+        -2
+      ],
+      [
+        0,
+        0,
+        2,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        0,
+        2,
+        0,
+        0,
+        0,
+        2,
+        0
+      ],
+      [
+        0,
+        0,
+        2,
+        0,
+        0,
+        2,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        2,
+        0,
+        2,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        2,
+        -2,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        2,
+        0,
+        -2,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        2,
+        0,
+        0,
+        -2,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        2,
+        0,
+        0,
+        0,
+        -2,
+        0,
+        0
+      ],
+      [
+        0,
+        2,
+        0,
+        0,
+        0,
+        0,
+        -2,
+        0
+      ],
+      [
+        0,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        -2
+      ],
+      [
+        0,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        0,
+        2,
+        0,
+        0,
+        0,
+        0,
+        2,
+        0
+      ],
+      [
+        0,
+        2,
+        0,
+        0,
+        0,
+        2,
+        0,
+        0
+      ],
+      [
+        0,
+        2,
+        0,
+        0,
+        2,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        2,
+        0,
+        2,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        2,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        -1,
+        -1,
+        1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        -1,
+        -1,
+        1,
+        1,
+        1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        -1,
+        1,
+        -1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        -1,
+        1,
+        -1,
+        1,
+        1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        -1,
+        1,
+        1,
+        -1,
+        1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        -1,
+        1,
+        1,
+        1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        1,
+        -1,
+        -1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        1,
+        -1,
+        -1,
+        1,
+        1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        1,
+        -1,
+        1,
+        -1,
+        1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        1,
+        -1,
+        1,
+        1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        1,
+        1,
+        -1,
+        -1,
+        1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        1,
+        1,
+        -1,
+        1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        1,
+        1,
+        1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        -1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        -1,
+        1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        1,
+        -1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        1,
+        1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        -1,
+        1,
+        -1,
+        1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        1,
+        -1,
+        1,
+        1,
+        1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        -1,
+        -1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        -1,
+        1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        1,
+        1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        1,
+        1,
+        -1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        -1,
+        1,
+        1,
+        1,
+        -1,
+        1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        1,
+        1,
+        1,
+        -1,
+        1
+      ],
+      [
+        1,
+        -1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        1,
+        -1,
+        -1,
+        -1,
+        -1,
+        1,
+        1
+      ],
+      [
+        1,
+        1,
+        -1,
+        -1,
+        -1,
+        1,
+        -1,
+        1
+      ],
+      [
+        1,
+        1,
+        -1,
+        -1,
+        -1,
+        1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        -1,
+        -1,
+        1,
+        -1,
+        -1,
+        1
+      ],
+      [
+        1,
+        1,
+        -1,
+        -1,
+        1,
+        -1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        -1,
+        -1,
+        1,
+        1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        1,
+        -1,
+        -1,
+        1,
+        1,
+        1,
+        1
+      ],
+      [
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        -1,
+        1
+      ],
+      [
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        1,
+        1,
+        1
+      ],
+      [
+        1,
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        1,
+        1
+      ],
+      [
+        1,
+        1,
+        -1,
+        1,
+        1,
+        1,
+        -1,
+        1
+      ],
+      [
+        1,
+        1,
+        -1,
+        1,
+        1,
+        1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        -1,
+        -1,
+        -1,
+        -1,
+        1
+      ],
+      [
+        1,
+        1,
+        1,
+        -1,
+        -1,
+        -1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        -1,
+        -1,
+        1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        -1,
+        -1,
+        1,
+        1,
+        1
+      ],
+      [
+        1,
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        1,
+        1
+      ],
+      [
+        1,
+        1,
+        1,
+        -1,
+        1,
+        1,
+        -1,
+        1
+      ],
+      [
+        1,
+        1,
+        1,
+        -1,
+        1,
+        1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        -1,
+        -1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        -1,
+        -1,
+        1,
+        1
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        -1,
+        1,
+        -1,
+        1
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        -1,
+        1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        1,
+        -1,
+        -1,
+        1
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        1,
+        -1,
+        1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        -1,
+        -1
+      ],
+      [
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1,
+        1
+      ],
+      [
+        2,
+        0,
+        -2,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        2,
+        0,
+        0,
+        -2,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        2,
+        0,
+        0,
+        0,
+        -2,
+        0,
+        0,
+        0
+      ],
+      [
+        2,
+        0,
+        0,
+        0,
+        0,
+        -2,
+        0,
+        0
+      ],
+      [
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        -2,
+        0
+      ],
+      [
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        -2
+      ],
+      [
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        2
+      ],
+      [
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        2,
+        0
+      ],
+      [
+        2,
+        0,
+        0,
+        0,
+        0,
+        2,
+        0,
+        0
+      ],
+      [
+        2,
+        0,
+        0,
+        0,
+        2,
+        0,
+        0,
+        0
+      ],
+      [
+        2,
+        0,
+        0,
+        2,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        2,
+        0,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ],
+    "singleton": 0,
+    "stratum_coefficients": [
+      [
+        1,
+        0
+      ],
+      [
+        0,
+        1
+      ],
+      [
+        1,
+        1
+      ],
+      [
+        1,
+        -1
+      ],
+      [
+        1,
+        2
+      ]
+    ],
+    "summary": {
+      "full_deletion_min": 7,
+      "original_min": 8,
+      "pairing_checks": 655,
+      "proper_deletion_checks": 600,
+      "proper_rank_counts": {
+        "8": 384,
+        "9": 216
+      },
+      "pure_correction_min": 7
+    },
+    "supports": [
+      [
+        24,
+        25,
+        26,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111
+      ],
+      [
+        24,
+        25,
+        26,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111
+      ],
+      [
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111
+      ],
+      [
+        24,
+        25,
+        26,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99
+      ],
+      [
+        24,
+        25,
+        26,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        33,
+        34,
+        35,
+        36,
+        37,
+        38,
+        39,
+        40,
+        41,
+        42,
+        43,
+        44,
+        45,
+        46,
+        47,
+        48,
+        49,
+        50,
+        51,
+        52,
+        53,
+        54,
+        55,
+        56,
+        57,
+        58,
+        59,
+        60,
+        61,
+        62,
+        63,
+        64,
+        65,
+        66,
+        67,
+        68,
+        69,
+        70,
+        71,
+        72,
+        73,
+        74,
+        75,
+        76,
+        77,
+        78,
+        79,
+        80,
+        81,
+        82,
+        83,
+        84,
+        85,
+        86,
+        87,
+        88,
+        89,
+        90,
+        91,
+        92,
+        93,
+        94,
+        95,
+        96,
+        97,
+        98,
+        99,
+        100,
+        101,
+        102,
+        103,
+        104,
+        105,
+        106,
+        107,
+        108,
+        109,
+        110,
+        111
+      ]
+    ]
+  },
+  "fixtures": [
+    {
+      "correction_support_size": 0,
+      "matrix_entries_checked": 12544,
+      "name": "zero correction",
+      "three_costs": [
+        8,
+        8,
+        0
+      ],
+      "whole_cost": 64
+    },
+    {
+      "correction_support_size": 24,
+      "matrix_entries_checked": 12544,
+      "name": "attaining full boundary",
+      "three_costs": [
+        8,
+        8,
+        0
+      ],
+      "whole_cost": 64
+    },
+    {
+      "correction_support_size": 24,
+      "matrix_entries_checked": 12544,
+      "name": "cancellation moves the bill",
+      "three_costs": [
+        7,
+        8,
+        7
+      ],
+      "whole_cost": 70
+    },
+    {
+      "correction_support_size": 24,
+      "matrix_entries_checked": 12544,
+      "name": "arbitrary full-support phases",
+      "three_costs": [
+        8,
+        9,
+        9
+      ],
+      "whole_cost": 74
+    },
+    {
+      "correction_support_size": 23,
+      "matrix_entries_checked": 12544,
+      "name": "maximal proper support",
+      "three_costs": [
+        8,
+        9,
+        9
+      ],
+      "whole_cost": 74
+    },
+    {
+      "correction_support_size": 1,
+      "matrix_entries_checked": 12544,
+      "name": "singleton within boundary",
+      "three_costs": [
+        8,
+        9,
+        9
+      ],
+      "whole_cost": 74
+    },
+    {
+      "correction_support_size": 24,
+      "matrix_entries_checked": 12544,
+      "name": "zero singleton amplitude",
+      "three_costs": [
+        8,
+        8,
+        9
+      ],
+      "whole_cost": 73
+    },
+    {
+      "correction_support_size": 24,
+      "matrix_entries_checked": 12544,
+      "name": "complex triangular dual factors",
+      "three_costs": [
+        8,
+        9,
+        1
+      ],
+      "whole_cost": 66
+    },
+    {
+      "correction_support_size": 0,
+      "matrix_entries_checked": 12544,
+      "name": "zero u with dense mixing",
+      "three_costs": [
+        8,
+        9,
+        9
+      ],
+      "whole_cost": 74
+    }
+  ],
+  "schema_version": 1,
+  "scope": "fixed PR1375 24-row boundary, arbitrary complex amplitudes and GL(3,C)"
+}
diff --git a/research/p112-boundary24-seed39/INDEPENDENT.json b/research/p112-boundary24-seed39/INDEPENDENT.json
new file mode 100644
index 0000000000..5763c8771a
--- /dev/null
+++ b/research/p112-boundary24-seed39/INDEPENDENT.json
@@ -0,0 +1,57 @@
+{
+  "all_pairs_identity_entries": 12544,
+  "cancellation_costs": [
+    7,
+    8,
+    7
+  ],
+  "cancellation_identity_entries": 12544,
+  "controls": [
+    "omitted affine one in pairing",
+    "span-loss premise treated as preserved",
+    "corrupted restoration rank",
+    "incomplete proper-subset coverage",
+    "omitted compensation fails a constrained entry",
+    "wrong singleton breaks free support"
+  ],
+  "geometry": "direct doubled E8 roots and Gram parity; set elimination",
+  "omission_counterexample": {
+    "column": 27,
+    "missing_value": 1,
+    "row": 27
+  },
+  "pairing_checks": 655,
+  "rank_nine_completion_minors": [
+    {
+      "determinant": "16",
+      "rows": [
+        0,
+        1,
+        2,
+        4,
+        8,
+        16,
+        24,
+        27,
+        36
+      ],
+      "side": "left"
+    },
+    {
+      "determinant": "16",
+      "rows": [
+        0,
+        1,
+        2,
+        3,
+        4,
+        8,
+        16,
+        24,
+        36
+      ],
+      "side": "right"
+    }
+  ],
+  "schema_version": 1
+}
diff --git a/research/p112-boundary24-seed39/README.md b/research/p112-boundary24-seed39/README.md
new file mode 100644
index 0000000000..f3185e5e17
--- /dev/null
+++ b/research/p112-boundary24-seed39/README.md
@@ -0,0 +1,262 @@
+# The first free-compatible 24-row boundary still costs COPY64
+
+**Scoped negative result with exact finite premises; no new supplier or kappa.**
+PR [#1375](https://github.com/CrocSwap/integer-mult-bounds/pull/1375) leaves a
+concrete next question: its first free-compatible 24-row deletion lowers a
+coordinate support's binary span from eight to seven. Can that boundary reduce
+the COPY bill when the decoder factors are coupled correctly?
+
+For that exact boundary, the answer is **no**, even with arbitrary complex
+correction amplitudes, zero amplitudes, and arbitrary `GL(3,C)` mixing. The
+three replacement ranks either include two ranks at least eight, or are all
+at least seven. Their separate COPY power bill cannot improve for
+`0 < q <= 1`. Identity mixing attains the whole-decoder cost 64.
+The cancellation-aligned example lowers one term to seven but changes the
+three-term bill from `(8,8,0)` to **`(7,8,7)`**, costing 70 overall.
+
+This closes the named boundary question, not the larger-rectangle problem.
+The claim was initially for cancellation-aligned amplitudes. The survivor
+argument below handles every complex amplitude on the same support without
+searching coefficients or changing the object. The pending PR1375 theorem is
+not assumed: all finite premises used here are recomputed.
+
+## Reproduce
+
+From the repository root, Python 3.12 and the standard library:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/p112-boundary24-seed39
+```
+
+Expected final marker:
+
+```text
+PASS_REGISTERED_RESEARCH_PACKAGE research/p112-boundary24-seed39 outcome=negative-result
+```
+
+The replay checks metadata and exact source pins, then both implementations.
+`verify.py` checks 655 support pairings, nine Gaussian-rational fixtures
+(112,896 entries), and nine controls. `independent_check.py` reconstructs
+Euclidean E8 geometry without importing either the primary checker or its
+predecessor geometry, uses set-based binary elimination, rechecks every finite
+premise, and checks 25,088 integer identities, two nonzero rank-nine minors,
+and six controls. Both defaults are read-only. Explicit `--write PATH`
+regenerates a receipt; `--check PATH` checks an alternate receipt.
+
+These are finite certificates supporting the written argument below. Neither
+implementation is a proof assistant, and separate code by the same contributor
+is not independent human review. See [VALIDATION.md](VALIDATION.md) for executed
+checks and their limits.
+
+## Exact object and statement
+
+Use PR845/PR717's P112 model, pinned in [SOURCES.json](SOURCES.json). Represent
+E8 roots at twice their usual scale, choose the lexicographically larger sign
+of each line, delete the eight roots `2e_(2j) +/- 2e_(2j+1)`, and sort the
+remaining 112 lines lexicographically. Frame columns are ordered by increasing
+`j`, with the plus root before the minus root. Let
+
+`G_ij = r_i dot r_j / 4`, `X_ik = r_i dot f_k / 4`,
+
+so `XX^T = 2G`. The binary label-pairing matrix is
+`B_ij = (G_ij + 1) mod 2`. For supports `A,C`, write
+`rho(A,C) = rank_F2 B[A,C]`. A scalar rank-one term costs
+`rho(supp(d), supp(t))`; its complex coefficients are not reduced modulo two.
+This is the inherited separate-term COPY objective.
+
+Take `x = X[:,0]`, `y = X[:,1]`, singleton index `beta = 0`, and
+
+`U = {i : x_i != 0 and B_i0 = 0}`.
+
+In the specified order,
+
+```text
+U = [27,28,31,32,69,70,73,74,77,78,81,82,
+     85,86,89,90,93,94,97,98,103,104,107,108].
+```
+
+This equals PR1375's `free_boundary.deleted` exactly. Its only common odd
+neighbor is 0. Choose any `u in C^112` with `supp(u) subset U`, any
+`lambda in C`, and any invertible complex `3 x 3` matrix `M`. Set
+
+`D = [x,y,u] M`, `T = [x,y,lambda e_0] M^(-T)`.
+
+Ordinary transpose gives
+
+`D T^T = xx^T + yy^T + lambda u e_0^T`.
+
+The correction is zero on constrained entries (`B_ij = 1`). Keep the other
+six coordinate terms unchanged. All assertions include `u=0`, `lambda=0`,
+and complex cancellation.
+
+**Theorem.** For the three ranks `r_j = rho(supp(D[:,j]),supp(T[:,j]))`,
+either at least two `r_j >= 8`, or all three `r_j >= 7`. Therefore
+
+`sum_j r_j >= 16`, and `sum_j r_j^q >= 2 * 8^q` for every `0 < q <= 1`.
+
+The whole decoder costs at least 64 and has at least the original separate
+COPY power bill. `M=I` attains both bounds for every allowed `u,lambda`.
+By symmetry of `B` and ordinary transpose, the transposed family has the
+same conclusion. Other 24-row sets, coordinate pairs and larger rectangles
+are not asserted to have these premises.
+
+## Finite premises
+
+A nonzero complex combination of `x,y` has one of five supports, represented
+by `x`, `y`, `x+y`, `x-y`, and `x+2y`. This classification is exact over C:
+nonzero coordinate entries are `+/-1`, so a row with both entries nonzero can
+cancel only at ratio `+1` or `-1`; zero coefficients give the first two cases.
+Write these supports as `S_0,...,S_4`, and `C_j = S_j minus {0}`.
+
+All ordered pairings are recomputed in [CERTIFICATE.json](CERTIFICATE.json).
+The original and complete-deletion matrices, respectively, are
+
+```text
+rho(S_i,C_j)                 rho(S_i minus U,C_j)
+8 8 8 8 8                   7 7 7 7 7
+8 8 8 8 8                   8 8 8 8 8
+8 8 9 9 9                   8 8 9 9 9
+8 8 9 9 9                   8 8 9 9 9
+8 8 9 9 9                   8 8 9 9 9
+```
+
+Also `rho(U,C_j)=7` for every `j`. For each of the 24 possible restored
+indices `k in U`, the 25 entries
+
+`rho(S_i minus (U minus {k}), C_j)`
+
+are at least eight. These 600 checks comprise 384 ranks eight and 216 ranks
+nine. Checking maximal proper deletions suffices for **every** proper subset
+of U, because enlarging either support cannot decrease pairing rank. This is
+an exact monotonicity reduction, not enumeration of all `2^24` subsets.
+The total is `25 + 25 + 5 + 24*25 = 655` prescribed pairing checks, plus
+the eight unchanged coordinate baseline checks.
+
+The full ambient pairing has rank nine. The binary span of `S_0` has dimension
+eight and that of `S_0 minus U` has dimension seven. Thus the predecessor's
+span-preservation premise really fails at this boundary; the new proof must
+use the coupled factors. The independent checker computes these dimensions
+using rows of B, an injective representation of the label space because B
+has its full ambient rank nine.
+
+## Proof for all complex amplitudes and factor changes
+
+Write column `j` of `M` as `(a_j,c_j)`, with `a_j in C^2`, and column `j`
+of `N=M^(-T)` as `(b_j,d_j)`. The top-left block of `M N^T = I_3` gives
+
+`sum_j a_j b_j^T = I_2`.
+
+At least two summands therefore have both `a_j != 0` and `b_j != 0`.
+For any such term, its left support contains `S_i minus supp(u)` for some
+stratum `S_i`; its right support contains `C_l` for some stratum `S_l`.
+Outside the correction supports, no choice of amplitudes can cancel those
+entries.
+
+If `supp(u)` is a proper subset of U, choose a missing index `k in U`.
+The maximal-proper-deletion checks and support monotonicity give rank at
+least eight for each of these two terms. This proves the first alternative,
+including `u=0`.
+
+It remains to take `supp(u)=U`. Suppose some `b_j=0`. Since N is invertible,
+`d_j != 0`. The off-diagonal identities in `M^T N = I_3` force
+`c_k d_j = 0` for both `k != j`, hence `c_k=0`. Those two columns of M have
+nonzero `a_k`, and their dual columns have nonzero `b_k` (two columns of N
+cannot both be multiples of `e_3`). Their left factors are original
+nonzero combinations of x,y, with no u component. The original pairing
+matrix above gives rank at least eight for both. This is again the first
+alternative.
+
+Otherwise all three `b_j` are nonzero. If `a_j != 0`, the complete-deletion
+matrix gives rank at least seven. If `a_j=0`, invertibility of M gives
+`c_j != 0`; the left support is exactly U, and the pure-correction row
+`rho(U,C_l)=7` gives the same bound. All three ranks are therefore at least
+seven. This proves the second alternative.
+
+In the first alternative, the power bill is at least `2*8^q`. In the second,
+
+`(3*7^q)/(2*8^q) = (3/2)*(7/8)^q >= 21/16 > 1`
+
+for `0<q<=1`. Adding the six unchanged rank-eight terms proves the stated
+whole-decoder comparison. With `M=I`, the extra term has rank zero because
+`B[U,{0}]=0`, proving sharpness. No sampled coefficient set is used to
+quantify this argument over C.
+
+## A concrete failed mechanism and its complete COPY bill
+
+Set `u_i=x_i` on U and zero elsewhere, `lambda=1`, and
+
+```text
+M = [ 1 0 0 ]
+    [ 0 1 0 ]
+    [-1 0 1 ].
+```
+
+The factors are `(x-u,y,u)` and `(x,y,x+e_0)`. The first term drops from
+eight to seven, but the third now costs seven. The replacement bill is
+`7+8+7=22`, and the whole decoder costs `6*8+22=70`. Counting only the first
+two terms would falsely report 63. Omitting the compensation also fails a
+constrained matrix entry; the independent receipt records an exact example.
+
+The attaining identity fixture is a genuinely rank-nine masked completion:
+the independent receipt supplies nonzero `9 x 9` minors for `[X,u]` and
+`[X,e_0]`. Full-rank factors imply rank nine of `XX^T+u e_0^T`. This
+witness confirms the result is not restricted to rank-eight masked matrices.
+
+For the optimistic rejection screen, retain the baseline's normalization,
+width and multiplicity and grant zero additional preparation, source-access,
+frame-change, restoration, hosting and recursive overhead. Even this
+relaxation cannot improve the separate COPY bill. No helper network is
+constructed, and no new complete child histogram, moment root or kappa is
+inferred. Changed billing or savings in other parts of a supplier require
+separate accounting and are outside this result.
+
+## Provenance, coordination and limits
+
+- Base: `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`. Its selected conditional
+  kappa is `836330098538459/500000000000000000`, from PR1094. Selection and
+  `upstream/` are unchanged. The selected source manifest, construction and
+  maintainer review were consulted; the quick baseline check is source and
+  arithmetic evidence, not a selected-supplier cold replay.
+- Assignment: complex-supplier track, OS-random seed **39**, generated once.
+  Three candidates were this boundary, another A8 puncture orbit, and a
+  two-entry masked completion. `39 mod 3 = 0` selected this boundary; the seed
+  also fixes the nonreal fixture phases and the omitted boundary index.
+  [TASK.json](TASK.json) records scope, stopping rule and overlap coverage.
+- Claim: [Discussion1316](https://github.com/CrocSwap/integer-mult-bounds/discussions/1316#discussioncomment-18912070).
+  No pinned sprint issue existed. The boundary and arbitrary-amplitude proof
+  are distinct from the all-nine-factor singleton claim in Discussion1360:
+  our 24-by-one correction mixes two original modes, not all eight.
+- Predecessor: commdata2338's PR1375,
+  `4a533aff2a7a87c9b36e077a31774b332a7f64bd`, supplies the boundary and open
+  question. Arham Tahir's PR1331 supplies the earlier one-coordinate
+  obstruction and two-coordinate handoff. Neither pending theorem is a
+  proof dependency here. Exact contextual source digests are recorded.
+- Mathematical and implementation credit: Mihir Srivastava / PR845 for
+  `geometry.py`; DreamingOfClouds / PR717 and PR446/595 for the decoder and
+  separate-copy framework; themilkman216 / PR968 for the pairing-cost model;
+  Joel Pulikkan / GamingPuzzled / PR620 for the coordinate COPY64 construction;
+  woklerx / PR1077 for the orientation check. Classical E8 geometry is retained.
+- Unchecked: physical gathering, legal delivery frames and owners,
+  restoration/hosting/precision invoices, all-size compilation,
+  common-label/mutable-source realization, analytic transfer and the bit
+  H1-H5 interfaces. No complete multiplication theorem, native/Lean proof,
+  hosted-CI success or maintainer acceptance is claimed.
+
+Prepared for **Hanson Sun / bbMisk**, with substantial **OpenAI Codex**
+assistance in mathematics, implementation, verification and writing.
+Both implementations are by the same AI-assisted contributor. Apache-2.0;
+predecessor attribution and source files are preserved.
+
+## Open next questions
+
+- **Other maximal free rectangles.** Can a different 24-row boundary, or a
+  rectangle with more than one column, lower the coupled bill? First compute
+  its survivor pairings and pure-correction pairing ranks. The proof here
+  relies on the particular U and the singleton dual-column case; it does not
+  supply those premises elsewhere.
+- **More mixed coordinate terms on this same U.** Can three or more original
+  modes exploit it? Start with three specified modes and a `GL(4,C)` identity,
+  charging all four replacement terms. The present two-mode rank identity and
+  three-term power comparison do not settle that problem.
+
+The structured questions, relevance and blockers are in [TASK.json](TASK.json).
diff --git a/research/p112-boundary24-seed39/SOURCES.json b/research/p112-boundary24-seed39/SOURCES.json
new file mode 100644
index 0000000000..62325ae10a
--- /dev/null
+++ b/research/p112-boundary24-seed39/SOURCES.json
@@ -0,0 +1,48 @@
+{
+  "schema_version": 1,
+  "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "c05fafaa25ba95b2d5af86b1800427198e3d20eb",
+      "sha256": "89b5928bc92c81e2647b6d702a7ad85a6795b8f44e2eb267b2ff3145d8f2b2ce"
+    },
+    {
+      "path": "research/complex-frame-pair-decoders/PROOF.md",
+      "usage": "input",
+      "git_blob": "889f3a653ed1bdbb7df61ebe3af4f2103602a1f4",
+      "sha256": "ba53c1d8a9bc2d935d546bde46ca7341bd65f8515013e07b073296b4db2a9a74"
+    },
+    {
+      "path": "research/p112-single-lift/geometry.py",
+      "usage": "input",
+      "git_blob": "34c1abf059d7be5fe5e5044cf01a09b843071c68",
+      "sha256": "3857c11ec731a602b8059d85d58fbb3b641bab687bb33016a0e54f7567752c8a"
+    }
+  ],
+  "external_context": [
+    {
+      "pr": 1375,
+      "head": "4a533aff2a7a87c9b36e077a31774b332a7f64bd",
+      "path": "research/p112-two-coordinate-small-rectangle/README.md",
+      "git_blob": "6b1dba8894d1a743145d029e226f6e588e6d40f5",
+      "sha256": "6ee1901e6836784cb1ec93ff3cd3720a126daab357ec2af887d6390d87a4955f",
+      "usage": "context only: boundary and open question, not an assumed theorem or runtime import"
+    },
+    {
+      "pr": 1375,
+      "head": "4a533aff2a7a87c9b36e077a31774b332a7f64bd",
+      "path": "research/p112-two-coordinate-small-rectangle/CERTIFICATE.json",
+      "git_blob": "e69ad4b1123e9d4869011c1313dd2a0f7063bdb8",
+      "sha256": "977b469b8fd4ec7e3eaab4509b637f770a7696c18bf5bd925eabdcb6792fb506",
+      "usage": "context only: boundary and open question, not an assumed theorem or runtime import"
+    }
+  ]
+}
diff --git a/research/p112-boundary24-seed39/TASK.json b/research/p112-boundary24-seed39/TASK.json
new file mode 100644
index 0000000000..d7db8bc07e
--- /dev/null
+++ b/research/p112-boundary24-seed39/TASK.json
@@ -0,0 +1,123 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-masked-decoder",
+  "priority_revision": 2,
+  "base_commit": "bce54fb3f895cbe5cd4c0eb477c3afeed100190f",
+  "original_card": {
+    "id": "complex-masked-decoder",
+    "question": "Can one specified masked or overcomplete decoder improve the complete moment budget?",
+    "starting_points": [
+      "research/complex-decoder-field-extension-seed44/README.md",
+      "research/complex-frame-pair-decoders/README.md"
+    ],
+    "methods": [
+      "Synthesize a decoder with exact coefficients and fully priced helper endpoints.",
+      "Bound the best possible budget for a fixed support alphabet before synthesis."
+    ],
+    "acceptance_gate": "Change an assumption of the eight-term all-pairs bound and count all copied information, frames and restoration.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-decoder-field-extension-seed44/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_DECODER_FIELD_EXTENSION_S44",
+      "inspect": "Locate the excluded classes: masked identities, at least nine terms, and deeper punctures.",
+      "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Choose one finite support alphabet and test exact decoding constraints before building a whole network.",
+    "bottleneck_link": "A cheaper fully realized decoder could increase deficit or lower recursive cost on the binding complex side.",
+    "allowed_variations": [
+      "Select a specific masked or overcomplete family with exact labels and supports."
+    ],
+    "scope_change_triggers": [
+      "Repeating the exact eight-term all-pairs search inside its proved scope."
+    ],
+    "overlap_terms": [
+      "masked decoder",
+      "overcomplete",
+      "eight-term"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "The fixed PR1375 24-row free boundary U with singleton column 0: arbitrary complex u supported in U, arbitrary lambda, and every GL(3,C) mixing of coordinate modes 0 and 1 with the correction; transposed family included.",
+  "scope_change_reason": "This changes the predecessor support cap from at most 23 per side to its named 24-row boundary, where span preservation fails. The initial cancellation-aligned question was generalized by a survivor proof to all amplitudes on exactly the same support, not to arbitrary larger rectangles.",
+  "bottleneck_link": "A masked overcomplete decoder could reduce the binding complex supplier COPY bill. The specified first span-loss boundary cannot do so under unchanged separate-term billing, even before physical overhead.",
+  "budget_minutes": 60,
+  "stop_rule": "Complete the 655 prescribed support pairings, prove the coupled-factor cases, and check the exact attaining and cancellation fixtures; stop before physical synthesis once the favorable COPY screen fails. This is finite-premise completion supporting a quantified proof, not a failed heuristic search.",
+  "outcome": "negative-result",
+  "evidence": "README.md quantified proof; CERTIFICATE.json complete 655-pairing premise census and nine exact Gaussian-rational fixtures; INDEPENDENT.json direct-geometry/set-elimination replay and rank-nine minors.",
+  "author": "Hanson Sun / bbMisk, with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance in mathematics, code, verification and writing. Both implementations have the same AI-assisted author; no independent human review or proof-assistant verification is claimed.",
+  "open_questions": [
+    {
+      "question": "Can another maximal free rectangle lower the coupled COPY bill?",
+      "why_it_matters": "The complex primitive binds and a free-support span loss is only a necessary lead, not a gain.",
+      "first_step": "Select another exact U,V and compute survivor and pure-correction pairing matrices before attempting factor synthesis.",
+      "blocked_by": "The specific singleton dual-column argument and the 655 finite premises do not cover other rectangles."
+    },
+    {
+      "question": "Can mixing three or more original modes exploit the same fixed U?",
+      "why_it_matters": "Changing the number of coupled modes leaves the proved GL(3,C) class.",
+      "first_step": "Specify three original coordinate modes and price all four GL(4,C) replacement terms.",
+      "blocked_by": "A new support classification and coupled-factor power comparison are needed; no physical invoice is available."
+    }
+  ],
+  "assignment_seed": 39,
+  "assignment_seed_generated_at_utc": "2026-10-14T00:20:37.399346+00:00",
+  "assignment_randomness": "Python secrets.randbelow using OS randomness",
+  "candidate_tasks": [
+    "First free-compatible 24-row boundary in PR1375: cancellation-aligned correction and arbitrary GL(3,C)",
+    "A8 simplex P112 puncture outside the matching-frame orbit of PR1304",
+    "Two odd-entry rank-ten masked completions beyond singleton Discussion1360"
+  ],
+  "chosen_candidate_index": 0,
+  "seed_use": "39 mod 3 selects the first of three narrow candidates; seed 39 also selects the omitted boundary index and nonreal fixture phases. Novelty comes from the changed support domain and coupled proof, not the seed.",
+  "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1316#discussioncomment-18912070",
+  "initial_overlap": {
+    "searched_at": "2026-10-14T00:23:30.382562+00:00",
+    "open_prs": 874,
+    "discussion_records": 132,
+    "complete_pagination": true,
+    "warnings": [],
+    "closest_work": [
+      {
+        "pr": 1375,
+        "head": "4a533aff2a7a87c9b36e077a31774b332a7f64bd",
+        "distinction": "Predecessor excludes nonzero supports through size 23 and explicitly leaves this 24-row boundary open."
+      },
+      {
+        "pr": 1331,
+        "head": "f08b698cc2bd74e2425486728a008e531fc35f0e",
+        "distinction": "One mixed coordinate with arbitrary free rectangles; provides the two-coordinate handoff."
+      },
+      {
+        "discussion": 1360,
+        "distinction": "All nine factors of a singleton-by-singleton completion; our correction is 24-by-one but only two original modes mix."
+      }
+    ],
+    "limits": "Open PR titles/bodies and discussions/comments/replies, plus local package notes and ledger; not all code diffs or arbitrary closed PRs."
+  },
+  "final_overlap": {
+    "searched_at": "2026-10-14T00:40:36.971874+00:00",
+    "coverage": {
+      "open_prs": {
+        "fetched_at": "2026-10-14T00:40:14.377597+00:00",
+        "complete_pagination": true,
+        "records": 788
+      },
+      "discussions": {
+        "fetched_at": "2026-10-14T00:40:36.924873+00:00",
+        "complete_pagination": true,
+        "records": 146
+      }
+    },
+    "warnings": [],
+    "finding": "No competing result found on the exact fixed boundary. PR1375 still leaves it open. Discussion1163 comment18911792 lists the boundary as a candidate but explicitly chooses another investigation. This claim is the only matching active exact-boundary investigation observed.",
+    "limits": "Remote PR scope is open PRs including drafts. Closed work is searched through local READMEs, TASK metadata and ledger only. No code diffs or arbitrary package files are searched. Recheck relevant heads before submission."
+  },
+  "integration_snapshot": {
+    "head": "410026dc5513b87db92ae98571d1d5984c69a983",
+    "result": "All four pinned main-tree files are unchanged and the new package path is absent on this head; original base remains pinned."
+  }
+}
diff --git a/research/p112-boundary24-seed39/VALIDATION.md b/research/p112-boundary24-seed39/VALIDATION.md
new file mode 100644
index 0000000000..9c26d2b629
--- /dev/null
+++ b/research/p112-boundary24-seed39/VALIDATION.md
@@ -0,0 +1,83 @@
+# Validation of the fixed-boundary result
+
+Executed locally on 2026-10-14 UTC (October 13 in America/New_York), with
+CPython 3.12.13 on macOS 27.0.1 arm64. No third-party packages are required.
+The base is `bce54fb3f895cbe5cd4c0eb477c3afeed100190f`.
+
+## Executed checks
+
+```sh
+python3.12 -B scripts/research_package.py --package research/p112-boundary24-seed39
+python3.12 -I -O -B research/p112-boundary24-seed39/verify.py
+python3.12 -I -O -B research/p112-boundary24-seed39/independent_check.py
+python3.12 -B -m unittest discover -s tests -p 'test_research_*.py'
+python3 -B scripts/verify_selected_result.py
+```
+
+All pass. The registered replay validates the metadata, source Git blobs and
+SHA256 pins, then executes both mathematical checks. The workflow suite runs
+20 tests, with no skips. The selected-record check confirms its original
+source inventory and proof supplements; it is not a supplier cold replay.
+The task card's first working example, `research/complex-decoder-field-extension-seed44/verify.py`,
+also passes (25 attainments, 14,400 pairing entries, seven controls).
+
+Primary receipt:
+
+```text
+PASS_P112_BOUNDARY24_S39 pairings=655 proper_deletions=24 fixtures=9 entries=112896 controls=9 copy_floor=64
+```
+
+Separate direct-geometry receipt:
+
+```text
+PASS_P112_BOUNDARY24_INDEPENDENT pairings=655 identities=25088 rank9_minors=2 controls=6 copy_floor=64
+```
+
+The finite data show the boundary's span change `8 -> 7`, all 600 maximal
+proper-deletion ranks (384 eight, 216 nine), and the fully coupled cancellation
+profile `(7,8,7)`. Nonzero minors of determinant 16 certify both nine-column
+factors of the rank-nine attaining completion. These support the scoped
+written proof; they do not formalize its quantified complex argument.
+
+## Additional delivery checks
+
+Both mathematical commands pass under `-I -O -B` from a minimal relocated
+export with its package and two pinned live inputs, from an unrelated working
+directory. Files and directories were set read-only, and content digests were
+unchanged after both commands. This checks path portability and avoids relying
+on removable Python assertions.
+
+Five separate subprocesses exit nonzero for the intended reason:
+
+1. Changed restoration rank: primary receipt comparison rejects it.
+2. The same changed rank: independent finite-premise comparison rejects it.
+3. Missing matrix fixture: primary full-receipt comparison rejects it.
+4. Changed rank-nine minor: independent receipt comparison rejects it.
+5. Changed geometry source bytes: primary source preflight rejects them before
+   import. Only the disposable export was changed and it was restored exactly.
+
+These supplement the 15 in-package controls, which include wrong pairing
+parity, inverse/transpose mistakes, conjugation, singular factor changes,
+nonfree support, and omitted required compensation. The two mathematical
+implementations share the same contributor; no human peer review is claimed.
+
+## Evidence boundary
+
+No selected cold replay (`make frontier1094-verify`), native compiler, Lean
+build, hosted CI, full supplier invoice or all-size multiplication theorem
+was run or established. This package does not modify the selected frontier,
+predecessor packages, frozen evidence or `upstream/`.
+
+The final live overlap snapshot at 00:40:36 UTC completely paginated 788 open
+PRs and 146 discussion records, without warnings. PR1375's source head was
+rechecked. The exact boundary remained its explicit next question; another
+agent mentioned it among candidates but chose a different task. Source scans
+are overlap evidence with the limitations recorded in TASK.json, not a proof
+of universal novelty.
+
+Hanson Sun / bbMisk; substantial OpenAI Codex assistance. Apache-2.0.
+
+Concurrent-main check: `410026dc5513b87db92ae98571d1d5984c69a983` retains
+all four pinned main-tree blobs, including both live inputs and the selected
+record. The new package path is absent there; the original research base is
+retained.
diff --git a/research/p112-boundary24-seed39/VERIFY.json b/research/p112-boundary24-seed39/VERIFY.json
new file mode 100644
index 0000000000..c2f16915cd
--- /dev/null
+++ b/research/p112-boundary24-seed39/VERIFY.json
@@ -0,0 +1,32 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/complex-frame-pair-decoders/PROOF.md",
+    "research/p112-single-lift/geometry.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "655 exact pairing premises, nine Gaussian-rational all-entry fixtures, source bindings and nine controls"
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/independent_check.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Independent direct E8 geometry, set-based binary ranks, complete finite receipt, rank-nine minors, compensation identity and six controls"
+    }
+  ]
+}
diff --git a/research/p112-boundary24-seed39/independent_check.py b/research/p112-boundary24-seed39/independent_check.py
new file mode 100644
index 0000000000..3c09f10a60
--- /dev/null
+++ b/research/p112-boundary24-seed39/independent_check.py
@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+"""Rebuild the boundary directly from Euclidean roots and set-based F2 rows.
+
+Imports neither verify.py nor predecessor code. Hanson Sun / bbMisk, with
+substantial OpenAI Codex assistance. Apache-2.0. Same author, not human review.
+"""
+import argparse
+from collections import Counter
+from copy import deepcopy
+from fractions import Fraction
+from itertools import combinations, product
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+
+
+def check(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def binary_rank(rows):
+    # Sets of column indices, smallest pivot, symmetric difference.
+    basis = {}
+    for original in rows:
+        row = set(original)
+        while row:
+            pivot = min(row)
+            if pivot not in basis:
+                basis[pivot] = row
+                break
+            row.symmetric_difference_update(basis[pivot])
+    return len(basis)
+
+
+def rational_basis(matrix):
+    echelon = {}
+    indices = []
+    for i, original in enumerate(matrix):
+        row = list(map(Fraction, original))
+        for p, old in sorted(echelon.items()):
+            scale = row[p]
+            row = [v - scale * w for v, w in zip(row, old)]
+        p = next((j for j, v in enumerate(row) if v), None)
+        if p is not None:
+            echelon[p] = [v / row[p] for v in row]
+            indices.append(i)
+    return indices
+
+
+def determinant(matrix):
+    a = [list(map(Fraction, row)) for row in matrix]
+    result = Fraction(1)
+    for k in range(len(a)):
+        p = next((j for j in range(k, len(a)) if a[j][k]), None)
+        if p is None:
+            return Fraction(0)
+        if p != k:
+            a[k], a[p] = a[p], a[k]
+            result = -result
+        scale = a[k][k]
+        result *= scale
+        for j in range(k + 1, len(a)):
+            weight = a[j][k] / scale
+            a[j] = [v - weight * w for v, w in zip(a[j], a[k])]
+    return result
+
+
+def build():
+    lines = set()
+    for i, j in combinations(range(8), 2):
+        for si, sj in product((-2, 2), repeat=2):
+            r = [0] * 8
+            r[i], r[j] = si, sj
+            lines.add(max(tuple(r), tuple(-v for v in r)))
+    for r in product((-1, 1), repeat=8):
+        if sum(v < 0 for v in r) % 2 == 0:
+            lines.add(max(r, tuple(-v for v in r)))
+    check(len(lines) == 120, 'E8 line count')
+    frame = []
+    for k in range(0, 8, 2):
+        for sign in (1, -1):
+            r = [0] * 8
+            r[k], r[k + 1] = 2, 2 * sign
+            frame.append(tuple(r))
+    roots = sorted(lines.difference(frame))
+    dot = lambda r, s: sum(a * b for a, b in zip(r, s))
+    check(len(roots) == 112, 'punctured line count')
+    check(all(dot(r, s) % 4 == 0 for r in roots for s in roots), 'integral Gram')
+    x = [[dot(r, f) // 4 for f in frame] for r in roots]
+    gram = [[dot(r, s) // 4 for s in roots] for r in roots]
+    b = [{j for j, v in enumerate(row) if (v + 1) % 2} for row in gram]
+    check(binary_rank(b) == 9, 'affine pairing rank nine')
+    check(all(sum(a * c for a, c in zip(x[i], x[j])) == 2 * gram[i][j]
+              for i in range(112) for j in range(112)), 'all 12544 coordinate identities')
+    return roots, x, b, gram
+
+
+def reconstruct(roots, x, b):
+    rho = lambda s, t: binary_rank(b[i].intersection(t) for i in s)
+    coeffs = [(1, 0), (0, 1), (1, 1), (1, -1), (1, 2)]
+    support = [[i for i, r in enumerate(x) if a * r[0] + c * r[1]] for a, c in coeffs]
+    columns = [[j for j in s if j != 0] for s in support]
+    u = sorted(i for i in support[0] if 0 not in b[i])
+    check(len(u) == 24, '24-row boundary')
+    common = [j for j in range(112) if all(j not in b[i] for i in u)]
+    check(common == [0], 'unique odd neighbor')
+    original = [[rho(s, t) for t in columns] for s in support]
+    surviving = [[i for i in s if i not in u] for s in support]
+    full = [[rho(s, t) for t in columns] for s in surviving]
+    pure = [rho(u, t) for t in columns]
+    proper = []
+    for kept in u:
+        erased = set(u).difference({kept})
+        matrix = [[rho(set(s).difference(erased), t) for t in columns] for s in support]
+        check(min(v for row in matrix for v in row) == 8, 'proper deletion minimum')
+        proper.append({'restored_index': kept, 'ranks': matrix})
+    check(min(v for row in original for v in row) == 8, 'original minimum')
+    check(min(v for row in full for v in row) == 7 and pure == [7] * 5, 'full boundary minimum')
+    counts = Counter(v for item in proper for row in item['ranks'] for v in row)
+    coordinates = [rho([i for i in range(112) if x[i][k]],
+                       [i for i in range(112) if x[i][k]]) for k in range(8)]
+    check(coordinates == [8] * 8, 'baseline eight-by-eight')
+    return {
+        'root_order': 'lexicographic positive-first doubled E8 roots',
+        'roots': [list(r) for r in roots], 'coordinate_pair': [0, 1], 'singleton': 0,
+        'boundary': u, 'common_odd_neighbors': common,
+        'stratum_coefficients': [list(c) for c in coeffs],
+        'supports': support, 'right_survivors': columns,
+        'original_ranks': original, 'full_deletion_ranks': full,
+        'pure_correction_ranks': pure, 'proper_deletions': proper,
+        'coordinate_costs': coordinates,
+        'boundary_spans': {'before': binary_rank(b[i] for i in support[0]),
+                          'after': binary_rank(b[i] for i in surviving[0])},
+        'summary': {'pairing_checks': 655, 'original_min': 8,
+                    'full_deletion_min': 7, 'pure_correction_min': 7,
+                    'proper_deletion_checks': 600,
+                    'proper_rank_counts': {str(k): v for k, v in sorted(counts.items())}},
+    }
+
+
+def expect_rejection(call, message):
+    try:
+        call()
+    except ValueError as e:
+        check(message in str(e), 'unexpected negative-control failure')
+        return
+    raise ValueError('negative control accepted: ' + message)
+
+
+def extra_checks(x, b, gram, finite):
+    u_set = set(finite['boundary'])
+    u = [row[0] if i in u_set else 0 for i, row in enumerate(x)]
+    left = [row + [u[i]] for i, row in enumerate(x)]
+    right = [row + [int(i == 0)] for i, row in enumerate(x)]
+    minors = []
+    for side, matrix in [('left', left), ('right', right)]:
+        indices = rational_basis(matrix)
+        check(len(indices) == 9, 'rank-nine completion factors')
+        det = determinant([matrix[i] for i in indices])
+        check(det != 0, 'rank-nine witness minor')
+        minors.append({'side': side, 'rows': indices, 'determinant': str(det)})
+    # Integer recheck of the cancellation fixture, including constrained entries.
+    d = [[r[0] - u[i], r[1], u[i]] for i, r in enumerate(x)]
+    t = [[r[0], r[1], r[0] + int(i == 0)] for i, r in enumerate(x)]
+    check(all(sum(a * c for a, c in zip(d[i], t[j])) ==
+              x[i][0] * x[j][0] + x[i][1] * x[j][1] + u[i] * int(j == 0)
+              for i in range(112) for j in range(112)), 'integer cancellation identity')
+    costs = [binary_rank(b[i].intersection(j for j in range(112) if t[j][k])
+                        for i in range(112) if d[i][k]) for k in range(3)]
+    check(costs == [7, 8, 7], 'coupled cancellation bill')
+    bad_entry = next((i, j) for i in range(112) for j in range(112)
+                     if j in b[i] and u[i] * t[j][2])
+    controls = []
+    wrong = [{j for j, v in enumerate(row) if v % 2} for row in gram]
+    expect_rejection(lambda: check(binary_rank(wrong) == 9, 'affine label offset'), 'affine label offset')
+    controls.append('omitted affine one in pairing')
+    expect_rejection(lambda: check(finite['boundary_spans']['after'] == 8, 'false span preservation'),
+                     'false span preservation')
+    controls.append('span-loss premise treated as preserved')
+    changed = deepcopy(finite)
+    changed['proper_deletions'][0]['ranks'][0][0] -= 1
+    expect_rejection(lambda: check(changed == finite, 'full finite receipt'), 'full finite receipt')
+    controls.append('corrupted restoration rank')
+    changed = deepcopy(finite)
+    changed['proper_deletions'].pop()
+    expect_rejection(lambda: check(changed == finite, 'full finite receipt'), 'full finite receipt')
+    controls.append('incomplete proper-subset coverage')
+    i, j = bad_entry
+    expect_rejection(lambda: check(u[i] * t[j][2] == 0, 'omitted required term'), 'omitted required term')
+    controls.append('omitted compensation fails a constrained entry')
+    bad = next(j for j in range(112) if any(j in b[i] for i in u_set))
+    expect_rejection(lambda: check(all(bad not in b[i] for i in u_set), 'free support'), 'free support')
+    controls.append('wrong singleton breaks free support')
+    return {'schema_version': 1, 'geometry': 'direct doubled E8 roots and Gram parity; set elimination',
+            'pairing_checks': 655, 'all_pairs_identity_entries': 12544,
+            'cancellation_identity_entries': 12544, 'cancellation_costs': costs,
+            'omission_counterexample': {'row': i, 'column': j, 'missing_value': u[i] * t[j][2]},
+            'rank_nine_completion_minors': minors, 'controls': controls}
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--certificate', type=Path, default=HERE / 'CERTIFICATE.json')
+    parser.add_argument('--check', type=Path, default=HERE / 'INDEPENDENT.json')
+    parser.add_argument('--write', type=Path)
+    args = parser.parse_args()
+    roots, x, b, gram = build()
+    finite = reconstruct(roots, x, b)
+    check(finite == json.loads(args.certificate.read_text())['finite_premises'], 'full finite receipt')
+    actual = extra_checks(x, b, gram, finite)
+    if args.write:
+        args.write.write_text(json.dumps(actual, indent=2, sort_keys=True) + '\n')
+    else:
+        check(actual == json.loads(args.check.read_text()), 'independent receipt equality')
+    print('PASS_P112_BOUNDARY24_INDEPENDENT pairings=655 identities=25088 '
+          'rank9_minors=2 controls=6 copy_floor=64')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/p112-boundary24-seed39/verify.py b/research/p112-boundary24-seed39/verify.py
new file mode 100644
index 0000000000..b86908b36f
--- /dev/null
+++ b/research/p112-boundary24-seed39/verify.py
@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+"""Exact premises and fixtures; the quantified proof is in README.md.
+
+Hanson Sun / bbMisk, substantial OpenAI Codex assistance. Apache-2.0.
+"""
+import argparse
+from collections import Counter
+from copy import deepcopy
+from fractions import Fraction as F
+import hashlib
+import importlib.util
+import json
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+INPUTS = {'research/p112-single-lift/geometry.py',
+          'research/complex-frame-pair-decoders/PROOF.md'}
+STRATA = ((1, 0), (0, 1), (1, 1), (1, -1), (1, 2))
+EXPECTED_U = (27, 28, 31, 32, 69, 70, 73, 74, 77, 78, 81, 82,
+              85, 86, 89, 90, 93, 94, 97, 98, 103, 104, 107, 108)
+
+
+def require(ok, message):
+    if not ok:
+        raise ValueError(message)
+
+
+def check_sources(sources):
+    rows = [r for r in sources['files'] if r['usage'] == 'input']
+    require(len(rows) == len(INPUTS) and {r['path'] for r in rows} == INPUTS,
+            'complete input inventory')
+    for row in rows:
+        require(hashlib.sha256((ROOT / row['path']).read_bytes()).hexdigest()
+                == row['sha256'], 'source digest: ' + row['path'])
+
+
+def rank(rows):
+    pivots = {}
+    for v in rows:
+        while v:
+            p = v.bit_length() - 1
+            if p in pivots:
+                v ^= pivots[p]
+            else:
+                pivots[p] = v
+                break
+    return len(pivots)
+
+
+def cost(pairing, left, right):
+    mask = sum(1 << j for j in right)
+    return rank(pairing[i] & mask for i in left)
+
+
+def model():
+    spec = importlib.util.spec_from_file_location(
+        'pinned_p112_geometry', ROOT / 'research/p112-single-lift/geometry.py')
+    geometry = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(geometry)
+    data = geometry.build()
+    geometry.check_geometry(data)
+    order = sorted(range(112), key=lambda i: max(tuple(data['roots'][i]),
+                              tuple(-v for v in data['roots'][i])))
+    roots, x, labels, duals = [], [], [], []
+    for i in order:
+        r = data['roots'][i]
+        canonical = max(tuple(r), tuple(-v for v in r))
+        sign = 1 if tuple(r) == canonical else -1
+        roots.append(list(canonical))
+        x.append([sign * v for v in data['X'][i]])
+        labels.append(data['labels'][i])
+        duals.append(data['duals'][i])
+    pairing = [sum(((d & label).bit_count() % 2) << j
+                   for j, label in enumerate(labels)) for d in duals]
+    require(rank(pairing) == 9, 'ambient pairing rank')
+    return roots, x, pairing
+
+
+def finite_premises(roots, x, pairing):
+    u_set = [i for i, row in enumerate(x) if row[0] and not (pairing[i] & 1)]
+    require(tuple(u_set) == EXPECTED_U, 'canonical PR1375 boundary')
+    neighbors = [j for j in range(112)
+                 if all(not (pairing[i] >> j & 1) for i in u_set)]
+    require(neighbors == [0], 'common odd neighbor')
+    supports = [[i for i, row in enumerate(x) if a * row[0] + b * row[1]]
+                for a, b in STRATA]
+    columns = [[i for i in s if i != 0] for s in supports]
+    surviving = [[i for i in s if i not in u_set] for s in supports]
+    original = [[cost(pairing, s, c) for c in columns] for s in supports]
+    full = [[cost(pairing, s, c) for c in columns] for s in surviving]
+    pure = [cost(pairing, u_set, c) for c in columns]
+    proper = [{'restored_index': k,
+               'ranks': [[cost(pairing, [i for i in s if i not in u_set or i == k], c)
+                          for c in columns] for s in supports]}
+              for k in u_set]
+    require(min(v for row in original for v in row) == 8, 'original floor eight')
+    require(min(v for row in full for v in row) == 7, 'full-deletion floor seven')
+    require(pure == [7] * 5, 'pure-correction floor seven')
+    require(min(v for p in proper for row in p['ranks'] for v in row) == 8,
+            'every maximal proper deletion restores floor eight')
+    coordinate_costs = [cost(pairing, [i for i in range(112) if x[i][k]],
+                            [i for i in range(112) if x[i][k]]) for k in range(8)]
+    require(coordinate_costs == [8] * 8, 'coordinate COPY baseline')
+    before = rank(pairing[i] for i in supports[0])
+    after = rank(pairing[i] for i in surviving[0])
+    require((before, after) == (8, 7), 'genuine boundary span loss')
+    counts = Counter(v for p in proper for row in p['ranks'] for v in row)
+    return {
+        'root_order': 'lexicographic positive-first doubled E8 roots',
+        'roots': roots, 'coordinate_pair': [0, 1], 'singleton': 0,
+        'boundary': u_set, 'common_odd_neighbors': neighbors,
+        'stratum_coefficients': [list(s) for s in STRATA],
+        'supports': supports, 'right_survivors': columns,
+        'original_ranks': original, 'full_deletion_ranks': full,
+        'pure_correction_ranks': pure, 'proper_deletions': proper,
+        'coordinate_costs': coordinate_costs,
+        'boundary_spans': {'before': before, 'after': after},
+        'summary': {'pairing_checks': 655, 'original_min': 8,
+                    'full_deletion_min': 7, 'pure_correction_min': 7,
+                    'proper_deletion_checks': 600,
+                    'proper_rank_counts': {str(k): v for k, v in sorted(counts.items())}},
+    }
+
+
+# Gaussian rationals, with ordinary transpose and no floating point.
+def q(x=0, y=0):
+    return (F(x), F(y))
+
+
+def add(z, w):
+    return (z[0] + w[0], z[1] + w[1])
+
+
+def neg(z):
+    return (-z[0], -z[1])
+
+
+def mul(z, w):
+    return (z[0] * w[0] - z[1] * w[1], z[0] * w[1] + z[1] * w[0])
+
+
+def inv(z):
+    d = z[0] ** 2 + z[1] ** 2
+    require(d != 0, 'nonzero scalar inverse')
+    return (z[0] / d, -z[1] / d)
+
+
+def total(values):
+    value = q()
+    for v in values:
+        value = add(value, v)
+    return value
+
+
+def inverse(matrix):
+    n = len(matrix)
+    a = [row[:] + [q(i == j) for j in range(n)] for i, row in enumerate(matrix)]
+    for j in range(n):
+        p = next((i for i in range(j, n) if a[i][j] != q()), None)
+        require(p is not None, 'invertible factor change')
+        a[j], a[p] = a[p], a[j]
+        scale = inv(a[j][j])
+        a[j] = [mul(v, scale) for v in a[j]]
+        for i in range(n):
+            if i != j:
+                scale = a[i][j]
+                a[i] = [add(v, neg(mul(scale, w))) for v, w in zip(a[i], a[j])]
+    return [row[n:] for row in a]
+
+
+def factors(x, u, lam, matrix, wrong_transpose=False):
+    mi = inverse(matrix)
+    left = [[q(row[0]), q(row[1]), u[i]] for i, row in enumerate(x)]
+    right = [[q(row[0]), q(row[1]), lam if i == 0 else q()]
+             for i, row in enumerate(x)]
+    d = [[total(mul(row[k], matrix[k][j]) for k in range(3)) for j in range(3)]
+         for row in left]
+    t = [[total(mul(row[k], mi[k][j] if wrong_transpose else mi[j][k])
+                for k in range(3)) for j in range(3)] for row in right]
+    return d, t
+
+
+def validate_factors(x, u, lam, d, t, conjugate=False):
+    for i in range(112):
+        for j in range(112):
+            actual = total(mul(d[i][k], (t[j][k][0], -t[j][k][1])
+                               if conjugate else t[j][k]) for k in range(3))
+            expected = q(x[i][0] * x[j][0] + x[i][1] * x[j][1])
+            if j == 0:
+                expected = add(expected, mul(u[i], lam))
+            require(actual == expected, 'three-term matrix identity')
+
+
+def factor_costs(pairing, d, t):
+    return [cost(pairing, [i for i in range(112) if d[i][k] != q()],
+                 [j for j in range(112) if t[j][k] != q()]) for k in range(3)]
+
+
+def rejected(call, text):
+    try:
+        call()
+    except ValueError as e:
+        require(text in str(e), 'unexpected failure: ' + str(e))
+        return
+    raise ValueError('negative control accepted: ' + text)
+
+
+def fixtures_and_controls(x, pairing, finite, sources):
+    one, zero, imag = q(1), q(), q(0, 1)
+    identity = [[q(i == j) for j in range(3)] for i in range(3)]
+    cancellation = [[one, zero, zero], [zero, one, zero], [q(-1), zero, one]]
+    dense = [[one, one, one], [zero, one, imag], [one, zero, one]]
+    shear = [[one, q(1, 1), zero], [zero, one, q(0, -1)], [zero, zero, one]]
+    full = [q(row[0]) if i in EXPECTED_U else zero for i, row in enumerate(x)]
+    varied = [zero] * 112
+    for n, i in enumerate(EXPECTED_U):
+        varied[i] = (one, imag, q(1, 1), q(2, -1))[(n + 39) % 4]
+    proper = varied[:]
+    proper[EXPECTED_U[39 % 24]] = zero
+    singleton = [zero] * 112
+    singleton[EXPECTED_U[39 % 24]] = q(1, 1)
+    cases = [('zero correction', [zero] * 112, one, identity),
+             ('attaining full boundary', full, one, identity),
+             ('cancellation moves the bill', full, one, cancellation),
+             ('arbitrary full-support phases', varied, imag, dense),
+             ('maximal proper support', proper, q(2, -1), dense),
+             ('singleton within boundary', singleton, imag, dense),
+             ('zero singleton amplitude', full, zero, dense),
+             ('complex triangular dual factors', varied, imag, shear),
+             ('zero u with dense mixing', [zero] * 112, imag, dense)]
+    fixtures = []
+    for name, u, lam, m in cases:
+        d, t = factors(x, u, lam, m)
+        validate_factors(x, u, lam, d, t)
+        ranks = factor_costs(pairing, d, t)
+        require(sum(r >= 8 for r in ranks) >= 2 or min(ranks) >= 7,
+                'proved rank-profile disjunction')
+        fixtures.append({'name': name, 'correction_support_size': sum(v != zero for v in u),
+                         'three_costs': ranks, 'whole_cost': 48 + sum(ranks),
+                         'matrix_entries_checked': 112 * 112})
+    require(fixtures[1]['three_costs'] == [8, 8, 0], 'sharp attainment')
+    require(fixtures[2]['three_costs'] == [7, 8, 7], 'cost of coupled cancellation')
+    controls = []
+    broken = deepcopy(sources)
+    next(r for r in broken['files'] if r['usage'] == 'input')['sha256'] = '0' * 64
+    rejected(lambda: check_sources(broken), 'source digest')
+    controls.append('source digest mutation')
+    broken = deepcopy(sources)
+    broken['files'] = [r for r in broken['files'] if r['path'] != sorted(INPUTS)[0]]
+    rejected(lambda: check_sources(broken), 'complete input inventory')
+    controls.append('missing proof-relevant source')
+    rejected(lambda: require(finite['boundary_spans']['after'] == 8,
+                             'false 24-row span preservation'), 'false 24-row span preservation')
+    controls.append('false extension of predecessor span premise')
+    bad_neighbor = next(j for j in range(112)
+                        if any(pairing[i] >> j & 1 for i in EXPECTED_U))
+    rejected(lambda: require(all(not (pairing[i] >> bad_neighbor & 1) for i in EXPECTED_U),
+                             'free rectangle'), 'free rectangle')
+    controls.append('nonfree singleton column')
+    d, t = factors(x, varied, imag, dense, wrong_transpose=True)
+    rejected(lambda: validate_factors(x, varied, imag, d, t), 'matrix identity')
+    controls.append('inverse used without transpose')
+    d, t = factors(x, varied, imag, dense)
+    rejected(lambda: validate_factors(x, varied, imag, d, t, conjugate=True), 'matrix identity')
+    controls.append('conjugate instead of ordinary transpose')
+    d, t = factors(x, full, one, cancellation)
+    for row in d:
+        row[2] = zero
+    rejected(lambda: validate_factors(x, full, one, d, t), 'matrix identity')
+    controls.append('omitted compensation term behind apparent 15-cost pair')
+    rejected(lambda: inverse([[one] * 3 for _ in range(3)]), 'invertible factor change')
+    controls.append('singular factor change')
+    return fixtures, controls
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--write', type=Path, help='explicitly write a newly computed receipt')
+    parser.add_argument('--check', type=Path, default=HERE / 'CERTIFICATE.json')
+    args = parser.parse_args()
+    sources = json.loads((HERE / 'SOURCES.json').read_text())
+    check_sources(sources)
+    roots, x, pairing = model()
+    finite = finite_premises(roots, x, pairing)
+    fixtures, controls = fixtures_and_controls(x, pairing, finite, sources)
+    actual = {'schema_version': 1,
+              'scope': 'fixed PR1375 24-row boundary, arbitrary complex amplitudes and GL(3,C)',
+              'finite_premises': finite, 'fixtures': fixtures, 'controls': controls}
+    changed = deepcopy(actual)
+    changed['finite_premises']['proper_deletions'][0]['ranks'][0][0] -= 1
+    rejected(lambda: require(changed == actual, 'complete receipt equality'), 'complete receipt equality')
+    actual['controls'].append('corrupted finite-premise receipt')
+    if args.write:
+        args.write.write_text(json.dumps(actual, indent=2, sort_keys=True) + '\n')
+    else:
+        require(json.loads(args.check.read_text()) == actual, 'complete receipt equality')
+    print('PASS_P112_BOUNDARY24_S39 pairings=655 proper_deletions=24 fixtures=9 '
+          'entries=112896 controls=9 copy_floor=64')
+
+
+if __name__ == '__main__':
+    main()