diff --git a/research/three-bank-restored-unpaid/README.md b/research/three-bank-restored-unpaid/README.md new file mode 100644 index 0000000000..f24b923896 --- /dev/null +++ b/research/three-bank-restored-unpaid/README.md @@ -0,0 +1,133 @@ +# A restored third bank does not add an unpaid coordinate + +**Scoped obstruction. No new κ. The selected record is unchanged.** + +Original card: `coverage-law-change`. The actual question is the third-bank cycle left open by +[multipair-schedule-bound](../multipair-schedule-bound/README.md): can a cycle `X → Y → Z` leave +more than one unpaid coordinate per family? Scope status is **refined**. The full card, the reason +for the refinement, and the bottleneck link are in [TASK.json](TASK.json). + +## What is certified + +The selected nested contract in +[INHERITED-COMPLEX-GEOMETRY.txt](../split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt) +starts at `X_(-1)=C_q` and ends at the Y endpoint `C_all C_q^(-1)`, with `m=73`. That note states +that a nested transition has Fourier rank equal to the dimension difference of the Lagrangian +preimages. On binary frames this package uses that dimension rule directly: + +- a frame is nested when every initial vector lies in the final span; +- the unpaid count is the initial rank; +- the acquired count is the final rank minus the initial rank. + +The selected initial direction inside the full 73-dimensional frame has unpaid count 1 and acquired +count 72. That is the `72W` term in the coverage identity `mass = 72W + 64N`. The selected word +`{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}` then has local mass 5586, idle mass 1646, and deficit +`320/9` at centre charge 64. + +Four explicit frames, each checked by Gaussian elimination: + +| Schedule | Initial frame | Final frame | Nested | Unpaid | Acquired | +|---|---|---|---|---:|---:| +| Selected family | one coordinate | full `F_2^73` | yes | 1 | 72 | +| Restored dirty bank | a 2-dimensional bank subspace | the same subspace | yes | bank rank 2, family still 1 | 0 | +| Datum copied into a second bank | the family coordinate | that coordinate plus the copy | yes | 1 | 1 | +| Cleared source, new bank written | the family coordinate | a different coordinate | no | — | — | +| Plane-port initial frame | two coordinates | full `F_2^73` | yes | 2 | 71 | + +A restored bank returns to the subspace it entered, so it acquires no data direction. The family's +initial frame is still the single coordinate `C_q`, and the family unpaid count stays 1. Copying +that datum into a second bank acquires one direction. That direction is paid mass. Two unpaid +coordinates appear when the initial frame itself has rank 2. That is the plane-port contract +already screened in [plane-port-copy-budgets](../plane-port-copy-budgets/README.md), whose +complex break-even copy charge is about 160–164 per call. This package does not reprice it. + +## Excursion prices + +The ceiling engine is the pinned +[complex-local-word-ceiling](../complex-local-word-ceiling/ceiling.py), grid `1/10^12`, idle cap +`R=51`, `w=896/9`. The selected saving is +`a = κ/(1-κ) = 836330098538459/499163669901461541` +for `κ = 836330098538459/500000000000000000`. + +| Profile | Idle mass | Deficit | Ceiling high endpoint | +|---|---:|---:|---:| +| Selected word, unpaid 1 | 1646 | 320/9 | 169005411/100000000000 | +| One extra rank-1 child per live family, unpaid 1 | 13918/9 | 320/9 | 1659158299/1000000000000 | +| Two extra rank-1 children per live family, unpaid 1 | 13022/9 | 320/9 | 1629372687/1000000000000 | +| Same word, unpaid 2 | 13918/9 | 1216/9 | 6377984109/1000000000000 | + +The one-step and two-step ceilings are about 0.982 and 0.964 times the selected ceiling. At the +selected saving, ideal idle packing of the selected word has relaxation strictly below 1. The same +packing of either excursion has relaxation strictly above 1 (floating orientation about 1.000048 +and 1.000139; the certificate is the inequality). Paying the third-bank copy on the selected word +therefore misses the current saving. + +The unpaid-2 ceiling is `708664901/187783790` times the selected ceiling, which prints as 3.77×, +the lever in [levers.py](../complex-local-word-ceiling/levers.py). Its idle mass equals the +one-step idle mass `13918/9`, because one extra unpaid coordinate and one extra rank-1 child per +family move the same amount of mass. They move it in opposite directions: unpaid 2 enlarges the +deficit and leaves the word's children idle-cheap, while the excursion spends that mass as rank-1 +children and keeps the deficit at `320/9`. The shared idle figure is the integrality obstruction +recorded by PR #3757 for a two-unpaid histogram. This package uses it only to separate those two +schedules. + +## Domain and limitations + +The frames are the binary preimages of the `C_q` products. The verifier authenticates the geometry +note, the multipair question, the selected word, and the selected κ, then counts ranks. It does +not replay Clifford phases, the 946 local frames, or a native tape. + +A cleared source has intersection zero with its replacement bank, so the nested unpaid rule does +not apply to it. A schedule that erases an initial direction and still leaves two unpaid +coordinates would need a different contract. No such schedule is supplied here. + +The ceiling calls are ideal idle packings of one changed histogram. They are planning bounds. +They do not exhibit a circuit, and they do not change the selected frontier. + +## Reproduce + +From the repository root, Python 3.12, standard library only: + +```sh +python3 -B research/three-bank-restored-unpaid/verify.py +python3 scripts/research_package.py --package research/three-bank-restored-unpaid --check-only +python3.12 scripts/research_package.py --package research/three-bank-restored-unpaid +``` + +`verify.py` prints + +`PASS_THREE_BANK_RESTORED_UNPAID restored_adds_unpaid=false one_step_exceeds_selected=true no_new_kappa` + +and checks [RESULT.json](RESULT.json) against a fresh execution. Pins are in +[SOURCES.json](SOURCES.json). The selected record and the task catalogue are historical +provenance at base `bb4bccbf42844d2801487450727c2f63e10d1d0f`. Live inputs are the five paths in +[VERIFY.json](VERIFY.json). + +Rejection controls inside the same run: a restored bank with positive acquired rank, a copied +second bank counted as unpaid 2, and a one-step excursion whose relaxation still meets the +selected saving. + +## Open next questions + +1. **Can a non-nested three-bank schedule, one that erases an initial direction and rewrites it, leave two unpaid coordinates without becoming a plane port?** + The nested contract is what makes the unpaid count equal the initial dimension. An erasure could in principle be paired with a second surviving direction. First step: write one explicit erasure and rewrite on three coordinates and count `dim(initial ∩ final)` after every paid climb. Blocker: no candidate schedule is supplied. The cleared-source example in this package drops the intersection to zero. + +2. **If the third bank is identified with a second initial direction, does any scalar endpoint pass the paired-plane obstruction while staying inside the plane-port copy budget?** + That identification is the actual two-unpaid contract. The 3.77 multiplier is the ideal screen. First step: recheck [paired-plane-scalar-mask-obstruction](../paired-plane-scalar-mask-obstruction/README.md) on one concrete endpoint whose copy charge is at most the certified complex budget near 160 per call. Blocker: this package does not contain a scalar endpoint or a native copy program. + +## Credit + +- The third-bank question and Theorem S are from themilkman216, + [multipair-schedule-bound](../multipair-schedule-bound/README.md). +- The ceiling and the 3.77× lever are Douglas Colkitt's + [complex-local-word-ceiling](../complex-local-word-ceiling/README.md), with Claude (Anthropic) + assistance, Apache-2.0. +- The nested Fourier-rank rule, `m=73`, and the `C_q` endpoints are the inherited complex + geometry note above. Its predecessor attribution stays in that file. +- PR #3561 (jwr404) caps a line-port replica offset at one unpaid coordinate per family + (896). PR #3757 records that the two-unpaid idle mass `13918/9` is not an integer histogram + on one call. Plane-port copy budgets are a separate contract and are not recomputed here. +- The selected κ is the repository's selected record. This package does not replace it. + +Prepared by unpaidmoon with substantial Cursor Grok assistance for the proof check, the ceiling +calls, and the package text. New work is Apache-2.0. diff --git a/research/three-bank-restored-unpaid/RESULT.json b/research/three-bank-restored-unpaid/RESULT.json new file mode 100644 index 0000000000..cc132038f2 --- /dev/null +++ b/research/three-bank-restored-unpaid/RESULT.json @@ -0,0 +1,38 @@ +{ + "selected_unpaid": 1, + "selected_acquired": 72, + "restored_bank_acquired": 0, + "family_unpaid_after_restored_bank": 1, + "copied_second_bank_unpaid": 1, + "copied_second_bank_acquired": 1, + "cleared_source_nested": false, + "plane_unpaid": 2, + "deficit": "320/9", + "two_unpaid_deficit": "1216/9", + "selected_saving": "836330098538459/499163669901461541", + "base_idle": "1646", + "one_step_idle": "13918/9", + "two_step_idle": "13022/9", + "two_unpaid_idle": "13918/9", + "base_ceiling": [ + "1690054109/1000000000000", + "169005411/100000000000" + ], + "two_unpaid_ceiling": [ + "1594496027/250000000000", + "6377984109/1000000000000" + ], + "two_unpaid_ratio": "708664901/187783790", + "one_step_ceiling": [ + "829579149/500000000000", + "1659158299/1000000000000" + ], + "two_step_ceiling": [ + "814686343/500000000000", + "1629372687/1000000000000" + ], + "one_step_exceeds_selected": true, + "two_step_exceeds_selected": true, + "restored_adds_unpaid": false, + "no_new_kappa": true +} diff --git a/research/three-bank-restored-unpaid/SOURCES.json b/research/three-bank-restored-unpaid/SOURCES.json new file mode 100644 index 0000000000..4a05005fd3 --- /dev/null +++ b/research/three-bank-restored-unpaid/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "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" + }, + { + "path": "research/complex-local-word-ceiling/levers.py", + "usage": "input", + "git_blob": "e6aee6ce1178f5b68b9ce893b2f5b7f80a143b59", + "sha256": "24c71fc5dce5e2d8f9fbd34d059fc9a1c8ad635d93b62102ccb41b03a7b38b9e" + }, + { + "path": "research/multipair-schedule-bound/README.md", + "usage": "input", + "git_blob": "a01bb3bda99ff8e3c7342829ccad5bd815e712bc", + "sha256": "b70972e022fa1b275993dacb30338f698ca50ce8d19ee056239c4320458d5276" + }, + { + "path": "research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt", + "usage": "input", + "git_blob": "c4150cb693414c098690eae79b3aea5f47c184ff", + "sha256": "c1ff55536594222a8d2a30bc0e0956959774e1be2d5420b7838ad553ee556df2" + } + ] +} diff --git a/research/three-bank-restored-unpaid/TASK.json b/research/three-bank-restored-unpaid/TASK.json new file mode 100644 index 0000000000..e8fd190cce --- /dev/null +++ b/research/three-bank-restored-unpaid/TASK.json @@ -0,0 +1,71 @@ +{ + "schema_version": 1, + "task_id": "coverage-law-change", + "priority_revision": 6, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "original_card": { + "id": "coverage-law-change", + "question": "Can a template or call contract leave two or more unpaid coordinates per live family?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/idle-axis-hosting/PROOF.md", + "certificates/selected-result.json" + ], + "methods": [ + "State a replacement for the coverage identity (mass = 72W + 64N) and the contract change that realizes it, with its implementation cost.", + "Find an obstruction: show which data-endpoint obligation forces exactly one unpaid coordinate in the current template." + ], + "acceptance_gate": "An explicit replacement identity, verified on a small complete instance with dirty inputs, priced with ceiling.ceiling(unpaid=...). 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": "Explain where the single unpaid coordinate per family comes from in the hosted template; propose one change and price it. Ideal budget: two unpaid coordinates per family is 3.77x (levers.py).", + "bottleneck_link": "The deficit is one coordinate per family minus the centre charge; doubling unpaid coordinates per family scales it directly.", + "allowed_variations": [ + "One template change or one endpoint-contract change.", + "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": [ + "Counting a coordinate as unpaid while leaving it unadvanced in the data endpoint.", + "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": [ + "coverage identity", + "unpaid coordinate", + "deficit law", + "W - 64N" + ] + }, + "scope_status": "refined", + "actual_scope": "Does a restored or newly written third bank raise the nested unpaid count of a selected family above one?", + "scope_change_reason": "The coverage-law card asks whether any template can leave two unpaid coordinates. This package answers only the third-bank cycle left open by multipair-schedule-bound. A restored bank and a copied second bank both keep the selected one-dimensional initial frame, so they do not realize that lever. A two-dimensional initial frame is the separate plane-port contract and is not repriced here.", + "bottleneck_link": "The two-unpaid lever is the largest ideal packing multiplier in levers.py, about 3.77 times the selected ceiling. It applies only when the initial data frame has dimension two. A third bank that does not enlarge that frame leaves the deficit at one coordinate per family minus the centre charge.", + "budget_minutes": 60, + "stop_rule": "Stop when the nested dimension count and the one-step and two-step excursion prices are certified. Do not search for a non-nested encoding or build a plane-port decoder in this package.", + "outcome": "negative-result", + "evidence": "On nested frames, unpaid count equals the initial dimension. The selected initial level C_q gives unpaid 1 and acquired 72. A restored dirty bank acquires nothing for the family, and copying the datum into a second bank acquires one paid direction. One or two extra rank-1 children per live family, still at unpaid 1, put the ideal idle relaxation strictly above 1 at the selected saving. The unpaid-2 ceiling ratio remains 3.77 and is a different contract.", + "author": "unpaidmoon", + "ai_assistance": "Substantial Cursor Grok assistance for the proof check, ceiling calls, and package text.", + "open_questions": [ + { + "question": "Can a non-nested three-bank schedule, one that erases an initial direction and rewrites it, leave two unpaid coordinates without becoming a plane port?", + "why_it_matters": "The nested contract is what makes unpaid count equal the initial dimension. An erasure could in principle be paired with a second surviving direction.", + "first_step": "Write one explicit erasure and rewrite on three coordinates and count dim(initial intersect final) after every paid climb.", + "blocked_by": "No candidate schedule is supplied. The cleared-source example in this package drops the intersection to zero." + }, + { + "question": "If the third bank is identified with a second initial direction, does any scalar endpoint pass the paired-plane obstruction while staying inside the plane-port copy budget?", + "why_it_matters": "That identification is the actual two-unpaid contract. The 3.77 multiplier is only the ideal screen.", + "first_step": "Recheck paired-plane-scalar-mask-obstruction on one concrete endpoint whose copy charge is at most the certified complex budget near 160 per call.", + "blocked_by": "This package does not contain a scalar endpoint or a native copy program." + } + ] +} diff --git a/research/three-bank-restored-unpaid/VERIFY.json b/research/three-bank-restored-unpaid/VERIFY.json new file mode 100644 index 0000000000..b7111d1011 --- /dev/null +++ b/research/three-bank-restored-unpaid/VERIFY.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-local-word-ceiling/levers.py", + "research/multipair-schedule-bound/README.md", + "research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Nested unpaid count on the selected C_q frame, a restored dirty bank, a copied second bank, a cleared source, and a plane. Ideal idle ceilings and idle masses for the selected word, the unpaid-2 lever, and one-step and two-step rank-1 excursions, including rejection of a charged restoration, a copied unpaid-2 count, and a free excursion." + } + ] +} diff --git a/research/three-bank-restored-unpaid/verify.py b/research/three-bank-restored-unpaid/verify.py new file mode 100644 index 0000000000..ac6c8590f9 --- /dev/null +++ b/research/three-bank-restored-unpaid/verify.py @@ -0,0 +1,228 @@ +#!/usr/bin/env python3 +"""A restored or newly written third bank does not add an unpaid coordinate. + +The selected nested contract starts at one coordinate. Fourier rank equals the +dimension difference, so unpaid count equals the initial dimension. A third +bank is not a second initial direction. Charging its excursion on the selected +word also fails the current saving. +""" + +import hashlib +import importlib.util +import json +from fractions import Fraction +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +MARKER = ( + "PASS_THREE_BANK_RESTORED_UNPAID restored_adds_unpaid=false " + "one_step_exceeds_selected=true no_new_kappa" +) + + +def fail(message): + raise SystemExit("FAIL_THREE_BANK_RESTORED_UNPAID " + message) + + +def require(condition, message): + if not condition: + fail(message) + + +def sha256(path): + digest = hashlib.sha256() + with path.open("rb") as handle: + for block in iter(lambda: handle.read(1 << 20), b""): + digest.update(block) + return digest.hexdigest() + + +def authenticate(): + sources = json.loads((PACKAGE / "SOURCES.json").read_text(encoding="utf-8")) + pinned = {row["path"]: row for row in sources["files"] if row["usage"] == "input"} + expected = { + "certificates/selected-result.json", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-local-word-ceiling/levers.py", + "research/multipair-schedule-bound/README.md", + "research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt", + } + require(set(pinned) == expected, "input inventory changed") + for path, row in pinned.items(): + require(sha256(ROOT / path) == row["sha256"], "input drift " + path) + + +def gaussian_rank(masks): + rows = [mask for mask in masks if mask] + rank = 0 + width = max((mask.bit_length() for mask in rows), default=0) + for bit in range(width): + pivot = next((i for i in range(rank, len(rows)) if (rows[i] >> bit) & 1), None) + if pivot is None: + continue + rows[rank], rows[pivot] = rows[pivot], rows[rank] + for other in range(len(rows)): + if other != rank and (rows[other] >> bit) & 1: + rows[other] ^= rows[rank] + rank += 1 + return rank + + +def nested(initial, final): + host = gaussian_rank(final) + return all(gaussian_rank(list(final) + [vector]) == host for vector in initial) + + +def frame_account(initial, final): + """Nested frames: unpaid is the initial dimension, and the climb is the difference.""" + require(nested(initial, final), "frame account requires a nested initial frame") + initial_dim = gaussian_rank(initial) + final_dim = gaussian_rank(final) + return { + "unpaid": initial_dim, + "acquired": final_dim - initial_dim, + "nested": True, + } + + +def load_ceiling(): + path = ROOT / "research/complex-local-word-ceiling/ceiling.py" + spec = importlib.util.spec_from_file_location("pinned_ceiling", path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def fraction_pair(value): + low, high = value + return [f"{low.numerator}/{low.denominator}", f"{high.numerator}/{high.denominator}"] + + +def evaluate(): + authenticate() + geometry = " ".join( + (ROOT / "research/split-centres-global/proofs/INHERITED-COMPLEX-GEOMETRY.txt").read_text( + encoding="utf-8").split()) + schedule = " ".join( + (ROOT / "research/multipair-schedule-bound/README.md").read_text(encoding="utf-8").split()) + levers = (ROOT / "research/complex-local-word-ceiling/levers.py").read_text(encoding="utf-8") + selected = json.loads((ROOT / "certificates/selected-result.json").read_text(encoding="utf-8")) + require("The construction below has m=73" in geometry, "selected width moved") + require("X_(-1)=C_q, Y_(-1)=I" in geometry, "initial level moved") + require("The final Y endpoint is C_all C_q^(-1)." in geometry, "final endpoint moved") + require( + "a nested transition has Fourier rank equal to the dimension difference" in geometry, + "nested rank rule moved", + ) + require( + "Can a cycle `X → Y → Z` leave more than one unpaid coordinate per family?" in schedule, + "third-bank question moved", + ) + require("WORD = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8}" in levers, "selected profile moved") + require(selected["decimal"] == "0.001672660197076918", "selected decimal moved") + kappa = Fraction(selected["kappa"]) + require(kappa == Fraction(836330098538459, 500000000000000000), "selected kappa moved") + saving = kappa / (1 - kappa) + + full = [1 << bit for bit in range(73)] + selected_frame = frame_account([1], full) + require(selected_frame == {"unpaid": 1, "acquired": 72, "nested": True}, "selected frame count moved") + + # Dirty restored bank: same subspace at exit, no acquired data direction. + restored = frame_account([0b010, 0b100], [0b010, 0b100]) + require(restored["acquired"] == 0 and restored["unpaid"] == 2, "restored bank was charged") + # Those two directions are the bank's own frame, not the family's initial datum. + family_after_restored_bank = frame_account([0b001], full) + require(family_after_restored_bank["unpaid"] == 1, "restored bank raised the family count") + + # Copying the datum into a second bank acquires a paid direction. It does not + # create a second initial coordinate. + copied = frame_account([0b001], [0b001, 0b010]) + require(copied == {"unpaid": 1, "acquired": 1, "nested": True}, "copy changed the unpaid count") + + # Clearing the source and writing another bank erases the initial direction. + require(not nested([0b001], [0b010]), "a cleared source was treated as nested") + require(gaussian_rank([0b001, 0b010]) == 2, "erased and new directions were dependent") + + # Two unpaid coordinates are exactly a two-dimensional initial frame. + plane = frame_account([0b001, 0b010], full) + require(plane == {"unpaid": 2, "acquired": 71, "nested": True}, "plane count moved") + require(plane["unpaid"] != copied["unpaid"], "copy was mistaken for a plane") + + ceiling = load_ceiling() + word = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8} + width, families, stages, centre = 73, 896, 9, 64 + grid = Fraction(1, 10 ** 12) + per_call = Fraction(families, stages) + base = ceiling.ceiling(word, width, families, stages, centre, grid=grid, unpaid=1) + two_unpaid = ceiling.ceiling(word, width, families, stages, centre, grid=grid, unpaid=2) + one_step_word = dict(word) + one_step_word[1] += per_call + two_step_word = dict(word) + two_step_word[1] += 2 * per_call + one_step = ceiling.ceiling(one_step_word, width, families, stages, centre, grid=grid, unpaid=1) + two_step = ceiling.ceiling(two_step_word, width, families, stages, centre, grid=grid, unpaid=1) + base_model = ceiling.model(word, width, families, stages, centre, unpaid=1) + one_model = ceiling.model(one_step_word, width, families, stages, centre, unpaid=1) + two_model = ceiling.model(word, width, families, stages, centre, unpaid=2) + two_step_model = ceiling.model(two_step_word, width, families, stages, centre, unpaid=1) + require(base_model["deficit"] == one_model["deficit"] == Fraction(320, 9), "deficit changed without unpaid") + require(two_model["deficit"] == Fraction(1216, 9), "two-unpaid deficit moved") + require(base_model["local_mass"] == 5586, "local mass moved") + require(base_model["idle_mass"] == 1646, "base idle mass moved") + require(one_model["idle_mass"] == two_model["idle_mass"] == Fraction(13918, 9), "shared idle mass moved") + require(two_step_model["idle_mass"] == Fraction(13022, 9), "two-step idle mass moved") + require(one_model["idle_mass"] >= 0, "one-step excursion exceeds the coverage budget") + require(one_step[1] < base[1] and two_step[1] < one_step[1], "excursion did not lower the ceiling") + require(two_unpaid[1] > base[1], "two-unpaid lever did not raise the ceiling") + ratio = two_unpaid[1] / base[1] + require(f"{float(ratio):.2f}" == "3.77", "two-unpaid lever ratio moved") + base_at_selected = ceiling.relax(word, width, families, stages, centre, saving, unpaid=1) + one_at_selected = ceiling.relax(one_step_word, width, families, stages, centre, saving, unpaid=1) + two_at_selected = ceiling.relax(two_step_word, width, families, stages, centre, saving, unpaid=1) + require(base_at_selected[1] < 1, "selected word is not under its ceiling at the selected saving") + require(one_at_selected[0] > 1 and two_at_selected[0] > 1, "excursion still meets the selected saving") + + # Rejection controls: the false claims this package exists to stop. + require(not (restored["acquired"] > 0), "control failed to reject a charged restoration") + require(copied["unpaid"] != 2, "control failed to reject a copied second unpaid coordinate") + require(one_at_selected[0] > 1, "control failed to reject a free one-step excursion") + + return { + "selected_unpaid": selected_frame["unpaid"], + "selected_acquired": selected_frame["acquired"], + "restored_bank_acquired": restored["acquired"], + "family_unpaid_after_restored_bank": family_after_restored_bank["unpaid"], + "copied_second_bank_unpaid": copied["unpaid"], + "copied_second_bank_acquired": copied["acquired"], + "cleared_source_nested": False, + "plane_unpaid": plane["unpaid"], + "deficit": "320/9", + "two_unpaid_deficit": "1216/9", + "selected_saving": f"{saving.numerator}/{saving.denominator}", + "base_idle": "1646", + "one_step_idle": "13918/9", + "two_step_idle": "13022/9", + "two_unpaid_idle": "13918/9", + "base_ceiling": fraction_pair(base), + "two_unpaid_ceiling": fraction_pair(two_unpaid), + "two_unpaid_ratio": f"{ratio.numerator}/{ratio.denominator}", + "one_step_ceiling": fraction_pair(one_step), + "two_step_ceiling": fraction_pair(two_step), + "one_step_exceeds_selected": True, + "two_step_exceeds_selected": True, + "restored_adds_unpaid": False, + "no_new_kappa": True, + } + + +def main(): + observed = evaluate() + stored = json.loads((PACKAGE / "RESULT.json").read_text(encoding="utf-8")) + require(observed == stored, "RESULT.json does not match the execution") + print(MARKER) + + +if __name__ == "__main__": + main()