#!/usr/bin/env python3 """Exact nonnegative rational-floor kernel. Python 3.10+, standard library. SPDX-License-Identifier: MIT Run: python3 floor_kernel.py 399 --verify Optional comparison: --site-reference evidence/omega_reference_checker.py The verifier checks finite arithmetic; the accompanying note gives the proof. """ import argparse from fractions import Fraction from hashlib import sha256 import importlib.util from pathlib import Path import re import sys Q = 339949771344778 S = 10**15 EXPECTED_STATES = [399, 135, 45, 15, 5, 1, 0] EXPECTED_REMAINDERS = [ 639958766566422, 893219131545030, 297739710515010, 99246570171670, 699748856723890, 339949771344778, ] def require(condition, message): if not condition: raise ValueError(message) def nonnegative_integer(value, name): require(type(value) is int and value >= 0, name + " must be a nonnegative integer (not float or bool)") return value def parse_seed(text): require(type(text) is str and re.fullmatch(r"0|[1-9][0-9]*", text) is not None, "seed must be canonical nonnegative decimal text") return int(text) def step(d): nonnegative_integer(d, "state") return divmod(Q * d, S) def trajectory(seed): d = nonnegative_integer(seed, "seed") states, remainders = [d], [] while d: d, remainder = step(d) states.append(d) remainders.append(remainder) return states, remainders def recover(terminal, remainders, expected_seed=None): """Recover an unpadded extinction trajectory from forward-ordered remainders. expected_seed is an optional external reference. Without one, a valid truncated suffix is correctly decoded as a different, shorter trajectory. """ require(nonnegative_integer(terminal, "terminal") == 0, "extinction ledger terminal must be zero") require(type(remainders) in (list, tuple), "ordered remainder list required") if expected_seed is not None: nonnegative_integer(expected_seed, "expected seed") d, reversed_states = terminal, [terminal] for remainder in reversed(remainders): nonnegative_integer(remainder, "remainder") require(remainder < S, "remainder must be less than S") previous, residue = divmod(S * d + remainder, Q) require(residue == 0, "reverse divisibility failed") require(previous > d, "nonminimal extinction ledger") require(step(previous) == (d, remainder), "forward replay failed") reversed_states.append(previous) d = previous require(expected_seed is None or d == expected_seed, "recovered seed differs from external expected seed") return list(reversed(reversed_states)) def record_bytes(seed, states, remainders): # This byte format is solely for comparing the two new local verifiers. return (str(seed) + "|" + ",".join(map(str, states)) + "|" + ",".join(map(str, remainders)) + "\n").encode("ascii") def expect_failure(operation): try: operation() except ValueError: return raise ValueError("invalid input was accepted") def load_site_reference(path): spec = importlib.util.spec_from_file_location("retrieved_site_reference", path) require(spec is not None and spec.loader is not None, "reference module missing") module = importlib.util.module_from_spec(spec) sys.modules[spec.name] = module spec.loader.exec_module(module) require(module.Q == Q and module.S == S, "reference parameters differ") return module def verify(reference=None): require(0 < Q < S, "contraction parameters") require(trajectory(399) == (EXPECTED_STATES, EXPECTED_REMAINDERS), "399 ledger") require(recover(0, EXPECTED_REMAINDERS, 399) == EXPECTED_STATES, "399 recovery") require(trajectory(0) == ([0], []), "empty zero ledger") require(recover(0, [], 0) == [0], "zero recovery") require([d for d in range(390, 410) if step(d)[0] == 135] == [398, 399, 400], "quotient alone merges three inputs") altered = EXPECTED_REMAINDERS.copy() altered[0] += 1 bad_cases = [ lambda: step(-1), lambda: step(True), lambda: step(399.0), lambda: parse_seed("399.0"), lambda: parse_seed("0399"), lambda: parse_seed("399\n"), lambda: recover(1, []), lambda: recover(0, [S]), lambda: recover(0, [-1]), lambda: recover(0, [True]), lambda: recover(0, [0]), lambda: recover(0, altered), lambda: recover(0, EXPECTED_REMAINDERS[1:], 399), lambda: recover(0, EXPECTED_REMAINDERS, 398), ] for operation in bad_cases: expect_failure(operation) require(recover(0, EXPECTED_REMAINDERS[1:]) == EXPECTED_STATES[1:], "a valid suffix describes a different initial state") require(int(float(Q) * 399) != Q * 399, "binary64 loss demonstration") digest, maximum_steps, transition_count = sha256(), 0, 0 for seed in range(32768): states, remainders = trajectory(seed) require(recover(0, remainders, seed) == states, "domain reverse replay") rational = Fraction(Q, S) * seed require(step(seed)[0] == rational.numerator // rational.denominator, "independent rational quotient") for d, nxt, remainder in zip(states, states[1:], remainders): require(Q*d == S*nxt + remainder and 0 <= remainder < S and nxt < d, "Euclidean identity, bounds, or descent") if reference is not None: row = reference.make_row(seed) require(row == {"seed": seed, "terminal": 0, "remainders": remainders}, "downloaded site reference ledger differs") require(reference.check_row(row, seed) == len(remainders), "downloaded site reference reverse differs") digest.update(record_bytes(seed, states, remainders)) maximum_steps = max(maximum_steps, len(remainders)) transition_count += len(remainders) require(maximum_steps == 10, "15-bit extinction maximum") large_seed = 10**80 + 399 states, remainders = trajectory(large_seed) require(recover(0, remainders, large_seed) == states, "large integer replay") print("PASS: worked ledger, zero seed, quotient ambiguity, and exact recovery") print("PASS: 14 rejection controls, valid suffix, and binary64 loss example") print("PASS: all 32768 seeds and every unpadded transition") print("MAXIMUM_STEPS=" + str(maximum_steps)) print("TOTAL_TRANSITIONS=" + str(transition_count)) print("DOMAIN_SHA256=" + digest.hexdigest()) print("PASS: 81-digit seed round trip") if reference is not None: print("PASS: downloaded site Python ledger and reverse on all 32768 seeds") print("RESULT=PASS") def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("seed", nargs="?", default="399", type=parse_seed) parser.add_argument("--verify", action="store_true") parser.add_argument("--site-reference", type=Path) args = parser.parse_args() require(args.site_reference is None or args.verify, "--site-reference requires --verify") states, remainders = trajectory(args.seed) print("Q=" + str(Q) + "; S=" + str(S)) print("input | Q*input | next | remainder") for d, nxt, remainder in zip(states, states[1:], remainders): print(f"{d} | {Q*d} | {nxt} | {remainder}") print("ORBIT=" + ",".join(map(str, states))) print("RECOVERED=" + str(recover(0, remainders)[0])) if args.verify: reference = load_site_reference(args.site_reference) if args.site_reference else None verify(reference) if __name__ == "__main__": main()