#!/usr/bin/env python3 """Independent exact-arithmetic checks of constructions and finite certificates. Run: python verify.py These tests validate code and finite instances; they are not a proof assistant formalization of the universal theorems in the manuscript. """ from fractions import Fraction as F from itertools import product from pathlib import Path from collections import Counter import json import random import subprocess import sys import tempfile import time import selection HERE = Path(__file__).resolve().parent COUNTS = Counter() RNG = random.Random(61492026) def sq_distance(a,b): return sum((F(x)-F(y))**2 for x,y in zip(a,b)) def reference_moments(points,weights=None): p = [F(1,len(points))]*len(points) if weights is None else list(map(F,weights)) mu = [sum(w*F(x[j]) for x,w in zip(points,p)) for j in range(len(points[0]))] # Pairwise-distance identity is independent of the selector's central-moment code. var = sum(p[i]*p[j]*sq_distance(points[i],points[j]) for i in range(len(points)) for j in range(i))/1 return mu,var def count_error(points,weights,counts,n): assert all(isinstance(i,int) and 0 <= i < len(points) for i in counts) assert all(isinstance(v,int) and not isinstance(v,bool) and v > 0 for v in counts.values()) assert sum(counts.values()) == n mu,var = reference_moments(points,weights) selected = [sum(v*F(points[i][j]) for i,v in counts.items())/n for j in range(len(mu))] return sq_distance(mu,selected),mu,var,selected def reference_coefficient(rank,n): if rank == 0: return F(0) if n == 1: return F(1) if rank <= 2: return F(1,2*n-1) a = max(F(1,3),F(rank-1,2*rank)) if n <= rank: return (F(n-2)+4*a)/(n*n) b = (F(rank-2)+4*a)/(rank*rank) return rank*b/(n*(1+b)-rank*b) def check_output(points,n): out = selection.select((row for row in points),n) error,mu,var,h = count_error(points,None,out['counts'],n) assert [F(x) for x in out['mean']] == mu assert [F(x) for x in out['selected_mean']] == h assert F(out['variance']) == var assert F(out['squared_mean_error']) == error rank = out['resident_affine_rank'] assert error <= reference_coefficient(rank,n)*var assert F(out['guaranteed_upper_coefficient']) == reference_coefficient(rank,n) assert F(out['full_data_loss_ratio']) == (1+error/var if var else 1) indices = out['compressed_indices'] compressed = [[F(v) for v in row] for row in out['compressed_points']] weights = [F(v) for v in out['compressed_weights']] assert all(w>0 for w in weights) and sum(weights)==1 assert compressed == [list(map(F,points[i])) for i in indices] cm,cv = reference_moments(compressed,weights) assert cm == mu and cv <= var assert cv == F(out['compressed_variance']) assert len(compressed) <= len(points[0])+1 # The chosen output is at least as good as either computed certificate. assert error <= F(out['residual_rounding_bound']) COUNTS['full_dataset_outputs'] += 1 COUNTS['selected_method_'+out['selected_method']] += 1 for entry in out['construction_trace']: COUNTS['trace_'+entry['step']] += 1 return out def independent_rule_optimum(points,n,weights,rules): m=len(points) lower=rules.get('lower',[0]*m) upper=rules.get('upper',[n]*m) best=None feasible=0 states=0 # Cartesian tuples, unlike the implementation's recursive compositions. for counts in product(range(n+1),repeat=m): if sum(counts)!=n: continue states+=1 if any(chi for c,lo,hi in zip(counts,lower,upper)): continue ok=True for row in rules.get('linear',[]): lhs=sum(F(str(a))*c for a,c in zip(row['a'],counts)) rhs=F(str(row['rhs'])) if not {'<=':lhs<=rhs,'>=':lhs>=rhs,'==':lhs==rhs}[row['sense']]: ok=False break if not ok: continue feasible+=1 e,*_=count_error(points,weights,{i:c for i,c in enumerate(counts) if c},n) if best is None or (e,counts)=3 and n>rank: prev=selection.coefficient(rank,n-1) assert c==F(n-1)*prev/(n+prev) COUNTS['coefficient_identities']+=1 for d in range(1,9): for case in range(3): points=[[F(RNG.randint(-9,9),RNG.randint(1,5)) for _ in range(d)] for _ in range(d+5)] for n in sorted({1,2,3,d,d+1,d+4}): check_output(points,n) degenerate=[ [[0]*8 for _ in range(7)], [[F(7,11),-2,3] for _ in range(4)], [[i,2*i+1,-3*i,4*i-2,0,1,2*i,7] for i in range(-3,4)], [[i,j,i+j,2*i-j,0,4,3*i,5*j] for i,j in [(0,0),(1,0),(0,1),(2,-1),(-3,2),(4,4)]], [[2**80+F(i,17),-2**75+F(i*i,29)] for i in range(7)], ] for points in degenerate: for n in (1,2,3,7,23): check_output(points,n) COUNTS['degenerate_or_large_exact_inputs']+=1 # A deliberately hard residual case must use the direct fallback. fallback=[[F(0),F(0)] for _ in range(18)]+[[F(1,10),F(1)],[F(1,10),F(-1)]] result=check_output(fallback,10) assert result['selected_method']=='pair-padding-peeling' assert F(result['squared_mean_error'])==F(1,10000) COUNTS['forced_direct_fallback_cases']+=1 # A billion requested copies must stay compact and avoid proportional loops. result=check_output([[0,0],[1,0],[0,1]],10**9) assert result['selected_method']=='floor-residual-atomic-selection' assert len(result['counts'])<=3 and sum(result['counts'].values())==10**9 COUNTS['billion_budget_compact_fastpath_cases']+=1 for m in range(2,10): for case in range(6): d=min(6,m) points=[[F(RNG.randint(-7,7),RNG.randint(1,4)) for _ in range(d)] for _ in range(m)] raw=[RNG.randint(1,17) for _ in range(m)] if case==0: raw[0]=10**8 if case==1: raw[-1]=0 weights=[F(v,sum(raw)) for v in raw] active=sum(w>0 for w in weights) for n in sorted({1,2,max(3,active-1),active+2}): counts,trace=selection.select_atomic(points,weights,n) error,_,var,_=count_error(points,weights,counts,n) assert error<=reference_coefficient(active-1,n)*var COUNTS['weighted_atomic_outputs']+=1 rcounts,bound=selection.residual_candidate(points,weights,n) re,_,_,_=count_error(points,weights,rcounts,n) assert re<=bound residual=[n*p-int(n*p) for p in weights] k=sum(residual) assert k.denominator==1 and 0<=k<=active-1 if not k: assert re==bound==0 COUNTS['fractional_residual_certificates']+=1 rational_points=[[F(0),F(0)],[F(1,3),F(2,7)],[F(-5,11),F(3,2)]] rational_weights=[F(1,6),F(1,3),F(1,2)] for n in (6,12,24,60,126): counts,bound=selection.residual_candidate(rational_points,rational_weights,n) error,*_=count_error(rational_points,rational_weights,counts,n) assert error==bound==0 COUNTS['exact_denominator_budgets']+=1 for n in range(1,31): points=[[0],[1]] weights=[1-F(1,2*n),F(1,2*n)] counts,_=selection.select_atomic(points,weights,n) error,_,var,_=count_error(points,weights,counts,n) assert error/var==F(1,2*n-1) COUNTS['finite_line_sharpness_budgets']+=1 for case in range(32): m=2+case%4 n=1+case%5 points=[[F(RNG.randint(-4,4),RNG.randint(1,3)) for _ in range(1+case%3)] for _ in range(m)] raw=[RNG.randint(1,8) for _ in range(m)] weights=[F(a,sum(raw)) for a in raw] mode=case%8 if mode==0: rules={} elif mode==1: rules={'upper':[1]*m} elif mode==2: rules={'lower':[1]+[0]*(m-1)} elif mode==3: rules={'linear':[{'a':[i%2 for i in range(m)],'sense':'==','rhs':n//2}]} elif mode==4: rules={'linear':[{'a':[i+1 for i in range(m)],'sense':'<=','rhs':n+2}]} elif mode==5: rules={'linear':[{'a':['1/2']+[0]*(m-1),'sense':'>=','rhs':'1/2'}], 'upper':[2]*m} elif mode==6: rules={'lower':[n+1]+[0]*(m-1)} else: rules={'upper':[n]*(m-1)+[0], 'linear':[{'a':[i-2 for i in range(m)],'sense':'>=','rhs':-n}]} actual=selection.exact_rule_selection(points,n,weights,rules) best,feasible,states=independent_rule_optimum(points,n,weights,rules) assert actual['enumerated_states']==states and actual['feasible_states']==feasible if best is None: assert actual['status']=='INFEASIBLE' COUNTS['infeasible_rule_instances']+=1 else: counts=tuple(actual['counts'].get(i,0) for i in range(m)) assert actual['status']=='OPTIMAL' assert (F(actual['squared_mean_error']),counts)==best COUNTS['optimal_rule_instances']+=1 COUNTS['independent_rule_comparisons']+=1 # Exact rational Gram witness: a^2=5, b^2=9, tetrahedral inner products -1/3. p=[F(2,5)]+[F(3,20)]*4 gram=[[F(0)]*5 for _ in range(5)] for i in range(1,5): for j in range(1,5): gram[i][j]=F(14 if i==j else 2) mean_norm=sum(p[i]*p[j]*gram[i][j] for i in range(5) for j in range(5)) variance=sum(p[i]*gram[i][i] for i in range(5))-mean_norm values=[] for counts in product(range(4),repeat=5): if sum(counts)!=3: continue delta=[F(c,3)-w for c,w in zip(counts,p)] error=sum(delta[i]*delta[j]*gram[i][j] for i in range(5) for j in range(5)) values.append(error) assert variance==F(33,5) and min(values)==F(61,45) assert min(values)/variance==F(61,297)>F(1,5) COUNTS['exact_rare_simplex_gram_witnesses']+=1 tetra=[[0,0,0,0],[4,3,3,3],[4,3,-3,-3],[4,-3,3,-3],[4,-3,-3,3]] best,_,_=independent_rule_optimum(tetra,3,p,{}) assert best[0]==F(916,225) assert reference_moments(tetra,p)[1]==F(501,25) assert best[0]/F(501,25)==F(916,4509)>F(1,5) finite=tetra[:1]*8+sum(([row]*3 for row in tetra[1:]),[]) check_output(finite,3) COUNTS['rational_coordinate_rare_simplex_witnesses']+=1 # Exact polynomial check that B_(4,n) exceeds 1/(2n-1). for n in range(2,101): k=4 a=2*n*(k-2)-(k-3) delta=(k-3)*(2*n*(n-2)*(k-2)+(k-3)) c=F(1,2*n-1) assert c0 COUNTS['dimension_four_strict_separation_checks']+=1 with tempfile.TemporaryDirectory() as directory: inp=Path(directory)/'input.json' inp.write_text('{"points":[[0.1000000000000000000000001,0.2],[0.3,-0.4],[0.5,0.6]],"n":7}') completed=subprocess.run([sys.executable,str(HERE/'selection.py'),str(inp)], check=True,text=True,capture_output=True) out=json.loads(completed.stdout) assert F(out['mean'][0])==F('0.9000000000000000000000001')/3 COUNTS['exact_decimal_cli_checks']+=1 inp.write_text('{"points":[[0],[1],[2]],"weights":["1/2","1/3","1/6"],"n":3,"rules":{"upper":[1,1,1]}}') completed=subprocess.run([sys.executable,str(HERE/'selection.py'),str(inp),'--exact'], check=True,text=True,capture_output=True) out=json.loads(completed.stdout) assert out['status']=='OPTIMAL' and out['counts']=={'0':1,'1':1,'2':1} COUNTS['weighted_constrained_cli_checks']+=1 bad_calls=[ lambda:selection.select([],2), lambda:selection.select([[1],[2,3]],2), lambda:selection.select([[0],[1]],True), lambda:selection.select([[0],[1]],0), lambda:selection.select_atomic([[0],[1]],[F(1,3),F(1,3)],2), lambda:selection.select_atomic([[0],[1]],[F(-1),F(2)],2), lambda:selection.exact_rule_selection([[0],[1]],3,rules={'linear':[{'a':[1,2],'sense':'!=','rhs':0}]}), lambda:selection.exact_rule_selection([[0],[1],[2]],20,max_states=5), ] for call in bad_calls: try: call() except ValueError: COUNTS['invalid_input_rejections']+=1 else: raise AssertionError('Invalid input was accepted') result={'status':'PASS','arithmetic':'fractions.Fraction; exact comparisons', 'seed':61492026,'counts':dict(sorted(COUNTS.items())), 'wall_seconds':round(time.monotonic()-started,3), 'independence':'Original-data variance uses pairwise distances; rule oracle uses Cartesian count tuples; rare-simplex certificate uses a rational Gram matrix.', 'scope':'Implementation and finite certificates only; universal claims rely on the manuscript proofs. No claim of proof-assistant formalization.'} (HERE/'verification_results.json').write_text(json.dumps(result,indent=2)+'\n') print(json.dumps(result,indent=2)) if __name__=='__main__': main()