diff --git a/.github/workflows/root-star-integer-cover.yml b/.github/workflows/root-star-integer-cover.yml new file mode 100644 index 0000000000..2ac894536b --- /dev/null +++ b/.github/workflows/root-star-integer-cover.yml @@ -0,0 +1,29 @@ +name: P112 root-star integer cover +on: + pull_request: + paths: + - 'research/root-star-integer-cover-seed46/**' + - '.github/workflows/root-star-integer-cover.yml' + push: + branches: [main] + paths: + - 'research/root-star-integer-cover-seed46/**' + - '.github/workflows/root-star-integer-cover.yml' + workflow_dispatch: +permissions: + contents: read +jobs: + verify: + runs-on: ubuntu-24.04 + timeout-minutes: 10 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 + with: + python-version: '3.12' + - name: Both exact implementations and failure controls + run: python -I -O -B research/root-star-integer-cover-seed46/test_package.py + - name: Committed artifacts remain unchanged + run: git diff --exit-code diff --git a/research/root-star-integer-cover-seed46/CERTIFICATE.json b/research/root-star-integer-cover-seed46/CERTIFICATE.json new file mode 100644 index 0000000000..9eca2c6652 --- /dev/null +++ b/research/root-star-integer-cover-seed46/CERTIFICATE.json @@ -0,0 +1,542 @@ +{ + "atoms": { + "ordered_pairs": 57600, + "pair_rank_encoding": "240 rows of 240 single-digit exact F2 ranks, support index 2*normal+trimmed", + "pair_rank_rows": [ + "888887878787888787878788888887878787888888888887878787888888888888888787878788888888878788888888878788888787878788888888878787878888878788888888878788888787878788888787888888888787878788888888878788888787878788888888888888878787878888888888", + "888887878787888787878788888887878787888888888887878787888888888888888787878788888888878788888888878788888787878788888888878787878888878788888888878788888787878788888787888888888787878788888888878788888787878788888888888888878787878888888888", + "888887878787888787878788888887878787888888888887878787888888888888888787878788888888888887878787888887878888888887878787888888888787888887878787888887878888888887878888878787878888888887878787888887878888888887878888888888878787878888888888", + "888887878787888787878788888887878787888888888887878787888888888888888787878788888888888887878787888887878888888887878787888888888787888887878787888887878888888887878888878787878888888887878787888887878888888887878888888888878787878888888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788778788888777888787888887878888888787888887878888888888878788888787888888888787888887878888878788888787888887878888878788888787888887878888878788888787888887878888878788888787888887878888878788888787888888888887878888878788888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887778887878877888788878788878888888788878788878888888888878887878887888888878887888887888788878887878887888887888787888788878887888887888788878887878887888788878888878887878887888887888788878887878887888888888887888787888788888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887778887878877888788878788878888888788878788878888888888878887878887888888888788878788878887888788888788878788878888878887888788878788878887888788888788878887888787888788888788878788878887888788888788878888888887888787888788888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788778788888777888787888887878888888787888887878888888888878788888787888888878888878788888787888887878888878788888787888887878888878788888787888887878888878788888787888887878888878788888787888887878888878888888887878888878788888888", + "888887878787888787878788878788888888878788878788888888878788888887878888888887878888888887878787888888888787878788888888878787878888888887878787888888888787878788888888878787878888888887878787888888888787878788888888888787888888888787888888", + "888887878787888787878788878788888888878788878788888888878788888887878888888887878888888887878787888888888787878788888888878787878888888887878787888888888787878788888888878787878888888887878787888888888787878788888888888787888888888787888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887778887878877878887888887888788878887888887888788888887888788888788878888888788878788878888878887878887888887888787888788888788878788878888878887878887888887888787888788888788878788878888878887878887888888888788878888878887888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788778788888777878888878788888788878888878788888788888887888887878888878888878888878788888788878788888787888887878888878788878888878788888788878788888787888788888787888887878888878788888788878788888787888888888788888787888887888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788778788888777878888878788888788878888878788888788888887888887878888878888888787888887878887888887878888878788888787888887888787888887878887888887878888878887878888878788888787888887878887888887878888878888888788888787888887888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887778887878877878887888887888788878887888887888788888887888788888788878888878887888887888787888788888788878788878888878887878887888887888787888788888788878788878888878887878887888887888787888788888788878888888788878888878887888888", + "888887878787888787878788878788888888878788878788888888878788888887878888888887878888878788888888878787878888888887878787888888888787878788888888878787878888888887878787888888888787878788888888878787878888888887878888888787888888888787888888", + "888887878787888787878788878788888888878788878788888888878788888887878888888887878888878788888888878787878888888887878787888888888787878788888888878787878888888887878787888888888787878788888888878787878888888887878888888787888888888787888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888778787878777888787878787878877878888888888888777888787888888888888878788888888888787878787878787888888888888888887878787878787878888888888888888878787878787878788888888888888888787878787878787888888888888878788888888888887878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888887878787778888888877878887878787888777888788888888878877888788878888888887888788888887878888878787878888878788888888878788888787878788888787888888888787888887878787888887878888888887878888878787878888878788888888878887888888888788878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887888788888788878788878788878777888887888887888877888788888788888788888788888788878887888787888788878887888887888788878887878887888788878888878887888788878788878887888788888788878887888787888788878887888888878888878888878888878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788888887878888878787888887878777888888878788888877888788888887878888888788878888878887878887888887888787888887878887888887888787888788888788878788878888878887878887888887878888878887878887888887888787888888878888888787888888878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788888887878888878787888887878777888888878788888877888788888887878888888788888787888788888788878788878888878788888788878788878888878887878887888887888787888788888788878788888787888788888788878788878888878888878888888787888888878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887888788888788878788878788878777888887888887888877888788888788888788888788878887888788878888878887888788878788878887888788888788878887888787888788878887888887888788878887878887888788878888878887888788878888878888878888878888878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888887878787778888888877878887878787888777888788888888878877888788878888888887888788878788888787888888888787888887878787888887878888888887878888878787878888878788888888878788888787878788888787888888888787888887878888878887888888888788878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888778787878777888787878787878877878888888888888777888787888888888888878788878787878888888888888888878787878787878788888888888888888787878787878787888888888888888887878787878787878888888888888888878787878888878788888888888887878888", + "888888888888888888888888878787878787878788878787878787878788878788888888888888888787888888888888888887878787878787878787878787878787888888888888888888888888888888888787878787878787878787878787878788888888888888888887878888888888888888878788", + "888888888888888888888888878787878787878788878787878787878788878788888888888888888787888888888888888887878787878787878787878787878787888888888888888888888888888888888787878787878787878787878787878788888888888888888887878888888888888888878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888778787878777878888888888888777888787878787878877878887888888888888878887888888888787878788888888878787878787878788888888878787878888888888888888878787878888888887878787878787878888888887878787888888888887888788888888888887888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888887878787778888888877888788888888878877878887878787888777878888878888888887888887888887878888878788888787888887878787888887878888878788888787888888888787888887878888878788888787878788888787888887878888878788888887888887888888888788888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887888788888788888887888887888877878788878788878777878888888788888788888887888788878887888788878887888788878788878887888788878887888788878888878887888788878887888788878887878887888788878887888788878887888887888888878888878888888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788888887878888888888878788888877878787888887878777878888888887878888888887878888878887878888878788878888878788888788878788888787888788888788878788878888878788888788878788888787888788888787888887888787888887888888888787888888888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788888887878888888888878788888877878787888887878777878888888887878888888887888787888788888787888887888787888887878887888887878888878887878887888887888787888887878887888887878888878887878888878788878888878887888888888787888888888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887888788888788888887888887888877878788878788878777878888888788888788888887878887888788878887888788878887888887888788878887888788878887888787888788878887888788878887888788888788878887888788878887888788878887888888878888878888888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888887878787778888888877888788888888878877878887878787888777878888878888888887888887878788888787888887878888878788888888878788888787888887878888878787878888878788888787888887878888888887878888878788888787888887878887888887888888888788888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888778787878777878888888888888777888787878787878877878887888888888888878887878787878888888887878787888888888888888887878787888888888787878787878787888888888787878788888888888888888787878788888888878787878887888788888888888887888788", + "888888888888888888888888878787878787878788878787878787878788878788888888888888888787878787878787878788888888888888888888888888888888878787878787878787878787878787878888888888888888888888888888888887878787878787878887878888888888888888878788", + "888888888888888888888888878787878787878788878787878787878788878788888888888888888787878787878787878788888888888888888888888888888888878787878787878787878787878787878888888888888888888888888888888887878787878787878887878888888888888888878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888888888888888888888888888888877878787878787878777888787878787878787878788888888888888888888888888888888888787878787878787878787878787878787878787878787878787878787878787888888888888888888888888888888887787888888888888888888888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888888888888888878787878787878777888888888888888877878887878787878787878887888888888888888887878787878787878888888888888888878787878787878787878787878787878888888888888888878787878787878788888888888888887788878888888888888888878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888778787878777878888888888888788878888888888888788878788878787878787888787888888888787878788888888878787878888888887878787888888888787878787878787888888888787878788888888878787878888888887878787888888887788888788888888888887888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888887878787778888888877888788888888878888888788888888878888878787888787878788878787888887878888878788888787888887878888878788888787888887878888878787878888878788888787888887878888878788888787888887878888878788887788888887888888888788888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887888788888788888887888887888888888887888887888888878787878887878887878787888788878887888788878887888788878887888788878887888788878887888787888788878887888788878887888788878887888788878887888788878887887788888888878888878888888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788888887878888888888878788888888888888878788888888878787878788888787878787878888878887878888878788878888878887878887888887878888878887878887888887888787888887878887888887888787888788888787888887888787887788888888888787888888888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788888887878888888888878788888888888888878788888888878787878788888787878787888787888788888787888887888787888788888788878788888787888788888788878788878888878788888788878788878888878887878888878788878888877788888888888787888888888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887888788888788888887888887888888888887888887888888878787878887878887878787878887888788878887888788878887888788878887888788878887888788878888878887888788878887888788878887888788878887888788878887888788877788888888878888878888888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888887878787778888888877888788888888878888888788888888878888878787888787878788878787878788888787888887878888878788888787888887878888878788888787888888888787888887878888878788888787888887878888878788888787888887877788888887888888888788888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888778787878777878888888888888788878888888888888788878788878787878787888787878787878888888887878787888888888787878788888888878787878888888888888888878787878888888887878787888888888787878788888888878787877788888788888888888887888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888888888888888878787878787878777888888888888888877878887878787878787878887878787878787878788888888888888888787878787878787888888888888888888888888888888888787878787878787888888888888888887878787878787877788878888888888888888878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888888888888888888888888888888877878787878787878777888787878787878787878788878787878787878787878787878787878888888888888888888888888888888888888888888888888888888888888888878787878787878787878787878787877787888888888888888888888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887888887888777888888878887878788888888878887878777888888888887888787878787888787878787878887878788878888888787878887888888878888888888888787878788878888888788888888888887878888888888888788888887888787877787878787878887888888888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788888788878877888887888788878788888887888788878777888888888788878887878787878887878787888787878887888788888787888788878888888788888888878887878887888788888887888888888788888788888888878888888788878887877787878787888788878888888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888778888878788888788888787888788888788888787888777888888878888878788878787878788878788878787888787888887888788878788888788888887888887888887888787888887888888878888878888888887888887888888878888878788877787878788878788888788888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787778787888888888787878888888788888787878888888777888888878787888888878787878787888887878788878787888888878887878788888887888888878788888888878787888888878888888787888888888888878788888887888888878787887787878788888887878788888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787778787888888878888888787878888878888888787878877888887888888878787888787878787888887878787888888878787888788888887878788888888878788888887888888878787888888888787888888888888878788888888878787888888877787878887878788888887888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888778888878788878887878888878888878887878888878877888887888787888887888787878788878788878788878888878788878887888887878887888887888887888888878888878788878888878888878888888887888887888887888787888887887787878887888887878887888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788888788878877878788878887888888878788878887888877888887878887888788888787878887878787888788888788878887878888878887888787888788888888878888888788878887878887888888888788888788888888878887878887888788887787878888878887888787888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887888887888777878787888788888888878787888788888877888887878788878888888787888787878787878888888887888787878888888788878787878888888888888788888887888787878788888888888887878888888888888787878788878888887787878888888788878787888888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787888888878777878787878888888877888888888787878788888788888888878787878887878787888788888888878787878787888788888888888887878787888788888887888888888888878787878887888888888888878887878787888888888888877787888787878788888888878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888888787888877878788888787888877888887878888878788888788888787888887878887878788878887888887888787878788878887888888888788878788878887888888878888888887888787888788878888888887888788878788878888888887887787888787888887878888878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788778887888788878887888788878877888788878887888788888788878887888788878887878887878888878887878887878887878888878888878888878887878888878888888788888788888788878788888788888788888787888788888788888788887787888788878887888788878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887778788878888878888878887878877888787888788888788888788878788878888878887888787878888888787878788888787878888888787888888888787878888888788888887878888888887878788888887878888888787878888888887878888887787888788888788878788878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887778788878888888787888788888777878888878887878888888787888887888787888887878888888787878887878788888787878888888787888888878888888787878888888887878888888788888887878788888787878888888788888887878888887787888887878887888887878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788778887888788888788878887888777878887888788878888888787888788878887888887888788888787888787878887878887878888878888878888888788888787888788888788888788888887888887878887878887878888878888888788888788887787888887888788878887878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888888787888877888887878888878777878788888787888888888787878888878788888887888887888788878787888787878788878887888888888788888887888788878788878888888887888888878887888787878788878887888888878888888887887787888888878788888787878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787888888878777888888888787878777878787878888888888888787878787888888888887888888878887878788878787878787888788888888888887888888878887878787888888888888878888888788878787878787888788888887888888888888877787888888888887878787878888", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787888888878777888888888787878777878787878888888888878888888888878787878788878787888788888887888888888888878887878787878788878787888788888887888888888888878888888788878787878787888788888887888888888888877788878787878788888888888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888888787888877888887878888878777878788888787888888878888888787888887878788878788878887888888878888888887888788878787878887878788878887888888878888888887888888878887888787878788878887888888878888888887887788878787888887878888888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788778887888788888788878887888777878887888788878888878888878887888788878788878887878888878888888788888788888787888787888787878887878888878888888788888788888887888887878887878887878888878888888788888788887788878788878887888788888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887778788878888888787888788888777878888878887878888878888878788878888878788888787878888888788888887878888888787878888878787888787878888888788888887878888888788888887878788888787878888888788888887878888887788878788888788878788888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887778788878888878888878887878877888787888788888788878887888887888787888788878888888787878888888887878888888787878888878787878888888787878888888887878888888887878788888887878888888787878888888887878888887788878887878887888887888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788778887888788878887888788878877888788878887888788878887888788878887888788888788888787888788888788888788888787888787888787888788888787888788888788888788888788878788888788888788888787888788888788888788887788878887888788878887888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888888787888877878788888787888877888887878888878788878887878888878788888788888887888788878788878888888887888788878787878887888887888788878788878888888887888787888788878888888887888788878788878888888887887788878888878788888787888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787888888878777878787878888888877888888888787878788878887878787888888888788888888878887878787888888888888878887878787878788888888878887878787888888888888878787878887888888888888878887878787888888888888877788878888888887878787888788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887888887888777878787888788888888878787888788888877878788888887888787878888878888888888888787878788878888888787878887888888888787878787878888888887888787878788888888888887878888888888888787878788878888887788888787878887888888878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788888788878877878788878887888888878788878887888877878788888788878887878888888788888888878887878887888788888787888788878888878887878787888788888788878887878887888888888788888788888888878887878887888788887788888787888788878888878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888778888878788878887878888878888878887878888878877878788878888878788878888888887888887888887888787888887888788878788888788878788878788878788878888878788878888878888878888888887888887888887888787888887887788888788878788888788878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787778787888888878888888787878888878888888787878877878788878787888888878888888888878788888888878787888888878887878788888887878787888887878787888888878787888888888787888888888888878788888888878787888888877788888788888887878788878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787778787888888888787878888888788888787878888888777878787888888878787888888888888878788888887888888878787888788888887878788878787888887878788878787888888878888888787888888888888878788888887888888878787887788888887878788888887878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888778888878788888788888787888788888788888787888777878787888787888887888888888887888887888888878888878788878887888887878887878788878788878787888787888887888888878888878888888887888887888888878888878788877788888887888887878887878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788888788878877888887888788878788888887888788878777878787878887888788888888888788888888878888888788878887878888878887888787878887878787888787878887888788888887888888888788888788888888878888888788878887877788888888878887888787878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887888887888777888888878887878788888888878887878777878787878788878888888888878888888888888788888887888787878888888788878787888787878787878887878788878888888788888888888887878888888888888788888887888787877788888888888788878787878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787888888878777888888888787878788888888888787878777878787878787888888888888878787888788888887888888888888878788888888888887888888878887878788878787878787888787878887888888878787888788888887888888888888878887878787878788888888888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888888787888877888887878888878788888887878888878777878787878888878788888888878788878887888888878888888887888887888888888788888887888788878787888787878788878787888788878888878788878887888888878888888887888887878787888887878888888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788778887888788888788878887888788888788878887888777878787888788878887888888878887878888878888888788888788888888878888878888888788888787888787878887878887878788878788888788878887878888878888888788888788888887878788878887888788888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887778788878888888787888788888788888787888788888777878787888887888787888888888787878888888788888887878888888888888787888888878888888787878887878788888787878887878788888887888787878888888788888887878888888887878788888788878788888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887778788878888878888878887878888878888878887878877878788878788878888878888878888888787878888888887878888888888888787888888888787878888888787878788888787878788888887878788878888888787878888888887878888888887878887878887888887888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788778887888788878887888788878888878887888788878877878788878887888788878888888788888787888788888788888788888888878888878888878887878888878887878887878887878887888887878887888788888787888788888788888788888887878887888788878887888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888888787888877878788888787888888878788888787888877878788888787888887878888888887888788878788878888888887888887888888888788878788878887888887888787878788878888878887888787888887888788878788878888888887888887878888878788888787888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787888888878777878787878888888888878787878888888877878788888888878787878888888888878887878787888888888888878788888888888887878787888788888888878787878787888888888788878787888888878887878787888888888888878887878888888887878787888877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887888887888777878787888788888877888888878887878788878887878788878888888788878888888888888787878788878888888888888788878787878888888888888787878788878888888887878787878788878888888888888787878788878888888887888787878887888888878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788888788878877878788878887888877888887888788878788878887878887888788888788888788888888878887878887888788888888878887888787888788888888878887878887888788888788878787878887888788888888878887878887888788888887888787888788878888878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888778888878788878887878888878877888788888787888788878887888787888887888788888887888887888887888787888887888887888887878887888887888887888887888787888887888787888787888787888887888887888887888787888887888887888788878788888788878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787778787888888878888888787878877888787878888888788878887888888878787888788888888878788888888878787888888878788888887878788888888878788888888878787888888878787878888878787888888878788888888878787888888878887888788888887878788878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787778787888888888787878888888777878888888787878888878888878787888888878788888888878788888887888888878787888887878788888887888888878788888887888888878787888787878888878787888888878788888887888888878787888887888887878788888887878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888778888878788888788888787888777878887878888878888878888878888878788878788888887888887888888878888878788878788878788888788888887888887888888878888878788878787888787888787888887888887888888878888878788878887888887888887878887878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788888788878877888887888788878777878788878887888888878888888788878887878788888788888888878888888788878887878787888788878888888788888888878888888788878887878788878787878887888788888888878888888788878887878887888888878887888787878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887888887888777888888878887878777878787888788888888878888888887888787878788878888888888888788888887888787878787878887888888878888888888888788888887888787878887878787878788878888888888888788888887888787878887888888888788878787878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887888887888777888888878887878777878787888788888888888787878788878888888887878888888888888788888887888787878787878887888888878888888888888787878788878888888788888888888887888787878787878887878788878888888888878787878887888888888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788888788878877888887888788878777878788878887888888888787878887888788888887888788888888878888888788878887878787888788878888888788888888878887878887888788888887888888888788878887878787888787878887888788888888878787888788878888888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888778888878788888788888787888777878887878888878888888787888787888887888887888887888887888888878888878788878788878788888788888887888887888887888787888887888888878888878888878788878788878787888787888887888888878788878788888788888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787778787888888888787878888888777878888888787878888888787888888878787888887888888878788888887888888878787888887878788888887888888878788888888878787888888878888888787888888878787888887878788878787888888878888878788888887878788888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787778787888888878888888787878877888787878888888788888788878787888888878887888888878788888888878787888888878788888887878788888888878788888887888888878787888888888787888888878787888887878787888888878787888888878887878788888887888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888778888878788878887878888878877888788888787888788888788878888878788878887888887888887888887888787888887888887888887878887888887888887888888878888878788878888878888878888878788878788878788878888878788878888878887888887878887888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788888788878877878788878887888877888887888788878788888788888788878887878887888788888888878887878887888788888888878887888787888788888888878888888788878887878887888888888788878887878787888788888788878887878888878888878887888787888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887888887888777878787888788888877888888878887878788888788888887888787878887878888888888888787878788878888888888888788878787878888888888888788888887888787878788888888888887888787878787878888888887888787878888878888888788878787888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787888888878777878787878888888888878787878888888877888887878787888888888787888888878887878787888888888888878788888888888887878787888788888887888888888888878787878887888888878787888788888888878787878787888888888787878788888888878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888888787888877878788888787888888878788888787888877888887878888878788888787888887888788878788878888888887888887888888888788878788878887888888878888888887888787888788878888878788878887888887888787878788878888888787888887878888878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788778887888788878887888788878888878887888788878877888887888788878887888787888788888787888788888788888788888888878888878888878887878888878888888788888788888788878788888788878887878888878887878887878887878888888788878887888788878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887778788878888878888878887878888878888878887878877888887888887888787888787878888888787878888888887878888888888888787888888888787878888888788888887878888888887878788888887888787878888888787878788888787878888888788888788878788878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778888878887778788878888888787888788888788888787888788888777888888878788878888878787888787878888888788888887878888888888888787888888878888888787878888888887878888888788888887878788878888888787878887878788888787878888888887878887888887878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "778887888788778887888788888788878887888788888788878887888777888888878887888788878787878887878888878888888788888788888888878888878888888788888787888788888788888788888887888887878887888788888787888787878887878887878888888887888788878887878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887787878888888787888877888887878888878788888887878888878777888888888787888887878787878788878887888888878888888887888887888888888788888887888788878788878888888887888888878887888787888887888788878787888787878788878888888888878788888787878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "887788888787888888878777888888888787878788888888888787878777888888888888878787878787878787888788888887888888888888878788888888888887888888878887878787888888888888878888888788878787888888878887878788878787878787888888888888888887878787878777", + "888888888888888888888888888888888888888888888888888888888888878787878787878787878787878787878787878787878787878787878787878787878787878787878787878788888888888888888888888888888888888888888888888888888888888888888887878787878787878787878788", + "888888888888888888888888888888888888888888888888888888888888878787878787878787878787878787878787878787878787878787878787878787878787878787878787878788888888888888888888888888888888888888888888888888888888888888888887878787878787878787878788", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888888888888888888888888888888877878787878787878777878888888888888888888887878787878787878787878787878787878888888888888888888888888888888887878787878787878787878787878787888888888888888888888888888888887788878787878787878787878877", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888888888888888878787878787878777888888888888888877888788888888888888888788878787878787878788888888888888888787878787878787888888888888888887878787878787878888888888888888878787878787878788888888888888887787888787878787878787888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888778787878777878888888888888788878888888888888788888887888888888888878888878787878888888887878787888888888787878788888888878787878888888887878787888888888787878788888888878787878888888887878787888888887787878887878787878788878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888887878787778888888877888788888888878888888788888888878888888888878888888887888888878788888787888887878888878788888787888887878888878788888787888887878888878788888787888887878888878788888787888887878888878788887787878788878787878887878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887888788888788888887888887888888888887888887888888888888888788888788888888878887888788878887888788878887888788878887888788878887888788878887888788878887888788878887888788878887888788878887888788878887887787878787888787888787878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788888887878888888888878788888888888888878788888888888888888887878888888888888787888788888787888887888787888788888788878788888787888788888787888887888787888887878887888887888787888788888787888887888787887787878787878888878787878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777788878788888887878888888888878788888888888888878788888888888888888887878888888888878888878887878888878788878888878887878887888887878888878887878888878788878888878788888788878788878888878887878888878788878888877787878787878888878787878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "777787888887888788888788888887888887888888888887888887888888888888888788888788888888888788878887888788878887888788878887888788878887888788878887888788878887888788878887888788878887888788878887888788878887888788877787878787888787888787878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888887878787778888888877888788888888878888888788888888878888888888878888888887888888888887878888878788888787888887878888878788888787888887878888878788888787888887878888878788888787888887878888878788888787888887877787878788878787878887878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888778787878777878888888888888788878888888888888788888887888888888888878888888888888787878788888888878787878888888887878787888888888787878788888888878787878888888887878787888888888787878788888888878787877787878887878787878788878777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888888888888888878787878787878777888888888888888877888788888888888888888788888888888888888887878787878787878888888888888888878787878787878788888888888888888787878787878787888888888888888887878787878787877787888787878787878787888777", + "888898989898889898989888989898989898989888989898989898989888989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898989898988898989898989898989898989888", + "888888888888888888888888888888888888888877878787878787878777878888888888888888888887888888888888888888888888888888888787878787878787878787878787878788888888888888888888888888888888878787878787878787878787878787877788878787878787878787878877", + "888888888888888888888888888888888888888888888888888888888888878787878787878787878787888888888888888888888888888888888888888888888888888888888888888887878787878787878787878787878787878787878787878787878787878787878887878787878787878787878788", + "888888888888888888888888888888888888888888888888888888888888878787878787878787878787888888888888888888888888888888888888888888888888888888888888888887878787878787878787878787878787878787878787878787878787878787878887878787878787878787878788" + ], + "rank7_frame_hits_histogram": { + "1080": 5824, + "1170": 1792 + }, + "rank7_live_trimmed_endpoint_count_histogram": { + "1": 1792, + "2": 5824 + }, + "rank_histogram": { + "7": 7616, + "8": 37440, + "9": 12544 + } + }, + "conclusion": { + "eight_term_obstruction": "Every term must meet every frame, excluding every rank-seven atom.", + "minimum_copy_cost": 64, + "nine_term_obstruction": "Nine rank-seven atoms require nine distinct pairwise nonorthogonal live trimmed endpoints; maximum is eight.", + "positive_terms_below_64": [ + 8, + 9 + ], + "scope": "Exact C(alpha)/N(alpha) supports on this P112; any finite term count and arbitrary real or complex coefficients; additional zero-cost terms permitted. No arbitrary proper sub-supports or new kappa." + }, + "controls": { + "all_104_extensions_of_witness_rejected": true, + "duplicate_endpoint_rejected": true, + "missing_coordinate_term_rejected": true, + "punctured_only_beta7_rejected": true, + "zero_cost_atoms_cannot_meet_frames": true + }, + "frames": { + "count": 1260, + "frames_per_line": 90, + "orthogonal_pair_frame_count_histogram": { + "10": 2856, + "15": 448 + }, + "sha256": "7099937f0ce3703e1c45235b1459dccef0a2a54efb55d814f2538d77075c610e" + }, + "model": { + "binary_pairing_rank": 9, + "live_global_indices": [ + 2, + 3, + 4, + 5, + 7, + 8, + 9, + 10, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 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, + 107, + 108, + 109, + 110, + 111, + 112, + 113, + 114, + 115, + 116, + 117, + 118 + ], + "removed_global_indices": [ + 0, + 1, + 6, + 11, + 20, + 29, + 106, + 119 + ], + "roots_sha256": "499909f15616b21ed34b704054685a0c90c244fb81819ba458e076b8dd97308c", + "supports": 240, + "supports_sha256": "cbe25a84d874368e5291d5ae53ed5ae9063b11621d6950e80b1e837d4f39fff5" + }, + "nonorthogonality": { + "clique_counts_including_empty": { + "0": 1, + "1": 112, + "2": 2912, + "3": 25088, + "4": 88704, + "5": 161280, + "6": 145152, + "7": 55296, + "8": 4032 + }, + "complete_recursion_nodes": 482577, + "maximum": 8, + "witness_doubled_roots": [ + [ + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + -2 + ], + [ + 0, + 0, + 0, + 2, + 0, + -2, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + -2, + 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 + ] + ], + "witness_live_indices": [ + 0, + 1, + 9, + 17, + 38, + 65, + 74, + 93 + ] + }, + "schema_version": 1, + "sharpness": { + "all_pairs_checked": 12544, + "coordinate_term_costs": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "cost": 64, + "decoder_sha256": "ec946a931e485a4b0a3f9cf735a9b9dc32c83ad0f5a13a591c585178e3187cea" + }, + "source_manifest_sha256": "e6c8bda741285d2737724821f8d472ea0b73b0574772674a38866cb4b86a1a3f", + "status": "SCOPED_ROOT_STAR_COPY_FLOOR_64" +} diff --git a/research/root-star-integer-cover-seed46/CLAIM.json b/research/root-star-integer-cover-seed46/CLAIM.json new file mode 100644 index 0000000000..3ac48e4ef2 --- /dev/null +++ b/research/root-star-integer-cover-seed46/CLAIM.json @@ -0,0 +1,54 @@ +{ + "assignment_seed": 46, + "randomness": "Python secrets.randbelow(100), OS-backed; generated 2026-10-13T20:41:26.209187+00:00", + "track": "Structural decoder research (40-49)", + "base_commit": "49b3157d1d89adcef16df8be98445451672be5ba", + "candidate_tasks": [ + "Classify the ten-term both-outside-code residual of PR1224; deferred because coefficient and cost geometry is too broad for one session.", + "Close PR1226 cost-63 root-star assembly window using integer frame coverage and the nonorthogonality clique number; selected, seed mod 3 = 1.", + "Remove PR1222 quadratic restriction from common three-dimensional five-cube codes; deferred because it needs a different symbolic rank argument." + ], + "object": "PR1226 P112 masked E-graph decoder, support pairs C(alpha) or N(alpha), 120 root normals; unrestricted coefficients and finite term count, plus free odd singleton corrections.", + "changed_mechanism": "Replace averaged fractional frame coverage by pairwise compatibility of missed-frame sets. The support alphabet is unchanged; no repeated optimizer search.", + "hypothesis": "Every decoder in this root-star support family has cost at least 64; eight coordinate-star terms attain 64.", + "method": "Independent integer E8 generation, exact F2 pairing ranks for 57600 support pairs, complete 1260-frame enumeration, exact 112-vertex nonorthogonality clique census and a separate coloring-bound oracle.", + "protected_invariant": "A lower bound must cover every allowed support pair and every finite term count, with exact arithmetic; it must not be promoted to arbitrary supports or a physical supplier.", + "ways_evidence_can_fail": [ + "Wrong punctured frame or root-line conventions", + "Confusing support containment with exact support", + "Omitting rank-7 atoms or frames", + "Assuming averaged coverage implies simultaneous compatibility", + "Mistaking bounded search for complete enumeration", + "Relying on assertions disabled by optimized Python" + ], + "optimistic_budget": "If cost>=64 in the unchanged copied-information model, this family cannot reduce the existing coordinate decoder charge; source access, helpers, frame changes, restoration, precision and recursive realization remain unprovided. No kappa claim.", + "expected_deliverable": "Scoped proof, deterministic certificate, independent check and meaningful rejection controls in one new research directory.", + "expected_finish_utc": "2026-10-13T21:41:26Z", + "budget": "60 minutes per AGENTS.md; orientation at most 12 minutes, final 15 reserved for verification/handoff; earlier completion allowed.", + "coordination": "No pinned issues at initial live inspection; local claim per donor instructions. Discussion 1210 is PR1226 census, a predecessor; live search found no integer missed-frame packing claim.", + "predecessor_prs": { + "1226": "8b10989e4e45f0f9ce41004d7898a21a32f87e11", + "1212": "072ae2f43d5c249a31e5d6ed266bfef3924417f3", + "1213": "8867cf20fbe0d3960f68bcffca118a5ac0624f7f", + "1236": "ee8437bd9879272094e20c024cd34a53c4e84cd8" + }, + "predecessor_credit": [ + "Navinor, PR1226: full trimmed-star census, covering lemma and residual assembly question", + "DreamingOfClouds, PR717/595: masked E-graph model and binary label pairing", + "Joel Pulikkan / GamingPuzzled, PR620: coordinate decoder and geometric lineage", + "David Arias / DavidAriasC, PR1236: concurrent theorem and same endpoint argument; this package independently corroborates it." + ], + "status": "COMPLETE", + "scope_status": "refined", + "scope_reason": "Exact integer compatibility closes the assembly gap explicitly left by the full fixed-family census; this is not a search inside an already excluded class.", + "final_contribution_type": "Independent verification of concurrent PR1236; no theorem priority claim.", + "overlap_refinement": { + "discovered_utc": "2026-10-13T20:57:44Z", + "pr": 1236, + "head": "ee8437bd9879272094e20c024cd34a53c4e84cd8", + "reason": "The same structural endpoint theorem arrived during the investigation. Preserve distinct independent maximal-clique verification and exact five-section source-certificate binding; do not submit as a new theorem." + }, + "result": "Independently corroborated PR1236 exact copy floor 64, with complete maximal-clique/subset and five-section certificate binding.", + "result_artifact": "README.md", + "local_final_handoff": "The submitted PR URL is recorded in the external sprint completion receipt." +} diff --git a/research/root-star-integer-cover-seed46/NOTICE.md b/research/root-star-integer-cover-seed46/NOTICE.md new file mode 100644 index 0000000000..f089fcaad1 --- /dev/null +++ b/research/root-star-integer-cover-seed46/NOTICE.md @@ -0,0 +1,42 @@ +# Attribution and provenance + +Independent verification contribution: Hanson Sun (@bbMisk), with substantial OpenAI Codex +assistance in research, proof, implementation, verification and prose. +Both checkers are AI-assisted. Separate algorithms are not independent human +review. New work is supplied under the repository's Apache-2.0 license. + +Navinor's PR1226 at `8b10989e4e45f0f9ce41004d7898a21a32f87e11` supplies +the precise root-star alphabet, the complete mixed-cost census, the averaged +frame-cover lemma and the residual cost-63 assembly question. Its README, +proof, notice, results and verifier are retained verbatim under `sources/`, +with Git blob and SHA256 bindings in SOURCES.json. Those files preserve their +own attribution to opencode and predecessor authors. The new executables do +not import or execute that verifier. + +The model and free odd-entry corrections belong to DreamingOfClouds' +PR717/595 and retained E8/common-label lineage. The coordinate-star cost-64 +decoder is predecessor work, including Joel Pulikkan / GamingPuzzled's PR620. +This package does not claim a new attaining decoder, frame geometry, or rank +histogram. Its contribution is independent evidence for the integer +compatibility obstruction that closes PR1226's fixed-family assembly window. + +David Arias' concurrent PR1236 (@DavidAriasC), prepared with substantial +OpenAI Codex assistance, had already submitted the same theorem and endpoint +argument when the final overlap refresh found it. The exact audited head is +`ee8437bd9879272094e20c024cd34a53c4e84cd8`. Its certificate is retained +verbatim and source-bound under `sources/pr1236-CERTIFICATE.json`. The separate +checker reconstructs and matches all five geometric sections, including the +full atom-stream hash. It uses a pivoted maximal-clique/subset proof instead +of PR1236's lattice/quadratic-form method. PR1236's control-execution claims +and its independent lattice receipt are not being replayed or certified. +There is no theorem-priority claim over PR1236. + +Concurrent PR1212 (@burntout76) and PR1213 (@DavidAriasC) address broader +eight-term masked decoder rigidity. They are credited as related work, not +imported mathematical dependencies. PR1191 (@mightyOil) treats a root-linear +factor at arbitrary term count. None of these hypotheses is assumed by the +nine-cost-seven endpoint argument. + +Selected PR1094 (Rohan Arun), Jeremy Kothe's packing/construction lineage, +Hao Yan's controller and the unchanged PR589/PR555 bit lineage are the +reviewed background at the base. This package makes no change to that result. diff --git a/research/root-star-integer-cover-seed46/OVERLAP.json b/research/root-star-integer-cover-seed46/OVERLAP.json new file mode 100644 index 0000000000..8034e0ef93 --- /dev/null +++ b/research/root-star-integer-cover-seed46/OVERLAP.json @@ -0,0 +1,100 @@ +{ + "status": "POSSIBLE_OVERLAP_NOT_A_NOVELTY_CERTIFICATE", + "searched_at": "2026-10-13T20:43:49.152543+00:00", + "terms": [ + "five-cube", + "nine-term", + "mixed-beta" + ], + "coverage": { + "open_prs": { + "fetched_at": "2026-10-13T20:43:47.202163+00:00", + "complete_pagination": true, + "records": 839 + }, + "discussions": { + "fetched_at": "2026-10-13T20:43:49.110585+00:00", + "complete_pagination": true, + "records": 11 + } + }, + "warnings": [], + "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.", + "matches_total": 19, + "nearest_work": [ + { + "number": 1236, + "title": "Research: close the masked root-star assembly gap with sharp cost 64 (no new kappa)", + "head": "ee8437bd9879272094e20c024cd34a53c4e84cd8", + "updated_at": "2026-10-13T20:46:58Z", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1236", + "distinction": "Same theorem and endpoint argument arrived concurrently. Final submission is independent verification: direct root generation, low-column elimination, pivoted maximal-clique/subset coverage and byte-bound reproduction of all five geometric sections of this exact PR certificate. No priority claim." + }, + { + "number": 1226, + "title": "Research: masked root-star trimmed-star census on P112; exact covering bound 784/13, 64 falsified for beta-7 atoms (no new kappa)", + "head": "8b10989e4e45f0f9ce41004d7898a21a32f87e11", + "updated_at": "2026-10-13T20:29:08Z", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1226", + "distinction": "Direct predecessor. Adds simultaneous missed-frame compatibility and excludes every cost-63 assembly; source census is independently reconstructed." + }, + { + "number": 1224, + "title": "Research: nine-term complex E8 decoders are one-sided overcomplete representations (seed 42, no new kappa)", + "head": "00e6ed0810b8ebc7f6133e2c036d0f1c9a3a4162", + "updated_at": "2026-10-13T20:26:31Z", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1224", + "distinction": "Nine-term all-pairs normal form; not used. Here exactness is only on the E-graph." + }, + { + "number": 1213, + "title": "Research: classify the P112 masked decoder coordinate component (no new kappa)", + "head": "8867cf20fbe0d3960f68bcffca118a5ac0624f7f", + "updated_at": "2026-10-13T20:22:41Z", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1213", + "distinction": "Eight-term coordinate-component classification; not used." + }, + { + "number": 1212, + "title": "Research: rank-8 complex decoders are gauge-rigid; E-graph eight-term floor (no new kappa)", + "head": "072ae2f43d5c249a31e5d6ed266bfef3924417f3", + "updated_at": "2026-10-13T20:14:55Z", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1212", + "distinction": "Broader eight-term masked rigidity; not used. New step concerns nine cost-seven terms in a fixed alphabet." + }, + { + "number": 1191, + "title": "Research: one-sided E8 mask rigidity on 1,373 punctured units (no new kappa)", + "head": "640b43bb13d3d476a2d83b74ef0d33f14d1b5711", + "updated_at": "2026-10-13T19:54:49Z", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/1191", + "distinction": "One root-linear factor at arbitrary term count; not used. Root-star coefficients here are unrestricted on their exact supports." + } + ], + "coordination": "Initial GraphQL pinnedIssues inventory empty. All active discussions inspected; local claim follows user instructions when no pinned issue exists.", + "final_refresh": { + "searched_at": "2026-10-13T20:57:44.369567+00:00", + "terms": [ + "root-star", + "trimmed-star", + "cost-63", + "missed-frame", + "integer cover" + ], + "coverage": { + "open_prs": { + "fetched_at": "2026-10-13T20:57:40.322905+00:00", + "complete_pagination": true, + "records": 843 + }, + "discussions": { + "fetched_at": "2026-10-13T20:57:44.311345+00:00", + "complete_pagination": true, + "records": 16 + } + }, + "warnings": [], + "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.", + "matches_total": 10 + } +} diff --git a/research/root-star-integer-cover-seed46/PROOF.md b/research/root-star-integer-cover-seed46/PROOF.md new file mode 100644 index 0000000000..0e60b2e758 --- /dev/null +++ b/research/root-star-integer-cover-seed46/PROOF.md @@ -0,0 +1,145 @@ +# Independent finite proof of the P112 root-star cost-64 floor + +This is a computer-assisted theorem about one finite support alphabet. It is +not a physical supplier, a formal proof-assistant result, or a multiplication +theorem. The finite premises below are reconstructed by two separate programs. +The result and endpoint argument independently corroborate David Arias' +concurrent PR1236 at `ee8437bd9879272094e20c024cd34a53c4e84cd8`, found during +the submission overlap refresh. The distinct second implementation uses +pivoted maximal-clique enumeration, not PR1236's lattice/quadratic-form +obstruction. No new theorem priority is claimed. + +## Model and statement + +Use the E8 roots of squared norm two and identify antipodal roots. Remove the +eight lines of the coordinate frame +`f = e_(2a) +/- e_(2a+1)`, `a=0,...,3`, leaving P112. Write +`G_ij = `. The binary label pairing of PR717/PR1226 is + +```text +S_ij = (G_ij + 1) mod 2. +``` + +The E-graph includes the diagonal and the orthogonal pairs. A masked decoder +has finitely many real or complex rank-one terms `d_k t_k^T` whose sum equals +`2G` on that graph. Transpose is ordinary transpose, not conjugate transpose. +In particular, on any eight-line orthogonal frame F the sum is `4 I_8`. + +For each of the 120 root-line normals alpha, permit the supports + +```text +C(alpha) = {i in P112 : != 0}, +N(alpha) = C(alpha) minus alpha's own line, if that line is live. +``` + +Each positive-cost term must have **exactly** one of these supports on each +side. Its cost is `beta_k = rank_F2 S[supp(d_k), supp(t_k)]`. Arbitrary nonzero +coefficients on those supports are allowed; arbitrary proper sub-supports are +not included. Additional terms of pairing rank zero may have arbitrary +supports. In particular, the free odd-entry singleton corrections in PR717 +are allowed. Zero terms can be discarded. + +**Theorem.** Every such decoder has `sum beta_k >= 64`. Eight coordinate-star +terms attain 64. This closes the fixed-family assembly window left by +Navinor's PR1226; it does not strengthen the fractional inequality itself. + +## Exact finite premises + +Both implementations independently generate the 120 lines and the same +punctured frame. Their internal root order differs from PR1226's order; the +certificate specifies this package's order by a hash and explicit witness roots. + +1. P112 has exactly **1,260** orthogonal eight-line frames. Every live line is + in **90** frames. Every orthogonal pair of distinct live lines extends to a + live frame: 2,856 such pairs belong to ten frames each, and 448 to fifteen. +2. The 240 indexed supports and all **57,600 ordered support pairs** have + cost histogram `7: 7616`, `8: 37440`, `9: 12544`. Indexing retains the eight + duplicates `C(f)=N(f)` at punctured normals, as in PR1226. +3. A support misses a live frame precisely when it is `N(alpha)` with alpha + live and the frame contains alpha. Every cost-seven atom has at least one + such live trimmed endpoint. There are 1,792 atoms with one and 5,824 with + two; these meet 1,170 and 1,080 frames respectively. +4. The graph on P112 joining distinct **nonorthogonal** lines has clique + number **eight**. The complete clique counts, including the empty clique, + are: + + | Size | Count | + |---:|---:| + | 0 | 1 | + | 1 | 112 | + | 2 | 2,912 | + | 3 | 25,088 | + | 4 | 88,704 | + | 5 | 161,280 | + | 6 | 145,152 | + | 7 | 55,296 | + | 8 | 4,032 | + + The primary checker visits all **482,577** cliques by increasing-vertex + recursion, with no size cutoff. The second checker finds all **27,968** + maximal cliques by pivoted Bron-Kerbosch recursion, then takes the union of + all their subsets. Every clique of a finite graph extends to a maximal + clique, so this is a separate complete coverage argument. Both recover the + entire displayed census and an explicit size-eight witness. + +The support/frame assertion in item 3 also has a direct explanation. A frame +is a real basis, so a nonzero root normal cannot be orthogonal to every frame +line. Removing the normal's own line can remove the final intersection only +when that line belongs to the frame. If it does belong, it is orthogonal to +the other seven lines. The programs check this identity on every indexed +support and every frame; no generic-position assumption is used. + +## From the premises to the floor + +Call a term a *hit* on F when both supports meet F. Its restricted outer +product has rank at most one and vanishes unless it hits F. Since the target +on F is `4 I_8`, at least eight terms must hit every frame. A cost-zero term +cannot hit a frame: every binary pairing between two members of F is one, +whereas a matrix of binary rank zero has all entries zero. + +Let n count positive-cost terms. Each costs at least seven, by item 2. +Suppose the total cost were below 64. Then `8 <= n <= 9`. + +* If `n=8`, every term must hit every frame. But cost below 64 forces at + least one cost-seven term. Its live trimmed endpoint belongs to 90 missed + frames, contradicting the eight-hit requirement. +* If `n=9`, every term must cost seven: the integer total is exactly 63. + Select one live trimmed endpoint alpha_k from each term, which item 3 + permits. A frame containing alpha_k is missed by that term. No frame can + contain two selected endpoints, since it would receive at most seven + hits. Repeated endpoints are therefore impossible. Two orthogonal + endpoints are also impossible, by item 1. The nine selected endpoints + would consequently form a nonorthogonality nine-clique, contradicting + item 4. This holds for any choice when a term has two eligible endpoints. + +All finite term counts have been covered. This is an integer compatibility +argument: the averaged coverage bound `784/13` from PR1226 stays valid, but +does not account for two terms missing the same frame. + +## Attainment and accounting limits + +For the eight removed frame roots f_k take +`d_k(i)=t_k(i)=`. Orthogonality and norm two give + +```text +sum_k = 2 . +``` + +All 12,544 entries are checked exactly, and each term costs eight. This is +the existing coordinate decoder, credited to the predecessor lineage; the +result being corroborated is its optimality in the specified mixed-cost root-star family. + +The result prevents a reduction of the copied-information constant below 64 +within this alphabet, even before charging source access, gather arithmetic, +helper frames, dirty restoration, recursive realization, precision, or +hosting. It does not assert that all other costs are fixed, nor rule out +improvements to them. No complete new invoice, native word, improved moment, +or kappa is claimed. Selected PR1094 and its compiler, all-size, mutable-source, +whole-call hosting, precision/tape, analytic and bit-interface assumptions +are unchanged. + +Further trimming, unions of stars, other punctures, different label pairings, +and positive-cost terms outside this alphabet remain outside the theorem. +The assertion is for the displayed coordinate-frame puncture; no unverified +frame-transitivity argument is needed. It covers complex coefficients because +the only coefficient-field fact used is the rank of `4 I_8`. diff --git a/research/root-star-integer-cover-seed46/README.md b/research/root-star-integer-cover-seed46/README.md new file mode 100644 index 0000000000..6aa880b152 --- /dev/null +++ b/research/root-star-integer-cover-seed46/README.md @@ -0,0 +1,80 @@ +# Independent verification of the P112 root-star copy floor + +**Independent verification of PR1236's scoped cost-64 result; no new kappa.** + +David Arias' concurrent [PR1236](https://github.com/CrocSwap/integer-mult-bounds/pull/1236) +closes the assembly window left by Navinor's +[PR1226](https://github.com/CrocSwap/integer-mult-bounds/pull/1226): its +fractional frame-cover bound is `784/13`, but the exact minimum is **64**. +This package independently corroborates that result for the same 240 indexed +root-star supports, arbitrary real or complex coefficients, any finite term +count and additional cost-zero corrections. It makes no priority claim. + +The shared proof uses simultaneous frame coverage. Nine cost-seven terms would +require nine distinct, pairwise nonorthogonal live trimmed endpoints. The +complete P112 graph has maximum clique eight. Eight terms below cost 64 are +also impossible, since a cost-seven term misses a frame. The existing eight +coordinate stars attain 64. The distinct verification uses a complete +**pivoted maximal-clique census and all of its subsets**, rather than +PR1236's quadratic-form checker, and retains every individual atom rank. +It independently matches all five geometric sections of PR1236's exact +certificate, including its root, support, frame and full atom-stream hashes. + +From the repository root, Python 3.10+ and the standard library: + +```sh +python3 -I -O -B research/root-star-integer-cover-seed46/test_package.py +``` + +Expected: **six test groups pass (`Ran 6 tests`, `OK`)**. The suite runs both +complete implementations, optimized standalone replay, mathematical failure +controls, certificate/source mutations and overwrite protection. + +Direct primary replay: + +```sh +python3 -I -B research/root-star-integer-cover-seed46/verify.py +``` + +Expected marker: + +```text +PASS_ROOT_STAR_INTEGER_COVER_S46 atoms=57600 frames=1260 cliques=482577 omega=8 copy_floor=64 no_new_kappa +``` + +[PROOF.md](PROOF.md) gives the finite premises and term-count argument. +[CERTIFICATE.json](CERTIFICATE.json) contains all 57,600 binary ranks as 240 +single-digit rows, and the full clique census. The separate checker imports no generator or predecessor +code and uses different root, rank and graph algorithms. +[CLAIM.json](CLAIM.json), [SOURCES.json](SOURCES.json), +[OVERLAP.json](OVERLAP.json) and [VALIDATION.json](VALIDATION.json) record the +assignment, exact pins, scope and executed checks. + +The claim requires exact C(alpha)/N(alpha) supports. Arbitrary proper +sub-supports, further trims, unions, other punctures and changed copy or stage +accounting are excluded. This is a finite computer-assisted proof with a +written implication, not proof-assistant or full multiplication verification. + +## Open next questions + +* Can a specified further-trimmed or union-of-stars support escape the missed + endpoint argument at a favorable full cost? First compute its exact binary + pairing ranks and missed frames. The current obstruction applies only to + the stated alphabet; a new decoder would still need every source access, + frame change, helper, restoration and recursive child priced. +* Does the same endpoint obstruction survive another explicit puncture? + First recompute pair-to-frame completion and the nonorthogonality clique + bound. Those finite premises are the blockers to transferring this proof. + +Exact base: `49b3157d1d89adcef16df8be98445451672be5ba`; OS seed **46**. +Audited PR1236: `ee8437bd9879272094e20c024cd34a53c4e84cd8`. +The structural investigation reached the same argument before the submission +refresh revealed PR1236; the final contribution is explicitly corroboration. +Credit Navinor's PR1226 census/open assembly question, DreamingOfClouds' +PR717/595 masked model and Joel Pulikkan / GamingPuzzled's PR620 coordinate +decoder lineage. Concurrent PR1212/1213 handle the broader eight-term case; +their code and proofs are not premises here. See [NOTICE.md](NOTICE.md). + +Prepared by **Hanson Sun (@bbMisk)** with substantial **OpenAI Codex +assistance** in research, proof, both implementations, verification and +writing. No independent human review is claimed. Apache-2.0. diff --git a/research/root-star-integer-cover-seed46/SOURCES.json b/research/root-star-integer-cover-seed46/SOURCES.json new file mode 100644 index 0000000000..a9ee5519d4 --- /dev/null +++ b/research/root-star-integer-cover-seed46/SOURCES.json @@ -0,0 +1,56 @@ +{ + "schema_version": 1, + "base_commit": "49b3157d1d89adcef16df8be98445451672be5ba", + "dependencies": [ + { + "path": "sources/pr1226-NOTICE.md", + "source_path": "research/masked-root-star-floor/NOTICE.md", + "source_commit": "8b10989e4e45f0f9ce41004d7898a21a32f87e11", + "git_blob": "767d5458bc299cb2ac0fa04cb061eb174c25f95f", + "sha256": "e072c0269eae7bdfc438e0b9b980be79cf0b2b7618bc66656fac9c24ce32c256", + "origin": "https://github.com/CrocSwap/integer-mult-bounds/pull/1226" + }, + { + "path": "sources/pr1226-PROOF.md", + "source_path": "research/masked-root-star-floor/PROOF.md", + "source_commit": "8b10989e4e45f0f9ce41004d7898a21a32f87e11", + "git_blob": "65604debc38a0cb4bc4b2052e7f1ce336e6cdbd4", + "sha256": "c30adb551579a2df0ad15e6e4485c5beb5a0342b0e89674d349f57ba0f84db4f", + "origin": "https://github.com/CrocSwap/integer-mult-bounds/pull/1226" + }, + { + "path": "sources/pr1226-README.md", + "source_path": "research/masked-root-star-floor/README.md", + "source_commit": "8b10989e4e45f0f9ce41004d7898a21a32f87e11", + "git_blob": "5440a1de61154bbf2185c7799226012323c027b4", + "sha256": "df3dcacbed655a25dbc71a2761aa43e5b87abe95d3ccff39261ee748a24fe13d", + "origin": "https://github.com/CrocSwap/integer-mult-bounds/pull/1226" + }, + { + "path": "sources/pr1226-RESULTS.json", + "source_path": "research/masked-root-star-floor/RESULTS.json", + "source_commit": "8b10989e4e45f0f9ce41004d7898a21a32f87e11", + "git_blob": "1827eb490341fac9a1ff0ed21f46fbdbc86048b8", + "sha256": "de4c6f61f169479aab410b56051776c52a9f2ce191636d5c679a25afdbd1b8bf", + "origin": "https://github.com/CrocSwap/integer-mult-bounds/pull/1226" + }, + { + "path": "sources/pr1226-verify.py", + "source_path": "research/masked-root-star-floor/verify.py", + "source_commit": "8b10989e4e45f0f9ce41004d7898a21a32f87e11", + "git_blob": "7578bc6bc3084ddbed9f1283332129ee40046f28", + "sha256": "dba3a51d57c9c670ab54172a8b345cdd9fb1065c39b6e41f3f3706b15d374283", + "origin": "https://github.com/CrocSwap/integer-mult-bounds/pull/1226" + }, + { + "path": "sources/pr1236-CERTIFICATE.json", + "source_path": "research/masked-root-star-assembly/CERTIFICATE.json", + "source_commit": "ee8437bd9879272094e20c024cd34a53c4e84cd8", + "git_blob": "ecc639bca2700c78459ec2e0ca9e7b79ecd846b4", + "sha256": "181eddec639da62417f4176fe275d091e243766c5df69ebb35a19482b8155019", + "origin": "https://github.com/CrocSwap/integer-mult-bounds/pull/1236", + "usage": "Audited receipt; every geometric hash and count is checked by the separate implementation." + } + ], + "executable_reuse": "No predecessor code is imported by the new verifier or independent checker. The pinned predecessor checker is retained for separate replay only." +} diff --git a/research/root-star-integer-cover-seed46/VALIDATION.json b/research/root-star-integer-cover-seed46/VALIDATION.json new file mode 100644 index 0000000000..f08858719f --- /dev/null +++ b/research/root-star-integer-cover-seed46/VALIDATION.json @@ -0,0 +1,75 @@ +{ + "schema_version": 1, + "validated_utc": "2026-10-13T21:07:28.292765+00:00", + "base_commit": "49b3157d1d89adcef16df8be98445451672be5ba", + "refreshed_upstream_main": "dadfea6e8a78ff6ba901705f87532a71c6f5bbb8", + "upstream_refresh_effect": "No changes to AGENTS.md, CONTRIBUTING.md, selected-result.json, or package paths. No rebase or merge performed.", + "environment": { + "platform": "macOS-27.0.1-arm64-arm-64bit-Mach-O", + "machine": "arm64", + "dependencies": "Python standard library only" + }, + "complete_package_suites": [ + { + "python": "3.14.6", + "command": "python3 -I -O -B research/root-star-integer-cover-seed46/test_package.py", + "exit_code": 0, + "groups": 6, + "elapsed_seconds": 109.24, + "evidence": "evidence/python-3.14.6.txt" + }, + { + "python": "3.12.13", + "command": "python3 -I -O -B research/root-star-integer-cover-seed46/test_package.py", + "exit_code": 0, + "groups": 6, + "elapsed_seconds": 120.54, + "evidence": "evidence/python-3.12.13.txt" + } + ], + "additional_executed_checks": [ + { + "command": "python3 -I -B research/root-star-integer-cover-seed46/sources/pr1226-verify.py --check research/root-star-integer-cover-seed46/sources/pr1226-RESULTS.json", + "result": "FAILS: none", + "pass_lines": 29, + "evidence": "evidence/pr1226-replay.txt" + }, + { + "command": "python3 scripts/verify_selected_result.py", + "result": "PASS selected record, exact kappa, original source inventory and proof supplement" + }, + { + "command": "python3 -m unittest discover -s tests -p 'test_selected_result.py'", + "result": "5 tests passed" + } + ], + "independent_binding": { + "audited_pr": 1236, + "head": "ee8437bd9879272094e20c024cd34a53c4e84cd8", + "matched_sections": [ + "model", + "frames", + "atoms", + "odd_graph", + "sharp_decoder" + ], + "not_replayed": [ + "PR1236 execution-control claims", + "PR1236 separate lattice receipt" + ] + }, + "scope": "Finite root-star masked decoder theorem; no new kappa or physical supplier. No independent human review or formal multiplication theorem.", + "not_run": [ + "Hosted CI at packaging time", + "Full selected-supplier cold replay", + "Repository-wide historical regeneration", + "Lean" + ], + "tested_core_sha256": { + "verify.py": "4b7eb7f12867c53834dd2bd339623b4587e71e1ec98c744b6434c49bea6b80a3", + "independent.py": "22ea142ad5d7581776190b74432182b86ea15e6d4ff3295542d8041d91ddd140", + "test_package.py": "4996300b617c8cf22f2d3de2b22ea89224fe11d71809929fe16380096611ef25", + "CERTIFICATE.json": "cae52ff950df2ec25edcd5563ffad26de10e472a5acc4494ff297d59c1ae5283", + "SOURCES.json": "237c0c777dd2cc899020d76a0e297571c0d5f6dd13a0e49fe62705f7e1a76fae" + } +} diff --git a/research/root-star-integer-cover-seed46/evidence/pr1226-replay.txt b/research/root-star-integer-cover-seed46/evidence/pr1226-replay.txt new file mode 100644 index 0000000000..8119edc095 --- /dev/null +++ b/research/root-star-integer-cover-seed46/evidence/pr1226-replay.txt @@ -0,0 +1,30 @@ +PASS A.lines-120 | 120 lines from 240 roots +PASS A.p112-112 | P112 = 120 - 8 frame lines +PASS A.ip-diag-2 +PASS A.egraph-60-per-row | {60} +PASS A.free-odd-entries-5824 | 5824 +PASS A.odd-entries-nonzero-in-2G | 5824 odd entries all nonzero in 2G +PASS B.frames-1260 | 1260 +PASS B.no-9-clique +PASS B.90-frames-per-line | {90} +PASS C.bound-beta-ge-8-is-64 | bound over beta>=8 atoms = 64 +PASS C.pairs-57600 | 57600 +PASS C.beta0-atoms-have-zero-hit | max hit among beta-0 atoms = 0 +PASS C.beta7-atoms-counted | 7616 beta-7 atoms +PASS C.census-complete | max hit/beta = 1170/7 at (a0,tr=False,b2,tr=True) beta=7 hit=1170; bound = 784/13 +PASS C.beta7-max-hit | max hit among beta-7 atoms = 1170 at (a0,tr=False,b2,tr=True) +PASS D.singleton-odd-patch-cost-0 | odd pair (2,4) +PASS D.singleton-odd-patch-off-egraph | patch only touches free odd entries +PASS E.coordinate-star-term-0-beta-8 | normal line 0, support 56 lines +PASS E.coordinate-star-term-1-beta-8 | normal line 1, support 56 lines +PASS E.coordinate-star-term-2-beta-8 | normal line 26, support 56 lines +PASS E.coordinate-star-term-3-beta-8 | normal line 27, support 56 lines +PASS E.coordinate-star-term-4-beta-8 | normal line 44, support 56 lines +PASS E.coordinate-star-term-5-beta-8 | normal line 45, support 56 lines +PASS E.coordinate-star-term-6-beta-8 | normal line 54, support 56 lines +PASS E.coordinate-star-term-7-beta-8 | normal line 55, support 56 lines +PASS E.coordinate-star-egraph-identity | sum_k ()() = 2G on every entry +PASS E.coordinate-cst-64 | cst = 64 +PASS E.coordinate-stars-are-family-atoms | each N(f_k) is a trimmed root-star support of the census +PASS E.receipt-matches | research/root-star-integer-cover-seed46/sources/pr1226-RESULTS.json +FAILS: none diff --git a/research/root-star-integer-cover-seed46/evidence/python-3.12.13.txt b/research/root-star-integer-cover-seed46/evidence/python-3.12.13.txt new file mode 100644 index 0000000000..d10b8dd77f --- /dev/null +++ b/research/root-star-integer-cover-seed46/evidence/python-3.12.13.txt @@ -0,0 +1,11 @@ +test_01_complete_primary_replay (__main__.PackageTests.test_01_complete_primary_replay) ... ok +test_02_complete_independent_replay (__main__.PackageTests.test_02_complete_independent_replay) ... ok +test_03_semantic_certificate_mutations (__main__.PackageTests.test_03_semantic_certificate_mutations) ... ok +test_04_mathematical_controls (__main__.PackageTests.test_04_mathematical_controls) ... ok +test_05_source_corruption_and_optimized_relocation (__main__.PackageTests.test_05_source_corruption_and_optimized_relocation) ... ok +test_06_exact_regeneration_and_overwrite_protection (__main__.PackageTests.test_06_exact_regeneration_and_overwrite_protection) ... ok + +---------------------------------------------------------------------- +Ran 6 tests in 120.540s + +OK diff --git a/research/root-star-integer-cover-seed46/evidence/python-3.14.6.txt b/research/root-star-integer-cover-seed46/evidence/python-3.14.6.txt new file mode 100644 index 0000000000..72451686d5 --- /dev/null +++ b/research/root-star-integer-cover-seed46/evidence/python-3.14.6.txt @@ -0,0 +1,11 @@ +test_01_complete_primary_replay (__main__.PackageTests.test_01_complete_primary_replay) ... ok +test_02_complete_independent_replay (__main__.PackageTests.test_02_complete_independent_replay) ... ok +test_03_semantic_certificate_mutations (__main__.PackageTests.test_03_semantic_certificate_mutations) ... ok +test_04_mathematical_controls (__main__.PackageTests.test_04_mathematical_controls) ... ok +test_05_source_corruption_and_optimized_relocation (__main__.PackageTests.test_05_source_corruption_and_optimized_relocation) ... ok +test_06_exact_regeneration_and_overwrite_protection (__main__.PackageTests.test_06_exact_regeneration_and_overwrite_protection) ... ok + +---------------------------------------------------------------------- +Ran 6 tests in 109.240s + +OK diff --git a/research/root-star-integer-cover-seed46/independent.py b/research/root-star-integer-cover-seed46/independent.py new file mode 100644 index 0000000000..df0f84b1df --- /dev/null +++ b/research/root-star-integer-cover-seed46/independent.py @@ -0,0 +1,210 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Separate proof-obligation checker; imports neither verify.py nor predecessor code. + +Uses directly generated positive roots, squared-distance pairings, low-column +binary elimination, and pivoted maximal-clique enumeration. All cliques are +then recovered as subsets of maximal cliques, independently of the producer's +ordered-prefix census. Hanson Sun (@bbMisk), OpenAI Codex assisted. +""" + +import argparse +from collections import Counter +import hashlib +from itertools import combinations, product +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent + + +def check(condition, message): + if not condition: + raise ValueError(message) + + +def sha(value): + return hashlib.sha256(json.dumps(value, separators=(",", ":"), sort_keys=True).encode()).hexdigest() + + +def indices(value): + return [i for i in range(value.bit_length()) if value >> i & 1] + + +def low_rank(rows): + rows = list(rows) + rank = 0 + width = max(rows, default=0).bit_length() + for col in range(width): + pivot = next((r for r in range(rank, len(rows)) if rows[r] >> col & 1), None) + if pivot is None: + continue + rows[rank], rows[pivot] = rows[pivot], rows[rank] + for r in range(rank + 1, len(rows)): + if rows[r] >> col & 1: + rows[r] ^= rows[rank] + rank += 1 + return rank + + +def maximal_cliques(adjacency): + """Bron-Kerbosch with a deterministic pivot; no requested size cutoff.""" + output = [] + + def visit(chosen, possible, excluded): + if not possible and not excluded: + output.append(chosen) + return + union = possible | excluded + pivot = max(indices(union), key=lambda v: (possible & adjacency[v]).bit_count()) + choices = possible & ~adjacency[pivot] + while choices: + bit = choices & -choices + choices ^= bit + vertex = bit.bit_length() - 1 + visit(chosen | bit, possible & adjacency[vertex], excluded & adjacency[vertex]) + possible ^= bit + excluded |= bit + + visit(0, (1 << len(adjacency)) - 1, 0) + return output + + +def verify(certificate): + roots = [] + for a in range(8): + for b in range(a + 1, 8): + for sign in (-2, 2): + vector = [0] * 8 + vector[a], vector[b] = 2, sign + roots.append(tuple(vector)) + for tail in product((-1, 1), repeat=7): + if sum(x == -1 for x in tail) % 2 == 0: + roots.append((1,) + tail) + roots.sort() + check(len(set(roots)) == 120, "direct positive root generation") + gram = [] + for x in roots: + row = [] + for y in roots: + distance = sum((a - b) ** 2 for a, b in zip(x, y)) + check(distance % 8 == 0, "root squared-distance integrality") + row.append(2 - distance // 8) + gram.append(row) + puncture = [i for i, root in enumerate(roots) if any(root[2 * k] == 2 and abs(root[2 * k + 1]) == 2 and sum(v != 0 for v in root) == 2 for k in range(4))] + live = [i for i in range(120) if i not in puncture] + check(len(puncture) == 8 and len(live) == 112, "puncture inventory") + position = {normal: i for i, normal in enumerate(live)} + orth = [sum(1 << j for j, b in enumerate(live) if a != b and gram[a][b] == 0) for a in live] + nonorth = [sum(1 << j for j, b in enumerate(live) if a != b and gram[a][b] != 0) for a in live] + s9 = [sum((1 - abs(gram[a][b]) % 2) << j for j, b in enumerate(live)) for a in live] + check(low_rank(s9) == 9, "binary model rank") + + orth_maximal = maximal_cliques(orth) + check(max(m.bit_count() for m in orth_maximal) == 8, "orthogonal dimension") + frames = sorted(tuple(indices(m)) for m in orth_maximal if m.bit_count() == 8) + check(len(frames) == 1260, "independent complete frames") + frame_sets = [set(frame) for frame in frames] + containing = [{k for k, frame in enumerate(frame_sets) if i in frame} for i in range(112)] + pair_hist = Counter(len(containing[i] & containing[j]) for i in range(112) for j in range(i + 1, 112) if orth[i] >> j & 1) + check(min(pair_hist) > 0 and {len(x) for x in containing} == {90}, "orthogonal-pair completion") + + support_records = [] + support_indices = [] + miss_sets = [] + for a in range(120): + for trimmed in (False, True): + members = [i for i, b in enumerate(live) if gram[a][b] != 0 and not (trimmed and a == b)] + support_records.append((a, trimmed, sum(1 << i for i in members))) + support_indices.append(members) + miss = {k for k, frame in enumerate(frame_sets) if frame.isdisjoint(members)} + expected = containing[position[a]] if trimmed and a in position else set() + check(miss == expected, "independent missing-frame support identity") + miss_sets.append(miss) + + # Direct restricted matrices; deliberately does not use compressed support bases. + table = [] + for members in support_indices: + table.append([low_rank(s9[i] & mask for i in members) for _, _, mask in support_records]) + ranks = Counter(rank for row in table for rank in row) + check(ranks == {7: 7616, 8: 37440, 9: 12544}, "independent atom prices") + endpoints, hit_counts = Counter(), Counter() + for i in range(240): + for j in range(240): + if table[i][j] == 7: + live_trimmed = [a for a, trimmed, _ in (support_records[i], support_records[j]) if trimmed and a in position] + check(live_trimmed, "missing live endpoint on rank-seven atom") + check(containing[position[live_trimmed[0]]] <= miss_sets[i] | miss_sets[j], "rank-seven endpoint containment") + endpoints[len(live_trimmed)] += 1 + hit_counts[1260 - len(miss_sets[i] | miss_sets[j])] += 1 + + maximal = maximal_cliques(nonorth) + check(max(m.bit_count() for m in maximal) == 8, "independent maximum clique") + all_cliques = {0} + for maximal_mask in maximal: + subset = maximal_mask + while subset: + all_cliques.add(subset) + subset = (subset - 1) & maximal_mask + counts = Counter(m.bit_count() for m in all_cliques) + check(len(all_cliques) == 482577, "independent clique coverage") + witness = certificate["nonorthogonality"]["witness_live_indices"] + check(len(witness) == len(set(witness)) == 8, "clique witness size") + check(all(nonorth[i] >> j & 1 for i, j in combinations(witness, 2)), "clique witness edges") + check(all(any(orth[v] >> i & 1 for i in witness) for v in range(112) if v not in witness), "all witness extensions") + + decoder = [[gram[a][b] for b in puncture] for a in live] + check(all(sum(decoder[i][k] * decoder[j][k] for k in range(8)) == 2 * gram[a][b] for i, a in enumerate(live) for j, b in enumerate(live)), "independent all-pairs attainment") + check([table[2 * b][2 * b] for b in puncture] == [8] * 8, "independent cost 64 attainment") + + model = certificate["model"] + check(model == {"roots_sha256": sha(roots), "removed_global_indices": puncture, "live_global_indices": live, "binary_pairing_rank": 9, "supports_sha256": sha(support_records), "supports": 240}, "model receipt") + check(certificate["frames"] == {"count": 1260, "sha256": sha(frames), "frames_per_line": 90, "orthogonal_pair_frame_count_histogram": {str(k): v for k, v in sorted(pair_hist.items())}}, "frame receipt") + check(certificate["atoms"] == {"ordered_pairs": 57600, "rank_histogram": {str(k): v for k, v in sorted(ranks.items())}, "pair_rank_rows": ["".join(map(str, row)) for row in table], "pair_rank_encoding": "240 rows of 240 single-digit exact F2 ranks, support index 2*normal+trimmed", "rank7_live_trimmed_endpoint_count_histogram": {str(k): v for k, v in sorted(endpoints.items())}, "rank7_frame_hits_histogram": {str(k): v for k, v in sorted(hit_counts.items())}}, "atom receipt") + check(certificate["nonorthogonality"] == {"clique_counts_including_empty": {str(k): v for k, v in sorted(counts.items())}, "complete_recursion_nodes": len(all_cliques), "maximum": 8, "witness_live_indices": witness, "witness_doubled_roots": [list(roots[live[i]]) for i in witness]}, "clique receipt") + check(certificate["sharpness"] == {"coordinate_term_costs": [8] * 8, "all_pairs_checked": 12544, "decoder_sha256": sha(decoder), "cost": 64}, "attainment receipt") + check(certificate["conclusion"]["minimum_copy_cost"] == 64 and certificate["conclusion"]["positive_terms_below_64"] == [8, 9], "conclusion receipt") + + manifest = json.loads((HERE / "SOURCES.json").read_text()) + check(len(manifest["dependencies"]) == 6, "source coverage") + for source in manifest["dependencies"]: + data = (HERE / source["path"]).read_bytes() + check(hashlib.sha256(data).hexdigest() == source["sha256"], "source content binding") + check(hashlib.sha1(b"blob %d\0" % len(data) + data).hexdigest() == source["git_blob"], "source Git binding") + expected_commit = "ee8437bd9879272094e20c024cd34a53c4e84cd8" if source["path"] == "sources/pr1236-CERTIFICATE.json" else "8b10989e4e45f0f9ce41004d7898a21a32f87e11" + check(source["source_commit"] == expected_commit, "source commit binding") + check(certificate["source_manifest_sha256"] == sha(manifest), "source manifest binding") + + # PR1236 uses the same sorted positive roots but global (120-line) indices. + # Re-encode our independently generated live-index data; import no PR code. + audited = json.loads((HERE / "sources/pr1236-CERTIFICATE.json").read_text()) + global_supports = [(a, trimmed, sum(1 << live[i] for i in members)) for (a, trimmed, _), members in zip(support_records, support_indices)] + global_frames = [tuple(live[i] for i in frame) for frame in frames] + atom_rows = [(i, j, table[i][j], len(miss_sets[i] | miss_sets[j])) for i in range(240) for j in range(240)] + check(audited["model"] == {"root_lines": 120, "live_lines": 112, "root_sha256": sha(roots), "punctured_frame_indices": puncture, "field": "R or C, ordinary transpose", "support_masks_sha256": sha(global_supports)}, "PR1236 model binding") + check(audited["frames"] == {"count": 1260, "sha256": sha(global_frames), "per_live_line": 90, "orthogonal_pair_frame_multiplicities": {str(k): v for k, v in sorted(pair_hist.items())}}, "PR1236 complete frame binding") + check(audited["atoms"] == {"ordered_support_pairs": 57600, "rank_histogram": {str(k): v for k, v in sorted(ranks.items())}, "sha256": sha(atom_rows), "beta7_missed_frame_histogram": {str(1260-k): v for k, v in hit_counts.items()}, "beta7_live_endpoint_histogram": {str(k): v for k, v in endpoints.items()}}, "PR1236 complete atom binding") + audit_witness = audited["odd_graph"]["maximum_clique_indices"] + check(len(audit_witness) == len(set(audit_witness)) == 8 and all(v in live for v in audit_witness), "PR1236 witness domain") + check(all(gram[a][b] != 0 for a, b in combinations(audit_witness, 2)), "PR1236 witness pairings") + check(audited["odd_graph"] == {"vertices": 112, "degrees": sorted({v.bit_count() for v in nonorth}), "clique_census": {str(k): v for k, v in sorted(counts.items())}, "maximum_clique_indices": audit_witness, "maximum_clique_roots": [list(roots[i]) for i in audit_witness]}, "PR1236 complete clique binding") + check(audited["sharp_decoder"] == {"terms": 8, "costs": [8]*8, "cost": 64, "checked_all_pairs": 12544, "support_sizes": [sum(gram[a][b] != 0 for a in live) for b in puncture]}, "PR1236 attainment binding") + check(audited["result"] == "SHARP_MASKED_ROOT_STAR_ASSEMBLY_FLOOR_64", "PR1236 result label") + return {"maximal_nonorthogonal_cliques": len(maximal), "all_cliques": len(all_cliques), "pair_ranks_checked": 57600, "frames_checked": 1260, "copy_floor": 64, "pr1236_geometric_sections_matched": 5} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--certificate", type=Path, default=HERE / "CERTIFICATE.json") + args = parser.parse_args() + result = verify(json.loads(args.certificate.read_text())) + print("PASS_INDEPENDENT_ROOT_STAR_S46 " + json.dumps(result, sort_keys=True)) + + +if __name__ == "__main__": + try: + main() + except (ValueError, OSError, KeyError, TypeError, IndexError) as error: + print("FAIL_INDEPENDENT_ROOT_STAR_S46:", error, file=sys.stderr) + sys.exit(1) diff --git a/research/root-star-integer-cover-seed46/sources/pr1226-NOTICE.md b/research/root-star-integer-cover-seed46/sources/pr1226-NOTICE.md new file mode 100644 index 0000000000..767d5458bc --- /dev/null +++ b/research/root-star-integer-cover-seed46/sources/pr1226-NOTICE.md @@ -0,0 +1,21 @@ +# Notice and attribution + +Prepared by **Navinor** with help from opencode (research, proof development, +implementation, verification and documentation). Apache-2.0; new contributions are under +the repository's license. + +Model and question: CrocSwap/integer-mult-bounds#717 (DreamingOfClouds), `research/format-limits-2/` at head +`4a97676294f9fa413b65986e9984fddeda71e4cc` (B14 decoder model, D1(a) masked reduction, +D1 mixed-beta open problem, D1(e) sampled covering bound; read for definitions only, not +vendored or executed). Prior decoder floors: CrocSwap/integer-mult-bounds#620 (Joel Pulikkan / GamingPuzzled), +CrocSwap/integer-mult-bounds#968 and CrocSwap/integer-mult-bounds#1077 (woklerx and the seed44/seed48 packages; both defer masked E-graph +identities), CrocSwap/integer-mult-bounds#845 (Mihir Srivastava; fixed-reader ninth total). The E8 line enumeration +is adapted from `research/complex-frame-pair-decoders/verify.py` (Apache-2.0, same +repository) with attribution; no predecessor file is modified or imported at runtime. + +The selected construction chain (see `certificates/selected-result.json`) is read only: +Jonathan Capalbo, Chafik Boukhalfa, Jeremy Kothe, Hao Yan, DreamingOfClouds, eumemic and +the other credited authors of the T37/CrocSwap/integer-mult-bounds#589 chain. No selected-frontier change is proposed. + +Third-party code: none. Standard library only. Retained source attribution and licenses of +all predecessor packages apply to their own files. diff --git a/research/root-star-integer-cover-seed46/sources/pr1226-PROOF.md b/research/root-star-integer-cover-seed46/sources/pr1226-PROOF.md new file mode 100644 index 0000000000..65604debc3 --- /dev/null +++ b/research/root-star-integer-cover-seed46/sources/pr1226-PROOF.md @@ -0,0 +1,114 @@ +# Masked root-star copy-cost floor on P112: covering bound and complete trimmed-star census + +Every finite fact cited as **(Fk)** is checked by `verify.py` with exact integer and F2 +arithmetic. The rest is written argument. This is a scoped obstruction and a complete +finite census for one support family; it is not a theorem about all decoders. + +## 1. Model and the masked identity + +This is CrocSwap/integer-mult-bounds#717's B14 decoder model in its masked (E-graph) form, exactly as stated in D1(a) +of [PR717](https://github.com/CrocSwap/integer-mult-bounds/pull/717) (DreamingOfClouds). The +120 E8 root lines carry labels `u_i` in F2^9 with pairing `S9(u_i,u_j) = ( + 1) mod 2`. +P112 is the 120 lines minus the 8 coordinate frame lines. A decoder is a list of terms +`(d_k, t_k)` with `sum_k d_k t_k^T = 2G` required **only on the E-graph** (the 6720 pairs of +even inner product, the diagonal included): `x_i . y_j = 0` off-diagonal and `x_i . y_i = 4`. +The 5824 odd entries of `2G` are all nonzero, so they are fixed afterwards at zero cost by +singleton terms `(c e_i, e_j)` on odd pairs, whose label pairing rank is 0 **(F1)**. Term k +costs `beta_k`, the F2 rank of the label pairing between its row and column supports, and +`cst = sum_k beta_k`. The coordinate stars `d_k = t_k = ()_i` over the eight frame +lines satisfy `sum_k = 2` on every entry and cost 8 per term, +`cst = 64` **(F2)**; they are trimmed root-star atoms of the census below. + +## 2. The covering lemma (frame substitution) + +A **frame** is an 8-clique of the E-graph; there are exactly 1260 of them in P112 and no +9-clique **(F3)**, and every line lies in exactly 90 frames **(F4)**. Restricting the masked +identity to a frame F gives `[x_i . y_j] = 4 I_8`, a full-rank 8x8 system. Each term +contributes the block `(d_k|_F)(t_k|_F)^T`, of rank at most one, and contributes nothing +unless its row and column supports both meet F. Hence **at least 8 terms meet every frame**. +A beta-0 atom can never meet a frame: both supports inside a frame would force an +even-paired pair inside `R x A`, contradicting pairing rank 0 **(F5)**. + +Let `h_k` be the number of frames term k meets and let `gamma` be the minimum of +`beta/hit` over the allowed atoms. Then + + cst = sum_k beta_k >= gamma * sum_k h_k >= gamma * 8 * 1260 = 10080 * gamma. + +For the class of all supports this recovers the weakness of CrocSwap/integer-mult-bounds#717 D1(e) (sampled there at +`8/rho` about 43.8). The point here is that for a **finite** family `gamma` is exact. + +## 3. The census (root-star family) + +For each of the 120 root lines `alpha` the root-star supports on P112 are +`C(alpha) = {i : != 0}` and `N(alpha) = C(alpha)` minus alpha's own line when +that line is live (for the 8 frame normals the self-line is punctured, so both coincide). +The label span of `N(alpha)` is `H_alpha = u_alpha^perp` (dimension 8), so an odd root pair +`( odd)` gives pairing rank `8 - [ odd] = 7` — the mixed-beta atoms +that CrocSwap/integer-mult-bounds#717 D1(b)'s flat-support census excludes (its supports are complements of hyperplane +flats with all pairwise span pairings of rank at least 8; a trimmed star is not of that form). + +The census enumerates all 240 supports and all 57,600 ordered support pairs **(F6)**: + +| beta | atoms | +|---|---:| +| 7 | 7,616 | +| 8 | 37,440 | +| 9 | 12,544 | + +with exact pairing ranks and exact frame-hit counts (frames met on both sides): + +- `max(hit/beta) = 1170/7`, attained at beta-7 atoms such as `(N(f), N(beta))` with + `f` a frame normal and `` odd; every beta-7 atom hits at most 1170 of the 1260 + frames **(F7)**. The eight best atoms are recorded in `RESULTS.json`. +- The bound over the whole family is `10080 * 7/1170 = 784/13`, about **60.31** **(F8)**. +- Restricting to atoms of pairing rank at least 8, `gamma = 8/1260` and the bound is + **exactly 64** **(F9)**, attained by the coordinate stars of section 1. + +## 4. What this establishes, and what it does not + +1. **Mixed-beta trimmed stars are not excluded by the covering argument.** The task card's + hoped-for condition (every beta-7 atom hits at most `7/8` of the frames, which would have + forced the bound to 64) is **false**: atoms of pairing rank 7 hit 1170 frames + (the falsifying instance; threshold was 1102). The complete covering bound for the + root-star family is `784/13`, so an assembly of beta-7 trimmed stars at total cost 63 or + 64 is not contradicted by frame counting alone. +2. **All the slack lives in the 7,616 trimmed odd-pair atoms.** Any root-star decoder whose + terms all have pairing rank at least 8 costs at least 64 for any number of terms, with + the coordinate stars attaining it. This extends the star floor from the eight-term + all-pairs statements of [PR968](https://github.com/CrocSwap/integer-mult-bounds/pull/968) + and CrocSwap/integer-mult-bounds#717 D1(b)/(c) to arbitrary term counts under the masked identity, inside this family. +3. **The remaining question for the family is an assembly problem** in the exact window + `[784/13, 64]`: can nine or more of the beta-7 atoms (the recorded leads hit 1170 of the + 1260 frames each) be combined so that every frame is met by at least 8 terms whose + restricted blocks sum to `4 I_8`? Frame counting cannot answer this; a solver or an + algebraic obstruction would. This package does not attempt that assembly. + +No cost below 64 is claimed or constructed. No supplier, word, or kappa change is claimed. +The favourable-cost accounting of the task card (one cst unit is +2.81% of `b` on the +selected T37 profile per CrocSwap/integer-mult-bounds#717 P1, and any complex-side change is capped by the CrocSwap/integer-mult-bounds#589 bit +supplier at kappa 0.001730427469823602) is unchanged: nothing here lowers cst, so the paid +recursive moment does not move. Realization charges that a future construction would owe +(centre reads, frame legality, dirty restoration; CrocSwap/integer-mult-bounds#717 recorded unpaired-centre parity +costs and negative net buildability for its P104/P111 hits) are **not** checked here. + +## 5. Scope + +- **Covered.** The masked E-graph identity on P112; terms with support pairs from the 240 + root-star supports (untrimmed `C(alpha)` and self-trimmed `N(alpha)`, 120 normals); + arbitrary real coefficients and arbitrary sign patterns (the covering bound depends only + on supports); any number of terms. +- **Not covered.** Supports trimmed by more than the self-line, unions of stars, non-star + supports (CrocSwap/integer-mult-bounds#717 D3's cost-63 P111 and cost-56 P104 decoders are non-star), general + supports (where D1(e)'s 43.8 applies), punctures other than P112, and any assembly or + coefficient search. The eight-term all-pairs results of CrocSwap/integer-mult-bounds#968 and CrocSwap/integer-mult-bounds#1077 are unchanged; + the eight-term masked case is closed concurrently by + [PR1212](https://github.com/CrocSwap/integer-mult-bounds/pull/1212) and + [PR1213](https://github.com/CrocSwap/integer-mult-bounds/pull/1213), and one-sided + root-linear masked factors at arbitrary term count by + [PR1191](https://github.com/CrocSwap/integer-mult-bounds/pull/1191); those routes do not + reach the trimmed, non-root-linear star atoms censused here. +- **Not a formal proof.** Finite replay supports the written argument; no proof assistant + or independent human review is claimed. A finite census is not an impossibility theorem + outside the stated family. + +Prepared by **Navinor** with help from opencode. Apache-2.0. diff --git a/research/root-star-integer-cover-seed46/sources/pr1226-README.md b/research/root-star-integer-cover-seed46/sources/pr1226-README.md new file mode 100644 index 0000000000..5440a1de61 --- /dev/null +++ b/research/root-star-integer-cover-seed46/sources/pr1226-README.md @@ -0,0 +1,110 @@ +# Masked root-star floor on P112: complete trimmed-star census (no new kappa) + +**Scoped negative / method-obstruction result; no new kappa, no supplier.** In CrocSwap/integer-mult-bounds#717's B14 +decoder model on the pinned P112 label set, masked E-graph identity (CrocSwap/integer-mult-bounds#717 D1(a): exactness +only on the 6720 even-pair entries, the 5824 odd entries fixed by cost-0 singleton terms), +this package answers one bounded question: can root-star decoders with **trimmed** supports +`N(alpha)` (pairing rank 7 atoms — the mixed-beta class CrocSwap/integer-mult-bounds#717 D1 leaves open) improve on +the coordinate decoder's copy cost `cst = 64`, with any number of terms? + +**Answer: not by the frame-substitution argument, and the argument's exact limit is +recorded.** A complete census of all 240 root-star supports and all 57,600 ordered support +pairs (exact pairing ranks, exact frame-hit counts over the 1260 E-graph 8-cliques) gives: + +- the covering bound over the whole family is exactly **784/13 ≈ 60.31** + (`cst >= 10080 * min(beta/hit)`, `min(beta/hit) = 7/1170`); +- the hoped-for 64 bound is **falsified**: beta-7 trimmed atoms exist that meet **1170** of + the 1260 frames (the task card's threshold for the bound to hold was 1102), so nine or + more cheap trimmed stars at total cost 63–64 are not excluded by frame counting; +- over atoms of pairing rank at least 8 the bound is **exactly 64**, sharp at the eight + coordinate stars, so all the slack sits in the **7,616** beta-7 atoms (the eight best are + recorded in `RESULTS.json` as leads for an assembly search). + +The covering lemma, the reduction lemma, the falsification record and the exact scope are +in [PROOF.md](PROOF.md). The result extends the star floor of +[PR968](https://github.com/CrocSwap/integer-mult-bounds/pull/968) and CrocSwap/integer-mult-bounds#717 D1(b)/(c) from +eight-term all-pairs statements to arbitrary term counts under the masked identity inside +this family, and it isolates the remaining window `[784/13, 64]` as an assembly problem. +No construction below 64 is claimed; the paid moment is unchanged. + +## Reproduce + +From the repository root, Python 3.10+, standard library only: + +```text +python research/masked-root-star-floor/verify.py +``` + +Expected final lines include: + +```text +PASS C.bound-beta-ge-8-is-64 | bound over beta>=8 atoms = 64 +PASS C.census-complete | max hit/beta = 1170/7 at (a0,tr=False,b2,tr=True) beta=7 hit=1170; bound = 784/13 +PASS E.coordinate-cst-64 | cst = 64 +FAILS: none +``` + +The run rebuilds the 120-line E8 model, the 1260 frames and the full 57,600-pair census, +and compares every field of the recomputed receipt with the committed `RESULTS.json` +(mutation-detecting: altered ranks, hit counts, frames or model facts fail the comparison). +`--write /new/file.json` writes a fresh receipt; `--check PATH` compares against another. + +## Files + +`verify.py` (checker, exact integer/F2), `RESULTS.json` (receipt), `PROOF.md` (statement and +argument), `SOURCES.json` (pins), `CLAIM.md` (task card), `NOTICE.md` (attribution). The E8 +line enumeration is adapted from `research/complex-frame-pair-decoders/verify.py` (CrocSwap/integer-mult-bounds#968 +package, Apache-2.0) with attribution; nothing is imported and no predecessor file changes. + +## Scope and inherited obligations + +Covered: the masked identity on P112, root-star supports (untrimmed `C(alpha)`, +self-trimmed `N(alpha)`), arbitrary real coefficients, any term count. Not covered: deeper +trims and unions, non-star supports (CrocSwap/integer-mult-bounds#717 D3's P111/P104 hits are non-star and beat 64 off +P112), general supports (CrocSwap/integer-mult-bounds#717 D1(e)'s sampled 43.8 bound), other punctures, and any +assembly of the recorded beta-7 leads. Finite replay is not a formal proof of the +multiplication theorem. The selected record (kappa 836330098538459/5e17), +`certificates/selected-result.json`, `upstream/` and all frozen pins are unchanged; all +all-size/compiler, common-label/mutable-source, hosting, precision/tape and analytic +obligations of the selected construction remain inherited and unchecked here. + +## Credit and overlap + +- **DreamingOfClouds** ([PR717](https://github.com/CrocSwap/integer-mult-bounds/pull/717), + [PR595](https://github.com/CrocSwap/integer-mult-bounds/pull/595), + [PR604](https://github.com/CrocSwap/integer-mult-bounds/pull/604)): the B14 model, the + masked reduction D1(a), the mixed-beta open problem and the sampled covering bound D1(e). +- **woklerx** ([PR968](https://github.com/CrocSwap/integer-mult-bounds/pull/968), + [PR1077](https://github.com/CrocSwap/integer-mult-bounds/pull/1077)): the eight-term + all-pairs floor and its complex extension; both defer masked E-graph identities. +- **seed48 package** (`research/root-pair-first-drop-seed48/`): second deferral of masked + identities; **Joel Pulikkan / GamingPuzzled** + ([PR620](https://github.com/CrocSwap/integer-mult-bounds/pull/620)): star floors and the + complex frame decoder of cost 64; **Mihir Srivastava** + ([PR845](https://github.com/CrocSwap/integer-mult-bounds/pull/845)): the fixed-reader + ninth total, whose scope excludes masked completions. +- The open star-decoder PRs + ([#631](https://github.com/CrocSwap/integer-mult-bounds/pull/631), + [#669](https://github.com/CrocSwap/integer-mult-bounds/pull/669), + [#725](https://github.com/CrocSwap/integer-mult-bounds/pull/725), + [#732](https://github.com/CrocSwap/integer-mult-bounds/pull/732), + [CrocSwap/integer-mult-bounds#1171](https://github.com/CrocSwap/integer-mult-bounds/pull/1171)) concern the bit-side + label-code star model and puncture ratios; this result is on the complex B14 side and does + not import their claims. +- **Concurrent masked-model results (found in the final overlap refresh).** + [CrocSwap/integer-mult-bounds#1212](https://github.com/CrocSwap/integer-mult-bounds/pull/1212) proves the E-graph + eight-term floor via rank-8 gauge rigidity, and + [CrocSwap/integer-mult-bounds#1213](https://github.com/CrocSwap/integer-mult-bounds/pull/1213) classifies the masked + coordinate component for eight terms (cost 64 along continuous paths from the coordinate + decoder); both explicitly leave nine or more terms open. [CrocSwap/integer-mult-bounds#1191](https://github.com/CrocSwap/integer-mult-bounds/pull/1191) + proves one-sided root-linear masked rigidity at arbitrary term count — one factor in the + root-coordinate space forces all-pairs exactness. This package is complementary to all + three: it covers **arbitrary term counts with root-star support patterns and unrestricted + (non-root-linear) coefficients on both factors**, the setting where the trimmed beta-7 + atoms live; no predecessor census covers those atoms. Coordination claim: + [discussion CrocSwap/integer-mult-bounds#1210](https://github.com/CrocSwap/integer-mult-bounds/discussions/1210) + (which [CrocSwap/integer-mult-bounds#1213](https://github.com/CrocSwap/integer-mult-bounds/pull/1213) cites as the + announced scope of this census). + +Prepared by **Navinor** with help from opencode. New contributions are under the +repository's Apache-2.0 license. diff --git a/research/root-star-integer-cover-seed46/sources/pr1226-RESULTS.json b/research/root-star-integer-cover-seed46/sources/pr1226-RESULTS.json new file mode 100644 index 0000000000..1827eb4903 --- /dev/null +++ b/research/root-star-integer-cover-seed46/sources/pr1226-RESULTS.json @@ -0,0 +1,122 @@ +{ + "census": { + "beta0_max_hit": 0, + "beta7_atom_count": 7616, + "beta_histogram": { + "7": 7616, + "8": 37440, + "9": 12544 + }, + "frame_substitution_bound": [ + 784, + 13 + ], + "frame_substitution_bound_beta_ge_8": [ + 64, + 1 + ], + "gamma_min_beta_over_hit": [ + 7, + 1170 + ], + "max_hit_beta7": 1170, + "max_hit_beta7_atom": [ + 0, + false, + 2, + true, + 1170 + ], + "max_hit_over_beta": [ + 1170, + 7 + ], + "max_hit_over_beta_atom": [ + 0, + false, + 2, + true, + 7, + 1170 + ], + "pairs": 57600, + "supports": 240, + "top_beta7_atoms_by_hit": [ + [ + 1170, + 119, + true, + 55, + true + ], + [ + 1170, + 119, + true, + 55, + false + ], + [ + 1170, + 119, + true, + 44, + true + ], + [ + 1170, + 119, + true, + 44, + false + ], + [ + 1170, + 119, + true, + 26, + true + ], + [ + 1170, + 119, + true, + 26, + false + ], + [ + 1170, + 119, + true, + 1, + true + ], + [ + 1170, + 119, + true, + 1, + false + ] + ] + }, + "coordinate": { + "coordinate_cst": 64, + "coordinate_support_sizes": [ + 56 + ], + "coordinate_terms": 8 + }, + "frames": { + "count": 1260, + "frames_per_line": 90, + "max_clique": 8 + }, + "model": { + "egraph_row_ones": 60, + "free_odd_entries": 5824, + "lines": 120, + "p112": 112 + }, + "name": "MASKED_ROOT_STAR_FLOOR_P112" +} diff --git a/research/root-star-integer-cover-seed46/sources/pr1226-verify.py b/research/root-star-integer-cover-seed46/sources/pr1226-verify.py new file mode 100644 index 0000000000..7578bc6bc3 --- /dev/null +++ b/research/root-star-integer-cover-seed46/sources/pr1226-verify.py @@ -0,0 +1,354 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Masked root-star copy-cost floor on P112: complete trimmed-star census (CrocSwap/integer-mult-bounds#717 D1 hole). + +Standard library only; exact integer and F2 arithmetic throughout. + +Model (CrocSwap/integer-mult-bounds#717 B14, masked/E-graph form, see CrocSwap/integer-mult-bounds#717 format-limits-2 D1(a)): the 120 E8 root +lines; P112 = 120 minus the 8 coordinate frame lines; labels pair as ( + 1) mod 2. +A decoder is a list of terms (d_k, t_k); term k costs beta_k = F2 rank of the label pairing +between its row support and column support; the identity is required only on the E-graph +(even inner-product pairs): x_i.y_j = 0 off-diagonal, x_i.y_i = 4 (target 2G). The 5824 +odd entries are free (fixed after the fact by cost-0 singleton terms: section D). + +Root-star supports: for a root line alpha, C(alpha) = {i in P112 : != 0} +(untrimmed) and N(alpha) = C(alpha) minus alpha's own line (self-trimmed). N(alpha) has +label span H_alpha (dimension 8), so an odd root pair (alpha, beta) gives the mixed-beta +atom cost 7 -- exactly the atoms CrocSwap/integer-mult-bounds#717 D1(b) excludes from its flat-support census. + +Sections (each prints PASS/FAIL lines): + A model facts: 120 lines, P112, E-graph row counts, 5824 free odd entries + B frames: 1260 eight-cliques of the E-graph, none of size 9, 90 frames per line + C the complete atom census: all 240 root-star supports, all 57,600 ordered pairs, + exact pairing rank beta and exact frame-hit count; the frame-substitution bound + D reduction control: a cost-0 singleton patch fixes one odd entry exactly + E controls: coordinate decoder (cst 64) rebuilt exactly; beta-0 atoms never meet a + frame; receipt comparison against RESULTS.json (mutation-detecting) + +The frame-substitution argument (used with the census): every frame F of the E-graph is an +8-clique, and the masked identity restricted to F is [x_i.y_j] = 4 I_8, a full-rank 8x8 +system. Each term contributes a rank-at-most-one block (d_k|_F)(t_k|_F)^T and contributes +nothing unless its row and column supports both meet F ("meets F"). So >= 8 terms meet +every frame. With h_k the number of frames term k meets and gamma = min over allowed +atoms of beta/hit, cst = sum beta_k >= gamma * sum h_k >= gamma * 8 * 1260. +""" +import argparse +import hashlib +import itertools +import json +import sys +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +FAILS = [] +LOG = [] + + +def check(tag, cond, info=''): + line = ('PASS ' if cond else 'FAIL ') + tag + (' | ' + info if info else '') + print(line, flush=True) + LOG.append(line) + if not cond: + FAILS.append(tag) + + +# ------------------------------------------------------- A. E8 lines, labels, E-graph +def e8_roots(): + """240 roots in doubled coordinates; enumeration as in research/complex-frame-pair-decoders/verify.py (adapter, attributed).""" + roots = [] + for i, j in itertools.combinations(range(8), 2): + for si in (1, -1): + for sj in (1, -1): + v = [0] * 8 + v[i], v[j] = 2 * si, 2 * sj + roots.append(tuple(v)) + for s in itertools.product((1, -1), repeat=8): + if s.count(-1) % 2 == 0: + roots.append(tuple(s)) + return roots + + +def neg(v): + return tuple(-a for a in v) + + +def dot(x, y): + return sum(a * b for a, b in zip(x, y)) + + +ROOTS = e8_roots() +LINES = [] +_seen = set() +for r in ROOTS: + key = r if r > neg(r) else neg(r) + if key not in _seen: + _seen.add(key) + LINES.append(r) +NL = len(LINES) + + +def ip(x, y): + d = dot(x, y) + assert d % 4 == 0 + return d // 4 + + +IP = [[ip(LINES[i], LINES[j]) for j in range(NL)] for i in range(NL)] +# Label pairing rows over F2^9: bit j is ( + 1) mod 2. +NROW = [sum(((IP[i][j] + 1) & 1) << j for j in range(NL)) for i in range(NL)] +FRAME0 = [] +for a in range(4): + for s in (1, -1): + v = [0] * 8 + v[2 * a], v[2 * a + 1] = 2, 2 * s + FRAME0.append(LINES.index(tuple(v))) +P112 = [i for i in range(NL) if i not in FRAME0] +NP = len(P112) + + +def f2_rank(rows): + basis = {} + rank = 0 + for v in rows: + while v: + h = v.bit_length() - 1 + if h in basis: + v ^= basis[h] + else: + basis[h] = v + rank += 1 + break + return rank + + +def pair_rank(rows, cols): + cm = 0 + for j in cols: + cm |= 1 << j + return f2_rank([NROW[i] & cm for i in rows]) + + +def section_a(): + check('A.lines-120', NL == 120 and len(ROOTS) == 240, '120 lines from 240 roots') + check('A.p112-112', NP == 112 and len(FRAME0) == 8, 'P112 = 120 - 8 frame lines') + check('A.ip-diag-2', all(IP[i][i] == 2 for i in range(NL))) + rows = [((IP[i][j] + 1) & 1) for i in P112 for j in P112] + ones = sum(rows) + e_row = [sum((IP[i][j] + 1) & 1 for j in P112) for i in P112] + check('A.egraph-60-per-row', set(e_row) == {60}, str(set(e_row))) + check('A.free-odd-entries-5824', NP * NP - ones == 5824, str(NP * NP - ones)) + odd_nonzero = all(IP[i][j] != 0 for i in P112 for j in P112 if ((IP[i][j] + 1) & 1) == 0) + check('A.odd-entries-nonzero-in-2G', odd_nonzero, '5824 odd entries all nonzero in 2G') + + +# ------------------------------------------------------------------ B. E-graph frames +def eg_adj(i, j): + return i != j and ((IP[i][j] + 1) & 1) == 1 + + +def section_b(): + adj = [[k for k in range(NP) if eg_adj(P112[i], P112[k])] for i in range(NP)] + frames = [] + + def ext(cl, cand): + if len(cl) == 8: + frames.append(tuple(cl)) + return + for k, v in enumerate(cand): + ext(cl + [v], [w for w in cand[k + 1:] if eg_adj(P112[v], P112[w])]) + ext([], list(range(NP))) + check('B.frames-1260', len(frames) == 1260, str(len(frames))) + common9 = 0 + for c in frames: + cand = set(range(NP)) + for v in c: + cand &= set(adj[v]) + common9 += 1 if cand else 0 + check('B.no-9-clique', common9 == 0) + per_line = [0] * NP + for c in frames: + for v in c: + per_line[v] += 1 + check('B.90-frames-per-line', set(per_line) == {90}, str(set(per_line))) + return frames + + +# ------------------------------------------------- C. root-star supports and the census +def support_masks(): + """240 root-star supports as 112-bit masks over P112 positions: (normal line, trimmed, mask).""" + out = [] + pos = {g: i for i, g in enumerate(P112)} + for a in range(NL): + untrimmed = 0 + for i in P112: + if IP[i][a] != 0: + untrimmed |= 1 << pos[i] + trimmed = untrimmed + if a in pos: + trimmed &= ~(1 << pos[a]) + out.append((a, False, untrimmed)) + out.append((a, True, trimmed)) + return out + + +def section_c(frames): + sup = support_masks() + fm = [sum((1 << v) for v in c) for c in frames] + meet = [] + for (a, tr, m) in sup: + bits = 0 + for f, fmask in enumerate(fm): + if fmask & m: + bits |= 1 << f + meet.append(bits) + hist = {} + max_ratio = None + argmax = None + max_hit7 = -1 + argmax7 = None + n7 = 0 + gamma = None + gamma8 = None + beta0_hit_max = 0 + idxs = [[P112[i] for i in range(NP) if (m >> i) & 1] for (_, _, m) in sup] + top7 = [] + for r in range(len(sup)): + for a2 in range(len(sup)): + beta = pair_rank(idxs[r], idxs[a2]) + hit = bin(meet[r] & meet[a2]).count('1') + hist[beta] = hist.get(beta, 0) + 1 + if beta == 0 and hit > beta0_hit_max: + beta0_hit_max = hit + if beta == 7: + n7 += 1 + top7.append((hit, sup[r][0], sup[r][1], sup[a2][0], sup[a2][1])) + if hit > max_hit7: + max_hit7 = hit + argmax7 = (sup[r][0], sup[r][1], sup[a2][0], sup[a2][1], hit) + if hit > 0: + ratio = Q(hit, beta) + if max_ratio is None or ratio > max_ratio: + max_ratio = ratio + argmax = (sup[r][0], sup[r][1], sup[a2][0], sup[a2][1], beta, hit) + g = Q(beta, hit) + if gamma is None or g < gamma: + gamma = g + if beta >= 8 and (gamma8 is None or g < gamma8): + gamma8 = g + bound = Q(8 * 1260) * gamma + bound8 = Q(8 * 1260) * gamma8 + top7.sort(reverse=True) + check('C.bound-beta-ge-8-is-64', bound8 == 64, 'bound over beta>=8 atoms = %s' % bound8) + check('C.pairs-57600', sum(hist.values()) == 57600, str(sum(hist.values()))) + check('C.beta0-atoms-have-zero-hit', beta0_hit_max == 0, + 'max hit among beta-0 atoms = %d' % beta0_hit_max) + check('C.beta7-atoms-counted', n7 == hist.get(7, 0), '%d beta-7 atoms' % n7) + info = 'max hit/beta = %s at (a%s,tr=%s,b%s,tr=%s) beta=%d hit=%d; bound = %s' % ( + max_ratio, argmax[0], argmax[1], argmax[2], argmax[3], argmax[4], argmax[5], bound) + check('C.census-complete', True, info) + check('C.beta7-max-hit', True, 'max hit among beta-7 atoms = %d at (a%s,tr=%s,b%s,tr=%s)' % ( + (max_hit7,) + argmax7[:4] if argmax7 else (max_hit7, '-', '-', '-', '-'))) + return { + 'supports': len(sup), + 'pairs': sum(hist.values()), + 'beta_histogram': {str(k): v for k, v in sorted(hist.items())}, + 'max_hit_over_beta': [max_ratio.numerator, max_ratio.denominator], + 'max_hit_over_beta_atom': list(argmax), + 'max_hit_beta7': max_hit7, + 'max_hit_beta7_atom': list(argmax7) if argmax7 else None, + 'beta7_atom_count': n7, + 'beta0_max_hit': beta0_hit_max, + 'gamma_min_beta_over_hit': [gamma.numerator, gamma.denominator], + 'frame_substitution_bound': [bound.numerator, bound.denominator], + 'frame_substitution_bound_beta_ge_8': [bound8.numerator, bound8.denominator], + 'top_beta7_atoms_by_hit': [list(t) for t in top7[:8]], + } + + +# ------------------------------------------------------------- D. reduction (cost-0) +def section_d(): + for i in P112: + for j in P112: + if i != j and IP[i][j] != 0 and ((IP[i][j] + 1) & 1) == 0: + cost = pair_rank([i], [j]) + check('D.singleton-odd-patch-cost-0', cost == 0, 'odd pair (%d,%d)' % (i, j)) + check('D.singleton-odd-patch-off-egraph', ((IP[i][j] + 1) & 1) == 0, + 'patch only touches free odd entries') + return + check('D.singleton-odd-patch-cost-0', False, 'no odd pair found') + + +# ------------------------------------------------- E. coordinate decoder and controls +def section_e(): + """The attaining coordinate decoder: 8 frame-normal star terms, d_k = t_k = ()_i. + + The frame lines f_0..f_7 are orthogonal of norm 2, so sum_k = 2: + the term matrix is exactly 2G on every entry. Supports are N(f_k) = C(f_k) on P112 + (the self-line is punctured), label span H_{f_k}, pairing rank 8 each.""" + cols = [] + for fidx in FRAME0: + s = [i for i in P112 if IP[i][fidx] != 0] + cols.append((fidx, s)) + for k, (fidx, s) in enumerate(cols): + check('E.coordinate-star-term-%d-beta-8' % k, pair_rank(s, s) == 8, + 'normal line %d, support %d lines' % (fidx, len(s))) + ok_identity = True + for i in P112: + for j in P112: + s = sum(IP[i][f] * IP[j][f] for f in FRAME0) + if s != 2 * IP[i][j]: + ok_identity = False + if ((IP[i][j] + 1) & 1) == 1: + want = 4 if i == j else 0 + if 2 * IP[i][j] != want: + ok_identity = False + check('E.coordinate-star-egraph-identity', ok_identity, + 'sum_k ()() = 2G on every entry') + cst = sum(pair_rank(s, s) for _, s in cols) + check('E.coordinate-cst-64', cst == 64, 'cst = %d' % cst) + check('E.coordinate-stars-are-family-atoms', all( + any(a == fidx and tr for (a, tr, m) in support_masks()) for fidx in FRAME0), + 'each N(f_k) is a trimmed root-star support of the census') + return {'coordinate_cst': cst, 'coordinate_terms': 8, 'coordinate_support_sizes': sorted( + {len(s) for _, s in cols})} + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument('--write', metavar='PATH', help='write the receipt to PATH') + ap.add_argument('--check', metavar='PATH', help='compare the receipt with PATH') + args = ap.parse_args() + section_a() + frames = section_b() + census = section_c(frames) + section_d() + coord = section_e() + receipt = { + 'name': 'MASKED_ROOT_STAR_FLOOR_P112', + 'model': {'lines': NL, 'p112': NP, 'egraph_row_ones': 60, 'free_odd_entries': 5824}, + 'frames': {'count': 1260, 'max_clique': 8, 'frames_per_line': 90}, + 'census': census, + 'coordinate': coord, + } + ref = None + ref_path = Path(args.check) if args.check else HERE / 'RESULTS.json' + if ref_path.exists(): + ref = json.loads(ref_path.read_text(encoding='utf-8')) + same = ref == receipt + check('E.receipt-matches', same, str(ref_path)) + if not same: + for key in set(list(ref.keys()) + list(receipt.keys())): + if ref.get(key) != receipt.get(key): + print(' DIFF %s: recorded=%r computed=%r' % (key, ref.get(key), receipt.get(key))) + else: + check('E.receipt-present', args.write is not None, 'no RESULTS.json; use --write to create one') + if args.write: + Path(args.write).write_text(json.dumps(receipt, indent=1, sort_keys=True) + '\n', encoding='utf-8') + print('wrote', args.write) + print('FAILS:', FAILS if FAILS else 'none') + return 1 if FAILS else 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/research/root-star-integer-cover-seed46/sources/pr1236-CERTIFICATE.json b/research/root-star-integer-cover-seed46/sources/pr1236-CERTIFICATE.json new file mode 100644 index 0000000000..ecc639bca2 --- /dev/null +++ b/research/root-star-integer-cover-seed46/sources/pr1236-CERTIFICATE.json @@ -0,0 +1,197 @@ +{ + "assembly_cases": { + "8_terms_with_beta7": "a frame has at most 7 active terms", + "9_terms_below_64": "nine beta7 atoms require a forbidden nine-clique", + "at_least_10_terms": "cost at least 70", + "fewer_than_8_terms": "rank obstruction" + }, + "atoms": { + "beta7_live_endpoint_histogram": { + "1": 1792, + "2": 5824 + }, + "beta7_missed_frame_histogram": { + "90": 1792, + "180": 5824 + }, + "ordered_support_pairs": 57600, + "rank_histogram": { + "7": 7616, + "8": 37440, + "9": 12544 + }, + "sha256": "1c7b13d041e48e2dde7076c76417cd702e42da2510d653e7d87e6f32c0f59e85" + }, + "frames": { + "count": 1260, + "orthogonal_pair_frame_multiplicities": { + "10": 2856, + "15": 448 + }, + "per_live_line": 90, + "sha256": "9f4794b9b10349aa5e4e095547b75fd08c4e895c08980db020c79c525a9a3924" + }, + "model": { + "field": "R or C, ordinary transpose", + "live_lines": 112, + "punctured_frame_indices": [ + 0, + 1, + 6, + 11, + 20, + 29, + 106, + 119 + ], + "root_lines": 120, + "root_sha256": "499909f15616b21ed34b704054685a0c90c244fb81819ba458e076b8dd97308c", + "support_masks_sha256": "1e195ccfa67882af8702ea48deadc1247eca6a6b32e2eb6836af1fe09300fca9" + }, + "negative_controls": [ + "wrong_root_norm", + "rank_counts_rows_instead_of_pivots", + "omit_pairing_plus_one", + "remove_all_extensions_of_pair", + "orthogonal_endpoint_pair", + "repeated_endpoint", + "injected_nine_clique", + "omit_coordinate_term" + ], + "odd_graph": { + "clique_census": { + "0": 1, + "1": 112, + "2": 2912, + "3": 25088, + "4": 88704, + "5": 161280, + "6": 145152, + "7": 55296, + "8": 4032 + }, + "degrees": [ + 52 + ], + "maximum_clique_indices": [ + 2, + 3, + 13, + 22, + 44, + 71, + 80, + 99 + ], + "maximum_clique_roots": [ + [ + 0, + 0, + 0, + 0, + 0, + 2, + -2, + 0 + ], + [ + 0, + 0, + 0, + 0, + 0, + 2, + 0, + -2 + ], + [ + 0, + 0, + 0, + 2, + 0, + -2, + 0, + 0 + ], + [ + 0, + 0, + 2, + 0, + 0, + -2, + 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 + ] + ], + "vertices": 112 + }, + "result": "SHARP_MASKED_ROOT_STAR_ASSEMBLY_FLOOR_64", + "schema": 1, + "sharp_decoder": { + "checked_all_pairs": 12544, + "cost": 64, + "costs": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8 + ], + "support_sizes": [ + 56, + 56, + 56, + 56, + 56, + 56, + 56, + 56 + ], + "terms": 8 + } +} diff --git a/research/root-star-integer-cover-seed46/test_package.py b/research/root-star-integer-cover-seed46/test_package.py new file mode 100644 index 0000000000..58564efab1 --- /dev/null +++ b/research/root-star-integer-cover-seed46/test_package.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Complete replays and semantic controls for the finite copy-cost theorem.""" + +import copy +import importlib.util +import json +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +HERE = Path(__file__).resolve().parent + + +def module(name): + spec = importlib.util.spec_from_file_location(name, HERE / (name + ".py")) + value = importlib.util.module_from_spec(spec) + spec.loader.exec_module(value) + return value + + +def run(script, *args, package=HERE): + return subprocess.run([sys.executable, "-I", "-O", "-B", str(package / script), *map(str, args)], capture_output=True, text=True, timeout=120, cwd=package) + + +class PackageTests(unittest.TestCase): + def test_01_complete_primary_replay(self): + result = run("verify.py") + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertIn("copy_floor=64", result.stdout) + + def test_02_complete_independent_replay(self): + result = run("independent.py") + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertIn('"maximal_nonorthogonal_cliques": 27968', result.stdout) + + def test_03_semantic_certificate_mutations(self): + original = json.loads((HERE / "CERTIFICATE.json").read_text()) + changes = [ + lambda c: c["atoms"]["pair_rank_rows"].__setitem__(0, "6" + c["atoms"]["pair_rank_rows"][0][1:]), + lambda c: c["nonorthogonality"]["clique_counts_including_empty"].__setitem__("9", 1), + lambda c: c["frames"]["orthogonal_pair_frame_count_histogram"].__setitem__("0", 1), + lambda c: c["model"]["live_global_indices"].pop(), + lambda c: c["conclusion"].__setitem__("minimum_copy_cost", 63), + ] + with tempfile.TemporaryDirectory(prefix="root-star-controls-") as tmp: + path = Path(tmp) / "bad.json" + for index, change in enumerate(changes): + corrupted = copy.deepcopy(original) + change(corrupted) + path.write_text(json.dumps(corrupted)) + for script in ("verify.py", "independent.py"): + with self.subTest(control=index, script=script): + result = run(script, "--certificate", path) + self.assertNotEqual(result.returncode, 0, result.stdout) + self.assertIn("FAIL_", result.stderr) + + def test_04_mathematical_controls(self): + primary, separate = module("verify"), module("independent") + # Neither clique routine may silently stop at the desired bound eight. + complete9 = [((1 << 9) - 1) ^ (1 << i) for i in range(9)] + counts, witness = primary.clique_census(complete9) + self.assertEqual(counts[9], 1) + self.assertEqual(len(witness), 9) + self.assertEqual(separate.maximal_cliques(complete9), [(1 << 9) - 1]) + roots, gram, removed, live, pairing, orth, nonorth, supports = primary.model() + frames = primary.all_frames(orth) + # Treating a live trimmed star as an untrimmed star loses 90 obstructions. + normal = live[0] + full, trimmed = supports[2 * normal][2], supports[2 * normal + 1][2] + misses = lambda mask: sum(not any(mask >> i & 1 for i in frame) for frame in frames) + self.assertEqual((misses(full), misses(trimmed)), (0, 90)) + # One removed coordinate cannot still realize the diagonal target 4I. + self.assertTrue(any(sum(gram[a][b] ** 2 for b in removed[:-1]) != 4 for a in live)) + # A duplicate endpoint creates two misses on a real frame. + self.assertEqual(sum(0 in frame for frame in frames), 90) + + def test_05_source_corruption_and_optimized_relocation(self): + with tempfile.TemporaryDirectory(prefix="root-star standalone with spaces ") as tmp: + package = Path(tmp) / "package" + shutil.copytree(HERE, package, ignore=shutil.ignore_patterns("__pycache__")) + before = {p.relative_to(package): p.read_bytes() for p in package.rglob("*") if p.is_file()} + for script in ("verify.py", "independent.py"): + result = run(script, package=package) + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + after = {p.relative_to(package): p.read_bytes() for p in package.rglob("*") if p.is_file()} + self.assertEqual(before, after) + path = package / "sources" / "pr1226-PROOF.md" + path.write_bytes(path.read_bytes() + b"\nchanged source\n") + for script in ("verify.py", "independent.py"): + result = run(script, package=package) + self.assertNotEqual(result.returncode, 0) + self.assertIn("source", result.stderr) + + def test_06_exact_regeneration_and_overwrite_protection(self): + with tempfile.TemporaryDirectory(prefix="root-star-receipt-") as tmp: + path = Path(tmp) / "receipt.json" + result = run("verify.py", "--write-certificate", path) + self.assertEqual(result.returncode, 0, result.stdout + result.stderr) + self.assertEqual(path.read_bytes(), (HERE / "CERTIFICATE.json").read_bytes()) + path.write_bytes(b"preserve this occupied output\n") + result = run("verify.py", "--write-certificate", path) + self.assertNotEqual(result.returncode, 0) + self.assertEqual(path.read_bytes(), b"preserve this occupied output\n") + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/research/root-star-integer-cover-seed46/verify.py b/research/root-star-integer-cover-seed46/verify.py new file mode 100644 index 0000000000..935e67f871 --- /dev/null +++ b/research/root-star-integer-cover-seed46/verify.py @@ -0,0 +1,265 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact integer frame-cover obstruction for the P112 root-star alphabet. + +Hanson Sun (@bbMisk), with substantial OpenAI Codex assistance. +Model and predecessor census: Navinor, PR1226; DreamingOfClouds, PR717/595. +No predecessor executable is imported. Python 3.10+, standard library only. +""" + +import argparse +from collections import Counter +import hashlib +from itertools import combinations, product +import json +from pathlib import Path +import sys + +HERE = Path(__file__).resolve().parent +PREDECESSOR = "8b10989e4e45f0f9ce41004d7898a21a32f87e11" +AUDITED = "ee8437bd9879272094e20c024cd34a53c4e84cd8" + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def digest(value): + return hashlib.sha256(json.dumps(value, separators=(",", ":"), sort_keys=True).encode()).hexdigest() + + +def bits(mask): + while mask: + bit = mask & -mask + yield bit.bit_length() - 1 + mask ^= bit + + +def basis(rows): + pivots = {} + for row in rows: + while row: + pivot = row.bit_length() - 1 + if pivot in pivots: + row ^= pivots[pivot] + else: + pivots[pivot] = row + break + return tuple(pivots.values()) + + +def root_lines(): + roots = [] + for i, j in combinations(range(8), 2): + for a, b in product((-2, 2), repeat=2): + row = [0] * 8 + row[i], row[j] = a, b + roots.append(tuple(row)) + roots.extend(s for s in product((-1, 1), repeat=8) if s.count(-1) % 2 == 0) + require(len(set(roots)) == 240, "E8 root inventory") + lines = set() + for row in roots: + if next(x for x in row if x) < 0: + row = tuple(-x for x in row) + lines.add(row) + require(len(lines) == 120, "E8 line inventory") + return sorted(lines) + + +def model(): + roots = root_lines() + inner = [] + for row in roots: + values = [] + for col in roots: + value = sum(a * b for a, b in zip(row, col)) + require(value % 4 == 0, "nonintegral root pairing") + values.append(value // 4) + inner.append(values) + removed = [] + for i in range(0, 8, 2): + for sign in (-2, 2): + row = [0] * 8 + row[i], row[i + 1] = 2, sign + removed.append(roots.index(tuple(row))) + removed.sort() + require(all(inner[a][b] == (2 if a == b else 0) for a in removed for b in removed), "puncture is not a frame") + live = [i for i in range(120) if i not in removed] + pos = {normal: i for i, normal in enumerate(live)} + pairing = [sum(((inner[a][b] + 1) % 2) << j for j, b in enumerate(live)) for a in live] + orthogonal = [sum(1 << j for j, b in enumerate(live) if a != b and inner[a][b] == 0) for a in live] + nonorthogonal = [sum(1 << j for j, b in enumerate(live) if a != b and inner[a][b] != 0) for a in live] + supports = [] + for normal in range(120): + full = sum(1 << i for i, line in enumerate(live) if inner[line][normal] != 0) + for trimmed in (False, True): + mask = full + if trimmed and normal in pos: + mask &= ~(1 << pos[normal]) + supports.append((normal, trimmed, mask)) + return roots, inner, removed, live, pairing, orthogonal, nonorthogonal, supports + + +def all_frames(adjacency): + result = [] + + def extend(prefix, candidates): + if len(prefix) == 8: + result.append(tuple(prefix)) + return + while candidates and len(prefix) + candidates.bit_count() >= 8: + bit = candidates & -candidates + candidates ^= bit + vertex = bit.bit_length() - 1 + extend(prefix + [vertex], candidates & adjacency[vertex]) + + extend([], (1 << len(adjacency)) - 1) + return result + + +def clique_census(adjacency): + counts = Counter() + witness = [] + + def extend(prefix, candidates): + nonlocal witness + counts[len(prefix)] += 1 + if len(prefix) > len(witness): + witness = prefix[:] + while candidates: + bit = candidates & -candidates + candidates ^= bit + vertex = bit.bit_length() - 1 + extend(prefix + [vertex], candidates & adjacency[vertex]) + + extend([], (1 << len(adjacency)) - 1) + return dict(sorted(counts.items())), witness + + +def source_bindings(): + manifest = json.loads((HERE / "SOURCES.json").read_text()) + seen = set() + for item in manifest["dependencies"]: + require(item["path"] not in seen, "duplicate source pin") + seen.add(item["path"]) + expected_commit = AUDITED if item["path"] == "sources/pr1236-CERTIFICATE.json" else PREDECESSOR + require(item["source_commit"] == expected_commit, "changed source commit") + path = HERE / item["path"] + require(path.resolve().is_relative_to(HERE), "source path escapes package") + data = path.read_bytes() + require(hashlib.sha256(data).hexdigest() == item["sha256"], "source SHA256 mismatch: " + item["path"]) + blob = hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() + require(blob == item["git_blob"], "source Git blob mismatch: " + item["path"]) + require(len(seen) == 6, "incomplete source inventory") + return digest(manifest) + + +def build_certificate(): + source_hash = source_bindings() + roots, inner, removed, live, pairing, orth, nonorth, supports = model() + require(len(basis(pairing)) == 9, "binary pairing rank") + frames = all_frames(orth) + require(len(frames) == 1260, "frame coverage") + frame_masks = [sum(1 << i for i in frame) for frame in frames] + contain = [sum(1 << k for k, frame in enumerate(frame_masks) if frame >> i & 1) for i in range(112)] + require(all(m.bit_count() == 90 for m in contain), "line-frame incidence") + pair_hist = Counter() + for i in range(112): + for j in bits(orth[i]): + if i < j: + count = (contain[i] & contain[j]).bit_count() + require(count > 0, "orthogonal live pair extends to no live frame") + pair_hist[count] += 1 + + pos = {line: i for i, line in enumerate(live)} + all_frame_bits = (1 << len(frames)) - 1 + missed = [] + for normal, trimmed, support in supports: + actual = sum(1 << k for k, frame in enumerate(frame_masks) if not support & frame) + expected = contain[pos[normal]] if trimmed and normal in pos else 0 + require(actual == expected, "root-star missed-frame identity") + missed.append(actual) + + support_bases = [basis(pairing[i] for i in bits(mask)) for _, _, mask in supports] + rank_table = [] + rank_hist = Counter() + endpoint_hist = Counter() + hit_hist = Counter() + for i, row_basis in enumerate(support_bases): + row = [] + for j, (_, _, mask) in enumerate(supports): + rank = len(basis(value & mask for value in row_basis)) + row.append(rank) + rank_hist[rank] += 1 + if rank == 7: + endpoints = [normal for normal, trimmed, _ in (supports[i], supports[j]) if trimmed and normal in pos] + require(endpoints, "rank-seven atom has no live trimmed endpoint") + selected = pos[endpoints[0]] + require(contain[selected] & ~(missed[i] | missed[j]) == 0, "rank-seven missed endpoint") + endpoint_hist[len(endpoints)] += 1 + hit_hist[(all_frame_bits ^ (missed[i] | missed[j])).bit_count()] += 1 + rank_table.append(row) + require(rank_hist == {7: 7616, 8: 37440, 9: 12544}, "support-pair rank census") + + counts, witness = clique_census(nonorth) + require(max(counts) == 8, "nonorthogonality clique bound") + require(all(nonorth[i] >> j & 1 for i, j in combinations(witness, 2)), "clique witness") + require(sum(counts.values()) == 482577, "clique census coverage") + + decoder = [[inner[line][normal] for normal in removed] for line in live] + for i, a in enumerate(live): + for j, b in enumerate(live): + require(sum(x * y for x, y in zip(decoder[i], decoder[j])) == 2 * inner[a][b], "coordinate decoder identity") + coordinate_costs = [rank_table[2 * normal][2 * normal] for normal in removed] + require(coordinate_costs == [8] * 8, "sharp coordinate decoder price") + + # Mathematical negative controls: structural constraints, not only output hashes. + require(any(sum(decoder[i][k] ** 2 for k in range(7)) != 4 for i in range(112)), "deleted coordinate term was not detected") + require(contain[witness[0]] & contain[witness[0]], "duplicate endpoint control") + extending = [] + for vertex in range(112): + if vertex in witness: + continue + conflicts = [i for i in witness if orth[vertex] >> i & 1] + require(conflicts, "ninth endpoint escaped the maximal clique") + extending.append((vertex, conflicts[0], (contain[vertex] & contain[conflicts[0]]).bit_count())) + require(len(extending) == 104, "ninth-endpoint control coverage") + require(all(rank_table[2 * a + 1][2 * b + 1] >= 8 for a in removed for b in removed), "punctured endpoint control") + require(all(pairing[i] >> j & 1 for frame in frames for i in frame for j in frame), "zero-cost frame control") + + return { + "schema_version": 1, + "status": "SCOPED_ROOT_STAR_COPY_FLOOR_64", + "source_manifest_sha256": source_hash, + "model": {"roots_sha256": digest(roots), "removed_global_indices": removed, "live_global_indices": live, "binary_pairing_rank": 9, "supports_sha256": digest(supports), "supports": 240}, + "frames": {"count": len(frames), "sha256": digest(frames), "frames_per_line": 90, "orthogonal_pair_frame_count_histogram": dict(sorted(pair_hist.items()))}, + "atoms": {"ordered_pairs": 57600, "rank_histogram": dict(sorted(rank_hist.items())), "pair_rank_rows": ["".join(map(str, row)) for row in rank_table], "pair_rank_encoding": "240 rows of 240 single-digit exact F2 ranks, support index 2*normal+trimmed", "rank7_live_trimmed_endpoint_count_histogram": dict(sorted(endpoint_hist.items())), "rank7_frame_hits_histogram": dict(sorted(hit_hist.items()))}, + "nonorthogonality": {"clique_counts_including_empty": counts, "complete_recursion_nodes": sum(counts.values()), "maximum": len(witness), "witness_live_indices": witness, "witness_doubled_roots": [roots[live[i]] for i in witness]}, + "sharpness": {"coordinate_term_costs": coordinate_costs, "all_pairs_checked": 12544, "decoder_sha256": digest(decoder), "cost": sum(coordinate_costs)}, + "controls": {"missing_coordinate_term_rejected": True, "duplicate_endpoint_rejected": True, "all_104_extensions_of_witness_rejected": True, "punctured_only_beta7_rejected": True, "zero_cost_atoms_cannot_meet_frames": True}, + "conclusion": {"minimum_copy_cost": 64, "positive_terms_below_64": [8, 9], "eight_term_obstruction": "Every term must meet every frame, excluding every rank-seven atom.", "nine_term_obstruction": "Nine rank-seven atoms require nine distinct pairwise nonorthogonal live trimmed endpoints; maximum is eight.", "scope": "Exact C(alpha)/N(alpha) supports on this P112; any finite term count and arbitrary real or complex coefficients; additional zero-cost terms permitted. No arbitrary proper sub-supports or new kappa."}, + } + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--certificate", type=Path, default=HERE / "CERTIFICATE.json") + parser.add_argument("--write-certificate", type=Path, help="Create a new receipt; never overwrite an existing file.") + args = parser.parse_args() + certificate = json.loads(json.dumps(build_certificate())) + if args.write_certificate: + with args.write_certificate.open("x") as output: + json.dump(certificate, output, indent=2, sort_keys=True) + output.write("\n") + else: + require(json.loads(args.certificate.read_text()) == certificate, "certificate differs from complete recomputation") + print("PASS_ROOT_STAR_INTEGER_COVER_S46 atoms=57600 frames=1260 cliques=482577 omega=8 copy_floor=64 no_new_kappa") + + +if __name__ == "__main__": + try: + main() + except (ValueError, OSError, KeyError, TypeError) as error: + print("FAIL_ROOT_STAR_INTEGER_COVER_S46:", error, file=sys.stderr) + sys.exit(1)