#!/usr/bin/env python3
"""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')
    # Each declared mismatch term must be checked, not silently ignored.
    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():
    # Exact PSD edge cases include a zero diagonal with nonzero coupling.
    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()