Exclude arbitrary-slot single-role BIT idle fusion (0% κ change)

docs/ci-verification.md

@@ -1,8 +1,25 @@
 # CI verification
 
-## Current selected-family replay: #6030
+## Current selected-family replay: #7000 with #7001
 
 The [selected record](../certificates/selected-result.json) binds conditional
+κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md),
+[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json),
+and [explicit source closure](../certificates/frontier7000-source.json).
+`make frontier7000-verify` follows that exact-source selected replay. The review
+reuses eleven authenticated preceding executions and records seven fresh serial
+application, scalar and complete native-catalogue executions. The earlier
+monolithic timeout is retained separately and is not completed coverage.
+Consult the receipts for exact commands, source heads and limits.
+
+The five inherited framework assumptions remain. No complete uniform word,
+literal multiplier execution, independent human proof or formal-kernel proof
+is asserted. Routine research submissions do not need to rerun this
+selected-family replay. The sections below preserve historical checkpoints.
+
+## Historical selected-family replay: #6030
+
+The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional
 κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md),
 [validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json),
 and [explicit source closure](../certificates/frontier6030-source.json).

research/bit-single-role-idle-rank-bound/NOTICE

@@ -0,0 +1,5 @@
+Apache-2.0.
+Retained #7001 paired BIT caller and invoice and #6726 native word.
+Credit #6834 and #6980 for the caller lineage, and #7163, #7190 and #7201
+for related native volume and same-mask packing bounds.
+OpenAI Codex and subagents materially assisted.

research/bit-single-role-idle-rank-bound/PRIMARY.json

@@ -0,0 +1,32 @@
+{
+  "caller_sha256": "757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b",
+  "disjoint_scope": 256,
+  "field_polynomial": "0x11b",
+  "physical_sites": 0,
+  "q": 1,
+  "rank_counts": {
+    "2": 256
+  },
+  "stage_probe": [
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19
+  ],
+  "unresolved": [],
+  "unvisited": 0
+}

research/bit-single-role-idle-rank-bound/README.md

@@ -0,0 +1,85 @@
+# Arbitrary-slot single-role BIT idle fusion
+
+**NO VERIFIED GAIN. Conditional κ change 0%.** On the exact #7001
+paired E-free caller, every pair of disjoint-mask IDLE_ONE events
+requires a rank-two correction after deletion. One one-role idle
+changes the scalar operator by rank at most one, at any clock.
+The complete 256-pair scope has zero compatible savings. The
+fixed target κ = 0.0040075385047236 remains short by about
+60.10389921914735 raw units. #7277 at κ = 0.003645669928698 remains
+the complete comparable witness.
+
+## Rank certificate
+
+Fix one 38-role port group and specialize the formal caller at
+q=1 and nonzero body symbols in a finite extension of F₂. Write
+the operator around two idle events as L D_j M D_i R, with M
+the intervening word and L,R the unchanged outer words. Deleting
+both idles leaves L M R. The difference after inserting one
+one-role diagonal idle anywhere in the deleted word is of the
+form A(D−I)B. Its rank is at most one at every specialization.
+
+For original idle factors D_i = I + α e_r e_r^T and
+D_j = I + β e_s e_s^T, take off-axis entries
+l = (M e_r)_u ≠ 0 with u ≠ s and
+h = (e_s^T M)_v ≠ 0 with v ≠ r. The inner difference
+D_j M D_i − M on rows (u,s) and columns (r,v) has determinant
+αβlh. All 256 disjoint pairs have such a nonzero minor in
+GF(128), with nonzero idle corrections. The outside factors
+L,R are invertible at the probe because each stage scalar is
+nonzero and every remaining shear or swap is invertible.
+The exact symbolic equality required by a replacement would
+survive this specialization. A direct whole-operator replay
+over a different GF(256) specialization also finds rank two
+for all 256 pairs.
+
+The disjoint stock is exhaustive within this scope. The 240
+overlapping-mask pairs, additional ordinary edits, changes to
+other caller factors, and a genuinely multi-role child are
+outside it. No physical site is tested.
+
+## Whole signed price
+
+There are 32 literal IDLE_ONE events, each repeated over 111
+port groups, giving 444 paid jobs at each rank 7,14,…,56.
+Write H(r)=r^(1−κ). Concavity gives
+H(a+b) ≥ H(2)(H(a)+H(b))/2. Even granting every compatible
+rank-additive pair free setup and routing, the disjoint-pair
+saving upper is about 305.93670924546 before support. The rank
+obstruction then reduces the declared stock upper to exactly
+zero. The independent verifier reconstructs the 36-copy bill
+of 107,352 paid and 19,950 productive jobs, authenticates all
+62,474 native contact incidences and rejects a missing paid
+MOVE and a missing original idle.
+
+## Reproduction
+
+Use CPython 3.12 with assertions. From a clean checkout:
+
+    python3.12 -B scripts/research_package.py --package research/bit-single-role-idle-rank-bound
+    python3.12 -B scripts/check_research_commit.py --package research/bit-single-role-idle-rank-bound --check-modes --check-source-history
+
+From a Git-free official export root:
+
+    python3.12 -I -B research/bit-single-role-idle-rank-bound/replay.py --root .
+
+The exact caller, native word and signed receipt are declared
+by stable source path with Git blob and SHA-256 pins. Duplicate
+JSON and source-path controls reject. The replay needs no prior
+temporary state, external interpreter path or network.
+
+## Open next questions
+
+Can one charged two-role child supply the necessary rank-two
+correction while preserving both arbitrary-input fields? First
+reprice the compatible paid stock including extra ordinary
+operators, ownership and restoration. Then check one exact
+signed native prototype only if the total can reach the target.
+
+Credit #7001 and #6726 for the retained exact inputs, #6834
+and #6980 for the caller lineage, and #7277 for the complete
+comparison. #7163 concerns native full-fibre reflection volume,
+and #7190 and #7201 treat equal-mask alignment and cover
+assumptions. They are different from the fixed remaining
+caller and disjoint masks used here. OpenAI Codex and subagents
+materially assisted.

