"""Exact transcription checks for the uniform ordinary-star corner proof. Run from any working directory with Python 3.9 or later:: python weighted/verify_uniform_corner.py python weighted/verify_uniform_corner.py --large --output checks.json The default is a quick representative check. --large reproduces the full 124-rectangle, 12,241,657-scalar-pivot, and 24,830,850-Toda-entry audit. Only Python's standard library and the adjacent verify.py are used. These finite checks audit the formulas in ordinary_star_corners.tex; the dimension-independent proof is in that source file. """ import argparse import json from pathlib import Path import sys import time sys.path.insert(0, str(Path(__file__).resolve().parent)) import verify as v def check(condition, context): """Keep verification active even when Python is invoked with -O.""" if not condition: raise AssertionError(context) def cells(xmax, ymax): """Baxter cells in diagonal and parity order, without storing a list.""" for diagonal in range(-ymax, xmax + 1): low = max(0, diagonal) high = min(xmax, ymax + diagonal) for x in range(low + low % 2, high + 1, 2): yield x, x - diagonal top = high if high % 2 else high - 1 for x in range(top, low - 1, -2): yield x, x - diagonal def omega_sum(values, index): """Compute sum_i values[i] Omega(i,index), with zero boundary values.""" size = len(values) answer = (values[index + 1] if index + 1 < size else 0) answer -= values[index - 1] if index else 0 if index % 2: answer += values[index + 2] if index + 2 < size else 0 answer -= values[index - 2] if index >= 2 else 0 return answer def scalar_check(m, case): """Replay the scalar triangular recurrence, checking every signed pivot.""" xmax = 2 * m if case == "short1" else 2 * m - 2 ymax = 2 * m - 2 row = [0] * (xmax + 1) column = [0] * (ymax + 1) corner = count = 0 for x, y in cells(xmax, ymax): if case == "short1": incoming = int(y == 0) elif case == "long1": incoming = int(x == xmax) else: incoming = int(x in (0, 1)) actual = incoming + omega_sum(row, x) - omega_sum(column, y) if case == "long1": expected = int((x, y) == (xmax, xmax) or (x % 2 and x == y + 1)) elif case == "short1": expected = int((x, y) in ((0, 0), (xmax, ymax)) or (x % 2 == 0 and x == y + 1)) elif x == 0: expected = int(y % 2 == 0) elif x == 1: expected = -(m - 1 - y // 2) else: expected = 0 check(actual == expected, ("scalar", m, case, x, y, actual, expected)) positive = max(actual, 0) row[x] += positive column[y] += positive corner += positive * int(y <= 1 if case == "short1" else x >= xmax - 1) count += 1 check(corner == (0 if case == "long2" else 2), ("corner", m, case, corner)) return count def rectangle_check(a, b): """Check the shuffle, green root, and positive column against framed mutation.""" xmax, ymax = 2 * a - 2, 2 * b - 2 dimensions = {0: a, 1: b} labels = [z for h in range(1, b) for z in (("s", 1, h), ("t", 1, h))] labels += [("edge", 0, 1)] labels += [z for h in range(1, a) for z in (("t", 0, h), ("s", 0, h))] seed = v.Framed(v.negate(v.principal(labels, dimensions, {0: 1, 1: 1}))) size = len(labels) letters = [("L", y) for y in range(ymax + 1)] letters += [("A", x) for x in range(xmax + 1)] count = 0 for x, y in cells(xmax, ymax): slot = x + y check(letters[slot:slot + 2] == [("L", y), ("A", x)], ("adjacent shuffle", a, b, x, y)) expected = [int(y <= j <= ymax + x) for j in range(size)] check(seed.rows[slot][size:] == expected, ("rectangle root", a, b, x, y, seed.rows[slot][size:], expected)) positive_column = [max(seed.rows[i][slot], 0) for i in range(size)] check(positive_column == [int(abs(i - slot) == 1) for i in range(size)], ("rectangle positive column", a, b, x, y, positive_column)) seed.step(slot) letters[slot:slot + 2] = letters[slot:slot + 2][::-1] count += 1 check(letters == [("A", x) for x in range(xmax + 1)] + [("L", y) for y in range(ymax + 1)], ("final shuffle", a, b)) return count def toda_check(m): """Compare the path-matrix recurrence with its closed interval formula.""" size = m - 1 previous = [[0] * size for _ in range(size)] current = v.identity(size) for r in range(m): expected = [[int(abs(h - k) <= r <= min(h + k, 2 * m - h - k - 4) and (r - h + k) % 2 == 0) for k in range(size)] for h in range(size)] check(current == expected, ("Toda", m, r)) following = [[(current[h - 1][k] if h else 0) + (current[h + 1][k] if h + 1 < size else 0) - previous[h][k] for k in range(size)] for h in range(size)] previous, current = current, following return m * size * size def star_stages(a, b, side): """Construct the opposite ordinary star and replay it with an unmutated probe.""" dimensions = {0: a, 1: b, 2: b} labels = v.strips(dimensions) + [("edge", 0, 1), ("edge", 0, 2)] matrix = v.negate(v.principal(labels, dimensions, {0: 1, 1: 1, 2: 1})) size = len(labels) target = v.identity(size) slots = list(range(size)) height = a - 1 if side == 0 else 1 adjacency = [int(label == ("s", side, height)) for label in labels] augmented = [row + [-adjacency[k]] for k, row in enumerate(matrix)] augmented += [adjacency + [0]] probe_seed = v.Framed(augmented) seed = v.Framed(matrix) target_column = labels.index(("t", side, height)) records = [] def snapshot(name): records.append({ "stage": name, "Hj": probe_seed.rows[size][size + 1 + target_column], "adj": [(labels[i], probe_seed.rows[size][slots[i]]) for i in range(size) if probe_seed.rows[size][slots[i]]], "H": probe_seed.rows[size][size + 1:2 * size + 1], }) def step(slot): seed.step(slot) probe_seed.step(slot) snapshot("initial") for leaf in (1, 2): for label in v.rectangle(0, leaf, dimensions): step(slots[labels.index(label)]) edge = ("edge", 0, leaf) target[labels.index(edge)] = [ -int(label == edge or label[0] in ("s", "t") and label[1] in (0, leaf)) for label in labels ] slots = seed.permutation(target) snapshot("gate" + str(leaf)) for color, dimension in dimensions.items(): for turn in range(dimension): for h in range(1, dimension): kind = "s" if turn % 2 == 0 else "t" step(slots[labels.index((kind, color, h))]) snapshot("Toda{}_{}".format(color, turn)) seed.endpoint() check(seed.red == 0, ("ordinary word is not green", a, b, seed.red)) return records def full_check(m): long_records = star_stages(m, m, 0) short_records = star_stages(m + 1, m, 1) check(long_records[-1]["Hj"] == 2 and short_records[-1]["Hj"] == 2, ("full corners", m)) long_gate = next(row for row in long_records if row["stage"] == "gate2") check(long_gate["adj"] == [(("s", 0, 1), m - 1), (("t", 0, 1), -m)], ("long gate row", m, long_gate["adj"])) short_gate = next(row for row in short_records if row["stage"] == "gate1") check(short_gate["adj"] == [(("t", 1, m - 1), -1)], ("short gate row", m, short_gate["adj"])) leaf2_start = 2 * m + 2 * (m - 1) check(short_records[-1]["H"][leaf2_start:leaf2_start + 2 * (m - 1)] == [0] * (2 * (m - 1)), ("cross-leaf response", m)) return len(long_records) + len(short_records) def main(): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument("--large", action="store_true", help="run the full published finite audit") parser.add_argument("--output", type=Path, help="also write the JSON result to this path") args = parser.parse_args() if args.large: pairs = [(a, b) for a in range(2, 13) for b in range(2, 13)] pairs += [(17, 23), (23, 17), (31, 31)] scalar_dimensions = list(range(2, 101)) + [127, 128, 255, 256, 511, 512] toda_dimensions = list(range(2, 101)) full_dimensions = list(range(2, 17)) else: pairs = [(a, b) for a in range(2, 7) for b in range(2, 7)] pairs += [(3, 11), (11, 3)] scalar_dimensions = list(range(2, 17)) + [31, 32, 63, 64] toda_dimensions = list(range(2, 25)) full_dimensions = list(range(2, 7)) start = time.perf_counter() report = {"mode": "large" if args.large else "quick", "arithmetic": "Python arbitrary-precision integers", "proof": "weighted/ordinary_star_corners.tex"} report["rectangle_pairs"] = len(pairs) report["rectangle_mutations"] = sum(rectangle_check(a, b) for a, b in pairs) print("Rectangle identities verified.", file=sys.stderr, flush=True) report["scalar_dimensions"] = len(scalar_dimensions) report["maximum_scalar_m"] = max(scalar_dimensions) report["scalar_pivots"] = sum(scalar_check(m, case) for m in scalar_dimensions for case in ("long1", "long2", "short1")) print("Scalar probe identities verified.", file=sys.stderr, flush=True) report["Toda_dimensions"] = len(toda_dimensions) report["Toda_entries"] = sum(toda_check(m) for m in toda_dimensions) print("Toda identities verified.", file=sys.stderr, flush=True) report["full_star_dimensions"] = len(full_dimensions) report["full_star_stages"] = sum(full_check(m) for m in full_dimensions) report["elapsed_seconds"] = round(time.perf_counter() - start, 3) report["result"] = "all checks passed" encoded = json.dumps(report, indent=2) + "\n" if args.output: args.output.write_text(encoded) print(encoded, end="") if __name__ == "__main__": main()