From cd09decd71843287ef180f537f4cb39508bae369 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Tue, 20 Oct 2026 02:45:03 +0000 Subject: [PATCH] Record the exact floor-stable shifts of both bootstrap savings. The twenty-four cutoff floors accept native denominator shifts -2..1 and conservative shifts -86..15, with both ends forced by the stage-7 margin. No stock coefficient and no new kappa. Co-authored-by: unpaidmoon --- research/stock-saving-floor-window/README.md | 116 +++++++++ .../stock-saving-floor-window/SOURCES.json | 24 ++ research/stock-saving-floor-window/TASK.json | 88 +++++++ .../stock-saving-floor-window/VERIFY.json | 20 ++ research/stock-saving-floor-window/verify.py | 238 ++++++++++++++++++ 5 files changed, 486 insertions(+) create mode 100644 research/stock-saving-floor-window/README.md create mode 100644 research/stock-saving-floor-window/SOURCES.json create mode 100644 research/stock-saving-floor-window/TASK.json create mode 100644 research/stock-saving-floor-window/VERIFY.json create mode 100644 research/stock-saving-floor-window/verify.py diff --git a/research/stock-saving-floor-window/README.md b/research/stock-saving-floor-window/README.md new file mode 100644 index 0000000000..647bcbf51d --- /dev/null +++ b/research/stock-saving-floor-window/README.md @@ -0,0 +1,116 @@ +# Floor-stable denominator shifts of the recorded bootstrap savings + +**Finite certificate; no new κ and no stock coefficient.** On the frozen selected +bootstrap receipt, the twenty-four floor integers published by the cutoff chain +do not select one rational saving. Each branch's recorded `common_saving` may +move by a short explicit run of printed denominator units without changing any +`floor(s L_j - L_{j-1})` or `floor((1-s) L_{j-1})`. + +```sh +python3 -B research/stock-saving-floor-window/verify.py +``` + +Expected: + +```text +PASS_STOCK_SAVING_FLOOR_WINDOW native_k=-2..1 native_shifts=4 conservative_k=-86..15 conservative_shifts=102 binding=stage7_margin coefficient=unresolved no_new_kappa +``` + +Python 3.10+. The only live input is +`research/selected-bootstrap-stock-audit/RESULT.json`, SHA-256 +`f0bd4f2270826de7b935323e9b4d2e034f69b46205be9535488c4429e95f7917`. + +## Statement + +Write `s` for a branch's recorded `common_saving`, with printed denominator `D`, +and write `s_k = s + k/D` for an integer `k`. Let `L_1 < ... < L_7` be that +branch's recorded cutoffs. The twelve floor values are + +```text +margin_j(k) = floor(s_k L_j - L_{j-1}), +room_j(k) = floor((1 - s_k) L_{j-1}), +``` + +for `j = 2..7`. + +- Native branch (`bootstrap`): these twelve integers agree with `k = 0` if and + only if `k` is in `{-2, -1, 0, 1}`. The shifts `k = -3` and `k = 2` change + the stage-7 margin and no earlier stage. +- Conservative branch: the same holds if and only if `k` is in + `{-86, -85, ..., 15}` (102 shifts). The shifts `k = -87` and `k = 16` change + the stage-7 margin. + +Both endpoints of each interval are forced by the stage-7 margin alone. Every +other margin and every routing room allows a strictly larger integer interval. +Dropping the stage-7 margin widens the intersection. + +## Why the stage-7 margin is the whole window + +Let `M = s L_7 - L_6`, `f = floor(M)`, and `{M} = M - f`, so `0 <= {M} < 1`. +A shift changes the margin by `k L_7 / D`. The floor stays `f` exactly when + +```text +-{M} <= k L_7 / D < 1 - {M}. +``` + +The two rational slacks `{M} D / L_7` and `(1-{M}) D / L_7` are not integers. +Their floors are `2` and `1` on the native branch, and `86` and `15` on the +conservative branch, so the integer solutions are `k >= -2`, `k <= 1` and +`k >= -86`, `k <= 15` respectively. The verifier recomputes those floors from +the receipt and checks that every other constraint's integer interval properly +contains this one. It also walks outward from `k = 0` by direct floor +evaluation until the first failure, and requires the two procedures to agree. +Every integer inside the interval is evaluated, not only the endpoints. + +At `k = 0` the twelve floors on each branch reproduce the published cutoff +table, including the native stage-2 integer `2851485324488315` and the native +stage-3 integer `1015784602045963452130`. The recorded identity +`common_saving = 1 - gaps.stock` holds on both branches, and every +`actual_stock_coefficient` is null. Swapping the two branches' savings does +not preserve the native window. + +## What this does not establish + +This does not bind a stock coefficient, a routing-width factor `W_j`, or a +producer sentence. The receipt already stores one rational in each window; the +floor table also accepts the other shifts above. Choosing `k = 0` still +requires that stored field, or a separate producer identity. The complex +`m = 73` supplier, hosting, precision, and the selected frontier are untouched. +Selected κ stays `0.001672660197076918`. + +One denominator unit of native shift is the sample already reported to leave +the floors fixed, and `10^10` units is a sample already reported to move +stages 6 and 7. The new fact is the exact first failure: native `k = 2` and +`k = -3`, conservative `k = 16` and `k = -87`, all four at stage 7 only. + +## Reproduce + +```sh +python3 -B research/stock-saving-floor-window/verify.py +python3 scripts/research_package.py --package research/stock-saving-floor-window --check-only +python3.12 scripts/research_package.py --package research/stock-saving-floor-window +``` + +## Open next questions + +1. Which source sentence bounds a stage-`j` routing call into `A_{j-1}` by a + factor whose log2 is at most `floor((1-s) L_{j-1})`? The smallest room is + still the native stage-2 integer `4777557234646`. The floor window does not + contain that sentence. The first step is to match the retained PR185/PR387 + cover-row text with such a factor. +2. Does any identity of the frozen PR1087 assembler, other than the stored + `common_saving` field, exclude the nonzero shifts in these windows? The + first step is one stage-7 margin comparison at `k = 1` and `k = -2` against + the assembler recurrence rather than against `RESULT.json`. + +## Credit + +The cutoff table and the two named native controls are the stock-margin chain +on the selected bootstrap receipt. The one-unit and `10^10`-unit samples, and +the request to bind a single rational from floor granularity, are the later +independent tie-out of that table. The receipt and the fourteen cutoffs are +the selected stock audit of the PR1087 assembler. This package only delimits +the integer shifts that keep those floors. + +No independent human review or formal kernel is claimed. Prepared by +unpaidmoon with substantial Cursor Grok assistance. Apache-2.0. diff --git a/research/stock-saving-floor-window/SOURCES.json b/research/stock-saving-floor-window/SOURCES.json new file mode 100644 index 0000000000..35bdf7d2e5 --- /dev/null +++ b/research/stock-saving-floor-window/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/selected-bootstrap-stock-audit/RESULT.json", + "usage": "input", + "git_blob": "2826e072d4644b61b55ffbf322447513ed66f45d", + "sha256": "f0bd4f2270826de7b935323e9b4d2e034f69b46205be9535488c4429e95f7917" + } + ] +} diff --git a/research/stock-saving-floor-window/TASK.json b/research/stock-saving-floor-window/TASK.json new file mode 100644 index 0000000000..ea8142075f --- /dev/null +++ b/research/stock-saving-floor-window/TASK.json @@ -0,0 +1,88 @@ +{ + "schema_version": 1, + "task_id": "selected-stock-envelope", + "priority_revision": 6, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "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": "Which integer shifts of each recorded common_saving, in units of its printed denominator, preserve all twelve floor margins and all twelve routing rooms on the frozen selected bootstrap receipt?", + "scope_change_reason": "The card's second method asks for a missing implication of a proposed selected-stage envelope. The #2972 cutoff floors were being read as a stand-in for the branch saving. This package does not derive a reserve coefficient. It shows those twenty-four floors accept a short explicit run of neighboring rationals, so they do not select the recorded saving.", + "bottleneck_link": "The selected stock coefficient is still unresolved. A cutoff table that does not pin the saving cannot be used as that coefficient, and the exact size of the ambiguity is now known for both recorded branches.", + "budget_minutes": 60, + "stop_rule": "Stop when both branches' exact denominator-unit windows, the stage-7 binding, the adjacent failures, and the published floor table at k=0 are checked. Do not choose a coefficient, import a historical allowance, or open the complex supplier.", + "outcome": "partial", + "evidence": "On the SHA-256-bound receipt, native shifts k in {-2,-1,0,1} and conservative shifts k in {-86,...,15} are exactly the integers that preserve all twenty-four floor integers. Both endpoints are the stage-7 margin. Direct outward search agrees with the slack inequalities. k=0 reproduces the published cutoff table. Every actual_stock_coefficient stays null.", + "author": "unpaidmoon", + "ai_assistance": "Substantial Cursor Grok assistance for the overlap reading, the exact-arithmetic verifier, and the write-up. No proof assistant and no independent human review.", + "open_questions": [ + { + "question": "Which source sentence bounds a stage-j routing call into the previous stopped algorithm by a factor whose log2 is at most the stage's routing room?", + "why_it_matters": "That sentence is what would separate the external-factor-1 reading from the hoisted reading. The floor window does not supply it, and the stock coefficient stays unresolved without it.", + "first_step": "Match the retained PR185/PR387 cover-row text with a factor whose log2 is at most the native stage-2 room 4777557234646.", + "blocked_by": "The recorded receipt has cutoff arithmetic and common_saving, not that routing sentence." + }, + { + "question": "Does the frozen PR1087 assembler, rather than the stored common_saving field, exclude the nonzero shifts in these windows?", + "why_it_matters": "The receipt already stores one rational in each window. Another producer identity would be a reason to discard the neighboring shifts.", + "first_step": "Compare the stage-7 margin at native k=1 and k=-2 with the assembler recurrence instead of RESULT.json.", + "blocked_by": "This package reads only the audited receipt and does not execute the frozen assembler." + } + ] +} diff --git a/research/stock-saving-floor-window/VERIFY.json b/research/stock-saving-floor-window/VERIFY.json new file mode 100644 index 0000000000..a124ff7e5b --- /dev/null +++ b/research/stock-saving-floor-window/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/selected-bootstrap-stock-audit/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Receipt hash, common_saving identity, published floors at k=0, slack window equals outward search, every interior shift, adjacent stage-7 failures, and a cross-branch saving rejection." + } + ] +} diff --git a/research/stock-saving-floor-window/verify.py b/research/stock-saving-floor-window/verify.py new file mode 100644 index 0000000000..759ce8251b --- /dev/null +++ b/research/stock-saving-floor-window/verify.py @@ -0,0 +1,238 @@ +#!/usr/bin/env python3 +"""Exact denominator-unit window of the recorded bootstrap savings. + +The twenty-four floor integers in the #2972 cutoff table do not select one +rational saving. For each frozen branch this verifier computes the largest +integer interval of printed-denominator shifts that preserves every floor +margin and every routing room, proves that interval from the stage-7 slack, +and checks it by walking outward from the recorded saving. + +No stock coefficient is chosen. No kappa claim. +""" +import hashlib +import json +from fractions import Fraction +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +RESULT = ROOT / "research/selected-bootstrap-stock-audit/RESULT.json" +AUDITED_RECEIPT_SHA256 = "f0bd4f2270826de7b935323e9b4d2e034f69b46205be9535488c4429e95f7917" + +# Published floor(s*L_j - L_{j-1}) and floor((1-s)*L_{j-1}), stages 2..7. +# Native stages 2 and 3 are the earlier published controls; the rest are #2972. +PUBLISHED = { + "bootstrap": { + 2: (2851485324488315, 4777557234646), + 3: (1015784602045963452130, 1701909188404384116), + 4: (361852943409004062662957360, 606271101174941147673746), + 5: (128902872114845343680818492656976, 215971951161791423920760764122), + 6: (45919069451025819974017753079498485812, 76935687018952933071573623067467882), + 7: (16357749867431357886201881301751734180286423, 27406799379443943425326695785974298689751), + }, + "conservative_bootstrap": { + 2: (2851485349075174, 4777557267681), + 3: (1015784614274199324771, 1701909205985694510), + 4: (361852949001065216196285881, 606271109508797681506267), + 5: (128902874547204377208495156774925, 215971954868265831114423996024), + 6: (45919070474352818766043006228287526563, 76935688602102847428409756325327327), + 7: (16357750287845003715345973449256621277195623, 27406800037024020153662277717993715829414), + }, +} + +# Sharp windows in printed denominator units. Both ends are stage-7 margins. +EXPECTED = { + "bootstrap": {"k_min": -2, "k_max": 1, "binding": "margin7"}, + "conservative_bootstrap": {"k_min": -86, "k_max": 15, "binding": "margin7"}, +} + + +def require(ok, message): + if not ok: + raise SystemExit(message) + + +def floor_fraction(value): + return value.numerator // value.denominator + + +def load_branch(branch): + text = branch["common_saving"] + num_text, den_text = text.split("/") + numerator, denominator = int(num_text), int(den_text) + saving = Fraction(numerator, denominator) + require(saving.denominator == denominator, "printed saving denominator is not reduced") + cutoffs = [int(stage["cutoff_log2"]) for stage in branch["stages"]] + require(len(cutoffs) == 7, "expected seven cutoffs") + gap = Fraction(branch["stages"][0]["gaps"]["stock"]) + require( + all(Fraction(stage["gaps"]["stock"]) == gap for stage in branch["stages"]), + "stock gap is not uniform", + ) + require(saving == 1 - gap, "common_saving is not 1 - gaps.stock") + require( + all(stage["actual_stock_coefficient"] is None for stage in branch["stages"]), + "a stock coefficient is already stored", + ) + return saving, denominator, cutoffs + + +def floors(saving, cutoffs): + table = {} + for stage in range(2, 8): + length = cutoffs[stage - 1] + previous = cutoffs[stage - 2] + margin = saving * length - previous + room = (1 - saving) * previous + table[stage] = (floor_fraction(margin), floor_fraction(room)) + return table + + +def margin_shift_range(saving, length, previous, denominator): + """Integer k with floor(s*L - P) fixed, s = saving + k/denominator.""" + margin = saving * length - previous + lower = margin - floor_fraction(margin) + upper = floor_fraction(margin) + 1 - margin + require(0 <= lower < 1 and 0 < upper <= 1, "margin slack left [0, 1)") + down = lower * denominator / length + up = upper * denominator / length + # -lower <= k*L/D < upper. + k_min = -floor_fraction(down) + up_floor = floor_fraction(up) + k_max = up_floor - 1 if up == up_floor else up_floor + return k_min, k_max + + +def room_shift_range(saving, previous, denominator): + """Integer k with floor((1-s)*P) fixed.""" + room = (1 - saving) * previous + lower = room - floor_fraction(room) + upper = floor_fraction(room) + 1 - room + require(0 <= lower < 1 and 0 < upper <= 1, "room slack left [0, 1)") + # Room falls as k rises: -upper < k*P/D <= lower. + down = lower * denominator / previous + up = upper * denominator / previous + # k <= down. For a nonnegative rational this is k <= floor(down), + # whether or not down is an integer. + k_max = floor_fraction(down) + # k > -up, so k >= -floor(up) when up is not an integer, else -up + 1. + up_floor = floor_fraction(up) + k_min = -up_floor + 1 if up == up_floor else -up_floor + return k_min, k_max + + +def constraint_ranges(saving, denominator, cutoffs): + ranges = [] + for stage in range(2, 8): + length = cutoffs[stage - 1] + previous = cutoffs[stage - 2] + k_min, k_max = margin_shift_range(saving, length, previous, denominator) + ranges.append((k_min, k_max, f"margin{stage}")) + k_min, k_max = room_shift_range(saving, previous, denominator) + ranges.append((k_min, k_max, f"room{stage}")) + return ranges + + +def intersect(ranges): + lower = max(ranges, key=lambda item: (item[0], item[2])) + upper = min(ranges, key=lambda item: (item[1], item[2])) + require(lower[0] <= upper[1], "shift constraints have empty intersection") + # Uniqueness of the binding constraint on each side. + lower_names = [name for k_min, _, name in ranges if k_min == lower[0]] + upper_names = [name for _, k_max, name in ranges if k_max == upper[1]] + require(lower_names == ["margin7"], "stage-7 margin is not the unique lower bind: " + str(lower_names)) + require(upper_names == ["margin7"], "stage-7 margin is not the unique upper bind: " + str(upper_names)) + return lower[0], upper[1], "margin7" + + +def search_window(saving, denominator, cutoffs, base): + unit = Fraction(1, denominator) + + def same(shift): + return floors(saving + shift * unit, cutoffs) == base + + require(same(0), "recorded saving does not reproduce its own floors") + k_min = 0 + while same(k_min - 1): + k_min -= 1 + require(k_min > -100000, "downward search did not stop") + k_max = 0 + while same(k_max + 1): + k_max += 1 + require(k_max < 100000, "upward search did not stop") + return k_min, k_max + + +def failing_stage(saving, denominator, cutoffs, base, shift): + got = floors(saving + Fraction(shift, denominator), cutoffs) + stages = [stage for stage in range(2, 8) if got[stage] != base[stage]] + require(stages, "exterior shift left every floor unchanged") + return stages[0], got[stages[0]], base[stages[0]] + + +def check_branch(name, branch): + saving, denominator, cutoffs = load_branch(branch) + base = floors(saving, cutoffs) + for stage, pair in PUBLISHED[name].items(): + require(base[stage] == pair, f"{name} stage {stage} does not match the published floors") + formula_min, formula_max, binding = intersect(constraint_ranges(saving, denominator, cutoffs)) + search_min, search_max = search_window(saving, denominator, cutoffs, base) + expected = EXPECTED[name] + require(formula_min == search_min == expected["k_min"], f"{name} lower window mismatch") + require(formula_max == search_max == expected["k_max"], f"{name} upper window mismatch") + require(binding == expected["binding"], f"{name} binding mismatch") + # Every interior shift, including both endpoints, preserves all twenty-four-branch floors. + for shift in range(formula_min, formula_max + 1): + require( + floors(saving + Fraction(shift, denominator), cutoffs) == base, + f"{name} interior shift {shift} changed a floor", + ) + low_stage, _, _ = failing_stage(saving, denominator, cutoffs, base, formula_min - 1) + high_stage, _, _ = failing_stage(saving, denominator, cutoffs, base, formula_max + 1) + require(low_stage == 7 and high_stage == 7, f"{name} exterior failure is not stage 7") + # Stage 7 is necessary for this exact window: without it the interval grows. + others = [item for item in constraint_ranges(saving, denominator, cutoffs) if item[2] != "margin7"] + wider_min, wider_max, _ = intersect_loose(others) + require(wider_min < formula_min and wider_max > formula_max, f"{name} window did not widen without stage 7") + return formula_min, formula_max + + +def intersect_loose(ranges): + lower = max(item[0] for item in ranges) + upper = min(item[1] for item in ranges) + require(lower <= upper, "loose intersection empty") + return lower, upper, "loose" + + +def main(): + payload = RESULT.read_bytes() + require(hashlib.sha256(payload).hexdigest() == AUDITED_RECEIPT_SHA256, "receipt bytes drifted") + receipt = json.loads(payload.decode("utf-8")) + require(set(receipt["branches"]) == {"bootstrap", "conservative_bootstrap"}, "unexpected branches") + native = check_branch("bootstrap", receipt["branches"]["bootstrap"]) + conservative = check_branch("conservative_bootstrap", receipt["branches"]["conservative_bootstrap"]) + # A gap-numerator mutation is not a denominator-unit shift and must leave the + # recorded identity. Replacing common_saving by the other branch's saving + # must not keep the native floors. + native_branch = receipt["branches"]["bootstrap"] + other = receipt["branches"]["conservative_bootstrap"]["common_saving"] + swapped = json.loads(payload.decode("utf-8")) + swapped["branches"]["bootstrap"]["common_saving"] = other + try: + check_branch("bootstrap", swapped["branches"]["bootstrap"]) + except SystemExit: + pass + else: + raise SystemExit("cross-branch saving passed the native window check") + require(native_branch["common_saving"] != other, "branch savings unexpectedly equal") + native_count = native[1] - native[0] + 1 + conservative_count = conservative[1] - conservative[0] + 1 + print( + "PASS_STOCK_SAVING_FLOOR_WINDOW " + f"native_k={native[0]}..{native[1]} native_shifts={native_count} " + f"conservative_k={conservative[0]}..{conservative[1]} conservative_shifts={conservative_count} " + "binding=stage7_margin coefficient=unresolved no_new_kappa" + ) + + +if __name__ == "__main__": + main()