From 12d9fed0f10e3b04929dc09864ad73298a628961 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Sun, 18 Oct 2026 21:26:55 -0500 Subject: [PATCH] research: bind selected stage-one stock recurrence --- .../README.md | 55 +++++++++ .../SOURCES.json | 108 +++++++++++++++++ .../TASK.json | 82 +++++++++++++ .../VERIFY.json | 34 ++++++ .../verify.py | 111 ++++++++++++++++++ 5 files changed, 390 insertions(+) create mode 100644 research/selected-stage-stock-recurrence-20261018/README.md create mode 100644 research/selected-stage-stock-recurrence-20261018/SOURCES.json create mode 100644 research/selected-stage-stock-recurrence-20261018/TASK.json create mode 100644 research/selected-stage-stock-recurrence-20261018/VERIFY.json create mode 100644 research/selected-stage-stock-recurrence-20261018/verify.py diff --git a/research/selected-stage-stock-recurrence-20261018/README.md b/research/selected-stage-stock-recurrence-20261018/README.md new file mode 100644 index 0000000000..66864f89aa --- /dev/null +++ b/research/selected-stage-stock-recurrence-20261018/README.md @@ -0,0 +1,55 @@ +# Native stage-one stock factorization and its missing coefficient + +**Result:** a source-bound factorization and depth slope for the first native stopped stage of the selected #1094 branch. The factorization is concrete, but the numerical stock coefficient remains unproved because the retained sources do not quantify the row divisor or the old-leaf reserve. + +## Question and scope + +For the selected native branch, what parent stock divisor does the first stopped stage require, and which parts of its coefficient are actually fixed by the selected source? This narrows the assigned selected-stock-envelope card to stage 1 and the parent-versus-inner reserve split. It does not repeat the recorded cutoff or headroom arithmetic. + +The selected record at the pinned base selects the #1094 finite witness, whose exact complex supplier is the binding side. The pinned #1094 review identifies #1087 as its direct parent. In the frozen #1087 assembler, the native branch invokes the seven-step outer witness on the selected complex lower bound with m=73. This identifies the selected producer and branch; the cutoff values themselves are not recomputed here. + +Final live-overlap check: PR #3742 remained open at head 89f6af270c550dd02bdb05d7a69987159aa110f2 (updated 2026-10-18 19:21 UTC). Its DONE note answers the cutoff-location question and explicitly leaves sigma uncomputed. This pass takes that adjacent reserve-factorization obligation; it does not repeat PR #3742's chain arithmetic or publish a Discussion update. + +## Source-bound stage-one recurrence + +The retained stopped construction uses atom width w = ceil(e^s). At stage 1, its parent stock is the cover-tree row divisor times the inherited A0 ordinary-leaf reserve. Writing W(w) for the per-level row divisor, R0(w) for the A0 reserve and D(e) for the cover depth, the sufficient divisor has the form + + S1(e,w) = W(w)^D(e) R0(w). + +The retained row note bounds the depth by + + D(e) <= 47 ceil(log2(max(2,e))) + O(1). + +The leading depth coefficient 47 is source-bound. The additive depth constant is not supplied. The row note names W(w) but gives no selected numeric function or bound for it. It describes the old-leaf reserve as logarithmic but supplies no coefficient. Therefore this source chain does not give a numerical sigma_1 satisfying log_q S1(e,w) <= sigma_1 w(1+log2 e) over the selected stage's width domain. + +The inner-call split is explicit. The reviewed PR185 contract says a completed A0 call borrows from the two chunks passed to it, keeps outer fields as spectators, restores its row coordinate, and contributes zero additional externally supplied stock. The parent does not multiply its reserve by the number of sequential completed leaves. The retained 252 is unused allowance, not A0's measured internal reserve. + +This also distinguishes two selected-source fields with sigma-like names from the missing recurrence coefficient. The PR1094 audit records 7,870 actual 73-column maps; its producer computes that field as the length of the sigma-map list. The finite invoice separately records 7,670 physical stock cells as 7,168 data/owner families + 492 local helpers + 8 private centres + 2 coefficient-work cells. These are real selected finite ledgers, but neither gives W(w) or R0(w) as functions of variable e and w. + +The 57,604 w ceil(log2(max(2,n))) term is explicitly from the m=120, four-level historical bit candidate. It is not imported into the selected m=73 branch. The source also does not license treating 252 as the old-leaf coefficient. + +## Stop result + +The bounded success test was to bind one selected stage's parent reserve, depth coefficient and external inner-borrowing contribution to its sources, then decide whether those facts give a numerical uniform stock coefficient. The first three items are bound: S1 factors as above, the depth slope is 47, and completed inner leaves add zero external reserve. The numeric coefficient is not bound. The missing implementation lemma is an explicit same-domain bound for W(w), an explicit coefficient for R0(w), and a numerical additive depth term, all for the selected stage. + +This is a scoped source audit, not a stock-fit proof, supplier admission, new kappa or multiplication theorem. It does not infer a coefficient from the huge cutoff headroom, the finite invoice, 57,604, or 252. + +## Reproduction + +From the repository root, run: + + python3 -B research/selected-stage-stock-recurrence-20261018/verify.py + python3 scripts/research_package.py --package research/selected-stage-stock-recurrence-20261018 --check-only + python3.12 scripts/research_package.py --package research/selected-stage-stock-recurrence-20261018 + +The source receipt pins the selected assembly, its PR1087 archive, the actual #1094 invoice and map-count producer, and the retained PR387/PR185 row contract. The check verifies these source relationships and the finite invoice identity. It deliberately does not calculate cutoff headrooms. + +## Open next questions + +Can the original completed-row implementation give an explicit uniform formula for W(w) and R0(w), with an explicit additive constant in D(e), on the selected stage-one atom domain? This matters because those are the missing terms in sigma_1. First inspect the pinned PR182/PR185 row-conversion implementation and trace its exact row field through the selected A0 wrapper. The current retained proof only says logarithmic, so the coefficient is blocked until that implementation-level bound is found. + +## Credit and overlap + +The selected construction and source lineage are Rohan Arun's PR1094 and Jeremy Kothe's PR1087, reviewed in the selected #1099 record. The selected stock audit and its proof-boundary analysis are ToikY's package on Josie Elliston's PR1956/PR1965 work. The stopped-stage recurrence and completed-row interface come from Rohan Arun's PR387 and the reviewed PR185 proof. The m=120 stock estimate is eumemic's five-stage source-bank note and is retained only to delimit its scope. Nick Petalas's open PR #3742 locates the selected complex cutoff sequence but explicitly leaves sigma uncomputed; this note audits the next, distinct reserve-factorization obligation. No independent human review is claimed. + +Prepared by OpenAI Codex, worker homelab-10, with substantial AI assistance. New text and verifier are Apache-2.0; predecessor source files remain unchanged. diff --git a/research/selected-stage-stock-recurrence-20261018/SOURCES.json b/research/selected-stage-stock-recurrence-20261018/SOURCES.json new file mode 100644 index 0000000000..0485a62b26 --- /dev/null +++ b/research/selected-stage-stock-recurrence-20261018/SOURCES.json @@ -0,0 +1,108 @@ +{ + "schema_version": 1, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "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/bootstrap-cutoff-time-space-split/README.md", + "usage": "input", + "git_blob": "59986cb4b0a912ab18883a4f41dedae0fda1a5ae", + "sha256": "e7f215a11a81c02b657bac9ebb904f346d1ae95446f32fda74a4084360c79a86" + }, + { + "path": "research/bootstrap-depth-audit/sources/pr387/PROOF.md", + "usage": "input", + "git_blob": "915d08efd81fa304e1974e26d8212803e03e6623", + "sha256": "15997b908604d124d688482db46e58da3117ecf1c176597afb1556a767c073d8" + }, + { + "path": "research/bootstrap-depth-audit/sources/pr387/bootstrap-sources/research/community-round8-audit/pr185-proof-reviewed.md", + "usage": "input", + "git_blob": "93a588a73a38050dfa0a383cb44f228aff6f243e", + "sha256": "bbac6ec77f315dd76324f4595b8c7a9b0ec719f3903d0c56c61f23990326e8fa" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "input", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "input", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/complex-t16-rare-pattern-exchanges/upstream1087.tar.gz", + "usage": "input", + "git_blob": "2970ef79b0441e937449bed30f68f2e0558186ba", + "sha256": "d4acf04daef85d4514f80ec5fcd2492d0c60e5d6c49fa71b3e6523f8db2dea86" + }, + { + "path": "research/five-stage-source527-banks/proof/FINITE_BIT_ACCOUNTING.md", + "usage": "input", + "git_blob": "42a585d742660f9ed44ebd3ca2a9d1e0832bb0be", + "sha256": "602923520af184670170bf159fde7b4c72e79a72570eddd7746b7c97bc51fc5b" + }, + { + "path": "research/five-stage-source527-banks/proof/three-stage-cover-rows.tex", + "usage": "input", + "git_blob": "590da4b892a08b9d5182fb3d8a983c6239dd27db", + "sha256": "6ad97a5cd7d6aecf978a81226e1c2763d37840caca130c61f3bf5c4ac111c5c8" + }, + { + "path": "research/gauge44-slots-t16/code/assemble.py", + "usage": "input", + "git_blob": "581dd9cb29a45bd68cc651538311b63f6966ad68", + "sha256": "15f6986a476bac76bcdc0bfcf51da115389b46f1950d2766b6822f757888b13a" + }, + { + "path": "research/gauge44-slots-t16/code/audit_allcold.py", + "usage": "input", + "git_blob": "923bf7b675ca09f4d2633e7e53f16a1b23b6d5bc", + "sha256": "1467a2acb654e62552c69fb9a7c4c85f70a02120881d222313865058ab71a6cc" + }, + { + "path": "research/gauge44-slots-t16/code/invoice_allcold.py", + "usage": "input", + "git_blob": "d1dd2212917ad1e7f099287a141f741fd52bdcf6", + "sha256": "71eb57514e28ced97251e0507105f654f59885ec4d40486a780bf166098858a8" + }, + { + "path": "research/gauge44-slots-t16/evidence/audit/OWNERS-AND-PROFILE.json", + "usage": "input", + "git_blob": "bdb9441b7efc06b56585502ed0856d8dec8e1591", + "sha256": "a32ecc0d5387d65648e1ff284209122860ee37aaba43ce2dd12024c4bc394313" + }, + { + "path": "research/gauge44-slots-t16/evidence/audit/PREFIX-AND-INVOICE.json", + "usage": "input", + "git_blob": "6c96ec67062b536f40ecdedba96b497f58d5270e", + "sha256": "14b0f41c88209e800236ce4ebbf91d83537e22e18807153d90013f7eee57a582" + }, + { + "path": "research/selected-bootstrap-stock-audit/README.md", + "usage": "input", + "git_blob": "bba25c7feca4f7b6872f550ed4c874b6fe979f62", + "sha256": "0f3cda98c8382d41dc4f5d905460a4b4ed2854d6f94f20035b150e14825827c6" + }, + { + "path": "research/selected-bootstrap-stock-audit/RESULT.json", + "usage": "input", + "git_blob": "2826e072d4644b61b55ffbf322447513ed66f45d", + "sha256": "f0bd4f2270826de7b935323e9b4d2e034f69b46205be9535488c4429e95f7917" + } + ] +} diff --git a/research/selected-stage-stock-recurrence-20261018/TASK.json b/research/selected-stage-stock-recurrence-20261018/TASK.json new file mode 100644 index 0000000000..0db590e423 --- /dev/null +++ b/research/selected-stage-stock-recurrence-20261018/TASK.json @@ -0,0 +1,82 @@ +{ + "schema_version": 1, + "task_id": "selected-stock-envelope", + "priority_revision": 6, + "base_commit": "20ecf2891d80b5acf18d980b2164fb44ea7faa90", + "original_card": { + "id": "selected-stock-envelope", + "question": "What explicit uniform stock envelope does the actual selected stopped producer supply at one bootstrap stage?", + "starting_points": [ + "research/selected-bootstrap-stock-audit/README.md", + "research/bootstrap-cutoff-time-space-split/README.md", + "certificates/selected-result.json", + "docs/research/community-efficient1000-review.md", + "research/stock-margin-chain/README.md" + ], + "methods": [ + "Derive a source-bound reserve recurrence at the actual selected atom widths, separating parent stock from completed inner borrowing.", + "Find an exact missing implication or counterexample to a proposed selected-stage stock envelope." + ], + "acceptance_gate": "Bind every coefficient and depth factor to the selected producer and state the width domain. Compare a proved envelope with the sufficient cutoff guard; a large numerical headroom or a historical m=120 coefficient is not a selected m=73 proof.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read #2972 stock-margin chain and the selected stock audit. The new source archive reports the remaining cutoff comparisons, but leaves every actual stock coefficient unresolved; it is not an independently validated reserve envelope.", + "scope": "Source-bound orientation only. Read the named package and review before relying on its local evidence; this command is not its replay or supplier admission." + }, + "first_experiment": "Choose one actual selected producer/stage and derive its parent reserve and depth coefficient from source. Check whether newer handoffs already cover that exact obligation. Stop with the missing implementation lemma if it cannot be bounded; do not rerun #2972 cutoff/headroom arithmetic as a new contribution.", + "bottleneck_link": "This reduces a concrete inherited implementation obligation without confusing unchanged kappa arithmetic with a completed theorem.", + "allowed_variations": [ + "One stage or one explicit reserve/depth implication.", + "An independently checked same-domain proof repair, retaining all remaining assumptions." + ], + "scope_change_triggers": [ + "Importing the historical 57604 or 252 allowance without a selected-producer binding.", + "Calling a conditional fit lemma a full outer-proof adoption.", + "Replacing an actual selected stock coefficient with cutoff comparisons or a conditional fit inequality." + ], + "overlap_terms": [ + "selected stock", + "stock envelope", + "bootstrap cutoff", + "1956", + "1965", + "1990", + "2972", + "stock-margin-chain", + "actual_stock_coefficient" + ], + "existing_checks": [ + { + "scope": "Retained stock audit identifies missing actual selected-stage coefficients; later cutoff-chain arithmetic does not supply them.", + "evidence": "docs/research/research-family-status.md#revision-6-handoffs-source-archives-awaiting-independent-validation", + "remaining": "Derive one actual reserve/depth coefficient from the selected producer.", + "status": "reviewed", + "source_commit": "836b19bfa309ceafbc8ee32a15e8c4b10dde7e11", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + } + ] + }, + "scope_status": "refined", + "actual_scope": "Native stage 1 of the selected #1094 complex-binding branch: bind the parent stock factorization and cover-depth slope, and distinguish external parent stock from completed inner borrowing.", + "scope_change_reason": "Recent open PR #3742 locates the selected complex cutoff chain but leaves the actual sigma obligation open. This pass takes the card-permitted one-stage scope and checks the parent-versus-inner reserve factorization against the pinned selected producer and PR185/PR387 row contract.", + "bottleneck_link": "A numerical stage coefficient is needed to instantiate the selected stopped-producer fit inequality. This source audit identifies the exact unresolved factors without relying on cutoff headroom.", + "budget_minutes": 60, + "stop_rule": "Stop after binding the selected native stage-one parent reserve factorization, depth slope, and external inner-borrowing contribution. If W(w), the additive depth constant, or the old-leaf reserve coefficient is not numerically bounded at the selected widths by retained source, record the missing implementation lemma and stop.", + "outcome": "partial", + "evidence": "The native stage-one sufficient divisor factors as W(w)^D(e) times the inherited A0 reserve. The retained source gives depth slope 47 with an unquantified O(1), names but does not quantify W(w), and calls the old-leaf reserve logarithmic without a coefficient. PR185 proves completed inner calls add zero external stock and that 252 is unused slack. Selected finite invoice fields are separately checked and do not supply these functions. See README and verify.py.", + "author": "OpenAI Codex (homelab-10)", + "ai_assistance": "Substantial OpenAI Codex assistance; no independent human review claimed.", + "open_questions": [ + { + "question": "Can the pinned PR182/PR185 complete-row implementation give explicit uniform formulas for W(w) and the inherited A0 reserve, including the additive term in D(e), on the selected stage-one domain?", + "why_it_matters": "Those quantities are exactly the remaining factors needed to produce a numerical sigma_1 for the selected stopped producer.", + "first_step": "Trace the actual row field through the pinned PR182 ordinary wrapper and derive a uniform row-divisor bound for its two-chunk completed interface.", + "blocked_by": "The retained PR185/PR387 text gives only a logarithmic reserve and an O(1) depth term; the implementation-level coefficient is not present in the consumed source set." + } + ] +} diff --git a/research/selected-stage-stock-recurrence-20261018/VERIFY.json b/research/selected-stage-stock-recurrence-20261018/VERIFY.json new file mode 100644 index 0000000000..2794732d30 --- /dev/null +++ b/research/selected-stage-stock-recurrence-20261018/VERIFY.json @@ -0,0 +1,34 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bootstrap-cutoff-time-space-split/README.md", + "research/bootstrap-depth-audit/sources/pr387/PROOF.md", + "research/bootstrap-depth-audit/sources/pr387/bootstrap-sources/research/community-round8-audit/pr185-proof-reviewed.md", + "research/community-frontier1094-audit/ASSEMBLY.json", + "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "research/complex-t16-rare-pattern-exchanges/upstream1087.tar.gz", + "research/five-stage-source527-banks/proof/FINITE_BIT_ACCOUNTING.md", + "research/five-stage-source527-banks/proof/three-stage-cover-rows.tex", + "research/gauge44-slots-t16/code/assemble.py", + "research/gauge44-slots-t16/code/audit_allcold.py", + "research/gauge44-slots-t16/code/invoice_allcold.py", + "research/gauge44-slots-t16/evidence/audit/OWNERS-AND-PROFILE.json", + "research/gauge44-slots-t16/evidence/audit/PREFIX-AND-INVOICE.json", + "research/selected-bootstrap-stock-audit/README.md", + "research/selected-bootstrap-stock-audit/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Pins the selected assembler and finite invoice; verifies the source-bound stage-one parent factorization, depth slope, and zero external inner-leaf stock; rejects confusing finite map counts or historical coefficients with the missing reserve coefficient." + } + ] +} diff --git a/research/selected-stage-stock-recurrence-20261018/verify.py b/research/selected-stage-stock-recurrence-20261018/verify.py new file mode 100644 index 0000000000..01d8b24472 --- /dev/null +++ b/research/selected-stage-stock-recurrence-20261018/verify.py @@ -0,0 +1,111 @@ +#!/usr/bin/env python3 +"""Check the selected stage-one stock-factorization source boundary.""" +from __future__ import annotations + +import hashlib +import io +import json +import tarfile +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent + + +def require(condition: bool, message: str) -> None: + if not condition: + raise SystemExit("FAIL_SELECTED_STAGE_STOCK_RECURRENCE " + message) + + +def read(path: str) -> bytes: + return (ROOT / path).read_bytes() + + +def main() -> None: + sources = json.loads((PACKAGE / "SOURCES.json").read_text()) + for row in sources["files"]: + if row["usage"] != "input": + continue + raw = read(row["path"]) + require(hashlib.sha256(raw).hexdigest() == row["sha256"], "input hash " + row["path"]) + + tar_bytes = read("research/complex-t16-rare-pattern-exchanges/upstream1087.tar.gz") + with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:gz") as archive: + member = archive.extractfile("code/assemble.py") + require(member is not None, "PR1087 assembler member") + archived_assembler = member.read() + selected_assembler = read("research/gauge44-slots-t16/code/assemble.py") + require(archived_assembler == selected_assembler, "selected assembler equals pinned archive member") + assembler = archived_assembler.decode("utf-8") + require("check_moment('complex',H,73,owner['live'],b,5120,False)" in assembler, + "selected complex producer width m=73") + require("a=(1-s)*s+s*old" in assembler, + "selected outer chain first-stage recurrence") + require("for _ in range(7):" in assembler and "cuts.append(dict(exponent=str(a),gap=str(gap),cutoff_log2=str(cut)))" in assembler, + "selected native branch has seven recorded stages") + + assembly = json.loads(read("research/community-frontier1094-audit/ASSEMBLY.json")) + record = json.loads(read("certificates/selected-result.json")) + require(record["kappa"] == "836330098538459/500000000000000000", "selected kappa pin") + require(assembly["kappa"] == record["kappa"], "selected assembly record") + require(len(assembly["bootstrap"]) == 7, "selected native stage count") + require(assembly["binding"] == "complex", "selected binding side") + + owner = json.loads(read("research/gauge44-slots-t16/evidence/audit/OWNERS-AND-PROFILE.json")) + invoice = json.loads(read("research/gauge44-slots-t16/evidence/audit/PREFIX-AND-INVOICE.json")) + audit_code = read("research/gauge44-slots-t16/code/audit_allcold.py").decode("utf-8") + invoice_code = read("research/gauge44-slots-t16/code/invoice_allcold.py").decode("utf-8") + require(owner["actual_73column_sigmas"] == 7870, "selected sigma-map count") + require("actual_73column_sigmas=len(r['sigmas'])" in audit_code, + "sigma-like field is a map count") + stock_identity = invoice["physical_stock_identity"] + require(stock_identity == { + "data_and_owner_families": 7168, + "local_helpers": 492, + "private_centres": 8, + "coefficient_work": 2, + }, "selected finite stock identity") + require(sum(stock_identity.values()) == invoice["physical"] == 7670, + "selected finite physical stock sum") + require("physical_stock_identity=dict(data_and_owner_families=live,local_helpers=helpers" in invoice_code, + "invoice producer identity") + + rows = read("research/five-stage-source527-banks/proof/three-stage-cover-rows.tex").decode("utf-8") + require("47\\lceil\\log_2\\max(2,n)\\rceil+O(1)" in rows, "depth slope 47 and unquantified additive term") + require("W(w)^{D(n)}" in rows and "inherited old-leaf" in rows, + "parent reserve factorization") + require("logarithmic reserve" in rows and "log_qS(e,w)=O(w\\log e)" in rows, + "qualitative reserve only") + fit_note = read("research/bootstrap-cutoff-time-space-split/README.md").decode("utf-8") + require("w = ⌈e^s⌉" in fit_note and "log_q S(e,w) = O(w log e)" in fit_note, + "selected atom-width domain and fit target") + + pr387 = read("research/bootstrap-depth-audit/sources/pr387/PROOF.md").decode("utf-8") + pr185 = read("research/bootstrap-depth-audit/sources/pr387/bootstrap-sources/research/community-round8-audit/pr185-proof-reviewed.md").decode("utf-8") + require("For j=1,...,6 define A_j" in pr387 and "fixed depth" in pr387 + and "a_j=(1-s)s+s*a_(j-1)" in pr387, + "retained stopped-stage family") + require("new ordinary leaves need no *external* extra stock" in pr185, + "completed inner external reserve is zero") + require("252 is not asserted to be the new leaf's actual internal reserve" in pr185, + "252 is only retained slack") + + historical = read("research/five-stage-source527-banks/proof/FINITE_BIT_ACCOUNTING.md").decode("utf-8") + selected_audit = read("research/selected-bootstrap-stock-audit/README.md").decode("utf-8") + require("T(n,w)<=sum_r c_r*T(r*floor(n/120),w)+C*n" in historical, + "historical m=120 candidate") + require("57,604w*ceil(log2(max(2,n)))" in historical and "m=120" in selected_audit and "W=23,683" in selected_audit, + "historical 57,604 scope") + require("sigma_j=sigma_0+j*57604" in selected_audit, + "no selected 57,604 substitution") + + result = json.loads(read("research/selected-bootstrap-stock-audit/RESULT.json")) + require(result["source_boundary"]["inherited_old_leaf_reserve_coefficient"] is None, + "numerical old-leaf coefficient remains open") + require(result["source_boundary"]["actual_stage_stock_coefficients"] is None, + "numerical selected stage coefficient remains open") + print("PASS_SELECTED_STAGE_STOCK_RECURRENCE_STRUCTURE native_stage=1 depth_slope=47 inner_external_stock=0 row_divisor=unquantified old_leaf_coefficient=unquantified") + + +if __name__ == "__main__": + main()