From 75aa393e808d030930879b87815e0abb7bb5742d Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Thu, 12 Nov 2026 18:23:47 +0000 Subject: [PATCH] feat(research): sharpen chronological plateau width divisors --- research/additive-plateau-width/PROOF.md | 169 +++++++++++++++++++ research/additive-plateau-width/README.md | 131 ++++++++++++++ research/additive-plateau-width/SOURCES.json | 34 ++++ research/additive-plateau-width/TASK.json | 111 ++++++++++++ research/additive-plateau-width/VERIFY.json | 32 ++++ research/additive-plateau-width/verify.py | 144 ++++++++++++++++ research/additive-plateau-width/width.py | 133 +++++++++++++++ 7 files changed, 754 insertions(+) create mode 100644 research/additive-plateau-width/PROOF.md create mode 100644 research/additive-plateau-width/README.md create mode 100644 research/additive-plateau-width/SOURCES.json create mode 100644 research/additive-plateau-width/TASK.json create mode 100644 research/additive-plateau-width/VERIFY.json create mode 100644 research/additive-plateau-width/verify.py create mode 100644 research/additive-plateau-width/width.py diff --git a/research/additive-plateau-width/PROOF.md b/research/additive-plateau-width/PROOF.md new file mode 100644 index 0000000000..86afb471de --- /dev/null +++ b/research/additive-plateau-width/PROOF.md @@ -0,0 +1,169 @@ +# A minimum-decrement divisor for chronological widths + +This contribution was produced by Nick Petalas. All integers below are exact. +The recurrence and its separated-flow properties are credited premises from +Jerry Chen / CubeJerry [#7424](https://github.com/CrocSwap/integer-mult-bounds/pull/7424), +head `d622d8c62defa9defeb95741e88b33a120044866`, PROOF.md sections 1–4. +That work extends #7345, codyw912 #4638 and Mihir Srivastava #4507/#5071. +The new step is the additive plateau visit bound and its width divisor. +No predecessor theorem is audited here. + +## 1. Boundary and inherited recurrence + +Fix positive integer target multiplicities W_k and paid-site multiplicities P_r, +with finite nonempty supports satisfying + +``` +2 <= k_min <= k <= m <= A, 1 <= r <= r_max < k_min. +``` + +Each occurrence of a paid site and each chronological path remains distinct. +Let Gamma be the multiplicative semigroup generated by target and paid ranks, +including 1. Write gamma_next for the successor of gamma in Gamma. It exists +because k_min*gamma is in Gamma. For n < A let B_n=1. At n >= A the credited +flow supplies fresh-source multiplicities t_s > 0, their total S=sum_s t_s, +and a nonempty list of individual exit ranks e. Its least replication is + +``` +a_n = lcm( {B_(n-s)/gcd(B_(n-s),t_s): sgamma and s<=A*gamma, +and hence s>=gamma_next. These properties follow from the credited fresh-source +floor s>n/A and the product form of source ranks, evaluated at the plateau's +first rank. Every exit has + +``` +e <= r_max*k_min^G <= r_max*gamma < A*gamma, +``` + +where G=floor(log_(k_min) gamma). Thus every paid exit leaves this plateau. +These statements specify the exact application boundary of the theorem. + +## 2. New visit bound + +Fix a maximum N>=A and an observed plateau gamma<=floor(N/A). Put + +``` +L_gamma = A*gamma, +U_gamma = min(N, A*gamma_next - 1), +delta_gamma = min{s: t_s>0}, +nu_gamma = 1 + floor((U_gamma-L_gamma)/delta_gamma). +``` + +Consider any directed recursive rank chain starting at a rank <=N. Every edge +strictly decreases its rank, so its visits to one plateau are contiguous. An +edge that remains on that plateau cannot be an exit. It must be a complement +n -> n-s, which decreases rank by at least delta_gamma. If the chain visits +this plateau v times, its first and last such ranks differ by at least +(v-1)*delta_gamma, and by at most U_gamma-L_gamma. Therefore + +``` +v <= nu_gamma. +``` + +There is no logarithmic estimate or real-power rounding in this argument. +This visit bound is attained in the numerical recurrence: start at U_gamma +and repeatedly take the positive-count complement with s=delta_gamma until +it leaves the plateau. All intermediate ranks lie in [L_gamma,U_gamma], where +the source census is unchanged. If this process takes another edge while +remaining in the plateau then its child is positive, so that complement exists. +Thus the actual maximum number of visits is exactly nu_gamma. + +A useful uniform consequence is + +``` +nu_gamma <= ceil(A*(gamma_next-gamma)/delta_gamma) + <= ceil(A - A*gamma/gamma_next) + <= A-1. +``` + +The last inequality uses gamma_next<=k_min*gamma<=A*gamma. This also shows +nu_gamma is always smaller than the previous common visit exponent +`tau=A*ceil(log2 k_min)`, which is at least A. Truncating the last plateau +can improve it further. In particular the minimum with the inherited tau, +proposed in the advance claim, equals nu_gamma on this application boundary. + +## 3. New all-prime divisor + +For any prime p, including a prime absent from the rank alphabet, the LCM +recurrence gives + +``` +v_p(B_n) <= v_p(S_n) + max_child v_p(B_child). +``` + +The gcd can only lower a complement child's valuation. Follow a maximizing +child until a base rank is reached. Strict descent makes this finite. The +resulting sum has at most nu_gamma copies of v_p(S(gamma)) on each observed +plateau. The maximizing chain can depend on p; the visit bound holds for all +chains, so no common maximizing chain is needed. Therefore, simultaneously +for every 1<=n<=N, + +``` +B_n divides Q_new(N) = product_(gamma<=floor(N/A)) S(gamma)^nu_gamma. +``` + +Moreover + +``` +Q_new(N) divides Q_old(N) = product_(gamma<=floor(N/A)) S(gamma)^tau. +``` + +Every exponent is lower. Divisibility is strict whenever at least one observed +plateau has S(gamma)>1. Replacing tau by nu_gamma also tightens the explicit +bit envelope to `log2 B_n <= sum_gamma nu_gamma*log2 S(gamma)`; this does not +assert a lower asymptotic degree or change the width sequence. + +The argument is also a self-contained lemma for any integer width recurrence +with the same constant-plateau census, complement steps, below-plateau exits +and unit base widths. Physical native semantics are not needed for that lemma. + +## 4. A sharp first-plateau instance + +Take targets (2,3), one paid rank-1 site, A>=3 and A<=N<2A. Then gamma=1, +gamma_next=2, t_2=t_3=1, S=2, delta=2 and the individual exit is e=1. +The new divisor is + +``` +Q_new(N) = 2^(1+floor((N-A)/2)), +Q_old(N) = 2^A. +``` + +Jerry Chen's #7424 already gives the width formula +`B_n=2^(1+floor((n-A)/2))` on this plateau. We cite that formula as a premise; +it is not the new result. Our divisor attains it exactly at N, so its exponent +cannot be decreased even by one. At A=64, N=127 the upper divisor changes +from 2^64 to the attained 2^32. The source's quadratic explicit-output +obstruction still applies; the smaller divisor does not remove it. + +The uniform A-1 visit constant is sharp as well: two target roles of rank A +and one paid rank-1 site have their first plateau [A,A^2-1], with delta=A, +S=2 and exactly A-1 visits. This follows directly by taking successive +rank-A complements. No physical supplier for either toy rule is asserted. + +## 5. Evidence and limits + +The standard-library checker expands small productive words and paid paths, +then constructs only the exact width recurrence and directed child graph. It +checks the new divisor, its divisibility into the old divisor, actual longest +plateau visits by a separate graph dynamic program, and attaining truncated +plateaus. It imports no predecessor program and runs no predecessor suite. +Finite enumeration corroborates the new theorem; it is not an all-rank proof. + +The result assumes the stated separated numerical compiler and its credited +flow. It supplies no actual selected manifest, complete instruction stream, +new batching policy, native realization, owner erasure, precision/tape bound, +analytic recovery or multiplication theorem. All five selected assumptions +remain. Independent human and formal proof-kernel review are unclaimed. diff --git a/research/additive-plateau-width/README.md b/research/additive-plateau-width/README.md new file mode 100644 index 0000000000..6ca6f01bf8 --- /dev/null +++ b/research/additive-plateau-width/README.md @@ -0,0 +1,131 @@ +# A sharper plateau divisor for chronological widths + +**Scoped written proof with exact finite corroboration. No new κ.** +This contribution was produced by Nick Petalas. + +For the separated fixed-rule numerical compiler of Jerry Chen / CubeJerry's +[#7424](https://github.com/CrocSwap/integer-mult-bounds/pull/7424), replace its +common plateau exponent `tau=A*ceil(log2 k_min)` by + +``` +nu_gamma = 1 + floor((min(N,A*gamma_next-1)-A*gamma)/delta_gamma), +delta_gamma = smallest positive fresh-source rank on the plateau. + +B_n divides product_gamma S(gamma)^nu_gamma, for every 1 <= n <= N. +``` + +Every new exponent is at most `A-1`, strictly below the previous `tau`. +The new divisor divides the old one, strictly whenever an observed plateau +has source count greater than one. It also gives a smaller explicit bit +upper bound. It changes neither the width sequence nor its proved +asymptotic degree. [PROOF.md](PROOF.md) states all hypotheses and proves +that the visit exponent is the exact maximum on the numerical child graph. + +The reason is specific: every paid exit leaves its parent's plateau, while +every complement step inside it subtracts at least `delta_gamma`. Applying +that count to every prime-valuation chain proves the divisor, including +primes absent from the rank alphabet. + +For targets `(2,3)`, one paid rank-1 site, `A=64` and `N=127`, the upper +divisor decreases from `2^64` to `2^32`. The new divisor attains the width +already established by #7424. That width formula is credited prior work; +the new result is the general divisor refinement. No physical supplier for +this toy rule is asserted. + +## Exact evidence + +The independently written standard-library checker imports no predecessor +program. It constructs 670 distinct bounded rule/maximum fixtures, totaling +11,926 width rows and 851 plateau rows. All 851 literal graph maxima equal +the new visit bound. The divisor decreases strictly on 448 fixtures; 222 +have only base ranks. A further 294 first-plateau/truncation fixtures attain +the divisor exactly. Sixteen domain and semantic controls pass, including +lowering the exponent, dropping its final `+1`, allowing a same-plateau exit, +and pooling repeated chronological cuts. + +Normal and optimized runs print identical computed results and fixture digest: + +``` +PASS_ADDITIVE_PLATEAU_WIDTH +computed_library_sha256=39175e152722a32239563041f1ee5c4669c8aca9b5212d3bc96a0ccb98dd8365 +``` + +Counts refer to the stated finite fixtures. The universal statement rests +on the written proof and the cited numerical-flow premises. No predecessor +scientific suite or selected cold replay was run. + +## Reproduce + +From the repository root, with CPython 3.12 and its standard library: + +```sh +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/additive-plateau-width/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -O -W error -B research/additive-plateau-width/verify.py +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/additive-plateau-width +/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/additive-plateau-width --check-source-history --check-modes +``` + +Substitute another CPython 3.12 path on another machine. The two registered +commands have 120-second timeouts. Direct verification writes nothing. +Adding `--record /absolute/external/new.json` generates a receipt with the +computed results, interpreter version and SHA256 hashes of all seven package +files. It refuses existing paths. A receipt is never hand-written. + +[SOURCES.json](SOURCES.json) pins main's historical task/selected/width documents +as provenance. It separately identifies the exact public #7424 proof and its +SHA256 as cited mathematical provenance. No external executable/data inputs, +network access or unmerged Git objects are needed by the direct verifier. +The citation hash is not a claim of runtime authentication or theorem review. + +## Limits and implementation bounds + +The theorem concerns the exact least-replication recurrence for finite fixed +separated histograms with `r_max low // ambient, "fresh-source floor fails") + encoded = [ambient, targets, paid, maximum, widths, refined, old] + digest.update(json.dumps(encoded, separators=(',', ':')).encode()) + counts['computed_library_sha256'] = digest.hexdigest() + return counts + + +def check_sharpness(): + """For cap one the refinement is exact, including truncated last plateaus.""" + cases = 0 + for ambient in range(3, 101): + for maximum in (ambient, ambient + (ambient - 1) // 2, 2 * ambient - 1): + rows, widths, children, refined, old = library(ambient, (2, 3), (1,), maximum) + low, high, sources, exits, bound, tau = rows[0] + require(bound == (maximum - ambient) // 2 + 1, "wrong endpoint rounding") + require(refined == 2 ** bound, "unexpected cap-one divisor") + require(max(widths) == refined, "cap-one divisor is not attained") + require(maximum_visits(children, low, high) == bound, "visit bound not attained") + require(old == 2 ** ambient and sources == {2: 1, 3: 1} and exits == (1,), + "sharpness fixture changed") + cases += 1 + return {'attaining_truncated_plateaus': cases, + 'A64_N127_old_divisor': str(2 ** 64), + 'A64_N127_new_divisor': str(2 ** 32)} + + +def reject(call, message): + try: + call() + except ValueError: + return + raise ValueError('accepted invalid case: ' + message) + + +def check_controls(): + invalid = ( + ('boolean ambient', lambda: validate_rule(True, (2,), (1,), 4)), + ('unbounded library', lambda: validate_rule(2, (2,), (1,), MAX_N + 1)), + ('no productive role', lambda: validate_rule(4, (), (1,), 8)), + ('no paid site', lambda: validate_rule(4, (2,), (), 8)), + ('unseparated ranks', lambda: validate_rule(4, (2,), (2,), 8)), + ('target beyond ambient', lambda: validate_rule(4, (5,), (1,), 8)), + ('rank-one target', lambda: validate_rule(4, (1,), (1,), 8)), + ('noninteger rank', lambda: validate_rule(4, (2.0,), (1,), 8)), + ('unit generator', lambda: semigroup((1, 2), 20)), + ('zero census cap', lambda: literal_census(4, (2, 3), (1,), 0)), + ('zero maximum', lambda: plateaus(4, (2, 3), (1,), 0)), + ) + for name, call in invalid: + reject(call, name) + rows, widths, children, refined, old = library(64, (2, 3), (1,), 127) + semantic = {'lowered exponent': refined // 2 % max(widths) != 0} + wrong_visits = 1 + (127 - 64) // max(rows[0][2]) + semantic['maximum source replaces minimum'] = 2 ** wrong_visits % max(widths) != 0 + # Dropping the final +1 omits one actual visit. + rows, widths, children, refined, old = library(7, (2, 3), (1,), 13) + semantic['dropped final plus one'] = 2 ** ((13 - 7) // 2) % max(widths) != 0 + # A same-plateau exit invalidates the minimum-complement argument. + fake = [()] * 8 + fake[6], fake[7] = (5,), (6,) + semantic['same-plateau exits'] = maximum_visits(fake, 5, 7) > 1 + (7 - 5) // 3 + # Repeated exits are separate cuts, each requiring two copies. + sources, exits = literal_census(4, (3, 3), (2, 2), 3) + rows, widths, children, refined, old = library(4, (3, 3), (2, 2), 12) + semantic['pooled chronological cuts'] = ( + exits == (4, 4, 4, 4) and widths[4] == 2 and widths[12] == 8 and widths[12] != 4) + for name, detected in semantic.items(): + require(detected, 'semantic control failed: ' + name) + return {'controls': len(invalid) + len(semantic)} + + +def receipt(result): + names = ('PROOF.md', 'README.md', 'SOURCES.json', 'TASK.json', + 'VERIFY.json', 'verify.py', 'width.py') + files = [ROOT / name for name in names] + return {'result': result, 'python': platform.python_version(), + 'sources': {p.name: hashlib.sha256(p.read_bytes()).hexdigest() for p in files}} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--record', type=Path) + args = parser.parse_args() + result = {**check_libraries(), **check_sharpness(), **check_controls()} + if args.record is not None: + require(args.record.is_absolute(), 'record path must be absolute') + path = args.record.resolve() + require(not path.is_relative_to(ROOT), + 'record must be external to the package') + with path.open('x', encoding='utf-8') as stream: + stream.write(json.dumps(receipt(result), indent=2, sort_keys=True) + '\n') + print('PASS_ADDITIVE_PLATEAU_WIDTH ' + json.dumps(result, sort_keys=True)) + + +if __name__ == '__main__': + main() diff --git a/research/additive-plateau-width/width.py b/research/additive-plateau-width/width.py new file mode 100644 index 0000000000..9aff36787c --- /dev/null +++ b/research/additive-plateau-width/width.py @@ -0,0 +1,133 @@ +"""Exact small chronological libraries and the additive plateau divisor. + +New refinement produced by Nick Petalas. Apache-2.0. +The numerical recurrence is credited in README.md; no source code is imported. +""" +from collections import Counter +from itertools import product +from math import gcd, lcm, prod + +MAX_N = 256 +MAX_ROLES = 4 + + +def require(condition, message): + if not condition: + raise ValueError(message) + + +def validate_rule(ambient, targets, paid, maximum): + require(type(ambient) is int and type(maximum) is int, + "ambient and maximum must be integers") + require(2 <= ambient <= MAX_N and 1 <= maximum <= MAX_N, + "bounded checker requires 2 <= ambient <= 256 and 1 <= N <= 256") + for roles in (targets, paid): + require(isinstance(roles, tuple) and 1 <= len(roles) <= MAX_ROLES, + "supply one to four explicit roles") + require(all(type(x) is int and x > 0 for x in roles), + "role ranks must be positive integers") + require(2 <= min(targets) and max(targets) <= ambient, + "productive ranks must lie in [2, ambient]") + require(max(paid) < min(targets), "paid ranks must be separated") + + +def semigroup(generators, cap): + """Integer-by-integer membership, with an explicit cap.""" + require(type(cap) is int and 1 <= cap <= MAX_N * MAX_N, + "semigroup cap out of range") + require(isinstance(generators, tuple) and 1 <= len(generators) <= 2 * MAX_ROLES + and all(type(g) is int and g >= 2 for g in generators), + "semigroup generators must be at least two") + present = [False] * (cap + 1) + present[1] = True + for value in range(2, cap + 1): + present[value] = any(value % g == 0 and present[value // g] + for g in generators) + return tuple(i for i in range(1, cap + 1) if present[i]) + + +def literal_census(ambient, targets, paid, gamma): + """Expand role words and paid paths, without pooling chronological exits.""" + validate_rule(ambient, targets, paid, ambient) + require(type(gamma) is int and 1 <= gamma <= MAX_N // ambient, + "census cap exceeds the bounded library") + height = max(j for j in range(gamma.bit_length()) if min(targets) ** j <= gamma) + sources = Counter() + for depth in range(height + 1): + for path in product(paid, repeat=depth): + rho = prod(path) + for word in product(targets, repeat=height - depth): + column = rho * prod(word) + if column > gamma: + continue + for rank in targets: + sources[column * rank] += 1 + if depth < height: + for rank in paid: + sources[column * rank] -= 1 + require(all(t >= 0 for t in sources.values()), "negative source multiplicity") + sources = {s: t for s, t in sorted(sources.items()) if t} + exits = tuple(prod(path) for path in product(paid, repeat=height + 1)) + require(bool(sources) and min(sources) > gamma, "missing fresh-source floor") + require(max(sources) <= ambient * gamma, "source exceeds its parent") + require(all(0 < e < ambient * gamma for e in exits), "exit stays on plateau") + return sources, exits + + +def plateaus(ambient, targets, paid, maximum): + validate_rule(ambient, targets, paid, maximum) + if maximum < ambient: + return () + cap = maximum // ambient + generators = tuple(sorted(set(targets + paid) - {1})) + points = semigroup(generators, min(targets) * cap) + tau = ambient * (min(targets) - 1).bit_length() + rows = [] + for gamma, successor in zip(points, points[1:]): + if gamma > cap: + break + sources, exits = literal_census(ambient, targets, paid, gamma) + low, high = ambient * gamma, min(maximum, ambient * successor - 1) + delta = min(sources) + additive = 1 + (high - low) // delta + visits = additive + require(1 <= visits <= ambient - 1 < tau, "invalid visit budget") + rows.append((low, high, sources, exits, visits, tau)) + require(rows and rows[-1][1] == maximum, "incomplete plateau cover") + return tuple(rows) + + +def library(ambient, targets, paid, maximum): + """Evaluate only widths and their actual directed child graph.""" + rows = plateaus(ambient, targets, paid, maximum) + widths = [1] * (maximum + 1) + children = [()] * (maximum + 1) + new_divisor, old_divisor = 1, 1 + for low, high, sources, exits, visits, tau in rows: + total = sum(sources.values()) + new_divisor *= total ** visits + old_divisor *= total ** tau + for rank in range(low, high + 1): + replication = 1 + edges = [] + for source, count in sources.items(): + child = rank - source + if child: + replication = lcm(replication, widths[child] // gcd(widths[child], count)) + edges.append(child) + for child in exits: + replication = lcm(replication, widths[child]) + edges.append(child) + widths[rank] = total * replication + children[rank] = tuple(edges) + return rows, tuple(widths), tuple(children), new_divisor, old_divisor + + +def maximum_visits(children, low, high): + """Longest visits found by dynamic programming on the literal child DAG.""" + require(0 < low <= high < len(children) <= MAX_N + 1, "invalid plateau interval") + visits = [0] * (high + 1) + for rank in range(low, high + 1): + require(all(0 <= child < rank for child in children[rank]), "nondecreasing child") + visits[rank] = 1 + max((visits[c] for c in children[rank] if c >= low), default=0) + return max(visits)