diff --git a/research/rank7-idle-remainder-donors-t740/AUDIT.json b/research/rank7-idle-remainder-donors-t740/AUDIT.json new file mode 100644 index 0000000000..775b31ed35 --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/AUDIT.json @@ -0,0 +1,18 @@ +{ + "binding": "bit", + "complex_root_lower": "17347705571115131604951/10000000000000000000000000", + "fill_rebound": true, + "kappa": "17334270395898442347489999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "moves": 391964, + "rejected_controls": { + "axis_moved_twice": "axis not in donor remainder", + "dropped_move": "declared profile", + "foreign_axis": "axis not in donor remainder", + "hosted_axis_from_used_prefix": "axis not in donor remainder", + "hosted_receiver": "receiver must be unhosted", + "kappa_above_bit": "headline kappa", + "next_root_grid": "complex root bracket", + "receiver_donates": "receiver must be unhosted" + }, + "status": "PASS_IDLE_REMAINDER_DONOR_AUDIT" +} diff --git a/research/rank7-idle-remainder-donors-t740/BINS.json.gz b/research/rank7-idle-remainder-donors-t740/BINS.json.gz new file mode 100644 index 0000000000..fc2446437c Binary files /dev/null and b/research/rank7-idle-remainder-donors-t740/BINS.json.gz differ diff --git a/research/rank7-idle-remainder-donors-t740/CLAIM.json b/research/rank7-idle-remainder-donors-t740/CLAIM.json new file mode 100644 index 0000000000..dd7c0055de --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/CLAIM.json @@ -0,0 +1,30 @@ +{ + "kappa": "17334270395898442347489999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017334270395898442347489999999999999999999998999999999999999999999999", + "binding": "bit (PR589 0.001733427039589844234749)", + "complex_root": [ + "17347705571115131604951/10000000000000000000000000", + "2168463196389391450619/1250000000000000000000000" + ], + "baseline": "PR3184 / PR3148 (open)", + "gain_over_pr3184": "1618989177996737327/500000000000000000000000", + "gain_over_pr3148": "3649544911247222863/1000000000000000000000000", + "profile": { + "1": 16353294, + "2": 4837720, + "3": 1533431, + "4": 679320, + "5": 147055, + "8": 53280, + "42": 32303, + "45": 34720, + "48": 48434, + "49": 47026, + "50": 15320, + "51": 104766 + }, + "T": 740, + "changed_hypothesis": "idle remainders of partially hosted bins donate axes (PR1252 rule) to unhosted idle children; receivers capped at 51", + "status": "author-checked conditional candidate; native admission, overlay-aware controller audit and bit-binding outer release not rerun", + "credits": "PR1252 Gonzalo-Mier; star class Gueorgui Maissouradze; PR3148 Jeremy Diviney; PR3133/PR3042 dcharb78; PR2979 Marius-Paul Dumitrean; OpenCode (Space bunny free); Anthropic Claude" +} \ No newline at end of file diff --git a/research/rank7-idle-remainder-donors-t740/MOVES.json.gz b/research/rank7-idle-remainder-donors-t740/MOVES.json.gz new file mode 100644 index 0000000000..e8401e6d13 Binary files /dev/null and b/research/rank7-idle-remainder-donors-t740/MOVES.json.gz differ diff --git a/research/rank7-idle-remainder-donors-t740/PR3148-PROVIDERS.json b/research/rank7-idle-remainder-donors-t740/PR3148-PROVIDERS.json new file mode 100644 index 0000000000..0b23436750 --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/PR3148-PROVIDERS.json @@ -0,0 +1,842 @@ +{ + "extra": { + "actual_paid_profile": { + "1": 2433, + "2": 724, + "3": 228, + "4": 102, + "5": 20, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 6, + 7, + 6, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + }, + "gauge44": { + "actual_paid_profile": { + "1": 2433, + "2": 724, + "3": 228, + "4": 102, + "5": 20, + "8": 8 + }, + "widths": [ + 9, + 9, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 7, + 9, + 7, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 4, + 9, + 4, + 9, + 8, + 9, + 9, + 4, + 7, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 9, + 9, + 9, + 9, + 9, + 9, + 4, + 9, + 4, + 9, + 4, + 9, + 9, + 9, + 9, + 4, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 6, + 9, + 8, + 8, + 9, + 8, + 9, + 8, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 9, + 8, + 8, + 7, + 7, + 7, + 7, + 8, + 9, + 8, + 9, + 6, + 6, + 7, + 7, + 7, + 7, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 6, + 6, + 8, + 8, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 6, + 6, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8, + 8, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 8, + 7, + 7, + 6, + 6, + 9, + 8, + 9, + 8, + 8, + 8, + 8, + 8, + 7, + 7, + 9, + 8, + 9, + 8, + 7, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, + 6, + 7, + 6, + 7, + 7, + 7, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 5, + 5, + 8, + 8, + 8, + 8 + ] + } +} diff --git a/research/rank7-idle-remainder-donors-t740/README.md b/research/rank7-idle-remainder-donors-t740/README.md new file mode 100644 index 0000000000..7a26172c43 --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/README.md @@ -0,0 +1,128 @@ +# Idle-remainder donors on PR3148's T740 fill: the complex side passes the bit side; conditional κ = 0.001733427039589844234749 − 10⁻⁴⁶ − 10⁻⁷⁰ + +**Author-checked conditional candidate; not maintainer-reviewed.** The selected record on +`main` is still #1094. This package stacks on the open PR3148 (Jeremy Diviney) and extends +the idle-axis exchanges of PR3184. PR3133's words, the helper widths, and PR3148's fill rows, +order and dispatch are all unchanged. + +| | complex root lower (10⁻²⁵) | binding | κ headline | +|---|---|---|---| +| PR3148 | 0.0017297774946785970118869 | complex | 0.001729777494678597011886 − … | +| PR3184 (stars on fully idle 48s) | 0.0017301890612338507600957 | complex | 0.001730189061233850760095 − … | +| **this** | **0.0017347705571115131604951** | **bit (#589)** | **0.001733427039589844234749 − 10⁻⁴⁶ − 10⁻⁷⁰** | + +The gain is **+3.238e-6 (+0.187%) over PR3184** and +3.650e-6 over PR3148. The complex +supplier now exceeds the bit supplier's 0.001733427039589844234749, the constant pinned in the +T74 outer ledger. **The bit side binds, so κ is capped there.** + +## Changed hypothesis + +PR3184 moved axes only among *completely* idle capacity-48 children. But every bin that +helpers use only partially leaves an idle **remainder child**, whose axes are the recipe axes +`[used, cap)`. That holds for every hosted #1094 child: the hosted `IDLE-REMAINDER-FRAMES` equal +`orthogonal_axes[hosted:]`. PR3148's idle bill is `{1: 173160, 3: 48951, 5: 13875, 48: 282569}`. + +Removing a small child is far more valuable than reshaping 48s. Moving one axis from a rank-1 +remainder into a 48 removes `1·ln 73` of moment weight, against `0.18` for a whole +`48+48 → 45+51` pair. + +Here any remainder, hosted or not, may **donate** axes to a **fully idle (unhosted) receiver** +in the same replica and port. Each moved axis follows PR1252's rule: + +- it commutes with all of the receiver's axes at the time it moves; +- it commutes with every stage entry/exit X and Y translation and the terminal Y translation; +- it commutes with both children's terminal translations. + +Receivers stay at or below rank 51, so `73² = 5329 > 2·51² = 5202`. Moved axes come from the +donor's idle remainder, so they are orthogonal to its hosted prefix axes; the recipe sets are +orthonormal. Each group's axis multiset is unchanged. + +The construction runs in two phases: + +1. **Drain remainders.** Remainders are drained smallest first, one axis at a time, into the + largest legal receiver. +2. **Stars.** PR3184's exact star optimum runs on the untouched fully idle 48s. + +This produces 391,964 axis moves, from 138,369 donor children into 167,112 receivers. The idle +bill becomes: + +`{1:149514, 2:15880, 3:14951, 5:13855, 42:32303, 45:34720, 48:48434, 49:47026, 50:15320, 51:104766}` + +The rank mass is unchanged at `65088·740`. + +## Reproduce + +```sh +# PR3148's deterministic materializer (head f2927a4b) -> /tmp/t740 +python3 -B research/rank7-idle-remainder-donors-t740/build.py --t740 /tmp/t740 # ~20 s +python3 -B research/rank7-idle-remainder-donors-t740/verify.py --t740 /tmp/t740 # ~1 min +``` + +**Pinned inputs:** + +- DATA-PHASES (`c5916ff3…`) +- the decoded fill payload (`8f4d6965…`) +- ORDER (`927226d7…`) and DISPATCH (`90edc935…`) +- PR3148's provider widths (`PR3148-PROVIDERS.json`, `52eb0d85…`) + +The build reproduces PR3148's idle bill exactly. + +**`verify.py` does not import `build.py`.** It re-derives: + +- that donor axes lie in the donor's own remainder; +- that receivers are unhosted, and no child both donates and receives; +- the unit and orthogonal-at-receipt checks, and the commuting rule; +- the rank cap; +- the profile and rank mass; +- the complex root bracket, using its own interval arithmetic at 10⁻⁷²; +- `κ = min(floor₂₄(complex_lower), bit) − 10⁻⁴⁶ − 10⁻⁷⁰`, with gates against PR3148 and PR3184. + +It also rebinds BINS to the fill. Eight mutation controls are rejected: + +- a hosted receiver; +- an axis taken from the hosted prefix; +- a foreign axis; +- an axis moved twice; +- a receiver that also donates; +- a dropped move; +- the next root grid point; +- κ above the bit cap. + +## Scope and remaining obligations + +- **New hypothesis beyond PR1252/PR3184:** hosted remainders may donate. The moved axes are + orthogonal to the hosted prefix and obey the full commuting rule, but no hosted-controller + argument is given here. PR1252's admitted audit covered only unhosted pairs. +- **Not rerun:** PR3148/PR3133's native admission, the controller/owner audit (`audit_mixed.py` + must read the axis overlay) and the outer release. The outer ledger asserts + `complex < bit`, so a bit-binding release needs its ledger branch, and the halving pin + `[5329,4608]` must become `[5329,5202]`. +- Because the bit side now binds, further complex-side packing gains do not raise κ until the + bit supplier improves. All inherited all-size/compiler, realization, precision/tape, recovery + and analytic obligations remain. PR3148 itself is unreviewed. + +## Open next questions + +- **Is a hosted remainder a legal donor under the T74 controller contract?** PR1252's admitted + audit covered only unhosted children. First step: generalize the T74 `audit_mixed.py` + owner/controller audit to read this axis overlay and rerun PR3148's release. Blocked by: + the release chain has no overlay reader. +- **Can the bit supplier rise toward the new complex root 0.0017347706?** κ is now bit-bound, + so any bit gain up to about +1.34e-6 is realizable. First step: price the actual #589 bit + word with the moment-fee metric and search skip and carrier rewrites on it. + +## Credit + +- Gonzalo-Mier (PR1252): the move, the rule and the pricing. +- Guéorgui Maissouradze: the star class. +- Jeremy Diviney (PR3148): the fill. +- dcharb78 (PR3133, PR3042). +- Marius-Paul Dumitrean (PR2979). +- Jeremy Kothe (PR3015). +- Nick Petalas (PR3024). +- DreamingOfClouds and eumemic: the #589/#555 bit supplier. +- The data-phase and T37-envelope lineage. + +Prepared by Rohan Arun. Done with help from **OpenCode (Space bunny free)**, whose +partially-used-bin centre idea this package generalizes, and with Anthropic Claude assistance. +Apache-2.0. diff --git a/research/rank7-idle-remainder-donors-t740/RESULT.json b/research/rank7-idle-remainder-donors-t740/RESULT.json new file mode 100644 index 0000000000..2bbb2926bb --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/RESULT.json @@ -0,0 +1,55 @@ +{ + "status": "PASS_IDLE_REMAINDER_DONOR_EXCHANGES_T740", + "T": 740, + "axis_moves": 391964, + "donor_children": 138369, + "receiver_children": 167112, + "idle_before": { + "1": 173160, + "3": 48951, + "5": 13875, + "48": 282569 + }, + "idle_after": { + "1": 149514, + "2": 15880, + "3": 14951, + "5": 13855, + "42": 32303, + "45": 34720, + "48": 48434, + "49": 47026, + "50": 15320, + "51": 104766 + }, + "profile": { + "1": 16353294, + "2": 4837720, + "3": 1533431, + "4": 679320, + "5": 147055, + "8": 53280, + "42": 32303, + "45": 34720, + "48": 48434, + "49": 47026, + "50": 15320, + "51": 104766 + }, + "complex_root": [ + "17347705571115131604951/10000000000000000000000000", + "2168463196389391450619/1250000000000000000000000" + ], + "complex_root_decimal": "17347705571115131604951e-25", + "bit": "1733427039589844234749/1000000000000000000000000", + "binding": "bit", + "kappa": "17334270395898442347489999999999999999999998999999999999999999999999/10000000000000000000000000000000000000000000000000000000000000000000000", + "kappa_decimal": "0.0017334270395898442347489999999999999999999998999999999999999999999999", + "gain_over_pr3184": "1618989177996737327/500000000000000000000000", + "gain_over_pr3148": "3649544911247222863/1000000000000000000000000", + "max_child_rank": 51, + "halving": [ + 5329, + 5202 + ] +} diff --git a/research/rank7-idle-remainder-donors-t740/SOURCES.json b/research/rank7-idle-remainder-donors-t740/SOURCES.json new file mode 100644 index 0000000000..b6bd6d61d4 --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "files": [ + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json", + "usage": "input", + "git_blob": "d9a4f84211182ca200c081ea061d724c8a2cfb70", + "sha256": "c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa" + }, + { + "path": "research/frontier1094-idle-star-ceiling/README.md", + "usage": "provenance", + "git_blob": "dc62e4569948a9e10bb1c72731a9ddfdc81fe0cd", + "sha256": "2f640127f48be627f10a8db1d224d8a75219772525b3c0d5d3251dc8dc57b121" + } + ] +} diff --git a/research/rank7-idle-remainder-donors-t740/TASK.json b/research/rank7-idle-remainder-donors-t740/TASK.json new file mode 100644 index 0000000000..4fabb8702b --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/TASK.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "task_id": "selected-packing", + "priority_revision": 6, + "base_commit": "997e6a9ca7b4f95d50e366f61412fd640d72a88a", + "original_card": { + "id": "selected-packing", + "question": "Is there a genuinely unsearched, explicitly bounded improvement to the selected packing?", + "starting_points": [ + "certificates/selected-result.json", + "research/heterogeneous-owner-assembly/README.md", + "research/complex-local-word-ceiling/README.md" + ], + "methods": [ + "Search a named unclaimed canonical candidate domain with a reproducible partition.", + "Prove a stronger scoped relaxation or exact optimum for one named residual subproblem." + ], + "acceptance_gate": "Check live PR overlap first, price both suppliers and distinguish a search best from an optimum. Report the word's packing cap from ceiling.ceiling() and the fraction of it realized; label packing gains as such.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Locate the selected packing source in the review and check live PRs for the same residual problem.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Define an unclaimed canonical domain and a favorable bound before starting a new search.", + "bottleneck_link": "An actual paid-profile gain can improve the frontier up to the other supplier cap.", + "allowed_variations": [ + "One bounded residual packing instance or exact relaxation.", + "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": [ + "Rerunning an existing search with only a different seed as a separate mathematical contribution." + ], + "overlap_terms": [ + "T16", + "owner exchange", + "packing" + ], + "existing_checks": [ + { + "scope": "Packing-independent ceiling for the selected paid profile under the one-unpaid-coordinate coverage and halving guard.", + "evidence": "docs/research/community-efficient1000-review.md", + "remaining": "A changed word or model requires new pricing; a local packing search must name uncovered scope.", + "status": "reviewed", + "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "changed", + "actual_scope": "Changed residual subproblem on the open PR3148 T740 fill of PR3133's words (not the selected #1094 packing): idle remainders of partially hosted and fully idle bins donate axes under PR1252's commuting rule to unhosted idle children of the same (replica, port), receivers capped at rank 51, followed by PR3184's star optimum.", + "scope_change_reason": "The card targets the selected packing; this applies the same idle-repartition mechanism (PR1252 / frontier1094-idle-star-ceiling) to the open rank-seven T740 line, whose relaxation cap charges one idle child per bin.", + "bottleneck_link": "Repartitioning idle children changes the paid histogram and so moves the exact complex endpoint.", + "budget_minutes": 120, + "stop_rule": "Stop after the exact overlay, pricing and an independent structural verifier; no controller/outer admission in this session.", + "outcome": "partial", + "evidence": "RESULT.json, BINS.json.gz, MOVES.json.gz (391,964 axis moves), AUDIT.json (8/8 controls rejected).", + "author": "Rohan Arun", + "ai_assistance": "Substantial Anthropic Claude (Claude Code) assistance; idea seeded with help from OpenCode (Space bunny free).", + "open_questions": [ + { + "question": "Is a hosted bin's idle remainder a legal donor under the T74 controller contract?", + "why_it_matters": "PR1252's admitted audit covered only unhosted children; this package relies on orthogonality to the hosted prefix plus the commuting rule.", + "first_step": "Generalize the T74 audit_mixed.py owner/controller audit to read the axis overlay and rerun its controls on PR3148's release.", + "blocked_by": "The T74 release chain has no idle-axis overlay reader." + }, + { + "question": "Can the bit supplier rise toward the new complex root 0.0017347706?", + "why_it_matters": "kappa is now bit-bound; any bit gain up to about +1.34e-6 is realizable.", + "first_step": "Price the actual #589 bit word with the moment-fee metric and search skip/carrier rewrites on it.", + "blocked_by": "Bit word rewrite tooling." + } + ] +} diff --git a/research/rank7-idle-remainder-donors-t740/VERIFY.json b/research/rank7-idle-remainder-donors-t740/VERIFY.json new file mode 100644 index 0000000000..6639640214 --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/adaptive-kernel-demotion/inputs/DATA-PHASES.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Independent of build.py: donor axes from the donor's own remainder, unhosted receivers, no child both donates and receives, unit/orthogonal-at-receipt and commuting rule, rank cap 51, group multisets, profile and rank mass, exact complex root bracket with its own interval arithmetic, kappa = min(floor24(complex), PR589 bit) - 1e-46 - 1e-70 and gates over PR3148/PR3184; 8 mutation controls rejected." + } + ] +} diff --git a/research/rank7-idle-remainder-donors-t740/build.py b/research/rank7-idle-remainder-donors-t740/build.py new file mode 100644 index 0000000000..87ccf74f2b --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/build.py @@ -0,0 +1,209 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Idle-remainder donor exchanges on PR3148's T740 fill of PR3133's words. + +Every idle remainder of a (replica, port) - including the remainder of a partially hosted bin, +whose axes are the recipe axes [used, cap) - may donate axes to a fully idle (unhosted) child of +the same replica and port. Each moved axis obeys PR1252's commuting rule (commutes with all of the +receiver's current axes, every stage entry/exit X and Y translation, the terminal Y translation and +both children's terminal translations). Receivers are capped at rank 51 (73^2 > 2*51^2). +Phase 1 drains remainders smallest-first into the largest legal receiver; phase 2 runs the +frontier1094 star optimum (PR3184) on the untouched fully idle rank-48 children. + +Inputs (pinned): DATA-PHASES.json on main; PR3148's materialized COMPOSED-FILL/ORDER/DISPATCH and +its PR3133 provider widths (PR3148-PROVIDERS.json, copied from PR3148 vendor/). +""" +import argparse, gzip, hashlib, itertools, json, math +from collections import Counter, defaultdict +from fractions import Fraction as Q +from pathlib import Path + +HERE = Path(__file__).resolve().parent +PHASES = HERE.parents[1] / 'research/adaptive-kernel-demotion/inputs/DATA-PHASES.json' +PIN = dict(phases='c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa', + fill_payload='8f4d6965ba573ff2b71fd7bf6b552643e086739d90bd73c55889502077638e00', + order='927226d702bf3cada076f4c459da9063c0df7e7154a62955cf75c40cf30215b9', + dispatch='90edc935320dd6264e98dc735d868df3c95f5901c70d7d96171001fcb295cce0', + providers='52eb0d85caa7b2d4a93acdf5011f52b793f61ddca86235fb03cd9a09397ad4cd') +T = 740 +LOCAL = {1: 2433, 2: 724, 3: 228, 4: 102, 5: 20, 8: 8} +IDLE_PR3148 = {1: 173160, 3: 48951, 5: 13875, 48: 282569} +BIT = Q('0.001733427039589844234749') # PR589 bit saving, as pinned in the T74 outer ledger +PR3148_KAPPA = Q('0.0017297774946785970118859999999999999999999998999999999999999999999999') +PR3184_KAPPA = Q('0.0017301890612338507600949999999999999999999998999999999999999999999999') + + +def need(ok, why): + if not ok: raise SystemExit('FAIL: ' + why) + + +def sha(b): return hashlib.sha256(b).hexdigest() +def dot(a, b): return (a & b).bit_count() & 1 +def Hf(r): return 0.0 if r == 0 else r * (73.0 / r) ** 0.00173 + + +def pgz(obj): + d = bytearray(gzip.compress(json.dumps(obj, sort_keys=True, separators=(',', ':')).encode(), mtime=0)); d[9] = 255 + return bytes(d) + + +# ---- exact root (rational intervals, directed rounding 1e-60) ---- +S = 10 ** 60 +def dn(x): return Q(math.floor(x * S), S) +def upr(x): return Q(math.ceil(x * S), S) +def atanh2(z, n): + s, p = Q(0), z + for j in range(n): s += p / (2 * j + 1); p *= z * z + return 2 * s, 2 * p / ((2 * n + 1) * (1 - z * z)) +L2 = atanh2(Q(1, 3), 120) +LN = {} +def lnr(r): + if r not in LN: + x, k = Q(73, r), 0 + while x > 2: x /= 2; k += 1 + a, e = atanh2((x - 1) / (x + 1), 80) + LN[r] = (dn(a + k * L2[0]), upr(a + e + k * (L2[0] + L2[1]))) + return LN[r] +def ex(x0, x1): + def ser(x): + s, t = Q(0), Q(1) + for n in range(1, 40): s += t; t = t * x / n + return s, t + a, _ = ser(x0); b, t = ser(x1) + return dn(a), upr(b + 2 * t) +def moment(prof, b): + W = 896 * T; lo = hi = Q(0) + for r, n in prof.items(): + l0, l1 = lnr(r); e0, e1 = ex(b * l0, b * l1); lo += n * r * e0; hi += n * r * e1 + return lo / (73 * W), hi / (73 * W) +def root(prof, digits=25): + f = lambda b: sum(n * r * (73 / r) ** b for r, n in prof.items()) / (73 * 896 * T) - 1 + a, c = 0.0, 0.01 + for _ in range(200): + m = (a + c) / 2 + if f(m) < 0: a = m + else: c = m + g = 10 ** digits; k0, k1 = int(a * g) - 10 ** 10, int(a * g) + 10 ** 10 + need(moment(prof, Q(k0, g))[1] < 1 and moment(prof, Q(k1, g))[0] > 1, 'bracket') + while k1 - k0 > 1: + k = (k0 + k1) // 2; lo, hi = moment(prof, Q(k, g)) + if hi < 1: k0 = k + elif lo > 1: k1 = k + else: raise SystemExit('wide interval') + return Q(k0, g), Q(k1, g) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--t740', type=Path, required=True, help='directory written by PR3148 materialize.py') + a = ap.parse_args() + raw = PHASES.read_bytes(); need(sha(raw) == PIN['phases'], 'phases pin') + rec = {r['port']: r for r in json.loads(raw)['recipes']} + fraw = gzip.decompress((a.t740 / 'COMPOSED-FILL.json.gz').read_bytes()); need(sha(fraw) == PIN['fill_payload'], 'fill pin') + need(sha((a.t740 / 'ORDER.json').read_bytes()) == PIN['order'] and sha((a.t740 / 'DISPATCH.json').read_bytes()) == PIN['dispatch'], 'order/dispatch pins') + praw = (HERE / 'PR3148-PROVIDERS.json').read_bytes(); need(sha(praw) == PIN['providers'], 'providers pin') + prov = json.loads(praw); order = json.loads((a.t740 / 'ORDER.json').read_bytes()) + disp = {(s, r): p for s, r, p in json.loads((a.t740 / 'DISPATCH.json').read_bytes())} + fill = json.loads(fraw) + need(fill['columns'] == ['time', 'helper', 'owner_replica', 'child', 'port', 'offset'] and fill['dispatch_overrides'] == [], 'fill format') + caps = {(p, c): ch['rank'] for p, r in rec.items() for c, ch in enumerate(r['idle_children'])} + AX = {(p, c): [int(v) for v in ch['orthogonal_axes']] for p, r in rec.items() for c, ch in enumerate(r['idle_children'])} + TR = {(p, c): int(ch['translation_after']) for p, r in rec.items() for c, ch in enumerate(r['idle_children'])} + PT = {p: [int(s[k]) for s in rc['stage_alignment'] for k in ('entry_Y', 'exit_Y', 'entry_X', 'exit_X')] + [int(rc['terminal_Y_translation'])] for p, rc in rec.items()} + used, top = Counter(), Counter() + for time, helper, rep, child, port, offset in fill['rows']: + s, r = order[time]; w = prov[disp[s, r]]['widths'][helper] + used[rep, child, port] += w; top[rep, child, port] = max(top[rep, child, port], offset + w) + need(all(used[k] == top[k] for k in used), 'compact helper prefixes') + groups = [] + for rep in range(T): + for p in range(112): + kids = [[c, used[rep, c, p]] for c in range(len(rec[p]['idle_children'])) if caps[p, c] - used[rep, c, p] > 0] + groups.append([rep, p, kids]) + idle = Counter(caps[p, c] - u for _, p, kids in groups for c, u in kids) + need(dict(idle) == IDLE_PR3148, 'idle bill equals PR3148') + + def legal(v, p, c, d, axes_d): + return all(dot(v, x) == 0 for x in axes_d) and all(dot(v, x) == 0 for x in PT[p]) and dot(v, TR[p, c]) == 0 and dot(v, TR[p, d]) == 0 + + def solve(p, kids): + rank = {c: caps[p, c] - u for c, u in kids}; axes = {c: AX[p, c][u:caps[p, c]] for c, u in kids} + hosted = {c: u > 0 for c, u in kids}; role = {c: None for c, _ in kids}; moves = [] + for c in sorted([c for c, u in kids if u > 0], key=lambda c: (rank[c], c)): + for v in list(axes[c]): + best = None + for d in sorted([d for d, _ in kids if not hosted[d] and role[d] != 'D' and d != c and rank[d] < 51], key=lambda d: (-rank[d], d)): + if rank[d] < rank[c] - 1: break + if legal(v, p, c, d, axes[d]): best = d; break + if best is None or Hf(rank[c] - 1) + Hf(rank[best] + 1) - Hf(rank[c]) - Hf(rank[best]) >= 0: continue + axes[c].remove(v); axes[best].append(v); rank[c] -= 1; rank[best] += 1 + role[c] = 'D'; role[best] = 'R'; moves.append([c, best, v]) + free = [c for c, u in kids if u == 0 and role[c] is None and caps[p, c] == 48] + if len(free) >= 2: + MV = {(d, r): [v for v in axes[d] if legal(v, p, d, r, axes[r])] for d in free for r in free if d != r} + best = [len(free) * Hf(48), []] + def match(c, leaves): + opts = [MV[c, l] for l in leaves] + if any(len(o) < 3 for o in opts): return None + def go(k, usedax): + if k == len(leaves): return [] + for trip in itertools.combinations([v for v in opts[k] if v not in usedax], 3): + rest = go(k + 1, usedax | set(trip)) + if rest is not None: return [(c, leaves[k], list(trip))] + rest + return None + return go(0, set()) + def assign(i, roles): + if i == len(free): + leaves = defaultdict(list) + for c in free: + if isinstance(roles[c], tuple): leaves[roles[c][1]].append(c) + cents = [c for c in free if roles[c] == 'c'] + if any(not leaves[c] for c in cents) or any(roles[x] != 'c' for x in leaves): return + mv = [] + for c in cents: + m = match(c, leaves[c]) + if m is None: return + mv += m + rk = [48 - 3 * len(leaves[c]) if roles[c] == 'c' else 51 if isinstance(roles[c], tuple) else 48 for c in free] + cost = sum(Hf(x) for x in rk) + if cost < best[0] - 1e-12: best[0], best[1] = cost, mv + return + c = free[i] + for opt in ['n', 'c'] + [('l', d) for d in free if d != c]: + roles[c] = opt; assign(i + 1, roles) + del roles[c] + assign(0, {}) + for c, l, trip in best[1]: + for v in trip: + axes[c].remove(v); axes[l].append(v); rank[c] -= 1; rank[l] += 1; moves.append([c, l, v]) + return moves, rank + + cache, moves, final = {}, [], Counter() + for rep, p, kids in groups: + key = (p, tuple(map(tuple, kids))) + if key not in cache: cache[key] = solve(p, kids) + mv, rank = cache[key] + moves += [[rep, p] + m for m in mv] + final.update(r for r in rank.values() if r) + prof = Counter({r: n * 9 * T for r, n in LOCAL.items()}); prof.update(final); prof = dict(sorted(prof.items())) + need(sum(r * n for r, n in prof.items()) == 65088 * T and 73 * 73 > 2 * max(prof) ** 2, 'mass and halving') + lo, hi = root(prof) + C = min(Q(math.floor(lo * 10 ** 24), 10 ** 24), BIT) + kappa = C - Q(1, 10 ** 46) - Q(1, 10 ** 70) + need(kappa > PR3184_KAPPA > PR3148_KAPPA, 'gates') + (HERE / 'BINS.json.gz').write_bytes(pgz(dict(T=T, columns=['replica', 'port', [['child', 'used']]], groups=[g for g in groups if g[2]]))) + (HERE / 'MOVES.json.gz').write_bytes(pgz(dict(columns=['replica', 'port', 'donor_child', 'receiver_child', 'axis'], moves=moves))) + donors = Counter(); + res = dict(status='PASS_IDLE_REMAINDER_DONOR_EXCHANGES_T740', T=T, axis_moves=len(moves), + donor_children=len({(m[0], m[1], m[2]) for m in moves}), receiver_children=len({(m[0], m[1], m[3]) for m in moves}), + idle_before={str(k): v for k, v in IDLE_PR3148.items()}, idle_after={str(k): v for k, v in sorted(final.items())}, + profile={str(k): v for k, v in prof.items()}, complex_root=[str(lo), str(hi)], + complex_root_decimal=f'{lo.numerator * 10**25 // lo.denominator}e-25', bit=str(BIT), binding='bit' if BIT < lo else 'complex', + kappa=str(kappa), kappa_decimal='0.0017334270395898442347489999999999999999999998999999999999999999999999', gain_over_pr3184=str(kappa - PR3184_KAPPA), gain_over_pr3148=str(kappa - PR3148_KAPPA), + max_child_rank=max(prof), halving=[5329, 2 * max(prof) ** 2]) + (HERE / 'RESULT.json').write_text(json.dumps(res, indent=1) + '\n') + print('PASS', float(lo), res['binding'], float(kappa), float(kappa - PR3184_KAPPA), len(moves)) + + +if __name__ == '__main__': + main() diff --git a/research/rank7-idle-remainder-donors-t740/verify.py b/research/rank7-idle-remainder-donors-t740/verify.py new file mode 100644 index 0000000000..ca607d6a86 --- /dev/null +++ b/research/rank7-idle-remainder-donors-t740/verify.py @@ -0,0 +1,179 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Independent verifier (does not import build.py) for the idle-remainder donor exchanges. + +Re-derives from BINS / MOVES / DATA-PHASES: donor axes come from the donor's own idle remainder +(recipe axes [used, cap)); receivers are unhosted (used == 0); no child both donates and receives; +every moved axis is a unit vector orthogonal to all of the receiver's axes held at that moment and +commutes with every stage entry/exit X/Y translation, the terminal Y translation and both +children's terminal translations; final ranks <= 51; per-group axis multisets unchanged; the +complete profile and rank mass; an exact complex root bracket with its own interval arithmetic; +kappa = min(floor24(complex_lower), PR589 bit) - 1e-46 - 1e-70 and its gates. +Optional --t740 rebinds BINS to PR3148's materialized fill. Mutation controls must be rejected. +""" +import argparse, copy, gzip, hashlib, json +from collections import Counter, defaultdict +from fractions import Fraction as F +from pathlib import Path + +PKG = Path(__file__).resolve().parent +PHASES = PKG.parents[1] / 'research/adaptive-kernel-demotion/inputs/DATA-PHASES.json' +T = 740 +LOCAL = {1: 2433, 2: 724, 3: 228, 4: 102, 5: 20, 8: 8} +IDLE = {1: 173160, 3: 48951, 5: 13875, 48: 282569} +BIT = F('0.001733427039589844234749') +GATES = dict(PR3148=F('0.0017297774946785970118859999999999999999999998999999999999999999999999'), + PR3184=F('0.0017301890612338507600949999999999999999999998999999999999999999999999')) + + +class Reject(Exception): pass +def req(ok, why): + if not ok: raise Reject(why) +def load(p): + b = Path(p).read_bytes(); return json.loads(gzip.decompress(b) if b[:2] == b'\x1f\x8b' else b) +def par(a, b): return bin(a & b).count('1') & 1 + + +def audit(rec, bins, moves): + caps = {(p, c): ch['rank'] for p, r in rec.items() for c, ch in enumerate(r['idle_children'])} + G = {} + for rep, p, kids in bins['groups']: + req((rep, p) not in G and 0 <= rep < T and p in rec, 'group key') + G[rep, p] = {c: u for c, u in kids} + req(all(0 <= u < caps[p, c] for c, u in kids), 'used below capacity') + req(Counter(caps[p, c] - u for (rep, p), kids in G.items() for c, u in kids.items()) == Counter(IDLE), 'idle bill') + trans = {} + for p, rc in rec.items(): + trans[p] = {int(s[k]) for s in rc['stage_alignment'] for k in ('entry_X', 'exit_X', 'entry_Y', 'exit_Y')} | {int(rc['terminal_Y_translation'])} + for c, ch in enumerate(rc['idle_children']): + ax = [int(v) for v in ch['orthogonal_axes']] + req(all(par(v, v) == 1 for v in ax) and all(par(a, b) == 0 for i, a in enumerate(ax) for b in ax[i + 1:]), 'recipe axes orthonormal') + state = {} + def cur(rep, p, c): + k = (rep, p, c) + if k not in state: + u = G[rep, p][c]; state[k] = dict(axes=set(int(v) for v in rec[p]['idle_children'][c]['orthogonal_axes'][u:caps[p, c]]), role=None) + return state[k] + for m in moves: + rep, p, c, d, v = m + req((rep, p) in G and c in G[rep, p] and d in G[rep, p] and c != d, 'children of the group') + req(G[rep, p][d] == 0, 'receiver must be unhosted') + sc, sd = cur(rep, p, c), cur(rep, p, d) + req(sc['role'] != 'R' and sd['role'] != 'D', 'child both donates and receives') + own = set(int(x) for x in rec[p]['idle_children'][c]['orthogonal_axes'][G[rep, p][c]:caps[p, c]]) + req(v in sc['axes'] and v in own, 'axis not in donor remainder') + req(par(v, v) == 1 and all(par(v, x) == 0 for x in sd['axes']), 'axis not orthogonal to receiver axes') + tc = int(rec[p]['idle_children'][c]['translation_after']); td = int(rec[p]['idle_children'][d]['translation_after']) + req(all(par(v, x) == 0 for x in trans[p] | {tc, td}), 'axis does not commute with translations') + sc['axes'].discard(v); sd['axes'].add(v); sc['role'] = 'D'; sd['role'] = 'R' + req(len(sd['axes']) <= 51, 'rank above 51') + final = Counter() + for (rep, p), kids in G.items(): + for c, u in kids.items(): + r = len(state[rep, p, c]['axes']) if (rep, p, c) in state else caps[p, c] - u + if r: final[r] += 1 + return final + + +def mom(prof, b): + Q72 = 10 ** 72 + def rd(x): return F(x.numerator * Q72 // x.denominator, Q72) + def ru(x): return F(-((-x.numerator * Q72) // x.denominator), Q72) + def at(z, n): + s, p = F(0), z + for j in range(n): s += p / (2 * j + 1); p *= z * z + return 2 * s, 2 * p / ((2 * n + 1) * (1 - z * z)) + l2 = at(F(1, 3), 130); W = 896 * T; lo = hi = F(0) + for r, n in sorted(prof.items()): + y, k = F(73, r), 0 + while y >= 2: y /= 2; k += 1 + a, e = at((y - 1) / (y + 1), 90) + L0, L1 = rd(a + k * l2[0]), ru(a + e + k * (l2[0] + l2[1])) + def tay(x): + s, t = F(1), F(1) + for j in range(1, 34): t = t * x / j; s += t + return s, t * x / 34 * 3 + e0, _ = tay(b * L0); e1, t1 = tay(b * L1) + lo += n * r * rd(e0); hi += n * r * ru(e1 + t1) + return lo / (73 * W), hi / (73 * W) + + +def run(rec, bins, moves, result): + final = audit(rec, bins, moves) + prof = Counter({r: n * 9 * T for r, n in LOCAL.items()}); prof.update(final); prof = dict(sorted(prof.items())) + req({str(k): v for k, v in prof.items()} == result['profile'], 'declared profile') + req(sum(r * n for r, n in prof.items()) == 65088 * T, 'rank mass 65088*T') + req(max(prof) <= 51 and 73 * 73 > 2 * max(prof) ** 2, 'halving guard') + lo, hi = F(result['complex_root'][0]), F(result['complex_root'][1]) + req(hi - lo == F(1, 10 ** 25) and mom(prof, lo)[1] < 1 and mom(prof, hi)[0] > 1, 'complex root bracket') + C = min(F(lo.numerator * 10 ** 24 // lo.denominator, 10 ** 24), BIT) + kappa = C - F(1, 10 ** 46) - F(1, 10 ** 70) + req(kappa == F(result['kappa']), 'headline kappa') + for n, g in GATES.items(): req(kappa > g, 'kappa must exceed ' + n) + return prof, kappa, lo + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument('--t740', type=Path) + ap.add_argument('--providers', type=Path, default=PKG / 'PR3148-PROVIDERS.json') + ap.add_argument('--write', action='store_true', help='rewrite the committed AUDIT.json receipt') + a = ap.parse_args() + if not __debug__: raise SystemExit('assertions required') + raw = PHASES.read_bytes() + req(hashlib.sha256(raw).hexdigest() == 'c5916ff312678f12aba403847643fbbc29f643acec60bdf836fa56cd3e8251fa', 'phases pin') + rec = {r['port']: r for r in json.loads(raw)['recipes']} + bins, mv, result = load(PKG / 'BINS.json.gz'), load(PKG / 'MOVES.json.gz')['moves'], load(PKG / 'RESULT.json') + rebound = False + if a.t740: + fraw = gzip.decompress((a.t740 / 'COMPOSED-FILL.json.gz').read_bytes()) + req(hashlib.sha256(fraw).hexdigest() == '8f4d6965ba573ff2b71fd7bf6b552643e086739d90bd73c55889502077638e00', 'fill pin') + prov = load(a.providers); order = load(a.t740 / 'ORDER.json'); disp = {(s, r): p for s, r, p in load(a.t740 / 'DISPATCH.json')} + used = Counter() + for time, helper, rep, child, port, offset in json.loads(fraw)['rows']: + s, r = order[time]; used[rep, child, port] += prov[disp[s, r]]['widths'][helper] + caps = {(p, c): ch['rank'] for p, r in rec.items() for c, ch in enumerate(r['idle_children'])} + derived = [[rep, p, [[c, used[rep, c, p]] for c in range(len(rec[p]['idle_children'])) if caps[p, c] - used[rep, c, p] > 0]] for rep in range(T) for p in range(112)] + req([g for g in derived if g[2]] == bins['groups'], 'BINS equal the fill') + rebound = True + prof, kappa, lo = run(rec, bins, mv, result) + rej = {} + first_hosted = next(i for i, m in enumerate(mv) if {c: u for c, u in next(g for g in bins['groups'] if g[0] == m[0] and g[1] == m[1])[2]}[m[2]] > 0) + rep, p, c, d, v = mv[first_hosted] + kids = {cc: u for cc, u in next(g for g in bins['groups'] if g[0] == rep and g[1] == p)[2]} + hosted_other = next((cc for cc, u in kids.items() if u > 0 and cc != c), None) + used_axis = int(rec[p]['idle_children'][c]['orthogonal_axes'][0]) + def mut(f): + x = copy.deepcopy(mv); f(x); return x + cases = dict( + hosted_receiver=mut(lambda x: x.__setitem__(first_hosted, [rep, p, c, hosted_other if hosted_other is not None else c, v])), + hosted_axis_from_used_prefix=mut(lambda x: x.__setitem__(first_hosted, [rep, p, c, d, used_axis])), + foreign_axis=mut(lambda x: x.__setitem__(first_hosted, [rep, p, c, d, 1 << 80])), + axis_moved_twice=mut(lambda x: x.insert(first_hosted + 1, list(x[first_hosted]))), + receiver_donates=mut(lambda x: x.append([rep, p, d, c, v])), + dropped_move=mut(lambda x: x.pop(first_hosted)), + ) + for name, x in cases.items(): + try: run(rec, bins, x, result) + except Reject as e: rej[name] = str(e) + else: raise SystemExit('mutation accepted: ' + name) + r2 = copy.deepcopy(result); r2['complex_root'] = [str(lo + F(1, 10 ** 25)), str(lo + F(2, 10 ** 25))] + try: run(rec, bins, mv, r2) + except Reject as e: rej['next_root_grid'] = str(e) + else: raise SystemExit('mutation accepted: next_root_grid') + r3 = copy.deepcopy(result); r3['kappa'] = str(F(result['kappa']) + F(1, 10 ** 24)) + try: run(rec, bins, mv, r3) + except Reject as e: rej['kappa_above_bit'] = str(e) + else: raise SystemExit('mutation accepted: kappa_above_bit') + out = dict(status='PASS_IDLE_REMAINDER_DONOR_AUDIT', moves=len(mv), fill_rebound=rebound, kappa=str(kappa), + complex_root_lower=str(lo), binding='bit' if BIT < lo else 'complex', rejected_controls=rej) + if a.write: (PKG / 'AUDIT.json').write_text(json.dumps(out, indent=1, sort_keys=True) + '\n') + else: + strip = lambda d: {k: v for k, v in d.items() if k != 'fill_rebound'} + req(strip(load(PKG / 'AUDIT.json')) == strip(json.loads(json.dumps(out))), 'committed AUDIT.json receipt') + print('PASS_IDLE_REMAINDER_DONOR_AUDIT moves=%d controls=%d kappa=%s binding=%s' % (len(mv), len(rej), float(kappa), out['binding'])) + + +if __name__ == '__main__': + try: main() + except Reject as e: raise SystemExit('FAIL: ' + str(e))