Record that the rank-8/u2 16-child slack depends on the family split.

research/rank8-u2-split-boundary/README.md

@@ -0,0 +1,85 @@
+# Rank-8/u2 slack versus one moved family
+
+**Negative screen, no new κ.** Selected κ stays `0.001672660197076918`.
+
+## Question
+
+PR #3889's tight integer cell is the nine-call profile with paid mass delivered
+at ranks 8 and 2, selected centre 64, and two unpaid coordinates. Its open
+question asks whether a physical producer and consumer can fit that cell's
+remaining moment slack. The stated stop test is an additive bill of rank-1
+children, with no mass credit: 16 still pass `a = 1/98`, and 17 fail, on the
+pooled idle histogram.
+
+This note does not build that producer. It asks whether the same 16-child
+sentence survives the integer per-call family splits already allowed by the
+coverage identity.
+
+## Contract
+
+Width `m = 73`, nine calls, 896 live families, centre 64 on every call, and
+two unpaid coordinates. Call mass is `71 * families + 64`. The ideal per-call
+paid profile is `{8: 698, 2: 1}`, mass 5586, the same local mass as the
+selected word `{1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8}`. A call needs
+at least 78 families; 77 leaves negative idle. Nine-call totals are paid
+50274, idle 13918 and mass 64192.
+
+Idle children have rank at most 51. Each call's idle is packed by the usual
+exchange: `floor(idle / 51)` children of rank 51 and at most one remainder.
+The pooled alternative packs all 13918 idle units together as
+`{51: 272, 46: 1}`.
+
+Additive rank-1 children are extra. They are not paid for by deleting idle
+mass. The moment is the sum of pinned `child_cost` enclosures divided by 896.
+A high end below 1 is a pass, and a low end above 1 is a fail, at
+`a = 1/98`.
+
+## Result
+
+| Hosting | 15 extra rank-1 | 16 extra rank-1 | 17 extra rank-1 |
+|---|---|---|---|
+| Pooled idle `{51: 272, 46: 1}` | | pass | fail |
+| Five calls of 100 families and four of 99 | | pass | fail |
+| One family moved between two 100-calls: `101, 100, 100, 100, 99 × 5` | pass | fail | |
+
+The third row is the second row after transferring one family from one
+100-call to another. Its separate idle histogram is
+`{51: 267, 48: 3, 28: 5, 17: 1}` instead of `{51: 266, 48: 5, 28: 4}`.
+That one remainder of rank 17 is enough to spend the last rank-1 child of
+slack. The published "16 still pass" sentence is true for the pooled
+histogram and for the balanced split, and false for this adjacent split.
+
+## What this does not establish
+
+No rank-8 local word, no consumer, no owner chronology, and no proof that the
+selected template uses either split. Unknown restoration and precision costs
+are not zero. Passing either split is not a supplier. The catalogue acceptance
+gate for a new helper inventory is not met. Selected κ is unchanged.
+
+## Reproduce
+
+```sh
+python3.12 -B research/rank8-u2-split-boundary/verify.py
+python3.12 -B scripts/research_package.py --package research/rank8-u2-split-boundary
+```
+
+Expected marker: `PASS_RANK8_U2_SPLIT_BOUNDARY pooled=LT/GT balanced=LT/GT shifted=LT/GT no_new_kappa`.
+
+## Open next questions
+
+1. Which of the integer splits of 896 into nine calls of at least 78 families
+   still pass 16 additive rank-1 children? The examples show the answer is
+   not "all" and not "only the pool".
+2. Is there a literal local word with paid profile `{8: 698, 2: 1}`, centre
+   64 and two unpaid coordinates? Until there is, this boundary does not
+   reject a construction.
+
+## Credit
+
+The ceiling engine and the halving cap are Douglas Colkitt's
+`research/complex-local-word-ceiling`, with Claude assistance. The 16/17
+pooled screen and the rank-8/u2 question are ToikY's PR #3889, following
+Nick Petalas's PR #3874. The coverage identity is PR #1012. This note only
+recomputes that screen on two family splits.
+
+Prepared by unpaidmoon with substantial Cursor Grok assistance. Apache-2.0.

