experiments/exact_audits.py

"""Small independent Fraction enumerations supplement, but do not replace, written proofs."""
import argparse,itertools,json,math
from fractions import Fraction as F
from pathlib import Path
import numpy as np
from infinite_players.evidence_tree import EvidenceTree
from infinite_players.memory_contract import confusability_graph,exact_coloring

def signprob(sequence,mean):
    p=F(1)
    for x in sequence:p*=(1+mean*x)/2
    return p

def lag_audit():
    rho=F(3,5);kappa=F(2,5);count=0;total_atoms=0
    for n in range(1,5):
        for lag in range(4):
            inc_n=n+lag-1
            sums=[F(0),F(0),F(0)]
            for inc in itertools.product([-1,1],repeat=inc_n):
                pi=signprob(inc,rho)
                for noises in itertools.product([-1,1],repeat=n):
                    prob=pi*signprob(noises,kappa)
                    score=sum(noises[t]*math.prod(inc[t:t+lag]) for t in range(n))
                    sums[0]+=prob;sums[1]+=prob*score;sums[2]+=prob*score**2;total_atoms+=1
            mean=n*kappa*rho**lag
            variance=n*(1-kappa**2*rho**(2*lag))+2*kappa**2*sum((n-h)*(rho**(2*h)-rho**(2*lag)) for h in range(1,min(n,lag)))
            assert sums[0]==1 and sums[1]==mean and sums[2]-sums[1]**2==variance
            count+=1
    return {"parameter_cases":count,"enumerated_atoms":total_atoms,"result":"exact mean and covariance sum passed"}

def operator_audit():
    factors=[[[F(1,3),F(1,5)],[F(1,4),F(1,2)]],[[F(1,7),F(2,5)],[F(1,3),F(1,6)]],[[F(1,4),F(1,8)],[F(1,2),F(1,3)]]]
    initial=[F(2,5),F(3,5)];terminal=[F(3,7),F(4,7)]
    result=F(0);atoms=0
    for z in itertools.product(range(2),repeat=4):
        prob=initial[z[0]]*terminal[z[-1]]
        for t in range(3):prob*=factors[t][z[t]][z[t+1]]
        result+=prob;atoms+=1
    a=np.array(factors,dtype=float)[:,None,:,:]
    tree=EvidenceTree(a,["a","b","c"],model_id="audit")
    error=abs(math.exp(tree.log_likelihoods(np.array(initial,float),np.array(terminal,float))[0])-float(result))
    assert error<1e-14
    return {"hidden_paths":atoms,"exact_likelihood":str(result),"float_error":error}

def memory_audit():
    rows=[];encoders=0
    for n in (1,2,3):
        records=list(itertools.product([0,1],repeat=n));best=F(0)
        for mapping in itertools.product([0,1],repeat=len(records)):
            numerator=0
            for cell in (0,1):
                for j in range(n):
                    counts=[sum(1 for i,d in enumerate(records) if mapping[i]==cell and d[j]==bit) for bit in (0,1)]
                    numerator+=max(counts)
            success=F(numerator,n*len(records));best=max(best,success);encoders+=1
        graph=confusability_graph(records);states,_=exact_coloring(graph)
        assert states==2**n
        rows.append({"history_bits":n,"exact_memory_states":states,"best_one_bit_average_recovery":str(best)})
    assert rows[-1]['best_one_bit_average_recovery']=='3/4'
    return {"deterministic_encoders":encoders,"cases":rows}

def shield_audit():
    D=[[F(1,2),F(9,10),F(1,10)],[F(1,2),F(1,10),F(9,10)]]
    target=[F(1,2),F(1,2)];reward=[F(2,5),F(9,10),F(4,5)]
    mix=[F(0),F(1,2),F(1,2)];baseline=[F(1),F(0),F(0)]
    assert [sum(D[i][a]*mix[a] for a in range(3)) for i in range(2)]==target
    assert sum(reward[a]*mix[a] for a in range(3))==F(17,20)
    p=[F(1,3)]*3;null=[F(-2),F(1),F(1)]
    assert all(sum(row[a]*null[a] for a in range(3))==0 for row in D)
    scale=sum(reward[a]*null[a] for a in range(3))/sum(v*v for v in null)
    direction=[scale*v for v in null]
    assert sum(reward[a]*direction[a] for a in range(3))==sum(v*v for v in direction)
    # All binary semantic words have the same probability under baseline and mixture.
    words=0
    for horizon in range(1,11):
        for word in itertools.product([0,1],repeat=horizon):
            p0=F(1);p1=F(1)
            for bit in word:
                p0*=sum(D[bit][a]*baseline[a] for a in range(3))
                p1*=sum(D[bit][a]*mix[a] for a in range(3))
            assert p0==p1;words+=1
    return {"semantic_words":words,"reward_before":"2/5","reward_after":"17/20","projected_gain_squared_norm":str(sum(v*v for v in direction))}

def composition_audit():
    cases=0;max_error=F(0)
    for T in range(1,9):
        # Persistent identity mixtures with two opposite deterministic semantic paths.
        for p in (F(1,5),F(1,2),F(4,5)):
            for q in (F(1,4),F(1,2),F(3,4)):
                # Common stochastic binary-symmetric continuation can only contract this distance.
                probs=[]
                for word in itertools.product([0,1],repeat=T):
                    l0=F(1);l1=F(1)
                    for bit in word:l0*=F(4,5) if bit==0 else F(1,5);l1*=F(4,5) if bit==1 else F(1,5)
                    probs.append((p*l0+(1-p)*l1,q*l0+(1-q)*l1))
                error=sum(abs(x-y) for x,y in probs)/2
                assert error<=abs(p-q);max_error=max(max_error,error);cases+=1
    return {"posterior_horizon_cases":cases,"maximum_observed_TV":str(max_error)}

def main():
    p=argparse.ArgumentParser();p.add_argument('--output',type=Path,default=Path('results/exact_audits.json'));a=p.parse_args()
    result={"lag":lag_audit(),"operator":operator_audit(),"memory":memory_audit(),"shield":shield_audit(),"composition":composition_audit(),"status":"all assertions passed; in-session independent implementations, not external review"}
    a.output.parent.mkdir(parents=True,exist_ok=True);a.output.write_text(json.dumps(result,indent=2,sort_keys=True)+"\n");print(json.dumps(result,indent=2))
if __name__=='__main__':main()