code/verify_candidates.py

#!/usr/bin/env python3
"""Exact finite checks for the radical-product alternative.

Python 3 standard library only. This checks finite instances, not novelty or
universal theorems. The manuscript appendix supplies the proofs.

Run:
    python verify_candidates.py
"""
from itertools import product
import json


def recurrence_terminal(N, m):
    """Iterate the stated scalar one-step recurrence to its fixed point."""
    while True:
        nxt = max(m, 2 * min(m, N - m - 1))
        if nxt == m:
            return m
        if not m < nxt <= N - 1:
            raise AssertionError((N, m, nxt))
        m = nxt


def interval_formula(N, m):
    """Evaluate the closed terminal formula independently of the recurrence."""
    n = N - 1
    a = m
    while 2 * a < n:
        a *= 2
    return max(a, 2 * (n - a))


def literal_step(S, caps):
    """Monomial update by complementary supports and pairwise multiplication.

    Exponents are tuples. This function does not use interval endpoints or the
    tensor dimension formula. Coordinates exceeding their truncation cap
    represent a zero product and are omitted.
    """
    S = frozenset(S)
    dark = {
        u for u in S
        if tuple(cap - value for cap, value in zip(caps, u)) not in S
    }
    out = set(S)
    for u in dark:
        for v in dark:
            w = tuple(a + b for a, b in zip(u, v))
            if all(value <= cap for value, cap in zip(w, caps)):
                out.add(w)
    return frozenset(out), frozenset(dark)


def literal_terminal(S, caps):
    S = frozenset(S)
    rounds = 0
    while True:
        nxt, dark = literal_step(S, caps)
        if nxt == S:
            return S, dark, rounds
        if not S < nxt:
            raise AssertionError("Literal update was not strictly extensive")
        S = nxt
        rounds += 1


def interval_support(m):
    return frozenset((i,) for i in range(1, m + 1))


def check_async_sequence(N, products, expected):
    S = interval_support(1)
    for i, j in products:
        nxt, dark = literal_step(S, (N,))
        if (i,) not in dark or (j,) not in dark:
            raise AssertionError(("Unauthorized asynchronous product", S, i, j))
        born = (i + j,)
        if i + j > N or born in S or born not in nxt:
            raise AssertionError(("Invalid asynchronous birth", S, born))
        S = S | {born}
    if S != frozenset((i,) for i in expected):
        raise AssertionError(("Wrong asynchronous endpoint", S, expected))
    nxt, dark = literal_step(S, (N,))
    if nxt != S:
        raise AssertionError("Asynchronous endpoint was not terminal")
    return {
        "N": N,
        "products": [list(pair) for pair in products],
        "terminal_exponents": sorted(i for (i,) in S),
        "terminal_dark_exponents": sorted(i for (i,) in dark),
    }


def main():
    recurrence_cases = 0
    for N in range(2, 301):
        for m in range(1, N):
            actual = recurrence_terminal(N, m)
            expected = interval_formula(N, m)
            if actual != expected:
                raise AssertionError(("Recurrence/formula mismatch", N, m, actual, expected))
            recurrence_cases += 1
    assert recurrence_cases == 44850

    literal_interval_cases = 0
    literal_boundary_cases = 0
    for N in range(2, 41):
        for m in range(1, N):
            actual, dark, rounds = literal_terminal(interval_support(m), (N,))
            expected = interval_support(interval_formula(N, m))
            if actual != expected:
                raise AssertionError(("Literal interval mismatch", N, m, actual, expected))
            literal_interval_cases += 1
        for seed in (frozenset(), interval_support(N)):
            actual, dark, rounds = literal_terminal(seed, (N,))
            if actual != seed or rounds != 0:
                raise AssertionError(("Boundary state not fixed", N, seed, actual))
            literal_boundary_cases += 1
    assert literal_interval_cases == 780
    assert literal_boundary_cases == 78

    n13 = []
    for m in (3, 4):
        S = interval_support(m)
        dimensions = [len(S)]
        while True:
            nxt, dark = literal_step(S, (13,))
            if nxt == S:
                break
            S = nxt
            dimensions.append(len(S))
        n13.append({"initial_m": m, "dimensions_until_fixed": dimensions})
    assert [item["dimensions_until_fixed"] for item in n13] == [[3, 6, 12], [4, 8]]

    tensor_rows = []
    for r in range(1, 7):
        seed = frozenset(product((1, 2), repeat=r))
        first, initial_dark = literal_step(seed, (4,) * r)
        second, terminal_dark = literal_step(first, (4,) * r)
        expected = 2**r + 3**r - r - 2
        if len(first) != expected or second != first:
            raise AssertionError(("Tensor dimension/terminality mismatch", r, len(first), expected))
        if r >= 2 and len(terminal_dark) != 3**r - 2**r - r - 1:
            raise AssertionError(("Tensor terminal radical mismatch", r))
        tensor_rows.append({
            "r": r,
            "initial_dimension": len(seed),
            "initial_radical_dimension": len(initial_dark),
            "terminal_dimension": len(first),
            "terminal_radical_dimension": len(terminal_dark),
            "first_update_is_terminal": second == first,
        })
    assert [row["terminal_dimension"] for row in tensor_rows] == [2, 9, 30, 91, 268, 785]

    asynchronous = [
        check_async_sequence(7, [(1, 1), (2, 2), (1, 2)], [1, 2, 3, 4]),
        check_async_sequence(7, [(1, 1), (1, 2), (2, 3), (1, 3)], [1, 2, 3, 4, 5]),
    ]
    result = {
        "status": "PASS",
        "arithmetic": "Exact integer exponents and finite sets; Python standard library",
        "recurrence_vs_closed_formula": {
            "N_range_inclusive": [2, 300],
            "m_range": "1 <= m < N",
            "cases": recurrence_cases,
        },
        "independent_literal_interval_updates": {
            "N_range_inclusive": [2, 40],
            "m_range": "1 <= m < N",
            "cases": literal_interval_cases,
        },
        "literal_boundary_states": {
            "N_range_inclusive": [2, 40],
            "states_per_N": "empty and {1,...,N}",
            "cases": literal_boundary_cases,
        },
        "N13_nonmonotonicity": n13,
        "literal_tensor_cases": tensor_rows,
        "asynchronous_terminal_histories": asynchronous,
        "scope": (
            "Finite instances and implementation consistency only. These checks "
            "do not establish universal theorems, priority, general nonmonomial "
            "behavior, perturbation robustness, or computational usefulness."
        ),
    }
    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()