| """Independent exact-rational checker. Python standard library only.""" |
| from fractions import Fraction as F |
| from itertools import product |
|
|
|
|
| def eye(n): |
| return [[F(int(i == j)) for j in range(n)] for i in range(n)] |
|
|
|
|
| def zero(n): |
| return [[F(0) for _ in range(n)] for _ in range(n)] |
|
|
|
|
| def tr(a): |
| return [list(v) for v in zip(*a)] |
|
|
|
|
| def mul(a, b): |
| return [[sum((x*y for x, y in zip(row, col)), F(0)) for col in zip(*b)] for row in a] |
|
|
|
|
| def add(a, b, sign=1): |
| return [[x + sign*y for x, y in zip(ra, rb)] for ra, rb in zip(a, b)] |
|
|
|
|
| def outer(u): |
| return [[x*y for y in u] for x in u] |
|
|
|
|
| def scale(a, c): |
| return [[c*x for x in row] for row in a] |
|
|
|
|
| def rank(a): |
| if not a: |
| return 0 |
| a = [r[:] for r in a] |
| pivot = 0 |
| for col in range(len(a[0])): |
| at = next((i for i in range(pivot, len(a)) if a[i][col]), None) |
| if at is None: |
| continue |
| a[pivot], a[at] = a[at], a[pivot] |
| v = a[pivot][col] |
| a[pivot] = [x/v for x in a[pivot]] |
| for i in range(len(a)): |
| if i != pivot: |
| v = a[i][col] |
| a[i] = [x-v*y for x, y in zip(a[i], a[pivot])] |
| pivot += 1 |
| if pivot == len(a): |
| break |
| return pivot |
|
|
|
|
| def check_word(word): |
| n = 2 |
| p, q = eye(n), eye(n) |
| g = [zero(n), zero(n)] |
| rows, active = [[], []], [] |
| previous = [0, 0] |
| prefixes = 0 |
| for u, c, colour, unitary in word: |
| a = add(eye(n), scale(outer(u), c-1)) |
| v = mul([list(u)], p)[0] |
| g[colour] = add(g[colour], scale(outer(v), 1-c*c)) |
| if c != 1: |
| rows[colour].append(v) |
| active.append(mul([list(u)], q)[0]) |
| p = mul(mul(unitary, a), p) |
| q = mul(unitary, q) |
| total = add(g[0], g[1]) |
| assert total == add(eye(n), mul(tr(p), p), -1) |
| r = [rank(g[0]), rank(g[1])] |
| pooled = rank(total) |
| assert pooled == rank(active) |
| assert r == [rank(rows[0]), rank(rows[1])] |
| assert all(x >= y for x, y in zip(r, previous)) |
| assert 0 <= sum(r)-pooled <= pooled <= n |
| intersection = rank(g[0]) + rank(g[1]) - rank([ra+rb for ra, rb in zip(g[0], g[1])]) |
| assert intersection == sum(r)-pooled |
| previous = r |
| prefixes += 1 |
| return prefixes |
|
|
|
|
| def run(): |
| normals = [(F(1), F(0)), (F(0), F(1)), (F(3, 5), F(4, 5))] |
| cosines = [F(0), F(3, 5), F(1)] |
| symbols = [(u, c, colour, eye(2)) for u, c, colour in product(normals, cosines, range(2))] |
| words, prefixes = 0, 0 |
| for length in (1, 2, 3): |
| for word in product(symbols, repeat=length): |
| prefixes += check_word(word) |
| words += 1 |
| rotations = [eye(2), [[F(0), F(-1)], [F(1), F(0)]], [[F(0), F(1)], [F(1), F(0)]]] |
| for index in range(96): |
| word = [(normals[(index+t) % 3], cosines[(index+2*t) % 3], (index+t) % 2, |
| rotations[(index+3*t+t*t) % 3]) for t in range(1, 7)] |
| prefixes += check_word(word) |
| words += 1 |
| return {"exact_words": words, "exact_prefixes": prefixes, |
| "arithmetic": "fractions.Fraction", "status": "PASS"} |
|
|
|
|
| if __name__ == "__main__": |
| import json |
| print(json.dumps(run(), indent=2)) |
|
|
