File size: 7,672 Bytes
1263695 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | #!/usr/bin/env python3
"""Finite exact audits for the scalar strengthening and matching approximation."""
from fractions import Fraction as F
from itertools import permutations,product
from pathlib import Path
import json,random
from scalar_ordering import (build_scalar_reduction,endpoint,raw_residual,
interpolate_consecutive,determinant_mod,coefficient_oracle,next_prime,
approximate_scalar_order,degree_bound)
CHECKS={}
def check(condition,label):
if not condition:raise AssertionError(label)
CHECKS[label]=CHECKS.get(label,0)+1
def scalar_case(values,rho):
m=build_scalar_reduction(values,rho)
n,N=m['n'],m['N']
check(all(abs(t)<F(1,2) for t in m['centers']),'scalar_bounded_centers')
sums=[]
for mask in range(1<<N):
sums.append(sum(m['weights'][i] for i in range(N) if mask>>i&1))
check(len(set(sums))==len(sums),'rational_subset_weight_injectivity')
min_abs=None;zeros=0;canonical_count=0;count=0
selected=[]
for order in permutations(range(N)):
count+=1
digits=[0]*n
positions=[[] for _ in range(n)]
for p,j in enumerate(order):
digits[j//2]+=m['weights'][p]
positions[j//2].append(p)
control=sum(a*b for a,b in zip(m['markers'],digits))
canonical=all(pos==[2*i,2*i+1] for i,pos in enumerate(positions))
required=m['target']//m['Q']
check((control==required)==canonical,'marker_control_equivalence')
res=raw_residual(m,order)
perturbation=sum(m['weights'][p]*(m['data'][j//2] if j%2==0 else -m['data'][j//2]) for p,j in enumerate(order))
check(abs(perturbation)<=m['D'],'data_term_dominance_bound')
if not canonical:
check(abs(res)>=m['Q']-m['D'],'noncanonical_integer_separation')
else:
canonical_count+=1
signs=[]
for i in range(n):
signs.append(1 if order[2*i+1]%2==0 else -1)
check(res==m['H']*sum(s*a for s,a in zip(signs,values)),'canonical_scalar_partition_identity')
zeros+=res==0
min_abs=abs(res) if min_abs is None else min(min_abs,abs(res))
if count%max(1,(__import__('math').factorial(N)//24))==0:selected.append(order)
# Add all canonical orientations so perturbation checks include actual
# zero-error YES witnesses, rather than only generic sampled orders.
for signs in product([-1,1],repeat=n):
order=[]
for i,sign in enumerate(signs):
order.extend([2*i+1,2*i] if sign==1 else [2*i,2*i+1])
selected.append(tuple(order))
expected=any(sum(s*a for s,a in zip(signs,values))==0 for signs in product([-1,1],repeat=n))
check((zeros>0)==expected,'scalar_partition_decision_equivalence')
for order in selected:
state=F(0)
for j in order:
state=rho*state+(1-rho)*m['centers'][j]
check(abs(state)<F(1,2),'scalar_all_checked_prefixes_bounded')
check(state==F(raw_residual(m,order),rho.denominator**(N-1)*m['R']),'scalar_recurrence_integer_identity')
# A uniform center perturbation realizes a near-worst-case total shift.
eta=m['gap']/4
perturbed=[t+eta for t in m['centers']]
actual=endpoint(perturbed,order,rho)
check(abs(actual-state)<=eta,'scalar_perturbation_lipschitz_bound')
if state==0:
check(actual*actual<=m['gap']**2/16,'robust_yes_margin')
else:
check(actual*actual>=9*m['gap']**2/16,'robust_no_margin')
return dict(values=values,rho=str(rho),orders=count,canonical_orders=canonical_count,
zero_orders=zeros,partition_exists=expected,minimum_absolute_integer_residual=str(min_abs),
centers=[str(t) for t in m['centers']],normalizer=str(m['R']),
guaranteed_endpoint_gap=str(m['gap']),maximum_center_encoding_bits=max(max(abs(t.numerator).bit_length(),t.denominator.bit_length()) for t in m['centers']))
def matching_audits():
rng=random.Random(93811)
interpolation=[]
for degree in range(13):
p=next_prime(1000+degree)
coefficients=[rng.randrange(p) for _ in range(degree+1)]
values=[sum(c*pow(x,j,p) for j,c in enumerate(coefficients))%p for x in range(degree+1)]
check(interpolate_consecutive(values,p)==coefficients,'finite_field_interpolation')
for n in range(1,5):
for trial in range(6):
costs=[[None if rng.randrange(8)==0 else rng.randrange(5) for _ in range(n)] for _ in range(n)]
attainable={sum(costs[i][j] for i,j in enumerate(order)) for order in permutations(range(n)) if all(costs[i][j] is not None for i,j in enumerate(order))}
p=next_prime(8*n**3*(degree_bound(costs)+1)+1)
observed=coefficient_oracle(costs,p,rng)
check(observed<=attainable,'matching_oracle_no_false_positives')
# The fixed seed is an implementation audit, not a proof that
# every random labeling succeeds.
check(observed==attainable,'matching_oracle_observed_full_support')
# Equal edge labels can erase all genuine matchings by cancellation.
check(determinant_mod([[1,1],[1,1]],101)==0,'determinant_cancellation_witness')
return dict(interpolation_degrees_tested=13,matching_instances=24)
def approximate_audits():
configurations=[
([F(-1),F(0),F(1)],F(1,2),F(0),F(0),F(1,2)),
([F(-1,2),F(1,4),F(3,4)],F(2,3),F(1,4),F(-1,4),F(1,2)),
([F(-3,4),F(-1,4),F(1,4),F(3,4)],F(1,2),F(0),F(0),F(1,2)),
([F(-1),F(1,3),F(2,3),F(1)],F(9,10),F(-1,2),F(1,2),F(1,2)),
([F(-1,2),F(1,2),F(3,4)],F(1,3),F(1),F(-1),F(1,4)),
([F(0),F(0),F(0)],F(1,2),F(0),F(0),F(1,2))]
results=[]
for i,(centers,rho,initial,target,eps) in enumerate(configurations):
optimum=min((endpoint(centers,order,rho,initial)-target)**2 for order in permutations(range(len(centers))))
out=approximate_scalar_order(centers,rho,eps,F(1,16),initial,target,random.Random(451+i))
check(sorted(out['order'])==list(range(len(centers))),'approximation_feasible_permutation')
check(out['objective']==(endpoint(centers,out['order'],rho,initial)-target)**2,'approximation_exact_output_certificate')
check(out['objective']<=optimum+eps,'observed_additive_approximation_guarantee')
check(out['statistics']['degree']<=32*len(centers)/eps+len(centers),'rounded_degree_bound')
results.append(dict(centers=list(map(str,centers)),rho=str(rho),initial=str(initial),target=str(target),epsilon=str(eps),order=out['order'],objective=str(out['objective']),exact_optimum=str(optimum),statistics=out['statistics']))
return results
def main():
cases=[(v,rho) for rho in [F(1,2),F(1,3),F(2,3),F(9,10)] for v in [[1,2,3],[1,1,3]]]
cases.extend([(v,F(1,2)) for v in [[1,2,3,4],[1,2,4,8]]])
result=dict(arithmetic='Exact integers, rational fractions, and exact finite-field arithmetic; no floating-point proof decisions.',scalar_cases=[scalar_case(v,rho) for v,rho in cases],matching_audits=matching_audits(),approximation_cases=approximate_audits())
result['assertions']=CHECKS
result['assertions_total']=sum(CHECKS.values())
result['scalar_orders_total']=sum(case['orders'] for case in result['scalar_cases'])
result['baseline_assertions_retained']=344707
result['combined_assertions']=344707+result['assertions_total']
Path(__file__).with_name('broadening_verification_results.json').write_text(json.dumps(result,indent=2)+'\n')
print(json.dumps({key:result[key] for key in ['assertions_total','scalar_orders_total','baseline_assertions_retained','combined_assertions']},indent=2))
if __name__=='__main__':main()
|