#!/usr/bin/env python3 """Exact checks accompanying OMEGA Reference, Representation, and Recovery. Python 3.11+, standard library only. Run normally and with python -O. The written note supplies the quantified proofs. This program checks algebra, explicit finite cases, negative controls, and one numerical diagnostic group. The canonical sine is retained as a formal parameter in the exact carrier. """ from __future__ import annotations import cmath from dataclasses import dataclass from decimal import Decimal as D, localcontext from fractions import Fraction as F from hashlib import sha256 from itertools import combinations, product from math import ceil, gcd, isqrt, pi, sqrt from pathlib import Path import platform import random Q = 339_949_771_344_778 S = 10**15 def require(condition, message='check failed'): if not condition: raise RuntimeError(message) def rejects(function, *args): try: function(*args) except (ValueError, TypeError): return raise RuntimeError('malformed input was accepted') @dataclass(frozen=True) class Golden: """a+b*phi in Q(phi), where phi^2=phi+1, with exact field operations.""" a: F = F(0) b: F = F(0) def __post_init__(self): object.__setattr__(self, 'a', F(self.a)) object.__setattr__(self, 'b', F(self.b)) @staticmethod def cast(value): if isinstance(value, Golden): return value if isinstance(value, (int, F)): return Golden(value) return NotImplemented def __add__(self, other): other = self.cast(other) if other is NotImplemented: return NotImplemented return Golden(self.a+other.a, self.b+other.b) __radd__ = __add__ def __neg__(self): return Golden(-self.a, -self.b) def __sub__(self, other): other = self.cast(other) return NotImplemented if other is NotImplemented else self + (-other) def __rsub__(self, other): return (-self) + other def __mul__(self, other): other = self.cast(other) if other is NotImplemented: return NotImplemented return Golden(self.a*other.a+self.b*other.b, self.a*other.b+self.b*other.a+self.b*other.b) __rmul__ = __mul__ def __truediv__(self, other): other = self.cast(other) if other is NotImplemented: return NotImplemented norm = other.a**2+other.a*other.b-other.b**2 if norm == 0: raise ValueError('division by zero') return self*Golden((other.a+other.b)/norm, -other.b/norm) def __rtruediv__(self, other): return self.cast(other)/self def __pow__(self, exponent): if type(exponent) is not int or exponent < 0: raise ValueError('nonnegative integer power required') result, base = Golden(1), self while exponent: if exponent & 1: result *= base base *= base exponent //= 2 return result def sign(self): # self = A+B*sqrt(5); compare squares when the signs differ. A, B = self.a+self.b/2, self.b/2 sg = lambda x: (x > 0)-(x < 0) if B == 0: return sg(A) if A == 0: return sg(B) if sg(A) == sg(B): return sg(A) difference = A*A-5*B*B return sg(difference) if A > 0 else -sg(difference) def __float__(self): return float(self.a)+float(self.b)*(1+sqrt(5))/2 PHI = Golden(0, 1) class Poly: """Sparse polynomial over Q(phi). A monomial is a sorted tuple of names.""" def __init__(self, value=0, *, terms=None): source = {(): Golden.cast(value)} if terms is None else terms self.terms = {k: v for k, v in source.items() if v != Golden()} @staticmethod def var(name): return Poly(terms={(name,): Golden(1)}) @staticmethod def cast(value): return value if isinstance(value, Poly) else Poly(value) def __add__(self, other): other = self.cast(other) out = dict(self.terms) for key, value in other.terms.items(): out[key] = out.get(key, Golden())+value return Poly(terms=out) __radd__ = __add__ def __neg__(self): return Poly(terms={k: -v for k, v in self.terms.items()}) def __sub__(self, other): return self + (-self.cast(other)) def __rsub__(self, other): return self.cast(other) + (-self) def __mul__(self, other): other = self.cast(other) out = {} for k, v in self.terms.items(): for j, w in other.terms.items(): key = tuple(sorted(k+j)) out[key] = out.get(key, Golden())+v*w return Poly(terms=out) __rmul__ = __mul__ def __pow__(self, exponent): if type(exponent) is not int or exponent < 0: raise ValueError('nonnegative power required') out = Poly(1) for _ in range(exponent): out *= self return out def __eq__(self, other): return self.terms == self.cast(other).terms def scalar(self): if not self.terms: return Golden() if set(self.terms) == {()}: return self.terms[()] raise ValueError('not a constant polynomial') s = Poly.var('s') XREF = (-(s+PHI+1), -(s+1), -s, s, s+1, s+PHI+1) def encode_scale(number): if type(number) is not int or number < 1: raise ValueError('positive integer scale required') return tuple(number*x for x in XREF) def decode_scale(word): if not isinstance(word, tuple) or len(word) != 6: raise ValueError('six ordered formal coordinates required') a = (word[2]-word[1]).scalar() if a.b or a.a.denominator != 1 or a.a <= 0: raise ValueError('scale is not a positive integer') number = a.a.numerator if word != encode_scale(number): raise ValueError('word is not in the declared carrier image') return number def pack_bits(bits): if not isinstance(bits, str) or any(c not in '01' for c in bits): raise ValueError('binary string required') return int('1'+bits, 2) def unpack_bits(number): if type(number) is not int or number < 1: raise ValueError('positive integer required') return bin(number)[3:] def pack_bytes(data): if type(data) is not bytes: raise ValueError('bytes required') return (1 << (8*len(data)))+int.from_bytes(data, 'big') def unpack_bytes(number): bits = unpack_bits(number) if len(bits) % 8: raise ValueError('not a whole-byte payload code') return (number-(1 << len(bits))).to_bytes(len(bits)//8, 'big') def gamma(number): if type(number) is not int or number < 1: raise ValueError('positive integer required') bits = bin(number)[2:] return '0'*(len(bits)-1)+bits def encode_graph(size, edges): if type(size) is not int or size < 0: raise ValueError('nonnegative size required') if any(type(i) is not int or type(j) is not int or not (0 <= i < size and 0 <= j < size) for i, j in edges): raise ValueError('edge outside the domain') bits = gamma(size+1)+''.join('1' if (i, j) in edges else '0' for i in range(size) for j in range(size)) return encode_scale(pack_bits(bits)) def decode_graph(word): bits = unpack_bits(decode_scale(word)) zero_count = len(bits)-len(bits.lstrip('0')) end = 2*zero_count+1 if end > len(bits): raise ValueError('truncated size prefix') size = int(bits[zero_count:end], 2)-1 body = bits[end:] if len(body) != size*size: raise ValueError('wrong relation-table length') edges = {(i, j) for i in range(size) for j in range(size) if body[i*size+j] == '1'} return size, edges def eval_formula(formula, domain, relation, env=None): env = {} if env is None else env op, *args = formula if op == 'R': return relation(env[args[0]], env[args[1]]) if op == '=': return env[args[0]] == env[args[1]] if op == 'not': return not eval_formula(args[0], domain, relation, env) if op == 'and': return all(eval_formula(f, domain, relation, env) for f in args) if op == 'exists': name, child = args return any(eval_formula(child, domain, relation, {**env, name: x}) for x in domain) if op == 'forall': name, child = args return all(eval_formula(child, domain, relation, {**env, name: x}) for x in domain) raise ValueError('unknown formula node') def ceil_div(a, b): return -((-a)//b) def make_ledger(seed, horizon=None): if type(seed) is not int or seed < 0: raise ValueError('nonnegative seed required') if horizon is not None and (type(horizon) is not int or horizon < 0): raise ValueError('nonnegative horizon required') state, remainders = seed, [] limit = horizon if horizon is not None else seed.bit_length()+1 for _ in range(limit): if horizon is None and state == 0: break state, rho = divmod(Q*state, S) remainders.append(rho) if horizon is None: require(state == 0, 'extinction bound failed') return state, tuple(remainders) def reverse_ledger(terminal, remainders, expected_length=None): if type(terminal) is not int or terminal < 0: raise ValueError('nonnegative terminal required') if not isinstance(remainders, tuple): raise ValueError('ordered tuple required') if expected_length is not None and len(remainders) != expected_length: raise ValueError('horizon mismatch') state = terminal for rho in reversed(remainders): if type(rho) is not int or not 0 <= rho < S: raise ValueError('remainder outside its domain') numerator = S*state+rho state, residue = divmod(numerator, Q) if residue: raise ValueError('reverse divisibility failed') return state def auxiliary_marks(): # Exact member s=3/5, c=4/5. Not the canonical one-arcsecond seed. ss = F(3, 5) return tuple(Golden(x.a, x.b) for x in (-(PHI+1+ss), Golden(-1-ss), Golden(-ss), Golden(ss), Golden(1+ss), PHI+1+ss)) def decode_affine(received, error_budget): if len(received) != 6 or type(error_budget) is not int or error_budget < 0: raise ValueError('invalid decoding request') available = [i for i in range(6) if received[i] is not None] erased = 6-len(available) if 2*error_budget+erased > 4: raise ValueError('outside the declared correction guarantee') marks, candidates = auxiliary_marks(), set() for i, j in combinations(available, 2): scale = (received[j]-received[i])/(marks[j]-marks[i]) offset = received[i]-scale*marks[i] if scale.sign() <= 0: continue errors = sum(offset+scale*marks[k] != received[k] for k in available) if errors <= error_budget: candidates.add((offset, scale)) if len(candidates) != 1: raise ValueError('no unique permitted affine word') return next(iter(candidates)) def atan_bounds(inverse, terms): x = F(1, inverse) partial = sum(((-1)**k*x**(2*k+1)/F(2*k+1) for k in range(terms)), F()) next_term = (-1)**terms*x**(2*terms+1)/F(2*terms+1) return min(partial, partial+next_term), max(partial, partial+next_term) def constant_bounds(): scale = 10**100 root = isqrt(5*scale*scale) lower_phi = F(scale+root, 2*scale) upper_phi = F(scale+root+1, 2*scale) lo5, hi5 = atan_bounds(5, 80) lo239, hi239 = atan_bounds(239, 25) lower_pi, upper_pi = 16*lo5-4*hi239, 16*hi5-4*lo239 lower_lambda = lower_phi/(lower_phi+upper_pi) upper_lambda = upper_phi/(upper_phi+lower_pi) return lower_phi, upper_phi, lower_pi, upper_pi, lower_lambda, upper_lambda def check_field(): require(PHI*PHI-PHI-1 == Golden()) values = [Golden(a, b) for a in range(-3, 4) for b in range(-3, 4)] for x in values: if x != Golden(): require(x/x == Golden(1)) require((-x).sign() == -x.sign()) require((x.sign() == 0) == (x == Golden())) require((x*x).sign() == (0 if x == Golden() else 1)) for x, y in product(values, repeat=2): require(x*y == y*x) require((x+y)-y == x) return '49 exact field elements; 2401 operation pairs' def check_symbolic_geometry(): a, t, c, A, X, Y, Z = map(Poly.var, ('a','t','c','A','X','Y','Z')) require(sum(XREF, Poly()) == 0) gaps = [XREF[i+1]-XREF[i] for i in range(5)] require(gaps == [Poly(PHI), Poly(1), 2*s, Poly(1), Poly(PHI)]) marks = tuple(t+a*x for x in XREF) for i, j in combinations(range(6), 2): delta = XREF[j]-XREF[i] require(marks[j]-marks[i] == a*delta) require(XREF[j]*marks[i]-XREF[i]*marks[j] == t*delta) r0 = X*X+Y*Y+Z*Z rm = (X+a*A)**2+(Y-a*c)**2+Z*Z rp = (X-a*A)**2+(Y-a*c)**2+Z*Z require(rm-rp == 4*a*A*X) require(2*r0+2*a*a*(c*c+A*A)-rm-rp == 4*a*c*Y) r3 = X*X+Y*Y+(Z-a)**2 require(r0-r3+a*a == 2*a*Z) require(sum(c*x for x in XREF) == 0) # The affine contraction maps t -> 1+r(t-1), a -> r*a. r = Poly.var('r') for x, y in zip(XREF, marks): require(1+r*(y-1) == 1+r*(t-1)+(r*a)*x) return 'formal s retained; 15 two-mark identities; planar and 3D inverse identities' def check_planar_measurements(): marks = auxiliary_marks() A, c = marks[-1], Golden(F(4, 5)) count = 0 for scale in [F(1, 3), F(1), F(7, 2)]: for x, y in product(range(-5, 6), repeat=2): xx, yy = Golden(F(x, 3)), Golden(F(y, 4)) r0 = xx*xx+yy*yy rm = (xx+scale*A)**2+(yy-scale*c)**2 rp = (xx-scale*A)**2+(yy-scale*c)**2 recovered_x = (rm-rp)/(4*scale*A) recovered_y = (2*r0+2*scale**2*(c*c+A*A)-rm-rp)/(4*scale*c) require((recovered_x,recovered_y) == (xx,yy)) count += 1 return f'{count} exact planar locations from three squared distances' def check_reflection_obstruction(): c = Golden(F(4, 5)) references = [(Golden(), Golden(), Golden())] references += [(x, c, Golden()) for x in auxiliary_marks()] references += [(Golden(1), Golden(), Golden()), (Golden(-1), Golden(), Golden()), (Golden(), Golden(-1), Golden())] dsq = lambda p,q: sum(((x-y)**2 for x,y in zip(p,q)), Golden()) p = (Golden(),Golden(),Golden(1)) plus = (Golden(),Golden(),Golden(2)) minus = (Golden(),Golden(),Golden(-2)) for anchor in references: require(dsq(plus, anchor) == dsq(minus, anchor)) require(dsq(p,plus) == Golden(1)) require(dsq(p,minus) == Golden(9)) off_plane = (Golden(),Golden(),Golden(1)) require(dsq(plus,off_plane) != dsq(minus,off_plane)) return 'same planar distance profiles; mutual squared distances 1 and 9' def check_metric_profiles(): distance = lambda x,y: (x^y).bit_count() for x,y in product(range(8), repeat=2): full = max(abs(distance(x,a)-distance(y,a)) for a in range(8)) require(full == distance(x,y)) finite = max(abs(distance(x,a)-distance(y,a)) for a in (0,7)) require(distance(x,y)-2 <= finite <= distance(x,y)) require(distance(1,0) == distance(2,0) and distance(1,2) == 2) return '64 full-profile isometries; 64 finite-net bounds; one nonresolving collision' def check_joint_gram_data(): points = [(F(i,3),F((i*i)%7,4),F((3*i)%5,2),F((i+2)%4,3)) for i in range(12)] dot = lambda x,y: sum(a*b for a,b in zip(x,y)) for p,q in product(points,repeat=2): planar = sum((p[i]-q[i])**2 for i in (0,1)) total = sum((a-b)**2 for a,b in zip(p,q)) perpendicular = total-planar gram = (dot(p[2:],p[2:])+dot(q[2:],q[2:])-perpendicular)/2 require(gram == dot(p[2:],q[2:])) rotated_p,rotated_q = (-p[3],p[2]),(-q[3],q[2]) require(dot(rotated_p,rotated_q) == gram) return '144 exact perpendicular Gram entries and common orthogonal transforms' def check_graph_distances(): m,alpha = 5,F(1,10) pairs = list(combinations(range(m),2)) for mask in range(1 << len(pairs)): edges = {pair for k,pair in enumerate(pairs) if mask & (1 << k)} G = [[F(int(i==j))+alpha*int((min(i,j),max(i,j)) in edges) for j in range(m)] for i in range(m)] L = [[F(int(i==j)) for j in range(m)] for i in range(m)] diagonal = [] for i in range(m): value = G[i][i]-sum(L[i][k]**2*diagonal[k] for k in range(i)) require(value > 0) diagonal.append(value) for j in range(i+1,m): L[j][i] = (G[j][i]-sum(L[j][k]*L[i][k]*diagonal[k] for k in range(i)))/value for i,j in product(range(m),repeat=2): require(sum(L[i][k]*diagonal[k]*L[j][k] for k in range(m)) == G[i][j]) for i,j in pairs: distance = G[i][i]+G[j][j]-2*G[i][j] require((distance < 2-alpha) == ((i,j) in edges)) return '1024 simple graphs; exact positive LDL factors; 10240 distance predicates' def check_temporal_observability(): lam,mu = F(Q,S),1-F(Q,S) for x,y in product(range(-10,11),repeat=2): y0,y1 = x+y,lam*x+mu*y require((mu*y0-y1)/(mu-lam) == x) require((y1-lam*y0)/(mu-lam) == y) # Under A=lam*I and C=(1,1), two different states have the same history. for n in range(24): require(lam**n*(1+0) == lam**n*(0+1)) return '441 two-mode state recoveries; uniform-contraction observation collision' def check_finite_payloads(): rng = random.Random(20261024) payloads = [b'',b'\0',b'\0\0',b'\0A',bytes(range(256)), 'OMEGA: relations, representation, recovery.'.encode('utf-8')] payloads += [bytes([i]) for i in range(256)] payloads += [rng.randbytes(k) for k in range(1,65)] max_steps = 0 for payload in payloads: n = pack_bytes(payload) word = encode_scale(n) require(decode_scale(word) == n) terminal, ledger = make_ledger(n) recovered = reverse_ledger(terminal, ledger) require(unpack_bytes(decode_scale(encode_scale(recovered))) == payload) max_steps = max(max_steps, len(ledger)) for length in range(9): for number in range(1 << length): bits = format(number, f'0{length}b') if length else '' require(unpack_bits(pack_bits(bits)) == bits) rejects(unpack_bytes, 2) rejects(encode_scale, True) corrupted = list(encode_scale(123)); corrupted[0] += 1 rejects(decode_scale, tuple(corrupted)) return f'{len(payloads)} payload pipelines; 511 bitstrings; longest ledger {max_steps}' def check_relations_and_logic(): formulas = [ ('forall','x',('exists','y',('R','x','y'))), ('exists','x',('R','x','x')), ('forall','x',('forall','y',('and',('not',('and',('R','x','y'), ('not',('R','y','x')))),))), ('exists','x',('forall','y',('not',('=','x','y')))), ] for mask in range(512): edges = {(i,j) for i in range(3) for j in range(3) if mask & (1 << (3*i+j))} code = encode_graph(3, edges) size, restored = decode_graph(code) require(size == 3 and restored == edges) original_domain = tuple(range(3)) geometric_domain = tuple(encode_scale(i+1) for i in range(3)) original_R = lambda i,j: (i,j) in edges geometric_R = lambda a,b: (decode_scale(a)-1,decode_scale(b)-1) in restored for formula in formulas: require(eval_formula(formula, original_domain, original_R) == eval_formula(formula, geometric_domain, geometric_R)) return '512 labeled directed graphs; all 9 relation entries; 2048 formula comparisons' def check_affine_correction(): marks = auxiliary_marks() offset, scale = Golden(F(7, 3)), Golden(F(5, 2)) word = tuple(offset+scale*x for x in marks) patterns = 0 for erased_count in range(5): for erased in combinations(range(6), erased_count): available = [i for i in range(6) if i not in erased] for error_count in range((4-erased_count)//2+1): for errors in combinations(available, error_count): received = list(word) for i in erased: received[i] = None for i in errors: received[i] += Golden(17+i) require(decode_affine(received,error_count) == (offset,scale)) patterns += 1 # Tightness example: 3 changes can lie within 2 changes of another word. other_offset, other_scale = -marks[0], Golden(2) original = tuple(marks) other = tuple(other_offset+other_scale*x for x in marks) require(original[0] == other[0]) received = list(original) for i in (1,2,3): received[i] = other[i] require(decode_affine(received,2) == (other_offset,other_scale)) return f'{patterns} admissible error/erasure patterns; one beyond-bound ambiguity' def check_ledgers(): max_extinction = 0 factor = gcd(Q,S) period = S//factor inverse = pow(Q//factor,-1,period) for seed in range(32768): terminal, ledger = make_ledger(seed,23) require(terminal == 0) require(reverse_ledger(terminal,ledger,23) == seed) first = (Q*seed)%S require(((first//factor)*inverse)%period == seed) _, short = make_ledger(seed) max_extinction = max(max_extinction,len(short)) terminal, ledger = make_ledger(399,23) bad = list(ledger); bad[0] += 1 rejects(reverse_ledger,terminal,tuple(bad),23) rejects(reverse_ledger,terminal,ledger[:-1],23) rejects(reverse_ledger,terminal,(S,)) rejects(reverse_ledger,-1,ledger) rejects(reverse_ledger,0,(1,)) return f'32768 seed reversals and first-residue inversions; extinction <= {max_extinction}' def check_fibers(): lengths = set() for y in range(1000): lower = ceil_div(S*y,Q) upper = ceil_div(S*(y+1),Q) lengths.add(upper-lower) for index,d in enumerate(range(lower,upper)): require((Q*d)//S == y) require(lower+index == d) require(index < 4) require(lengths == {2,3}) require(ceil_div(S,Q) == 3) return '1000 quotient fibers; sizes 2 or 3; two-bit conditional index sufficient' def check_telescoping(): for n in range(1,24): ds = [Poly.var(f'd{i}') for i in range(n+1)] rhos = [Q*ds[i]-S*ds[i+1] for i in range(n)] rhs = S**n*ds[n]+sum((rhos[i]*S**i*Q**(n-1-i) for i in range(n)),Poly()) require(Q**n*ds[0] == rhs) return '23 free-state polynomial telescoping identities; general induction in note' def check_boolean_lift(): for b,c in product((0,1),repeat=2): require(1-b == int(not b)) require(b*c == (b & c)) require(b+c-2*b*c == (b ^ c)) for target in (0,1): lifted = (b,c,target ^ (b & c)) recovered = (lifted[0],lifted[1],lifted[2] ^ (lifted[0] & lifted[1])) require(recovered == (b,c,target)) return 'all Boolean input pairs and eight reversible lifted states' def check_normalized_powers(): normalize = lambda v: tuple(x/sum(v) for x in v) power = lambda p,r: normalize(tuple(x**r for x in p)) vectors = [(F(1),F(2),F(3),F(4),F(5),F(6)), (F(1,7),F(2,9),F(3,11),F(4,13),F(5,17),F(6,19))] count = 0 for vector in vectors: p = normalize(vector) for r,t in product((1,2,3,5), repeat=2): require(power(power(p,t),r) == power(p,r*t)) require(power(p,r) == normalize(tuple(x**r for x in vector))) count += 1 return f'{count} exact positive-rational power-law instances; real-parameter proof in note' def check_dimension_obstruction(): a,b,c,d = map(Poly.var,('j1','j2','k1','k2')) require((a*c)*(b*d)-(a*d)*(b*c) == 0) require(Poly(1) != 0) return 'rank-one Jacobian product has determinant zero; cannot equal the 2D identity' def check_constants(): lp,up,lc,uc,ll,ul = constant_bounds() require(lp < up and lc < uc and 0 < ll < ul < F(1,2)) require(F(Q,S) < ll and ul < F(Q+1,S)) require(up-lp < F(1,10**99)) # Rational tangent check supporting Machin's formula; branch argument in note. t4 = F(120,119) require((t4-F(1,239))/(1+t4*F(1,239)) == 1) return 'rational sqrt/atan enclosures certify Q/S < lambda < (Q+1)/S' def check_numerical_charts(): lp,up,lc,uc,_,_ = constant_bounds() dec = lambda q: D(q.numerator)/D(q.denominator) with localcontext() as ctx: ctx.prec = 120 phi = (D(1)+D(5).sqrt())/2 pi_d = dec((lc+uc)/2) beta = phi/(phi+pi_d) theta = pi_d/D(1296000) term, ss, k = theta, theta, 1 while abs(term) > D('1e-115'): term *= -(theta*theta)/D((2*k)*(2*k+1)) ss += term k += 1 z = (-(ss+phi+1),-(ss+1),-ss,ss,ss+1,ss+phi+1) exps = tuple((beta*x).exp() for x in z) probabilities = tuple(x/sum(exps) for x in exps) logs = tuple(x.ln() for x in probabilities) mean = sum(logs)/6 recovered = tuple((x-mean)/beta for x in logs) require(max(abs(x-y) for x,y in zip(z,recovered)) < D('1e-100')) p2 = tuple(x*x/sum(y*y for y in probabilities) for x in probabilities) e2 = tuple((2*beta*x).exp() for x in z) q2 = tuple(x/sum(e2) for x in e2) require(max(abs(x-y) for x,y in zip(p2,q2)) < D('1e-100')) # Full complex DFT, retaining phase. z = [-3.,-2.,-1.,1.,2.,3.] c0 = __import__('math').cos(pi/1296000) transform = lambda v: tuple(sum(x*cmath.exp(-2j*pi*j*k/6) for j,x in enumerate(v)) for k in range(6)) W = transform([complex(c0,x) for x in z]) inverse = tuple(sum(W[k]*cmath.exp(2j*pi*j*k/6) for k in range(6))/6 for j in range(6)) require(max(abs(x.imag-y) for x,y in zip(inverse,z)) < 1e-12) minus = transform([complex(c0,-x) for x in z]) require(max(abs(abs(x)-abs(y)) for x,y in zip(W,minus)) < 1e-12) require(any(abs(x-y) > 1 for x,y in zip(W,minus))) return '120-digit Decimal charts and binary64 DFT samples; numerical evidence only' def main(): checks = [check_field,check_symbolic_geometry,check_planar_measurements, check_reflection_obstruction,check_metric_profiles,check_joint_gram_data, check_graph_distances,check_temporal_observability,check_finite_payloads, check_relations_and_logic,check_affine_correction,check_ledgers, check_fibers,check_telescoping,check_boolean_lift, check_normalized_powers,check_dimension_obstruction, check_constants,check_numerical_charts] print('OMEGA REFERENCE CHECKER 1.0') print('Python '+platform.python_version()+'; standard library only') for function in checks: print('PASS '+function.__name__+': '+function()) print(f'TOTAL {len(checks)} GROUPS PASS') print('SOURCE SHA256 '+sha256(Path(__file__).read_bytes()).hexdigest()) if __name__ == '__main__': main()