research/bit-single-role-idle-rank-bound/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+  "files": [
+    {
+      "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8",
+      "path": "certificates/selected-result.json",
+      "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1",
+      "usage": "provenance"
+    },
+    {
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "path": "docs/research/agent-task-catalog.json",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81",
+      "usage": "provenance"
+    },
+    {
+      "git_blob": "b718d6b2848215ad785022106dfa9f871a3d1c0c",
+      "path": "research/paired-query-only-bit/retained/inputs/BIT-NATIVE-WORD.json.gz",
+      "sha256": "51203e7fc75ba10bd3ac3f8e675759f47e13d262bea66b6600d1e515095cad78",
+      "usage": "input"
+    },
+    {
+      "git_blob": "575f76487f9999ecc3e7b1b70f9f71bc582ef8a8",
+      "path": "research/paired-query-only-bit/EFREE-RESULT.json",
+      "sha256": "a46b6c6040f75184cab5467656811ad988c216e3bc8e44d595a5015b6e49620b",
+      "usage": "input"
+    },
+    {
+      "git_blob": "f022272a8d51ede841778dec76e2bfb24b614d04",
+      "path": "research/paired-query-only-bit/EFREE-CALLER.json.gz",
+      "sha256": "757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b",
+      "usage": "input"
+    }
+  ],
+  "schema_version": 1
+}

research/bit-single-role-idle-rank-bound/TASK.json

@@ -0,0 +1,77 @@
+{
+  "actual_scope": "Replace a pair of disjoint-mask retained BIT IDLE_ONE events by one one-role scalar idle at an arbitrary clock, with every other caller event and the native word fixed.",
+  "ai_assistance": "OpenAI Codex and subagents materially assisted proof, implementation, independent audit and packaging.",
+  "author": "Round 38 research campaign",
+  "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+  "bottleneck_link": "Resolve whether one-role idle fusion can meet the fixed BIT shortfall before constructing a provider.",
+  "budget_minutes": 2,
+  "evidence": "Two finite field specializations, all-pair rank-two certificates, complete literal signed invoice and omitted paid MOVE and idle controls.",
+  "open_questions": [
+    {
+      "blocked_by": "A rank-two scalar fit still requires a legal signed native operator, ownership and restoration, and complete paid and tape cost.",
+      "first_step": "Price one exact two-role replacement and account for all boundary work before attempting a physical site.",
+      "question": "Can a changed multi-role child contract or an additional ordinary caller edit absorb the rank-two difference?",
+      "why_it_matters": "The single-role replacement has only one transported correction direction."
+    }
+  ],
+  "original_card": {
+    "acceptance_gate": "A full boundary contract and paid profile; unchanged scalar counts alone are insufficient. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "existing_checks": [
+      {
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "status": "reviewed"
+      }
+    ],
+    "first_experiment": "First read #5679/#5708 and their audits as pending component proposals. Choose one uncovered helper group/cut on an exact word; compare arbitrary-input native action, targets, owned storage, both orientations and full signed bill. Stop if the gain is only a scalar count or repaid by lost targets. Do not rerun the frozen #5609 common-frame domain without changing its hypothesis.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "id": "bit-helper-contract",
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "overlap_terms": [
+      "G20",
+      "helper split",
+      "5679",
+      "5708",
+      "independent target"
+    ],
+    "question": "Can a changed G20 helper path or independent-target split improve the complete BIT moment without losing its physical endpoint?",
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+      "research/g20-helper-split/README.md",
+      "research/g20-conjugation-admission/README.md"
+    ]
+  },
+  "outcome": "negative-result",
+  "priority_revision": 8,
+  "schema_version": 1,
+  "scope_change_reason": "This tests paid caller idle stock rather than productive helper stock.",
+  "scope_status": "changed",
+  "stop_rule": "Census all 256 disjoint-mask pairs. If every omitted-pair difference has rank two, close the declared one-role family without any physical site.",
+  "task_id": "bit-helper-contract"
+}

research/bit-single-role-idle-rank-bound/VERIFY.json

