check_translation_regularities.py

#!/usr/bin/env python3
"""Exact finite regression audit for translation regularity.

The mathematical claims and their assurance boundary are recorded in
``TRANSLATION-REGULARITY-AUDIT.md``.  This program uses exact
``fractions.Fraction`` arithmetic to catch finite regressions in the boundary
criterion, maximum-gap formula, and digit-law rigidity calculation.  It does
not prove an infinite-stream, topological, descriptive, or variation theorem.
"""

from __future__ import annotations

from fractions import Fraction
from itertools import permutations, product


C = Fraction(2)


def h(x: Fraction) -> Fraction:
    return x / (C + x)


def h_iter(x: Fraction, count: int) -> Fraction:
    for _ in range(count):
        x = h(x)
    return x


def encode(digits: tuple[int, ...]) -> Fraction:
    value = Fraction(0)
    for digit in reversed(digits):
        value = Fraction(digit) + h(value)
    return value


def last_support(digits: tuple[int, ...]) -> int | None:
    return next((i for i in range(len(digits) - 1, -1, -1) if digits[i]), None)


def v2(value: int) -> int:
    assert value > 0
    result = 0
    while value % 2 == 0:
        value //= 2
        result += 1
    return result


def digit(digits: tuple[int, ...], index: int) -> int:
    return digits[index] if index < len(digits) else 0


def direct_boundary_continuity(
    translator: tuple[int, ...], boundary: tuple[int, ...]
) -> bool:
    """Evaluate the exact tail-and-divisibility cancellation criterion."""

    k = last_support(boundary)
    assert k is not None
    m = boundary[k]
    tail_zero = all(digit(translator, i) == 0 for i in range(k + 1, len(translator)))
    return tail_zero and digit(translator, k) % (2 ** (v2(m) + 1)) == 0


def classified_boundary_discontinuity(
    translator: tuple[int, ...], boundary: tuple[int, ...]
) -> bool:
    """Evaluate the closed support-and-final-valuation classification."""

    s = last_support(translator)
    k = last_support(boundary)
    assert k is not None
    if s is None:
        return False
    if k < s:
        return True
    if k > s:
        return False
    modulus = 2 ** v2(translator[s])
    return boundary[k] % modulus == 0


def prefix_map(prefix: tuple[int, ...], inner: int) -> Fraction:
    return encode(prefix + (inner,))


def finite_classification_probe() -> int:
    words = list(product(range(5), repeat=4))
    translators = [word for word in words if last_support(word) is not None]
    boundaries = [word for word in words if last_support(word) is not None]
    checks = 0
    for translator in translators:
        for boundary in boundaries:
            direct_disc = not direct_boundary_continuity(translator, boundary)
            classified_disc = classified_boundary_discontinuity(translator, boundary)
            assert direct_disc == classified_disc, (translator, boundary)
            checks += 1
    return checks


def maximum_gap_probes() -> list[tuple[int, int, Fraction, Fraction]]:
    rows: list[tuple[int, int, Fraction, Fraction]] = []
    for support in range(5):
        prefixes = list(product(range(3), repeat=support))
        for valuation in range(5):
            modulus = 2**valuation
            predicted = h_iter(Fraction(modulus), support)
            observed = Fraction(0)
            for prefix in prefixes:
                for quotient in range(20):
                    left = prefix_map(prefix, quotient * modulus)
                    right = prefix_map(prefix, (quotient + 1) * modulus)
                    gap = right - left
                    assert gap <= predicted, (support, valuation, prefix, quotient, gap)
                    observed = max(observed, gap)
            assert observed == predicted, (support, valuation, observed, predicted)
            rows.append((support, valuation, observed, predicted))
    return rows


def gray(value: int) -> int:
    return value ^ (value >> 1)


def gray_inverse(value: int) -> int:
    result = 0
    while value:
        result ^= value
        value >>= 1
    return result


def finite_digit_law_probe() -> tuple[int, int, bool]:
    """Enumerate all relabelings of the three-bit Boolean group."""

    valid = 0
    same_law = 0
    for tail in permutations(range(1, 8)):
        forward = (0,) + tail
        inverse = [0] * 8
        for index, value in enumerate(forward):
            inverse[value] = index
        obeys_bound = True
        induces_xor = True
        for left in range(8):
            for right in range(8):
                result = inverse[forward[left] ^ forward[right]]
                if result > left + right:
                    obeys_bound = False
                    break
                if result != (left ^ right):
                    induces_xor = False
            if not obeys_bound:
                break
        if obeys_bound:
            valid += 1
            same_law += int(induces_xor)

    gray_is_xor = all(
        gray_inverse(gray(left) ^ gray(right)) == (left ^ right)
        for left in range(256)
        for right in range(256)
    )
    return valid, same_law, gray_is_xor


def main() -> None:
    checks = finite_classification_probe()
    rows = maximum_gap_probes()
    valid, same_law, gray_is_xor = finite_digit_law_probe()

    print(f"finite boundary classifications: {checks}")
    print("maximum-gap probes (support, valuation, exact gap):")
    for support, valuation, observed, predicted in rows:
        assert observed == predicted
        print(f"  ({support}, {valuation}) -> {observed}")
    print(f"three-bit bound-preserving relabelings: {valid}")
    print(f"three-bit relabelings inducing XOR: {same_law}")
    print(f"Gray conjugacy equals XOR through 255: {gray_is_xor}")
    print("simultaneous-regularity finite probes: PASS")


if __name__ == "__main__":
    main()