| |
| """Exact rational certificates for observable rank and quotient guarantees. |
| |
| This module implements the constructive algebraic parts of the observable-rank |
| proof and the norm/mismatch certificates. The maximum-volume basis enumerates |
| rank-sized subsets: its running time is polynomial for FIXED variation rank. |
| The multivariate matching optimizer is specified in the manuscript; this module |
| does not replace it by a permutation enumeration or claim to implement it. |
| """ |
| from fractions import Fraction as F |
| from itertools import combinations |
|
|
|
|
| def dot(a,b): |
| return sum((F(x)*F(y) for x,y in zip(a,b)),F(0)) |
|
|
|
|
| def matvec(a,x): |
| return [dot(row,x) for row in a] |
|
|
|
|
| def transpose(a): |
| return [list(row) for row in zip(*a)] |
|
|
|
|
| def matmul(a,b): |
| bt=transpose(b) |
| return [[dot(row,col) for col in bt] for row in a] |
|
|
|
|
| def subtract(a,b): |
| return [[F(x)-F(y) for x,y in zip(ra,rb)] for ra,rb in zip(a,b)] |
|
|
|
|
| def determinant(a): |
| a=[[F(x) for x in row] for row in a] |
| n=len(a); value=F(1) |
| for i in range(n): |
| pivot=next((j for j in range(i,n) if a[j][i]),None) |
| if pivot is None:return F(0) |
| if pivot!=i: |
| a[i],a[pivot]=a[pivot],a[i];value=-value |
| d=a[i][i];value*=d |
| for j in range(i+1,n): |
| f=a[j][i]/d |
| for k in range(i+1,n):a[j][k]-=f*a[i][k] |
| a[j][i]=F(0) |
| return value |
|
|
|
|
| def solve(a,b): |
| n=len(a) |
| if not n:return [] |
| a=[[F(x) for x in row]+[F(v)] for row,v in zip(a,b)] |
| for i in range(n): |
| pivot=next((j for j in range(i,n) if a[j][i]),None) |
| if pivot is None:raise ValueError('singular linear system') |
| a[i],a[pivot]=a[pivot],a[i] |
| d=a[i][i];a[i]=[x/d for x in a[i]] |
| for j in range(n): |
| if j==i:continue |
| f=a[j][i] |
| a[j]=[x-f*y for x,y in zip(a[j],a[i])] |
| return [row[-1] for row in a] |
|
|
|
|
| def gram(vectors): |
| return [[dot(x,y) for y in vectors] for x in vectors] |
|
|
|
|
| def is_psd(a): |
| """Exact PSD test by symmetric positive-pivot Schur complements.""" |
| a=[[F(x) for x in row] for row in a] |
| n=len(a) |
| if any(len(row)!=n for row in a):return False |
| if any(a[i][j]!=a[j][i] for i in range(n) for j in range(n)): |
| return False |
| while a: |
| n=len(a) |
| if any(a[i][i]<0 for i in range(n)):return False |
| pivot=next((i for i in range(n) if a[i][i]>0),None) |
| if pivot is None:return all(not x for row in a for x in row) |
| order=[pivot]+[i for i in range(n) if i!=pivot] |
| a=[[a[i][j] for j in order] for i in order] |
| d=a[0][0] |
| a=[[a[i][j]-a[i][0]*a[0][j]/d |
| for j in range(1,n)] for i in range(1,n)] |
| return True |
|
|
|
|
| def norm_bound(x,bound): |
| bound=F(bound) |
| return bound>=0 and dot(x,x)<=bound*bound |
|
|
|
|
| def operator_norm_bound(a,bound): |
| bound=F(bound) |
| if bound<0 or not a:return False |
| n=len(a[0]) |
| if any(len(row)!=n for row in a):return False |
| ata=matmul(transpose(a),a) |
| residual=[[bound*bound*(i==j)-ata[i][j] |
| for j in range(n)] for i in range(n)] |
| return is_psd(residual) |
|
|
|
|
| def maximum_gram_basis(vectors): |
| """Return a rational maximum-Gram-volume basis and all coordinates.""" |
| vectors=[[F(x) for x in v] for v in vectors] |
| if not vectors:raise ValueError('nonempty vector list required') |
| m=len(vectors[0]) |
| if any(len(v)!=m for v in vectors):raise ValueError('dimension mismatch') |
| independent=[] |
| for v in vectors: |
| if determinant(gram(independent+[v]))>0:independent.append(v) |
| r=len(independent) |
| if not r:return dict(rank=0,basis=[],coordinates=[[] for _ in vectors], |
| gram=[],maximum_gram_determinant=F(1)) |
| candidates=list(dict.fromkeys(tuple(v) for v in vectors if any(v))) |
| best=None;bestdet=F(-1) |
| for choice in combinations(candidates,r): |
| value=determinant(gram(choice)) |
| if value>bestdet:best=list(choice);bestdet=value |
| g=gram(best) |
| coordinates=[solve(g,[dot(b,v) for b in best]) for v in vectors] |
| assert all(abs(x)<=1 for c in coordinates for x in c) |
| return dict(rank=r,basis=[list(b) for b in best],coordinates=coordinates, |
| gram=g,maximum_gram_determinant=bestdet) |
|
|
|
|
| def compress_assignment(a,edges): |
| """Compress observed edge variations; preserve exact squared objectives.""" |
| a=[F(x) for x in a];n=len(edges);m=len(a) |
| if not n or any(len(row)!=n for row in edges): |
| raise ValueError('edges must be a nonempty square array of vectors') |
| edges=[[[F(x) for x in v] for v in row] for row in edges] |
| if any(len(v)!=m for row in edges for v in row): |
| raise ValueError('vector dimension mismatch') |
| if any(not norm_bound(v,1) for row in edges for v in row): |
| raise ValueError('the theorem requires edge-vector norms at most one') |
| reference=[row[0] for row in edges] |
| variations=[[x-y for x,y in zip(v,reference[p])] |
| for p,row in enumerate(edges) for v in row] |
| result=maximum_gram_basis(variations) |
| constant=[a[j]+sum(reference[p][j] for p in range(n)) for j in range(m)] |
| flat=result.pop('coordinates') |
| coordinates=[flat[p*n:(p+1)*n] for p in range(n)] |
| result.update(size=n,ambient_dimension=m,constant=constant, |
| coordinates=coordinates, |
| constant_squared=dot(constant,constant), |
| cross=[dot(b,constant) for b in result['basis']]) |
| return result |
|
|
|
|
| def compressed_objective(model,order): |
| r=model['rank'] |
| total=[sum(model['coordinates'][p][i][j] for p,i in enumerate(order)) |
| for j in range(r)] |
| return (model['constant_squared']+2*dot(model['cross'],total) |
| +dot(total,matvec(model['gram'],total))) |
|
|
|
|
| def assignment_residual(a,edges,order): |
| return [F(x)+sum(F(edges[p][i][j]) for p,i in enumerate(order)) |
| for j,x in enumerate(a)] |
|
|
|
|
| def rounded_encoding(model,epsilon): |
| """Carry-free scalar costs for the matching primitive in the proof.""" |
| epsilon=F(epsilon);n=model['size'];r=model['rank'] |
| if not 0<epsilon<=1:raise ValueError('epsilon must be in (0,1]') |
| if not r:return dict(rank=0,delta=F(0),base=1,costs=[[0]*n for _ in range(n)], |
| minima=[],vector_costs=[[[] for _ in range(n)] for _ in range(n)], |
| degree=0,coordinate_degree=[]) |
| delta=epsilon/(32*r*n) |
| rounded=[[[int(F(x)//delta) for x in coord] for coord in row] |
| for row in model['coordinates']] |
| minima=[[min(rounded[p][i][j] for i in range(n)) for j in range(r)] |
| for p in range(n)] |
| costs=[[[rounded[p][i][j]-minima[p][j] for j in range(r)] |
| for i in range(n)] for p in range(n)] |
| degrees=[sum(max(costs[p][i][j] for i in range(n)) for p in range(n)) |
| for j in range(r)] |
| base=max(degrees)+1 |
| encoded=[[sum(costs[p][i][j]*base**j for j in range(r)) |
| for i in range(n)] for p in range(n)] |
| return dict(rank=r,delta=delta,base=base,costs=encoded, |
| minima=[sum(row[j] for row in minima) for j in range(r)], |
| vector_costs=costs,degree=sum(max(row) for row in encoded), |
| coordinate_degree=degrees) |
|
|
|
|
| def decode_cost(value,base,rank): |
| digits=[] |
| for _ in range(rank): |
| digits.append(value%base);value//=base |
| if value:raise ValueError('encoded total exceeds supplied rank') |
| return digits |
|
|
|
|
| def rounded_residual(model,encoding,order): |
| r=model['rank'];out=model['constant'][:] |
| if not r:return out |
| q=sum(encoding['costs'][p][i] for p,i in enumerate(order)) |
| digits=decode_cost(q,encoding['base'],r) |
| coordinates=[encoding['delta']*(x+y) |
| for x,y in zip(encoding['minima'],digits)] |
| for j,b in enumerate(model['basis']): |
| out=[x+coordinates[j]*y for x,y in zip(out,b)] |
| return out |
|
|
|
|
| def execute(matrices,increments,initial,order): |
| x=[F(v) for v in initial] |
| for i in order: |
| x=[u+F(v) for u,v in zip(matvec(matrices[i],x),increments[i])] |
| return x |
|
|
|
|
| def quotient_certificate(matrices,increments,response,quotient_increments, |
| readout,initial,quotient_initial,target,rho, |
| kappa=F(0),eta=F(0),eta0=F(0)): |
| """Validate supplied rational bounds and return the uniform certificate. |
| |
| q_N bounds every observation mismatch. 4*q_N bounds objective mismatch; |
| eps+8*q_N bounds true regret after eps-additive quotient optimization. |
| """ |
| rho=F(rho);kappa=F(kappa);eta=F(eta);eta0=F(eta0) |
| n=len(matrices) |
| if not n or not 0<=rho<1 or min(kappa,eta,eta0)<0: |
| raise ValueError('invalid contraction or mismatch constants') |
| if len(increments)!=n or len(quotient_increments)!=n: |
| raise ValueError('request count mismatch') |
| d=len(initial);r=len(quotient_initial) |
| if len(target)!=r or len(readout)!=r or any(len(row)!=d for row in readout): |
| raise ValueError('readout dimension mismatch') |
| if len(response)!=r or any(len(row)!=r for row in response): |
| raise ValueError('quotient response dimension mismatch') |
| if any(len(m)!=d or any(len(row)!=d for row in m) for m in matrices): |
| raise ValueError('hidden response dimension mismatch') |
| if any(len(b)!=d for b in increments) or any(len(c)!=r for c in quotient_increments): |
| raise ValueError('increment dimension mismatch') |
| if not operator_norm_bound(readout,1) or not operator_norm_bound(response,rho): |
| raise ValueError('readout or quotient norm bound failed') |
| if not all(norm_bound(x,1) for x in (initial,quotient_initial,target)): |
| raise ValueError('initial-state or target norm bound failed') |
| ac=matmul(response,readout) |
| for m,b,c in zip(matrices,increments,quotient_increments): |
| if not operator_norm_bound(m,rho):raise ValueError('hidden norm bound failed') |
| if not norm_bound(b,1-rho) or not norm_bound(c,1-rho): |
| raise ValueError('increment norm bound failed') |
| if not operator_norm_bound(subtract(matmul(readout,m),ac),kappa): |
| raise ValueError('observable response defect bound failed') |
| if not norm_bound([x-F(y) for x,y in zip(matvec(readout,b),c)],eta): |
| raise ValueError('observable increment defect bound failed') |
| if not norm_bound([x-F(y) for x,y in zip(matvec(readout,initial),quotient_initial)],eta0): |
| raise ValueError('initial observation mismatch bound failed') |
| q=rho**n*eta0+(kappa+eta)*(1-rho**n)/(1-rho) |
| return dict(requests=n,hidden_dimension=d,observed_dimension=r, |
| terminal_mismatch=q,objective_mismatch=4*q, |
| regret_transfer=8*q,exact_closure=(kappa==eta==eta0==0)) |
|
|