@@ -0,0 +1,25 @@
+{
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/replay.py",
+        "--root",
+        "."
+      ],
+      "checks": "Reconstruct the full BIT invoice, then verify arbitrary-slot rank obstruction in two field specializations and detect omitted paid operations.",
+      "timeout_seconds": 20
+    }
+  ],
+  "inputs": [
+    "research/paired-query-only-bit/retained/inputs/BIT-NATIVE-WORD.json.gz",
+    "research/paired-query-only-bit/EFREE-RESULT.json",
+    "research/paired-query-only-bit/EFREE-CALLER.json.gz"
+  ],
+  "python": "3.12",
+  "requirements": [],
+  "schema_version": 1,
+  "status": "ready"
+}

research/bit-single-role-idle-rank-bound/rank_gate.py

@@ -0,0 +1,106 @@
+"""Whole-stock rank obstruction to a single relocated BIT idle."""
+from collections import Counter
+import gzip
+from hashlib import sha256
+from itertools import combinations
+import json
+from pathlib import Path
+from time import monotonic
+
+HERE=Path(__file__).resolve().parent
+PIN='757b3523798f840bdb02028b23708c3416627a99ea09e7a3c4bcdc5cd0c7ce4b'
+
+
+def residue(a,b):
+    d=b.bit_length()-1
+    while a and a.bit_length()-1>=d:
+        a ^= b << (a.bit_length()-1-d)
+    return a
+
+
+def multiply(a,b):
+    z=0
+    while b:
+        if b&1:
+            z^=a
+        a<<=1
+        b>>=1
+    return residue(z,0x11b)
+
+
+def run():
+    deadline=monotonic()+18
+    assert all(residue(0x11b,b) for b in range(2,32))
+    products=[bytes(multiply(a,b) for b in range(256)) for a in range(256)]
+    raw=(HERE/'EFREE-CALLER.json.gz').read_bytes()
+    assert sha256(raw).hexdigest()==PIN
+    word=json.loads(gzip.decompress(raw))
+    n=word['roles']
+    def xor(row,other):
+        return bytes(a^b for a,b in zip(row,other,strict=True))
+    def forward(values,omit):
+        rows=[bytes(i==j for j in range(n)) for i in range(n)]
+        for t,(op,*args) in enumerate(word['events']):
+            if t in omit:
+                continue
+            if op=='ADD' or op=='QUERY':
+                d,s=args
+                rows[d]=xor(rows[d],rows[s])
+            elif op=='SWAP':
+                d,s=args
+                rows[d],rows[s]=rows[s],rows[d]
+            elif op=='LOCAL':
+                stage,s,d=args
+                rows[d]=xor(rows[d],rows[s])
+                row=products[values[stage-1]]
+                rows[s]=bytes(map(row.__getitem__,rows[s]))
+                rows[d]=bytes(map(row.__getitem__,rows[d]))
+            elif op=='IDLE_ONE':
+                d,stages=args
+                scale=1
+                for s in stages:
+                    scale=products[scale][values[s-1]]
+                rows[d]=bytes(map(products[scale].__getitem__,rows[d]))
+            else:
+                raise ValueError(op)
+        return rows
+    def rank_two(rows):
+        pivot=next((r for r in rows if any(r)),None)
+        if pivot is None:
+            return 0
+        i=next(i for i,v in enumerate(pivot) if v)
+        for r in rows:
+            if any(products[pivot[i]][v]!=products[r[i]][u] for u,v in zip(pivot,r,strict=True)):
+                return 2
+        return 1
+    assert rank_two([b'\x01\x00',b'\x00\x01'])==2
+    assert rank_two([b'\x01\x00',b'\x03\x00'])==1
+    assert rank_two([bytes(2),bytes(2)])==0
+    probe=tuple(range(2,20))
+    orig=forward(probe,set())
+    for i,d in enumerate(word['diagonal']):
+        scale=1
+        for stage in d['stages']:
+            scale=products[scale][probe[stage-1]]
+        assert orig[i]==bytes(scale if i==j else 0 for j in range(n))
+    idles={t:set(e[2]) for t,e in enumerate(word['events']) if e[0]=='IDLE_ONE'}
+    pairs=[(i,j) for i,j in combinations(idles,2) if not idles[i]&idles[j]]
+    assert len(pairs)==256
+    counts=Counter()
+    unresolved=[]
+    for i,j in pairs:
+        if monotonic()>=deadline:
+            break
+        changed=forward(probe,{i,j})
+        rk=rank_two([xor(a,b) for a,b in zip(orig,changed,strict=True)])
+        counts[rk]+=1
+        if rk<2:
+            unresolved.append([i,j,rk])
+    return {'caller_sha256':PIN,'field_polynomial':hex(0x11b),'q':1,
+            'stage_probe':probe,'disjoint_scope':len(pairs),'rank_counts':dict(counts),
+            'unresolved':unresolved,'unvisited':len(pairs)-sum(counts.values()),
+            'physical_sites':0}
+
+
+if __name__=='__main__':
+    print(json.dumps(run(),sort_keys=True,indent=2))