| |
| """Finite exact audits for observable-rank compression and robust quotients. |
| |
| Permutation enumeration occurs only in this verifier. It independently checks |
| small objectives and certificates; it is not the polynomial matching algorithm. |
| """ |
| from fractions import Fraction as F |
| from itertools import permutations |
| from pathlib import Path |
| import json |
| from observable_certificates import (dot,matvec,matmul,subtract,determinant, |
| is_psd,operator_norm_bound,norm_bound,compress_assignment, |
| compressed_objective,assignment_residual,rounded_encoding,rounded_residual, |
| decode_cost,execute,quotient_certificate) |
|
|
| COUNTS={} |
|
|
| def check(condition,label): |
| if not condition:raise AssertionError(label) |
| COUNTS[label]=COUNTS.get(label,0)+1 |
|
|
|
|
| def vector_sum(*vs): |
| return [sum(xs,F(0)) for xs in zip(*vs)] |
|
|
|
|
| def assignment_case(name,points,basis,weights,a,epsilon=F(1,3)): |
| edges=[[[w*sum(q*b[j] for q,b in zip(point,basis)) for j in range(len(a))] |
| for point in points] for w in weights] |
| model=compress_assignment(a,edges) |
| encoding=rounded_encoding(model,epsilon) |
| r=model['rank'];n=len(points) |
| for p in range(n): |
| for i in range(n): |
| reconstructed=vector_sum(edges[p][0],*[ [c*x for x in b] |
| for c,b in zip(model['coordinates'][p][i],model['basis'])]) |
| check(reconstructed==edges[p][i],'edge_reconstruction') |
| check(all(abs(c)<=1 for c in model['coordinates'][p][i]),'bounded_basis_coordinates') |
| values=[] |
| for order in permutations(range(n)): |
| actual=assignment_residual(a,edges,order) |
| true_value=dot(actual,actual) |
| check(true_value<=4,'true_residual_promise') |
| check(compressed_objective(model,order)==true_value,'compressed_objective_identity') |
| rounded=rounded_residual(model,encoding,order) |
| error=[x-y for x,y in zip(actual,rounded)] |
| check(dot(error,error)<(epsilon/16)**2,'uniform_rounding_margin') |
| if r: |
| code=sum(encoding['costs'][p][i] for p,i in enumerate(order)) |
| digits=decode_cost(code,encoding['base'],r) |
| vector_cost=[sum(encoding['vector_costs'][p][i][j] |
| for p,i in enumerate(order)) for j in range(r)] |
| check(digits==vector_cost,'carry_free_encoding') |
| check(code<=encoding['degree'],'encoded_degree_bound') |
| values.append((true_value,dot(rounded,rounded),order)) |
| optimum=min(v[0] for v in values) |
| rounded_optimum=min(v[1] for v in values) |
| for true_value,rounded_value,order in values: |
| if rounded_value==rounded_optimum: |
| check(true_value<=optimum+epsilon,'rounded_optimizer_additive_guarantee') |
| return dict(name=name,size=n,ambient_dimension=len(a),variation_rank=r, |
| maximum_gram_determinant=str(model['maximum_gram_determinant']), |
| maximum_coordinate=str(max((abs(c) for row in model['coordinates'] for cs in row for c in cs),default=F(0))), |
| rounded_degree=encoding['degree'],orders=len(values), |
| exact_optimum=str(optimum)) |
|
|
|
|
| def matrix_case(name,kappa=F(0),eta=F(0),eta0=F(0)): |
| n=4;d=7 |
| readout=[[F(1)]+[F(0)]*(d-1)] |
| rho=F(3,4);response=[[F(1,2)]] |
| matrices=[] |
| for i in range(n): |
| m=[[F(0) for _ in range(d)] for _ in range(d)] |
| m[0][0]=F(1,2) |
| for j in range(1,d):m[j][j]=F(1,8) |
| if i%2==0:m[1][2]=F(1,8) |
| else:m[2][1]=F(1,8) |
| m[0][1]=kappa*(1 if i%2==0 else -1) |
| matrices.append(m) |
| increments=[[F(1,8)*(1 if i%2==0 else -1)]+[F(0)]*(d-1) for i in range(n)] |
| ci=[[b[0]+eta*(1 if i<2 else -1)] for i,b in enumerate(increments)] |
| initial=[F(1,8),F(1,4),F(1,8)]+[F(0)]*(d-3) |
| u0=[initial[0]+eta0];target=[F(1,16)] |
| certificate=quotient_certificate(matrices,increments,response,ci,readout, |
| initial,u0,target,rho,kappa,eta,eta0) |
| check(any(x for row in subtract(matmul(matrices[0],matrices[1]), |
| matmul(matrices[1],matrices[0])) for x in row), |
| 'hidden_noncommutativity') |
| q=certificate['terminal_mismatch'];records=[];largest_error=F(0) |
| for order in permutations(range(n)): |
| x=execute(matrices,increments,initial,order) |
| u=execute([response]*n,ci,u0,order) |
| observed=matvec(readout,x) |
| error=[a-b for a,b in zip(observed,u)] |
| error_squared=dot(error,error) |
| largest_error=max(largest_error,error_squared) |
| check(error_squared<=q*q,'quotient_uniform_endpoint_bound') |
| check(norm_bound(x,1) and norm_bound(u,1),'invariant_unit_balls') |
| true_value=sum((a-b)**2 for a,b in zip(observed,target)) |
| surrogate_value=sum((a-b)**2 for a,b in zip(u,target)) |
| check(abs(true_value-surrogate_value)<=certificate['objective_mismatch'], |
| 'quotient_uniform_objective_bound') |
| if not q:check(observed==u,'exact_observable_closure') |
| records.append((true_value,surrogate_value,order)) |
| true_optimum=min(v[0] for v in records) |
| surrogate_optimum=min(v[1] for v in records) |
| epsilon=F(1,1000) |
| for actual,surrogate,order in records: |
| if surrogate<=surrogate_optimum+epsilon: |
| check(actual<=true_optimum+epsilon+certificate['regret_transfer'], |
| 'quotient_transfer_regret') |
| |
| for p in range(1,n+1): |
| bound=rho**p*eta0+(kappa+eta)*(1-rho**p)/(1-rho) |
| previous=eta0 if p==1 else rho**(p-1)*eta0+(kappa+eta)*(1-rho**(p-1))/(1-rho) |
| check(bound==rho*previous+kappa+eta,'certificate_recurrence_identity') |
| return dict(name=name,orders=len(records),hidden_dimension=d,observed_dimension=1, |
| response_defect=str(kappa),increment_defect=str(eta),initial_defect=str(eta0), |
| terminal_mismatch_bound=str(q),maximum_endpoint_error_squared=str(largest_error), |
| true_optimum=str(true_optimum),surrogate_optimum=str(surrogate_optimum)) |
|
|
|
|
| def main(): |
| |
| checks=[([[0,0],[0,0]],True),([[1,0],[0,0]],True),([[0,1],[1,0]],False), |
| ([[1,2],[2,1]],False),([[1,1],[1,1]],True),([[-1,0],[0,1]],False)] |
| for a,answer in checks:check(is_psd(a)==answer,'exact_psd_classification') |
| check(operator_norm_bound([[F(1,2),0],[0,F(1,3)]],F(1,2)), |
| 'exact_operator_norm_certificate') |
| check(not operator_norm_bound([[F(1,2),F(1,2)]],F(1,2)), |
| 'exact_operator_norm_rejection') |
| basis1=[[F(1,2),0,0,F(1,4),0],[0,F(1,2),0,0,F(1,4)]] |
| points3=[[F(-1,4),F(1,8)],[0,F(-1,4)],[F(1,4),F(1,8)]] |
| cases=[assignment_case('ambient-five-rank-two',points3,basis1,[F(1,8),F(1,4),F(1,2)], |
| [0,0,F(1,8),0,0])] |
| basis2=[[F(1,3)]+[F(0)]*7,[F(0)]*7+[F(1,3)]] |
| points4=points3+[[F(1,8),F(-1,8)]] |
| cases.append(assignment_case('ambient-eight-rank-two',points4,basis2, |
| [F(1,16),F(1,8),F(1,4),F(1,2)],[0,F(1,8),0,0,0,0,0,0])) |
| tiny=F(1,10**50) |
| singular=assignment_case('nearly-singular-exact-rational',points3, |
| [[F(1,4),0,0],[F(1,4),tiny,0]], |
| [F(1,8),F(1,4),F(1,2)],[0,0,F(1,8)]) |
| check(0<F(singular['maximum_gram_determinant'])<F(1,10**100), |
| 'nearly_singular_positive_volume') |
| cases.append(singular) |
| cases.append(assignment_case('zero-variation-rank',[[F(1,4)]]*3, |
| [[F(1,4),0]],[F(1,8),F(1,4),F(1,2)],[0,F(1,8)])) |
| cases.append(assignment_case('ambient-seven-rank-one',[[F(-1,4)],[0],[F(1,4)]], |
| [[F(1,3),0,F(1,4),0,0,0,0]], |
| [F(1,8),F(1,4),F(1,2)],[0,F(1,8),0,0,0,0,0])) |
| quotient_cases=[matrix_case('exact-closure'), |
| matrix_case('response-defect',kappa=F(1,1024)), |
| matrix_case('increment-defect',eta=F(1,2048)), |
| matrix_case('initial-defect',eta0=F(1,4096)), |
| matrix_case('combined-defects',F(1,1024),F(1,2048),F(1,4096))] |
| result=dict(arithmetic='exact Python Fraction, integers, and rational PSD Schur complements', |
| assignment_cases=cases,quotient_cases=quotient_cases, |
| assertions=COUNTS,assertions_total=sum(COUNTS.values()), |
| assignment_orders_total=sum(c['orders'] for c in cases), |
| quotient_orders_total=sum(c['orders'] for c in quotient_cases), |
| scope='Compression, rounding, quotient certificates, and finite exhaustive objective comparisons; no rank-two matching benchmark.') |
| path=Path(__file__).with_name('revision3_observable_results.json') |
| path.write_text(json.dumps(result,indent=2)+'\n') |
| print(json.dumps({k:result[k] for k in ('assertions_total','assignment_orders_total','quotient_orders_total')},indent=2)) |
|
|
| if __name__=='__main__':main() |
|
|