research/rank8-u2-split-boundary/SOURCES.json

@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5",
+      "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0"
+    },
+    {
+      "path": "research/complex-local-word-ceiling/ceiling.py",
+      "usage": "input",
+      "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c",
+      "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc"
+    }
+  ]
+}

research/rank8-u2-split-boundary/TASK.json

@@ -0,0 +1,72 @@
+{
+  "schema_version": 1,
+  "task_id": "complex-new-helper-inventory",
+  "priority_revision": 6,
+  "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f",
+  "original_card": {
+    "id": "complex-new-helper-inventory",
+    "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "research/complex-local-word-ceiling/README.md",
+      "research/heterogeneous-owner-assembly/README.md",
+      "certificates/selected-result.json",
+      "research/selected-k8-unrestricted-ends/README.md"
+    ],
+    "methods": [
+      "Propose a changed helper inventory and derive an optimistic exact moment.",
+      "Design a small completed instance and independently verify its endpoint and rank bill."
+    ],
+    "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model. 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.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "research/complex-local-word-ceiling/verify.py"
+      ],
+      "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING",
+      "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.",
+      "scope": "Positive control and planning budget only; this is not a new construction or full cold replay."
+    },
+    "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.",
+    "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.",
+    "allowed_variations": [
+      "Narrow to one changed boundary or helper type with explicit counts.",
+      "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope."
+    ],
+    "scope_change_triggers": [
+      "Mixing only providers already inside the pinned catalogue.",
+      "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.",
+      "Continuing a partial cost improvement while leaving the same unpriced consumer, restoration or central-readout obligation unresolved; refresh the family expansion decision first. Local product-retiming evidence has a narrow scope and is not a ban on changed graphs or contracts."
+    ],
+    "overlap_terms": [
+      "helper inventory",
+      "heterogeneous-owner",
+      "mutable leaver"
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "On the ideal nine-call rank-8/unpaid-2 integer profile, the additive 16-rank-1 slack is not invariant under legal per-call family splits.",
+  "scope_change_reason": "The open handoff asks for a physical rank-8/u2 producer charged against the 16-child stop test. No such producer is on this main. This note keeps that profile and stop test, and charges the integer family split the coverage identity still allows. It does not propose a new helper inventory.",
+  "bottleneck_link": "The tight planning cell is selected centre, all local mass at rank 8, and two unpaid coordinates. Its published slack is 16 additive rank-1 children on one pooled idle histogram. A split that spends that slack before a producer exists removes the screen those producers would be tested against.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop once the pooled, balanced and one-family-moved splits have certified moment signs at 16 and 17 additive rank-1 children. Do not search decoders or recompute the 24-cell lever grid.",
+  "outcome": "negative-result",
+  "evidence": "ceiling.child_cost enclosures at a=1/98 separate the signs: pooled and the 100/99 split pass at 16 and fail at 17; moving one family between two 100-calls fails at 16.",
+  "author": "unpaidmoon",
+  "ai_assistance": "Cursor Grok 4.7 wrote the verifier and the note from the pinned ceiling engine.",
+  "open_questions": [
+    {
+      "question": "Which integer family splits of 896 into nine calls, each with at least 78 families, still satisfy moment(1/98) < 1 after 16 additive rank-1 children?",
+      "why_it_matters": "The stop test used for a future rank-8/u2 producer depends on this split. The pooled histogram and the balanced split pass; an adjacent split fails.",
+      "first_step": "Classify the nine-tuples by their idle remainders modulo 51 and evaluate only the distinct remainder multisets.",
+      "blocked_by": "No rank-8 producer is required for that classification, but it is a finite census this session did not run."
+    },
+    {
+      "question": "Does any source-bound rank-8 local word realize paid profile {8:698, 2:1} per call with centre 64 and unpaid 2?",
+      "why_it_matters": "Without that word the split boundary is a screen, not a supplier rejection.",
+      "first_step": "Pin one literal local word whose non-centre children are rank 8 and whose coverage identity uses two unpaid coordinates, then add its restoration histogram.",
+      "blocked_by": "No such word is in the pinned ceiling package, and this note does not search the decoder literature."
+    }
+  ]
+}

