Conditional κ = 0.001675608585476885: joint entrances and X54 with T37 owners

.github/workflows/t37-joint-x54-owners.yml

@@ -0,0 +1,57 @@
+name: Joint entrances and X54 with T37 whole-owner composition
+
+on:
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - 'research/complex-t37-joint-x54-owners/**'
+      - '.github/workflows/t37-joint-x54-owners.yml'
+  push:
+    branches: [main, codex/joint-x54-t37-20261013]
+    paths:
+      - 'research/complex-t37-joint-x54-owners/**'
+      - '.github/workflows/t37-joint-x54-owners.yml'
+
+permissions:
+  contents: read
+
+jobs:
+  verify:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 90
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ['3.11', '3.14']
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7, retained repository pin
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7, retained repository pin
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Install retained cold-replay dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends g++ libboost-dev
+          python -m pip install -r research/e8-bit-p111-tuned/requirements.txt
+      - name: Fresh ancestry, supplier, owner construction and strict admission
+        env:
+          CXX: g++
+          BOOST_INCLUDE: /usr/include
+        run: >-
+          python -B research/complex-t37-joint-x54-owners/verify.py
+          --work "$RUNNER_TEMP/joint-x54-t37-cold"
+      - name: Require committed sources unchanged
+        if: always()
+        run: git diff --exit-code
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: joint-x54-t37-python-${{ matrix.python }}
+          path: |
+            ${{ runner.temp }}/joint-x54-t37-cold/*.json
+            ${{ runner.temp }}/joint-x54-t37-cold/*.log
+            ${{ runner.temp }}/joint-x54-t37-cold/t37/strict/*.json
+            ${{ runner.temp }}/joint-x54-t37-cold/t37/strict/*.log
+            ${{ runner.temp }}/joint-x54-t37-cold/t37/strict/global/audit/*.json

research/complex-t37-joint-x54-owners/.gitattributes

@@ -0,0 +1,2 @@
+# Preserve original vendored bytes and source-manifest identities.
+vendor/** -text -whitespace

research/complex-t37-joint-x54-owners/CLAIM.json

@@ -0,0 +1 @@
+{"T":37,"bit_lower":"1733427039589844234749/1000000000000000000000000","calls":333,"charged_prefix_bits":1024,"comparison":{"four_rank_seven_end_t37":"0.001674583473132219","independently_replayed_pr1050":"0.001672241870811633","joint_entrances_pr1148":"0.001675560947524449","joint_entrances_t37_draft_pr1169":"0.001675568675201533","rank_seven_end_t37_pr1152":"0.001674340686401949","selected_pr1042":"0.001672188119205421","selected_pr1094":"0.001672660197076918","selected_pr942":"0.001661960547713947","seven_slot_t37_predecessor":"0.001674097969905390"},"complex_lower":"1678420962050942454559/1000000000000000000000000","complex_profile":{"1":788046,"2":165834,"3":137862,"4":41958,"48":11374,"5":27972,"8":2664},"deficit":11840,"idle":{"1":834,"48":11374},"kappa":"335121717095377/200000000000000000","kappa_decimal":"0.001675608585476885","live":33152,"local_profile":{"1":2364,"2":498,"3":414,"4":126,"5":84,"8":8},"physical":33642,"physical_row_coefficient":17495,"prefix_bits":775,"rank_mass":2408256,"roles":159840,"scope":"Finite conditional construction under the retained compiler, whole-call hosting, common-label/mutable-source realization, precision/tape, analytic-transfer and bitH1-H5 hypotheses. No unconditional theorem or kappa=1 claim.","width_inventory":{"4":44,"5":44,"7":38,"8":114,"9":240}}

research/complex-t37-joint-x54-owners/NOTICE.md

@@ -0,0 +1,48 @@
+# Attribution and source boundary
+
+Prepared for Chafik Boukhalfa with substantial OpenAI Codex assistance. Apache-2.0.
+
+The new contribution is the checked composition of PR1148's joint-entrance
+word with PR1130's X54 operation, and its full T37 admission using PR1169's
+integer flow. The X54 scalar/frame operation and builder are unchanged;
+the input/output identities and paid profile are rebound to the stronger word.
+The helper-width vector is checked unchanged. PR1169's integer entries are
+normalized without alteration, then reconstructed with our retained PR1131/1152
+matching code for the final helper labels. Fresh native, independent and strict
+admission checks bind the final construction.
+
+- Thomas DiFiore: PR1148's eight-endpoint and joint-entrance construction,
+  literal recipes, native replay, local controls and T16 admission chain.
+  All 277 files in its five new packages are copied unchanged from the pinned
+  head. Its notices credit PR664's promotion mechanism, PR1018/987 word lineage,
+  PR1030's endpoint lead, PR864's frame model and their earlier sources.
+- `seslly/shipstuff`: PR1111's group-635 entrance-demotion lead, as credited
+  by PR1148. This package consumes the attributed PR1148 implementation.
+- Jeremy Kothe (`jeremykothe2`): PR1130's X54 eighth triangle slot, literal
+  builder, positive/negative controls and independent audits. Its 205 files
+  are copied unchanged. Its notices retain the rank-seven-end mechanism of
+  Alexander Schwartzman (`AlexS-scale`) in PR1030 and the independent
+  leaver-premise checker of `thakrarsagar` in PR1049.
+- Rohan Arun: PR1169's exact integer-flow certificate, frozen at the commit
+  in SOURCE-PINS.json. All twelve package files and their attribution are
+  retained, including Ali Romman's PR1129 flow/matching work and the PR1131
+  wave order. This composition uses the pinned integer certificate, with a
+  fresh reconstruction and independent geometric audit of the final roles.
+- Jeremy Kothe: PR1005 mutable-leaver k8, PR1018 seven-slot (following
+  Rohan Arun's PR987), PR1022's standalone supplier, and PR799's
+  paired-read-exchange construction. PR1022's leaver and slot source trees
+  are copied unchanged, with their complete notices and ancestry.
+- `jon314159`: PR942's T37 bank envelope, prefix reserve, explicit source
+  adapters and all-replica signed-price proof.
+- Chafik Boukhalfa: PR795/890 signed prices and independent geometry,
+  the retained earlier gauge/owner work, and PR1131/1152 matching reconstruction.
+- Hao Yan (`FanPUYen`): PR858's parent construction, strict physical-event
+  windows and independent owner audit; PR870/1074 retain the admission engines.
+- `DreamingOfClouds`: PR589's tuned P111 bit supplier, with its full notices.
+
+The original notices retain the PR514/484/507 controller lineage, PR558/552/531
+phase machinery, exact moment engines and outer reduction. PR635's required
+source subtree is retained at its constructor-pinned commit.
+SOURCE-PINS.json records original Git blobs and SHA-256 for every vendored file;
+DEPENDENCY-PINS.json binds retained repository dependencies. No optimizer is
+needed to reconstruct the submitted owner map.

research/complex-t37-joint-x54-owners/PROOF.md

@@ -0,0 +1,84 @@
+# Finite construction and fixed-family ceiling
+
+The unchanged PR1148 verifier freshly constructs and admits its eight-endpoint
+T16 parent and joint-entrance supplier. Its 32 endpoint and 27 joint-entrance
+controls, complete native phase replays and global admissions are retained.
+The literal X54 recipe in `data/X54-RECIPE.json` then applies PR1130's unchanged
+scalar/frame operation to the freshly rebuilt joint word. Its two positive and
+eight negative controls are checked, followed by full native scalar, wrapper,
+phase, independent frame/cone and leaver-premise replays.
+
+The final local paid profile is `(2364,498,414,126,84,8)` at ranks
+`(1,2,3,4,5,8)`. Its 480 helper widths have multiplicities
+`(44,44,38,114,240)` at `(4,5,7,8,9)`. The driver compares every helper width
+before and after X54. Its paid profile is recounted from the final word;
+the strict invoice binds all fresh supplier artifacts.
+
+`normalize_flow.py` translates PR1169's pinned integer-flow certificate into
+literal width values and explicit physical-window labels. Every positive
+integer entry is consumed once, with no new optimization or rounding. The
+normalized data are compared exactly with `data/FLOW.json.gz` before the
+retained matching constructor independently checks all conservation equations.
+The final helper-label assignments are reconstructed from the final native word.
+
+For `0 ≤ s < 9`, `0 ≤ r < 37`, order calls by `(37s+8r,s,r)`.
+Each replica retains the original stage order and hence all thirty original
+physical source events, including its nine bridges. PR858's event expansion
+reconstructs strict idle intervals. The independent PR890 checker reconstructs
+them separately from the original event stream.
+
+The frozen flow groups together only identical capacity/interval pairs. Each
+group retains the complete list of physical `(replica,child)` windows, with
+112 distinct port families per window. A pattern with multiplicity `N` has
+`N` bins. For every width `w`, its integer time flow totals `N` times the
+pattern multiplicity of `w`; at each invocation the total flow is at most `N`.
+
+Split each width's flow among that many left vertices of degree `N`. Add
+dummy left vertices to fill the unused capacity of the time vertices. This
+gives a regular bipartite multigraph of degree `N`. Successive perfect
+matchings decompose it into `N` bins. Every matching is checked to be a
+permutation using positive edges, and every used edge is removed. Consequently
+each bin has its exact pattern and receives at most one helper per invocation.
+`construct.py` performs the entire decomposition with exact integers and
+checks its reconstructed flow against the frozen one.
+
+Assign bins to their listed physical windows and port numbers in order; lay
+their helper slices consecutively. The independent audit checks all 159,840
+roles for strict bridge-aware timing, whole widths, complete per-call helper
+coverage, distinct physical families, disjoint prefix slices, and literal
+orthogonal 73-axis charts. These checks also detect aliasing between different
+idle children of the same physical family. The residual idle profile is
+`{1:834,48:11374}`. Adding 333 local profiles gives the profile in CLAIM.json.
+
+The retained PR942 parent lift has bank groups `(8,8,8,8,5)` and shared restored
+private workspace. Its independent parent checker is unchanged. The emitted
+controller removes the dedicated banks and uses the frozen whole-owner map.
+The strict invoice charges the enlarged 1,024-bit prefix reserve. It derives
+prefix 775 and row coefficient 17,495, and binds every provider artifact to
+the fresh native replay. Both moment engines certify the same root bracket:
+
+```
+0.001678420962050942454559 < b < 0.001678420962050942454560.
+```
+
+The retained bit endpoint is `1733427039589844234749 / 10^24`. All 47 strict
+outer constraints hold at `κ = 1675608585476885 / 10^18`.
+
+For the fixed-family ceiling, retain PR795/890/942's signed helper prices
+`(-1,-20,-8,-2,4)` and bin bonuses `(2,4,8,-13)` for capacities
+`(8,16,32,48)`. There are `(672,448,448,448)` bins per replica. The new word
+leaves idle mass 14,778 and signed budget −3,568 per replica. The retained
+supporting-inequality proof therefore gives rank-one credit
+`48*(-3568)+13*14778 = 20850`. At 37 replicas, the attained rank-one count
+is `37*20850/925 = 834`, with the remaining mass in rank 48.
+
+`price.py` re-enumerates all 1,163 bin patterns by two methods, checks the
+supporting inequalities with both exact arithmetic engines, and evaluates
+the outer reduction at both ends of the root bracket. Both yield the same
+`10^-18` grid tick. Thus this construction attains that fixed-family grid
+ceiling, even when other call orders and replica counts are admitted in the
+relaxation. This statement does not bound different local words, capacity
+families, helper interfaces or bit suppliers.
+
+All retained all-size and realization hypotheses are unchanged; this proof
+and its executable evidence establish the finite conditional composition.

research/complex-t37-joint-x54-owners/README.md

@@ -0,0 +1,61 @@
+# Joint entrances and X54 with 37-replica whole-owner packing
+
+Conditional **κ = 0.001675608585476885**. This combines Thomas DiFiore's
+PR1148 joint-entrance supplier, Jeremy Kothe's PR1130 X54 operation and
+Rohan Arun's PR1169 integer-flow certificate on the retained PR1131 wave order.
+It improves PR1148's admitted `0.001675560947524449` and PR1169's draft
+joint-entrance T37 target `0.001675568675201533` at the preparation snapshot.
+
+The X54 operation changes the local paid profile by `+2 H3 - 4 H4 + 2 H5`
+while preserving all 480 helper widths. The final local profile is
+`{1:2364,2:498,3:414,4:126,5:84,8:8}`. The normalized flow is expanded by
+exact deterministic bipartite matching into **159,840 whole-helper owners**
+for 333 calls. It leaves 834 rank-one and 11,374 rank-48 idle children.
+Both exact moment engines and all 47 outer inequalities certify the claim.
+
+## Reproduce
+
+Python 3.11+, a C++17 compiler, Boost headers and the retained baseline's
+NumPy/SymPy/SciPy requirements are needed. The owner constructor uses only
+the standard library; verification does not run an owner optimizer.
+
+```sh
+python -m pip install -r research/e8-bit-p111-tuned/requirements.txt
+CXX=g++ BOOST_INCLUDE=/usr/include python -B \
+  research/complex-t37-joint-x54-owners/verify.py \
+  --work /tmp/t37-joint-x54-fresh
+```
+
+Choose a new output directory outside the checkout. On Homebrew macOS use
+`CXX=clang++ BOOST_INCLUDE=/opt/homebrew/include`. The driver freshly rebuilds
+the retained PR589/741/799 ancestry, the k8 and seven-slot suppliers, the
+complete PR1148 eight-end/T16 and joint-entrance admissions, and the final X54
+supplier. It then normalizes the pinned flow, reconstructs owners, checks the
+independent geometry and five-bank parent, and runs strict controller admission.
+All source staging and input-package bytes are checked before and after.
+
+The driver includes 32 eight-end and 27 joint-entrance rejection controls,
+eight X54 negative controls, eight flow controls, six owner controls, eight
+parent-lift controls, fifteen controller controls, 69 admission controls and
+twelve bit-supplier controls, alongside the retained ancestral/supplier tests.
+`RESULT.json` binds completed stages and manifests; `MATH.json` is the portable
+mathematical receipt. `PRICE.json` records the two-engine signs, all outer
+inequalities and the attained fixed-family ceiling over all positive replica counts.
+
+## Result and scope
+
+The complex profile is
+`{1:788046,2:165834,3:137862,4:41958,5:27972,8:2664,48:11374}`.
+There are 33,152 live families, 33,642 physical families and deficit 11,840.
+The prefix is 775 bits within the charged 1,024-bit reserve; the physical-row
+coefficient is 17,495, below the retained 20,161 limit.
+
+This is a finite conditional construction. All-size compiler,
+common-label/mutable-source realization, whole-call hosting, precision/tape,
+analytic transfer, the PR559 recurrence correction and bit H1–H5 hypotheses remain.
+The fixed-family ceiling holds for this local paid profile, helper inventory,
+source capacity stock and retained bit endpoint. It does not bound different
+words, mixed providers, capacity families or recursion geometries.
+
+See [PROOF.md](PROOF.md), [NOTICE.md](NOTICE.md), [SOURCE-PINS.json](SOURCE-PINS.json)
+and [CLAIM.json](CLAIM.json). All package sources and data are manifest-bound.

research/complex-t37-joint-x54-owners/audit.py

@@ -0,0 +1,39 @@
+"""Independent PR890 owner audit, with exact T37/480-helper parameter edits."""
+import argparse
+from pathlib import Path
+from common import P,ROOT,read,dump,load,sha
+
+def check(base,local,owners_path,out):
+    source=ROOT/'research/complex-t21-owners/independent_check.py'
+    text=source.read_text()
+    edits=[('2 * 512','2 * 1024'),('prefix < 512','prefix < 1024'),
+      ('charged_prefix_bits=512','charged_prefix_bits=1024'),
+      ('{4: 80, 5: 32, 7: 54, 8: 122, 9: 216}','{4: 44, 5: 44, 7: 38, 8: 114, 9: 240}')]
+    for before,after in edits:
+        assert text.count(before)==1,(before,text.count(before));text=text.replace(before,after)
+    adapter=out.parent/'independent_owner_adapter.py';assert not adapter.exists();adapter.write_text(text)
+    ck=load(adapter,'independent_seven_slot_owner_checker');ck.T=37;ck.R=480;ck.EXPECTED_IDLE={1:834,48:11374}
+    refs=[base/'split-centres/GLOBAL-TEMPLATE.json.gz',base/'work/complex-nine-native/DATA-PHASES.json',
+          base/'split-centres/CANONICAL-WORD.json.gz',local/'CANONICAL-WORD.json.gz',
+          local/'INDEPENDENT-LOCAL-REPLAY.json',owners_path]
+    parent,phases,canonical,word,receipt,owners=map(read,refs)
+    assert receipt['canonical_word_sha256']==sha(refs[3])
+    assert receipt['status']=='PASS_INDEPENDENT_LOCAL_SCALAR_FRAME_AND_WRAPPER_REPLAY'
+    assert word['ports']==canonical['ports']
+    assert [ck.basis(word['frames'][f])for f in word['center_frames']]==[ck.basis(canonical['frames'][f])for f in canonical['center_frames']]
+    context=ck.make_context(parent,phases,word['ports'],word,receipt,owners)
+    result=ck.check_roles(context,owners);result['controls_rejected']=ck.controls(context,owners)
+    result.update(edits=edits,source_sha256=sha(source),adapter_sha256=sha(adapter),inputs={str(p):sha(p)for p in refs})
+    claim=read(P/'CLAIM.json')
+    for field in ('roles','calls','live','physical','rank_mass','deficit','prefix_bits','physical_row_coefficient'):
+        assert result[field]==claim[field],field
+    assert {str(r):n for r,n in result['profile'].items()}==claim['complex_profile']
+    dump(out,result);return result
+
+def main():
+    ap=argparse.ArgumentParser(description=__doc__)
+    for k in ('base','local','owners','out'):ap.add_argument('--'+k,type=Path,required=True)
+    a=ap.parse_args();out=a.out.resolve();assert not out.exists() and not out.is_relative_to(ROOT)
+    out.parent.mkdir(parents=True,exist_ok=True)
+    r=check(a.base,a.local,a.owners,out);print(r['status'],r['roles'],flush=True)
+if __name__=='__main__':main()

research/complex-t37-joint-x54-owners/common.py

@@ -0,0 +1,26 @@
+"""Strict shared I/O; construction and independent audit remain separate."""
+import gzip, hashlib, importlib.util, json, sys
+from pathlib import Path
+P=Path(__file__).resolve().parent
+ROOT=P.parents[1]
+if not __debug__:raise RuntimeError('Assertions must remain enabled')
+def read(path):
+    path=Path(path);raw=path.read_bytes()
+    return json.loads(gzip.decompress(raw)if path.suffix=='.gz'else raw)
+def canonical(value):return json.dumps(value,sort_keys=True,separators=(',',':')).encode()
+def sha(path):return hashlib.sha256(Path(path).read_bytes()).hexdigest()
+def identity(value):return hashlib.sha256(canonical(value)).hexdigest()
+def dump(path,value):
+    raw=canonical(value)
+    if path.suffix=='.gz':
+        raw=bytearray(gzip.compress(raw,mtime=0));raw[9]=255
+    path.write_bytes(raw)
+def load(path,name):
+    previous=sys.modules.pop('common',None);sys.path.insert(0,str(path.parent))
+    try:
+        spec=importlib.util.spec_from_file_location(name,path)
+        module=importlib.util.module_from_spec(spec);sys.modules[name]=module;spec.loader.exec_module(module)
+        return module
+    finally:
+        sys.path.pop(0);sys.modules.pop('common',None)
+        if previous is not None:sys.modules['common']=previous