#!/usr/bin/env python3 """Exact finite AIONVITA audit. Standard library only; no claimed unbounded RSI. Run from bundle root: python exact_kernel.py --output results/exact_audit.json Every algebraic assertion uses fractions.Fraction, not numerical tolerances. """ from __future__ import annotations import argparse from fractions import Fraction as F from functools import lru_cache from itertools import combinations, permutations, product import json from pathlib import Path import time DOMAIN = tuple(product((-1, 1), repeat=3)) def transpose(a): return [list(x) for x in zip(*a)] def rank(a): if not a: return 0 b = [[F(x) for x in row] for row in a] row = 0 for col in range(len(b[0])): p = next((i for i in range(row, len(b)) if b[i][col]), None) if p is None: continue b[row], b[p] = b[p], b[row] scale = b[row][col] b[row] = [x / scale for x in b[row]] for i in range(len(b)): if i != row: scale = b[i][col] b[i] = [x - scale*y for x, y in zip(b[i], b[row])] row += 1 if row == len(b): break return row def det(a): b = [[F(x) for x in row] for row in a] result = F(1) for col in range(len(b)): p = next((i for i in range(col, len(b)) if b[i][col]), None) if p is None: return F(0) if p != col: b[p], b[col] = b[col], b[p] result = -result pivot = b[col][col] result *= pivot for i in range(col+1, len(b)): scale = b[i][col] / pivot for j in range(col+1, len(b)): b[i][j] -= scale*b[col][j] return result def solve(a, b): n = len(a) aug = [[F(x) for x in row] + [F(y)] for row, y in zip(a, b)] for col in range(n): p = next(i for i in range(col, n) if aug[i][col]) aug[col], aug[p] = aug[p], aug[col] scale = aug[col][col] aug[col] = [x / scale for x in aug[col]] for i in range(n): if i != col: scale = aug[i][col] aug[i] = [x-scale*y for x,y in zip(aug[i],aug[col])] return [row[-1] for row in aug] def predict_fit(columns, labels): """Exact least squares on all eight uniform support inputs, no ridge.""" gram = [[sum(F(x)*F(y) for x,y in zip(a,b)) for b in columns] for a in columns] rhs = [sum(F(x)*F(y) for x,y in zip(a,labels)) for a in columns] weights = solve(gram,rhs) return [sum(w*c[i] for w,c in zip(weights,columns)) for i in range(len(labels))] def mse(pred, labels, weights=None): weights = weights or [1]*len(pred) return sum(F(w)*(F(p)-F(y))**2 for w,p,y in zip(weights,pred,labels))/sum(weights) def features(): one = [F(1)]*8 x1 = [F(x[0]) for x in DOMAIN] x2 = [F(x[1]) for x in DOMAIN] x3 = [F(x[2]) for x in DOMAIN] z12 = [a*b for a,b in zip(x1,x2)] return one,x1,x2,x3,z12 def obstruction_audit(): one,x1,x2,x3,z12 = features() old = [one,x1,x2,x3] dots = [sum(w*x for w,x in zip(z12,c)) for c in old] assert dots == [0]*4 pred0 = predict_fit(old,z12) pred1 = predict_fit(old+[z12],z12) assert pred0 == [0]*8 and pred1 == z12 return { "domain_size":8, "old_grammar":"rational affine features 1,x1,x2,x3; linear readout only", "host_constructor":"multiply(x1,x2), admitted as new learner-language fragment", "witness":list(map(str,z12)), "witness_dot_old_columns":list(map(str,dots)), "witness_dot_target":str(sum(z*z for z in z12)), "old_best_uniform_mse":str(mse(pred0,z12)), "new_best_uniform_mse":str(mse(pred1,z12)), "old_rank":rank(transpose(old)),"new_rank":rank(transpose(old+[z12])), "scope":"exact expressiveness relative to this non-universal DSL, not host Python", } def tract_audit(): one,x1,x2,x3,z12 = features() names=["1","x1","x2","x3","x1*x2","2*x1","x1+x2","x3+x1*x2"] columns=[one,x1,x2,x3,z12,[2*x for x in x1], [a+b for a,b in zip(x1,x2)],[a+b for a,b in zip(x3,z12)]] matrix=transpose(columns) r=rank(matrix) selected=[] for i,row in enumerate(matrix): if rank([matrix[j] for j in selected]+[row])>len(selected): selected.append(i) reduced=[matrix[i] for i in selected] @lru_cache(None) def minor(indices): if len(set(indices))indices[j] for i in range(r) for j in range(i+1,r)) ordered=tuple(sorted(indices)) if indices!=ordered: return (-1)**inv*minor(ordered) return det([[row[j] for j in ordered] for row in reduced]) bases={str(i):str(minor(i)) for i in combinations(range(8),r)} checked=nontrivial=0 for left in combinations(range(8),r-1): for right in combinations(range(8),r+1): terms=[(-1)**k*minor(left+(right[k],))*minor(right[:k]+right[k+1:]) for k in range(r+1)] assert sum(terms)==0 checked+=1 nontrivial+=int(any(terms)) circuits=[] for size in range(2,r+2): for inds in combinations(range(8),size): if rank(transpose([columns[i] for i in inds]))==size: continue if all(rank(transpose([columns[j] for j in inds if j!=i]))==size-1 for i in inds): circuits.append([names[i] for i in inds]) assert ["x1","2*x1"] in circuits assert ["x1","x2","x1+x2"] in circuits return { "tract":"Q field tract: multiplicative group Q^*, null sums are formal finite sums evaluating to 0 in Q", "specialization":"ordinary rational-representable strong matroid; no exotic-tract speedup claimed", "column_names":names,"rank":r,"independent_rows":selected, "maximal_minors":bases,"grassmann_pluecker_relations_checked":checked, "relations_with_nonzero_terms":nontrivial,"all_relations_zero":True, "minimal_dependent_circuits":circuits, "new_interaction_independent":rank(transpose(columns[:5]))==5, } def evaluator_audit(): """Finite selection functions compose through two-step backward induction.""" hs=tuple(range(4)) names=["x1","x2","x1*x2","x1*x3"] def output(h,q): a,b,c=q return (a,b,a*b,a*c)[h] def parts(state,q): return [tuple(h for h in state if output(h,q)==v) for v in (-1,1) if any(output(h,q)==v for h in state)] @lru_cache(None) def choose(state,depth): if depth==0 or len(state)==1: return F(len(state)),None choices=[] for q in DOMAIN: loss=sum(F(len(s),len(state))*choose(s,depth-1)[0] for s in parts(state,q)) choices.append((loss,q)) return min(choices) initial=(1,1,1) assert len(set(output(h,initial) for h in hs))==1 def tree(state,depth): value,q=choose(state,depth) if q is None: return {"hypotheses":[names[h] for h in state],"expected_remaining":str(value)} return {"query":q,"expected_remaining":str(value),"children":[tree(s,depth-1) for s in parts(state,q)]} value,_=choose(hs,2) assert value==1 return {"hypotheses":names,"initial_alias_probe":initial,"initial_equivalence_class_size":4, "optimal_one_step_expected_remaining":str(choose(hs,1)[0]), "optimal_two_step_expected_remaining":str(value),"selected_policy":tree(hs,2), "construction":"finite argmin selection functions with backward induction; no bar recursion or ludics instantiated"} def rewrite_audit(): fragments={"a":("input",0),"b":("input",1),"c":("input",2), "u":("mul","a","b"),"v":("mul","a","c")} def deps(key): return () if fragments[key][0]=="input" else fragments[key][1:] def assemble(storage): todo=set(storage) order=[] values={} while todo: ready=sorted(k for k in todo if all(d in values for d in deps(k))) if not ready: raise ValueError("cyclic or absent dependency") k=ready[0] # independent guide is canonical ready-node order f=fragments[k] values[k]=([F(x[f[1]]) for x in DOMAIN] if f[0]=="input" else [a*b for a,b in zip(values[f[1]],values[f[2]])]) todo.remove(k) order.append(k) return order,values orders=[] for storage in permutations(fragments): order,values=assemble(storage) assert values["u"]==[F(x[0]*x[1]) for x in DOMAIN] orders.append(order) legal_orders=[p for p in permutations(fragments) if all(p.index(d)= 8 min(w)/sum(w), without floating arithmetic. sigma_sq_bounds={name:str(F(8*min(w),sum(w))) for name,w in regimes.items()} useful_gains={name:[str(mse([0]*8,c,w)-mse(predict_fit(new,c),c,w)) for c in new] for name,w in regimes.items()} assert all(F(g)>=1 for gains in useful_gains.values() for g in gains) duplicate=new+[[2*x for x in x1]] collapse_rows=[i for i,x in enumerate(DOMAIN) if x[0]==x[1]] collapse_rank=rank([[col[i] for col in new] for i in collapse_rows]) # Rank expansion can harm: old learner only x1 filters x2-aligned support noise. support=[a+b for a,b in zip(x1,x2)] target=x1 old_noisy=predict_fit([one,x1],support) new_noisy=predict_fit([one,x1,x2],support) assert mse(old_noisy,target)==0 and mse(new_noisy,target)==1 # Exact functional continuity: new regression span contains old contracts. retained=[predict_fit(new,c)==c for c in old] assert all(retained) return {"dimension_definition":"largest jointly reachable response subset independent in every declared full-support regime, with per-target positive heldout loss gain", "support_label_interventions":5,"old_useful_dimension":4,"new_useful_dimension":5, "regime_response_ranks":dims,"joint_ternary_intervention_vectors_checked":3**5, "joint_reachability_verified":jointly_reachable, "common_labelled_subset":["1","x1","x2","x3","x1*x2"], "normalized_response_sigma_min_squared_lower_bounds":sigma_sq_bounds, "per_column_task_gain_vs_zero_baseline":useful_gains, "usefulness_threshold_delta":"1","support_cost_per_intervention_points":8, "new_target_mse_gain_by_regime":shift_gain, "duplicate_column_raw_count":6,"duplicate_column_dimension":rank(transpose(duplicate)), "collapse_shift":"only inputs satisfying x1=x2", "collapse_shift_rank":collapse_rank, "harmful_rank_counterexample":{"old_rank":2,"new_rank":3, "training_labels":"x1+x2","true_target":"x1","old_test_mse":str(mse(old_noisy,target)), "new_test_mse":str(mse(new_noisy,target)), "interpretation":"x2 fits aligned noise; fails usefulness gate on this task"}, "lineage_contracts_retained":sum(retained),"lineage_contracts_total":len(retained), "lineage_max_prediction_error":"0", "lineage_scope":"finite functional contracts; no universal or conscious identity certificate"} def run(): started=time.perf_counter() output={"schema":"aionvita.exact_audit.v1","arithmetic":"fractions.Fraction (exact rational)", "obstruction":obstruction_audit(),"tract":tract_audit(), "evaluation":evaluator_audit(),"reconstruction":rewrite_audit(), "aionvita":dimension_audit()} output["elapsed_seconds"]=time.perf_counter()-started return output if __name__=="__main__": parser=argparse.ArgumentParser() parser.add_argument("--output",default="results/exact_audit.json") args=parser.parse_args() result=run() target=Path(args.output) target.parent.mkdir(parents=True,exist_ok=True) target.write_text(json.dumps(result,indent=2)+"\n") print(json.dumps({"output":str(target),"all_assertions_passed":True, "elapsed_seconds":result["elapsed_seconds"]}))