From 5b74600f2296a0c6265e22a6dec46949ad9a6f89 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Tue, 20 Oct 2026 03:56:07 +0000 Subject: [PATCH] Bound the E8 label pairing rank by 9 and screen it. Every PR717 support pair has F2 pairing rank at most 9, and the favorable selected-template histogram under that cap misses a=1/99. No new kappa. Co-authored-by: unpaidmoon --- research/e8-label-pairing-rank-cap/PROOF.md | 77 +++++++ research/e8-label-pairing-rank-cap/README.md | 80 +++++++ .../e8-label-pairing-rank-cap/SOURCES.json | 30 +++ research/e8-label-pairing-rank-cap/TASK.json | 78 +++++++ .../e8-label-pairing-rank-cap/VERIFY.json | 33 +++ research/e8-label-pairing-rank-cap/verify.py | 208 ++++++++++++++++++ 6 files changed, 506 insertions(+) create mode 100644 research/e8-label-pairing-rank-cap/PROOF.md create mode 100644 research/e8-label-pairing-rank-cap/README.md create mode 100644 research/e8-label-pairing-rank-cap/SOURCES.json create mode 100644 research/e8-label-pairing-rank-cap/TASK.json create mode 100644 research/e8-label-pairing-rank-cap/VERIFY.json create mode 100644 research/e8-label-pairing-rank-cap/verify.py diff --git a/research/e8-label-pairing-rank-cap/PROOF.md b/research/e8-label-pairing-rank-cap/PROOF.md new file mode 100644 index 0000000000..a6dc545dc3 --- /dev/null +++ b/research/e8-label-pairing-rank-cap/PROOF.md @@ -0,0 +1,77 @@ +# Pairing rank of the E8 label alphabet is at most 9 + +This note bounds one support alphabet. It does not construct a decoder, price a +frame or a restoration, or change κ. The selected exponent stays +`0.001672660197076918`. + +## Alphabet + +Use the 240 doubled E8 roots and their 120 lines, with the integer inner +product normalized by 4. Off the diagonal those products lie in `{-1, 0, 1}`, +and each line has norm 2. The PR717 label pairing is the `120 × 120` matrix +over `F_2` + +```text +B_ij = ( + 1) mod 2. +``` + +`verify.py` rebuilds this matrix from the roots. It does not import the +frame-pair decoder checker. + +## Rank cap + +Gaussian elimination produces nine independent rows. Every one of the 120 rows +reduces to zero against that basis, so the row space has dimension 9 and +`rank(B) = 9`. + +Any term support is a row set `X` and a column set `Y`. The corresponding +block is a column restriction of a set of vectors in a 9-dimensional space, so + +```text +rank B[X, Y] <= 9. +``` + +The same nine basis rows, kept against all 120 columns, have rank 9. The cap +is attained by those supports. A synthetic extra column of rank 10 is rejected +by the rank routine and is not a row of `B`. + +If a child in this alphabet is priced by this pairing rank, no such child has +rank 10 or more. Copies, frame conversions and restoration that are not +themselves pairing-rank terms of `B` are outside the alphabet. + +## Favorable screen on the selected template + +The pinned ceiling record fixes the selected template: width 73, `2 · 4 · 112` +families, nine stages, centre charge 64, local mass 5586 and idle mass 1646. +The outer halving guard leaves idle rank 51. The published local profile is +`{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8}`. + +For `a > 0`, the per-unit child cost `r^{-a} m^{a-1}` is strictly decreasing +in the child rank `r`. The checker compares the pinned enclosures at +`a = 1/99` for every rank `1..8` against rank 9. Among local histograms of +mass 5586 whose ranks are at most 9, the fractional histogram + +```text +{9: 5586/9} +``` + +is therefore strictly cheapest at that saving. It keeps the same idle mass +1646, packed at rank 51. Its relaxation moment is strictly above 1. The +integer histogram `{9:620, 6:1}` has the same mass and is also strictly above +1. The certified ceiling bracket of the fractional histogram, on the pinned +`1e-15` grid, lies strictly below `1/99`. + +The same screen accepts the fractional rank-44 histogram at `a = 1/99`. The +rank-9 failure is not a comparator that rejects every profile. + +Extra local children of rank at most 9, including unpaid frame or restoration +children inside this alphabet, add a nonnegative moment and cannot bring the +relaxation back through 1. A child whose rank is not a pairing rank of `B` is +a different alphabet. + +## What this does not say + +The cap is not a bound on multiplication width, on idle children, or on a +block climb whose rank is a tensor or frame dimension. It does not say that an +exact eight-term decoder uses a rank-9 term. It does not meet the card's +five-percent construction gate. No new κ is claimed. diff --git a/research/e8-label-pairing-rank-cap/README.md b/research/e8-label-pairing-rank-cap/README.md new file mode 100644 index 0000000000..7acda4266c --- /dev/null +++ b/research/e8-label-pairing-rank-cap/README.md @@ -0,0 +1,80 @@ +# The E8 label alphabet cannot emit a local child of rank above 9 + +**Scoped obstruction. No new κ.** Selected κ stays `0.001672660197076918`. + +On the 120 root lines of E8, the PR717 label pairing +`B_ij = ( + 1) mod 2` has `F_2` rank 9. Every row lies in that +9-dimensional row space, so every support pair has pairing rank at most 9. +Nine basis lines against all 120 columns attain rank 9. The argument is in +[PROOF.md](PROOF.md). + +On the selected template pinned by +`research/complex-local-word-ceiling/RESULT.json` (width 73, 896 families, +nine stages, centre 64, local mass 5586, idle mass 1646, idle cap 51), the +cheapest local histogram whose children have rank at most 9 is the fractional +profile `{9: 5586/9}`. Its relaxation at `a = 1/99` is strictly above 1, and +its ceiling on the pinned `1e-15` grid is the bracket +`(1409316073/488281250000, 577255863501/200000000000000)`, whose upper end is +strictly below `1/99`. The integer +histogram `{9: 620, 6: 1}` fails the same saving. A fractional rank-44 +histogram passes that one-point screen, so the failure is specific to the cap. + +This is the catalogue method “bound the best effective child rank for one +fixed support alphabet,” narrowed to the PR717 label pairing. Frame, +restoration and copy children that are not pairing-rank terms of `B` are +outside the alphabet. Inside it, those extra children of rank at most 9 +cannot repair a moment that is already above 1. + +## Scope and evidence + +Original card: `complex-rank-shape-decoder`. Scope is **refined**: one +alphabet and the favorable rank-cap screen, not a block-climb construction. +The connection to the bottleneck is the rank-shape lever. Rank-1 children are +about half of the selected recursive cost; this alphabet cannot replace them +by children of rank 10 or more, and rank 9 still misses `a = 1/99` before any +frame or restoration charge. + +`verify.py` rebuilds the 240 roots, checks the pairing rank and the row-space +certificate, and evaluates the pinned `ceiling.py` enclosures. It does not +import the frame-pair decoder package. + +## Reproduce + +Python 3.12, standard library, from the repository root: + +```sh +python3.12 -B scripts/research_package.py --package research/e8-label-pairing-rank-cap +``` + +Expected marker: + +```text +PASS_E8_LABEL_PAIRING_RANK_CAP +``` + +The registered replay also repeats the checker under `-O`. Direct +`python3 -B research/e8-label-pairing-rank-cap/verify.py` prints the witness +line indices, the `1/99` relaxation lower bound and the ceiling bracket. + +## Open next questions + +1. Does exactness of an eight-term all-pairs decoder force every term’s + pairing rank to be at most 8, or does some live support attain 9? A single + dual-basis term of rank 9 would show the alphabet cap is realized by an + exact term; a proof that exactness stops at 8 would tighten this screen. + No decoder search is run here. +2. Can a block-climb child whose rank is a multiplication width, rather than + a pairing rank of `B`, exceed 9 on this template without leaving the + coverage law? The first step is one legal width-10 child with its frame + and restoration bill. This package has no such itinerary. + +## Credit + +The E8 line model and the rank-9 pairing fact are the PR717 alphabet as +recorded by themilkman216 in `research/complex-frame-pair-decoders`. The +selected-template ceiling engine and the published local mass are Douglas +Colkitt’s `research/complex-local-word-ceiling`, with Claude assistance. The +rank-cap question left open by that ceiling is Nick Petalas’s discussion +comment on PR #3701. New rank-space certificate and screen by unpaidmoon, +with substantial Cursor Grok assistance. Apache-2.0. No independent human or +formal-kernel review is claimed. diff --git a/research/e8-label-pairing-rank-cap/SOURCES.json b/research/e8-label-pairing-rank-cap/SOURCES.json new file mode 100644 index 0000000000..d9d08b4969 --- /dev/null +++ b/research/e8-label-pairing-rank-cap/SOURCES.json @@ -0,0 +1,30 @@ +{ + "schema_version": 1, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81", + "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "67f085acd86acd7d4e03922d9cf4b26bca66fed5", + "sha256": "47b42433f5a85809a3aadd29c2c339da2c6ed728e4f7762df6b88bccb7874cf0" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + } + ] +} diff --git a/research/e8-label-pairing-rank-cap/TASK.json b/research/e8-label-pairing-rank-cap/TASK.json new file mode 100644 index 0000000000..885980526c --- /dev/null +++ b/research/e8-label-pairing-rank-cap/TASK.json @@ -0,0 +1,78 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 6, + "base_commit": "bb4bccbf42844d2801487450727c2f63e10d1d0f", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "docs/research/research-family-status.md", + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md", + "research/selected-k8-unrestricted-ends/README.md", + "research/eisenstein-reduction-copy-floor/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "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": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope.", + "Only changing helper terminal subspaces and monotone frames within the fixed scalar word, entrances and cleanup contract already covered by #1995/#2013.", + "Searching below C=40 in the #2017 Eisenstein binary scalar-rectangle or fixed-support block-linear additive pairing model; specify a changed premise instead. This bound does not cover every complex decoder.", + "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": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "refined", + "actual_scope": "PR717 E8 label pairing on 120 root lines: every support pair has F2 rank at most 9, the bound is attained, and the favorable selected-template local histogram of mass 5586 under that cap misses a=1/99.", + "scope_change_reason": "The card's second method asks for the best effective child rank of one fixed support alphabet, with copies, frames and restoration counted. This package takes the PR717 E8 label pairing as that alphabet and proves its pairing rank is at most 9. The moment screen prices only those pairing-rank children. Frame and restoration children inside the alphabet can only raise the moment; children whose rank is not a pairing rank are outside the alphabet and are named as an open question.", + "bottleneck_link": "Rank-1 children are about half of the selected recursive cost. This alphabet cannot replace them by pairing-rank children above 9, and rank 9 still misses the planning target a=1/99 before frame or restoration charges.", + "budget_minutes": 60, + "stop_rule": "Stop once the row-space certificate, the attained rank-9 witness, and the favorable 1/99 screen are checked. Do not search for an exact decoder term of rank 9 or a width-10 block climb.", + "outcome": "negative-result", + "evidence": "verify.py rebuilds B, reduces every row into a 9-dimensional basis, attains rank 9 on that basis, and evaluates pinned ceiling.relax at a=1/99 for {9:5586/9} and {9:620,6:1}. Both lie strictly above 1. The 1e-15 ceiling bracket lies strictly below 1/99. A rank-44 fractional control passes the same one-point screen.", + "author": "unpaidmoon", + "ai_assistance": "Substantial Cursor Grok assistance. No independent human or formal-kernel review.", + "open_questions": [ + { + "question": "Does an exact eight-term all-pairs decoder on a live E8 set attain pairing rank 9 on any term, or does exactness force every term to rank at most 8?", + "why_it_matters": "The alphabet cap is 9 and is attained by some supports. If exact terms stop at 8, the favorable screen on this template gets stricter.", + "first_step": "Exhibit one dual-basis term whose live supports have pairing rank 9, or prove that AB^T=2I forces every term rank to be at most 8.", + "blocked_by": "This package does not search decoders or replay the eight-term census." + }, + { + "question": "Can a block-climb child whose rank is a multiplication width, rather than a pairing rank of B, exceed 9 under the selected coverage law?", + "why_it_matters": "A width-10 child would leave this alphabet. The rank-9 screen does not forbid it, and the published cap curve says rank 44 is the first cap that can clear a=1/99 when idle stays at rank 51.", + "first_step": "Name one legal width-10 child on the selected template and charge its frame and restoration before screening the profile.", + "blocked_by": "No source-bound width-10 itinerary is an input of this package." + } + ] +} diff --git a/research/e8-label-pairing-rank-cap/VERIFY.json b/research/e8-label-pairing-rank-cap/VERIFY.json new file mode 100644 index 0000000000..ffbd61c4ef --- /dev/null +++ b/research/e8-label-pairing-rank-cap/VERIFY.json @@ -0,0 +1,33 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/complex-local-word-ceiling/RESULT.json", + "research/complex-local-word-ceiling/ceiling.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Rebuild the 120 E8 label rows, certify pairing rank 9 and attainment, reject a synthetic rank-10 row, and screen the favorable rank-9 local histogram against a=1/99 with the pinned ceiling engine. The rank-44 control must pass that one-point screen." + }, + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Repeat the same certificate with interpreter optimization enabled. Rejection checks do not use assertions." + } + ] +} diff --git a/research/e8-label-pairing-rank-cap/verify.py b/research/e8-label-pairing-rank-cap/verify.py new file mode 100644 index 0000000000..5295702022 --- /dev/null +++ b/research/e8-label-pairing-rank-cap/verify.py @@ -0,0 +1,208 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Sharp F2 pairing-rank cap of the PR717 E8 label alphabet, screened on the selected template. + +Standard library only. Rejection controls raise through require(); they stay active under -O. +""" +import importlib.util +import itertools +import json +from fractions import Fraction +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +CEILING_PATH = ROOT / "research/complex-local-word-ceiling/ceiling.py" +RESULT_PATH = ROOT / "research/complex-local-word-ceiling/RESULT.json" + + +def require(ok, why): + if not ok: + raise SystemExit("FAIL: " + why) + + +def dot(x, y): + return sum(a * b for a, b in zip(x, y)) + + +def inner(x, y): + value = dot(x, y) + require(value % 4 == 0, "doubled E8 inner product is not divisible by 4") + return value // 4 + + +def neg(v): + return tuple(-a for a in v) + + +def e8_roots(): + roots = [] + for i, j in itertools.combinations(range(8), 2): + for si in (1, -1): + for sj in (1, -1): + vector = [0] * 8 + vector[i], vector[j] = 2 * si, 2 * sj + roots.append(tuple(vector)) + for signs in itertools.product((1, -1), repeat=8): + if signs.count(-1) % 2 == 0: + roots.append(tuple(signs)) + return roots + + +def f2_rank(rows): + basis = {} + rank = 0 + for value in rows: + while value: + pivot = value.bit_length() - 1 + if pivot in basis: + value ^= basis[pivot] + else: + basis[pivot] = value + rank += 1 + break + return rank + + +def row_basis(rows): + basis = {} + order = [] + for index, value in enumerate(rows): + reduced = value + while reduced: + pivot = reduced.bit_length() - 1 + if pivot in basis: + reduced ^= basis[pivot] + else: + basis[pivot] = reduced + order.append(index) + break + return order + + +def load_ceiling(): + spec = importlib.util.spec_from_file_location("pinned_ceiling", CEILING_PATH) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def main(): + roots = e8_roots() + require(len(roots) == 240, "E8 root count") + lines = [] + seen = set() + for root in roots: + key = root if root > neg(root) else neg(root) + if key not in seen: + seen.add(key) + lines.append(root) + count = len(lines) + require(count == 120, "E8 line count") + products = [[inner(lines[i], lines[j]) for j in range(count)] for i in range(count)] + require(all(products[i][i] == 2 for i in range(count)), "root-line norm") + off = {products[i][j] for i in range(count) for j in range(count) if i != j} + require(off == {-1, 0, 1}, "off-diagonal inner products") + rows = [ + sum(((products[i][j] + 1) & 1) << j for j in range(count)) + for i in range(count) + ] + require(len(set(rows)) == 120, "pairing rows are not distinct") + basis = row_basis(rows) + require(len(basis) == 9, "label pairing rank is not 9") + pivots = {} + for index in basis: + reduced = rows[index] + while reduced: + pivot = reduced.bit_length() - 1 + if pivot in pivots: + reduced ^= pivots[pivot] + else: + pivots[pivot] = reduced + break + for row in rows: + reduced = row + while reduced: + pivot = reduced.bit_length() - 1 + require(pivot in pivots, "a pairing row escapes the 9-dimensional row space") + reduced ^= pivots[pivot] + require(reduced == 0, "row reduction did not close") + full_columns = (1 << count) - 1 + witness = [rows[index] & full_columns for index in basis] + require(f2_rank(witness) == 9, "basis supports do not attain pairing rank 9") + + # The rank routine can see rank 10. The real pairing cannot. + extended = list(witness) + extended.append(1 << count) + require(f2_rank(extended) == 10, "rank routine missed an extended independent row") + require(f2_rank(rows) == 9, "full pairing rank drifted from the basis count") + + frame = [] + for axis in range(4): + for sign in (1, -1): + vector = [0] * 8 + vector[2 * axis], vector[2 * axis + 1] = 2, 2 * sign + frame.append(lines.index(tuple(vector))) + require(len(frame) == 8, "coordinate frame size") + require( + all(products[a][b] == 0 for a in frame for b in frame if a != b), + "coordinate frame is not an orthogonal 8-line set", + ) + + record = json.loads(RESULT_PATH.read_text(encoding="utf-8")) + model = record["model"] + selected = record["selected"] + require(model["m"] == 73 and model["stages"] == 9, "template width or stage count") + require(model["ports"] == 112 and model["pairs"] == 4, "port template") + require(model["centre_per_call"] == 64 and model["idle_rank_cap"] == 51, "centre or idle cap") + profile = {int(rank): int(count_) for rank, count_ in selected["local_profile_per_call"].items()} + require(profile == {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82, 8: 8}, "selected local profile") + mass = sum(rank * count_ for rank, count_ in profile.items()) + require(mass == 5586 and str(selected["local_mass_per_call"]) == "5586", "local mass") + require(str(selected["idle_mass_per_call"]) == "1646", "idle mass") + families = 2 * model["pairs"] * model["ports"] + require(families == 896, "family count") + + ceiling = load_ceiling() + target = Fraction(1, 99) + fractional = {9: Fraction(mass, 9)} + quantities = ceiling.model(fractional, 73, families, 9, 64) + require(quantities["local_mass"] == mass, "fractional profile changed the local mass") + require(quantities["idle_mass"] == 1646, "fractional profile changed the idle mass") + require(quantities["R"] == 51, "idle cap") + low, high = ceiling.relax(fractional, 73, families, 9, 64, target) + require(low > 1, "rank-9 relaxation at 1/99 is not strictly above one") + integer = {9: 620, 6: 1} + require(sum(rank * count_ for rank, count_ in integer.items()) == mass, "integer histogram mass") + integer_low, _integer_high = ceiling.relax(integer, 73, families, 9, 64, target) + require(integer_low > 1, "integer rank-9 histogram passes 1/99") + for rank in range(1, 9): + smaller = ceiling.child_cost(rank, 73, target) + larger = ceiling.child_cost(9, 73, target) + require(larger[1] / 9 < smaller[0] / rank, "rank 9 is not strictly cheaper per unit than rank %d" % rank) + cap_low, cap_high = ceiling.ceiling(fractional, 73, families, 9, 64, grid=Fraction(1, 10**15)) + require(cap_high < target, "rank-9 ceiling reaches 1/99") + require(cap_low < cap_high, "ceiling bracket is empty") + # A larger alphabet cap is visible to the same screen, so the failure is not a stuck comparator. + wide_low, wide_high = ceiling.relax({44: Fraction(mass, 44)}, 73, families, 9, 64, target) + require(wide_high < 1, "rank-44 control did not fall below one at 1/99") + require(wide_low < 1, "rank-44 control enclosure straddles one") + + print( + "PASS_E8_LABEL_PAIRING_RANK_CAP" + " lines=120 pairing_rank=9 attained=9" + " witness_lines=%s" + " local_mass=5586 idle_mass=1646" + " relax_1/99_low=%s" + " ceiling=(%s,%s)" + " below_1/99=yes integer_histogram_fails=yes rank44_control_passes=yes" + % ( + ",".join(str(index) for index in basis), + low, + cap_low, + cap_high, + ) + ) + + +if __name__ == "__main__": + main()