research/rank8-u2-split-boundary/VERIFY.json

@@ -0,0 +1,20 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/complex-local-word-ceiling/ceiling.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Selected mass 5586, nine-call coverage mass 64192, pooled and balanced 16-pass/17-fail, one-family-moved 15-pass/16-fail, cap-to-rank-1 control, and rejection of a 77-family call."
+    }
+  ]
+}

research/rank8-u2-split-boundary/verify.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+"""The rank-8/u2 16-child slack is not invariant under legal family splits.
+
+The pinned ceiling engine supplies the child-cost enclosures. This file does
+not edit it and does not claim a producer, a consumer or a new kappa.
+"""
+from fractions import Fraction
+import hashlib
+import importlib.util
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parents[2]
+ENGINE = ROOT / "research" / "complex-local-word-ceiling" / "ceiling.py"
+PIN = "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc"
+M = 73
+FAMILIES = 896
+CALLS = 9
+CENTRE = 64
+UNPAID = 2
+R = 51
+A = Fraction(1, 98)
+LOCAL = {8: 698, 2: 1}
+LOCAL_MASS = 8 * 698 + 2
+
+
+def require(ok, why):
+    if not ok:
+        raise SystemExit("FAIL: " + why)
+
+
+def load_engine():
+    digest = hashlib.sha256(ENGINE.read_bytes()).hexdigest()
+    require(digest == PIN, "ceiling.py sha256 differs from the package pin")
+    spec = importlib.util.spec_from_file_location("pinned_ceiling", ENGINE)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    require(module.max_idle_rank(M) == R, "halving cap is not 51")
+    return module
+
+
+def call_mass(families):
+    return (M - UNPAID) * families + CENTRE
+
+
+def idle_mass(families):
+    return call_mass(families) - LOCAL_MASS
+
+
+def pack_idle(mass):
+    require(mass >= 0, "negative idle")
+    quotient, remainder = divmod(mass, R)
+    histogram = {R: quotient}
+    if remainder:
+        histogram[remainder] = 1
+    require(R * quotient + remainder == mass, "idle packing dropped mass")
+    return histogram
+
+
+def add(left, right, times=1):
+    out = dict(left)
+    for rank, count in right.items():
+        out[rank] = out.get(rank, 0) + times * count
+    return out
+
+
+def hosted(counts):
+    require(len(counts) == CALLS, "a schedule needs nine calls")
+    require(sum(counts) == FAMILIES, "families must sum to 896")
+    histogram = {}
+    for families in counts:
+        require(families >= 78, "a call below 78 families cannot hold the paid profile")
+        histogram = add(histogram, LOCAL)
+        histogram = add(histogram, pack_idle(idle_mass(families)))
+    return histogram
+
+
+def moment(engine, histogram):
+    low = high = Fraction(0)
+    for rank, count in histogram.items():
+        if count == 0:
+            continue
+        left, right = engine.child_cost(int(rank), M, A)
+        require(left <= right, "cost enclosure is inverted")
+        low += count * left
+        high += count * right
+    return engine.down(low / FAMILIES), engine.up(high / FAMILIES)
+
+
+def sign(bounds):
+    low, high = bounds
+    if high < 1:
+        return "LT"
+    if low > 1:
+        return "GT"
+    return "UNK"
+
+
+def with_surcharge(histogram, extra):
+    out = dict(histogram)
+    out[1] = out.get(1, 0) + extra
+    return out
+
+
+def main():
+    engine = load_engine()
+    require(LOCAL_MASS == 5586, "paid mass is not the selected local mass")
+    require(sum(rank * count for rank, count in {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8}.items()) == 5586,
+            "selected word mass changed")
+    total = (M - UNPAID) * FAMILIES + CENTRE * CALLS
+    require(total == 64192, "nine-call coverage mass changed")
+    require(CALLS * LOCAL_MASS == 50274, "nine-call paid mass changed")
+    require(total - CALLS * LOCAL_MASS == 13918, "nine-call idle mass changed")
+    require(idle_mass(77) < 0, "77 families should be unable to hold the paid profile")
+    require(idle_mass(78) == 16, "minimum call idle is not 16")
+
+    pooled_idle = pack_idle(13918)
+    require(pooled_idle == {51: 272, 46: 1}, "pooled idle histogram changed")
+    pooled = add({8: 6282, 2: 9}, pooled_idle)
+    require(sum(rank * count for rank, count in pooled.items()) == 64192, "pooled mass")
+
+    balanced_counts = (100, 100, 100, 100, 100, 99, 99, 99, 99)
+    shifted_counts = (101, 100, 100, 100, 99, 99, 99, 99, 99)
+    require(sum(balanced_counts) == 896 and sum(shifted_counts) == 896, "split totals")
+    # Moving one family from one 100-call onto another 100-call.
+    require(sorted(shifted_counts) == sorted((101, 100, 100, 100, 99, 99, 99, 99, 99)), "shifted split")
+
+    balanced = hosted(balanced_counts)
+    require(balanced == {8: 6282, 2: 9, 51: 266, 48: 5, 28: 4}, "balanced histogram")
+    shifted = hosted(shifted_counts)
+    require(shifted == {8: 6282, 2: 9, 51: 267, 48: 3, 28: 5, 17: 1}, "shifted histogram")
+    for histogram in (pooled, balanced, shifted):
+        require(sum(rank * count for rank, count in histogram.items()) == 64192, "hosting lost mass")
+
+    pooled_16 = sign(moment(engine, with_surcharge(pooled, 16)))
+    pooled_17 = sign(moment(engine, with_surcharge(pooled, 17)))
+    balanced_16 = sign(moment(engine, with_surcharge(balanced, 16)))
+    balanced_17 = sign(moment(engine, with_surcharge(balanced, 17)))
+    shifted_15 = sign(moment(engine, with_surcharge(shifted, 15)))
+    shifted_16 = sign(moment(engine, with_surcharge(shifted, 16)))
+    require(pooled_16 == "LT" and pooled_17 == "GT", "pooled 16/17 boundary moved")
+    require(balanced_16 == "LT" and balanced_17 == "GT", "balanced 16/17 boundary moved")
+    require(shifted_15 == "LT" and shifted_16 == "GT", "one-family move did not drop the budget to 15")
+
+    # Failure controls. These stay explicit so -O cannot delete them.
+    bare = moment(engine, with_surcharge(pooled, 16))
+    dropped = dict(with_surcharge(pooled, 16))
+    dropped[51] -= 1
+    dropped[1] = dropped.get(1, 0) + 51
+    require(moment(engine, dropped)[0] > bare[1], "replacing a cap child by rank 1 should raise the moment")
+    try:
+        hosted((77,) + (100,) * 7 + (119,))
+    except SystemExit as exc:
+        require(str(exc).startswith("FAIL: a call below 78"), "illegal call was accepted")
+    else:
+        require(False, "illegal call did not fail")
+
+    print(
+        "PASS_RANK8_U2_SPLIT_BOUNDARY"
+        f" pooled={pooled_16}/{pooled_17}"
+        f" balanced={balanced_16}/{balanced_17}"
+        f" shifted={shifted_15}/{shifted_16}"
+        " no_new_kappa"
+    )
+
+
+if __name__ == "__main__":
+    main()