run_experiments.py

"""Reproduce finite exact experiments. No transformer, GPU or network required.

Strong conventional baselines are reported. Greater closure rank is NOT called
an intelligence score, and selection-only budgets are NOT total compute matches.
"""
from __future__ import annotations
from pathlib import Path
import sys
ROOT=Path(__file__).resolve().parent
sys.path.insert(0,str(ROOT/'src'))
import argparse, json, platform, subprocess, time
from itertools import combinations
import numpy as np
from axiomesh.core import *
from axiomesh.esre_v01 import (rank_mod, rref_mod, CentralExtension, wedge_row,
    coefficients_to_omega, RelationalMemory, learn_from_relations)


def chain(d, active=None):
    active=d if active is None else active
    a,b=np.eye(d,dtype=np.int64),np.eye(d,dtype=np.int64)
    for j in range(active-1):
        (a if j%2==0 else b)[j,j+1]=1
    return np.eye(d,dtype=np.int64)[:1],{'a':a,'b':b}


def conventional_batch_closure(q,ops,p):
    """Independent classical batch observability baseline. Not a novel method."""
    r,piv=rref_mod(q,p);r=r[:len(piv)];products=0
    while True:
        stack=[r]
        for t in ops.values():
            stack.append(r@t%p);products+=len(r)
        rr,piv=rref_mod(np.vstack(stack),p);rr=rr[:len(piv)]
        if len(rr)==len(r):return rr,products
        r=rr


def checks_for_model(frozen,q,ops,x,p,rng,n=200):
    names=list(ops);correct=0
    for _ in range(n):
        word=tuple(rng.choice(names,size=int(rng.choice([0,1,2,4,8,16,32]))))
        truth=q@word_matrix(word,ops,p)@x%p
        correct+=int(np.array_equal(frozen.run(word),truth))
    return correct


def experiment_counterexample():
    q,ops=chain(3);p=101
    m=Memory(np.eye(3,dtype=np.int64)[:2],np.array([3,4]),p)
    c=close_operators(q,ops,p);certificate=hole_certificate(c,m)
    x=np.array([3,4,2]);v=np.array(certificate['null_vector'])
    word=certificate['word']
    return {'current_query_status':m.recall(q)[0], 'future_status':weave(q,ops,m).status,
        'certificate':certificate,'compatible_state_1':x.tolist(),'compatible_state_2':((x+v)%p).tolist(),
        'future_output_1':(q@word_matrix(word,ops,p)@x%p).tolist(),
        'future_output_2':(q@word_matrix(word,ops,p)@(x+v)%p).tolist()}


def experiment_closure_and_frozen(rng):
    rows=[]
    for active,d in [(4,8),(8,16),(12,24),(16,32),(24,48),(32,64)]:
        p=101;q,ops=chain(d,active);x=rng.integers(p,size=d)
        t=time.perf_counter();c=close_operators(q,ops,p);proposed_sec=time.perf_counter()-t
        t=time.perf_counter();b,products=conventional_batch_closure(q,ops,p);baseline_sec=time.perf_counter()-t
        f=c.compile(c.basis@x%p);base_seed=b@x%p
        bh={a:coordinates(b@t%p,b,p) for a,t in ops.items()}
        bf=FrozenModel(p,base_seed,bh,coordinates(q,b,p))
        words=[tuple(rng.choice(['a','b'],size=int(rng.integers(0,65)))) for _ in range(300)]
        cp=cb=0
        for word in words:
            truth=q@word_matrix(word,ops,p)@x%p
            cp+=int(np.array_equal(f.run(word),truth));cb+=int(np.array_equal(bf.run(word),truth))
        e=emergence_rank(q,[{'a':ops['a']},{'b':ops['b']}],p)
        rows.append({'ambient_dimension':d,'quotient_rank':c.rank,'mixed_depth':c.depth,
           'isolated_union_rank':e['isolated_union_rank'],'emergence_rank':e['emergence_rank'],
           'test_words':len(words),'weave_correct':cp,'classical_correct':cb,
           'weave_row_products':c.row_operator_products,'batch_row_products':products,
           'weave_wall_seconds':proposed_sec,'batch_wall_seconds':baseline_sec,
           'dense_runtime_matvec_symbols_per_action':{'source':d*d,'quotient':active*active},
           'optimized_classical_worklist_expected_products':2*c.rank})
    return {'rows':rows,'scope':'Known finite operator matrices; classical optimized worklist has the same algorithmic complexity. Dense matvec counts do not compare against sparse source execution.'}


def experiment_erasures(rng):
    rows=[]
    for r,e in [(4,3),(8,4),(12,4)]:
        for erased in [0,e,e+1]:
            exact=ambiguous=false=0
            for trial in range(100):
                y=rng.integers(101,size=r);cap=Capsule.encode(y,101,e)
                lost=rng.choice(list(cap.shares),size=erased,replace=False).tolist()
                status,got=cap.erase(lost).recover()
                exact+=status=='exact';ambiguous+=status=='ambiguous'
                false+=status=='exact' and not np.array_equal(y,got)
            rows.append({'rank':r,'stored_symbols':r+e,'erased_symbols':erased,'trials':100,
                         'exact':int(exact),'abstentions':int(ambiguous),'false_certificates':int(false)})
    return {'rows':rows,'baseline':'Ordinary Reed-Solomon erasure decoding is identical; novelty is not assigned to this result.'}


def experiment_curriculum(rng):
    p=101;d=18;x=rng.integers(p,size=d);q=np.eye(d,dtype=np.int64)[:1]
    mem=Memory(q,q@x%p,p);ops={};rows=[];total_acquired=0
    for j in range(15):
        t=np.eye(d,dtype=np.int64);t[j,j+1]=1;ops[f't{j}']=t
        result=weave(q,ops,mem,oracle=lambda row:int(row@x)%p,observation_budget=1,erasure_budget=2)
        total_acquired+=result.acquisitions;mem=result.memory
        lost=list(result.capsule.shares)[:2];status,seed=result.capsule.erase(lost).recover()
        result.offspring.seed=seed
        correct=checks_for_model(result.offspring,q,ops,x,p,rng,n=100)
        rows.append({'round':j+1,'rank':result.closure.rank,'new_observations':result.acquisitions,
                     'after_erasure':status,'correct':correct,'tested':100})
    return {'rows':rows,'additional_observations':total_acquired,'initial_observations':1,
       'source_dimension':d,'final_rank':len(mem.matrix),
       'interpretation':'Incremental capability-library growth in a supplied linear family; not autonomous improvement of a neural proposer.'}


def experiment_gauge(rng):
    correct=0;trials=100;p=17;d=6
    q,ops=chain(d)
    original=close_operators(q,ops,p)
    for _ in range(trials):
        while True:
            g=rng.integers(p,size=(d,d))
            if rank_mod(g,p)==d:break
        gi=inverse(g,p);x=rng.integers(p,size=d)
        transformed={a:g@t@gi%p for a,t in ops.items()};qt=q@gi%p
        c=close_operators(qt,transformed,p)
        f=c.compile(c.basis@g@x%p)
        word=tuple(rng.choice(['a','b'],size=20))
        correct+=int(np.array_equal(f.run(word),q@word_matrix(word,ops,p)@x%p))
    return {'trials':trials,'exact_gauge_equivalent_outputs':correct,
        'mapping_information':'Invertible chart maps supplied by the lineage, not guessed from unpaired data.'}


def experiment_bundle_scheduler():
    p=101;core=24;distractors=6;d=core+2*distractors
    q,ops=chain(d,core)
    for i in range(distractors):
        t=np.eye(d,dtype=np.int64);j=core+2*i;t[0,j]=1;t[j,j+1]=1;ops[f'd{i}']=t
    names=list(ops)
    selected=[];greedy_evaluations=0;greedy_products=0
    for _ in range(2):
        candidates=[]
        for a in names:
            if a in selected:continue
            c=close_operators(q,{k:ops[k] for k in selected+[a]},p)
            greedy_evaluations+=1;greedy_products+=c.row_operator_products
            candidates.append((c.rank,a))
        best=max(candidates,key=lambda t:(t[0],t[1]))
        selected.append(best[1])
    gc=close_operators(q,{k:ops[k] for k in selected},p)
    bundles=[];pair_products=0
    for pair in combinations(names,2):
        c=close_operators(q,{k:ops[k] for k in pair},p);pair_products+=c.row_operator_products
        bundles.append((c.rank,pair))
    rank,pair=max(bundles,key=lambda t:t[0])
    return {'operator_candidates':len(names),'live_operator_budget':2,
      'individual_greedy':{'selected':selected,'rank':gc.rank,'evaluations':greedy_evaluations,'row_products':greedy_products},
      'bounded_bundle_search':{'selected':list(pair),'rank':rank,'evaluations':len(bundles),'row_products':pair_products},
      'conventional_exhaustive_baseline_rank':rank,
      'warning':'Equal live-operator capacity, NOT equal total selection compute. Conventional pair search matches. Rank is not general intelligence.'}


def experiment_partial_execution():
    p=101;m=Memory(np.array([[1,0,0]]),np.array([7]),p)
    ops={'swap':np.array([[0,1,0],[1,0,0],[0,0,1]]),
         'reset':np.zeros((3,3),dtype=np.int64)}
    q=np.eye(3,dtype=np.int64)[:1]
    rows=[{'word':list(w),**execute_partial(m,ops,q,w)} for w in [(),('swap',),('swap','swap'),('reset',),('reset','swap')]]
    return {'rows':rows,'full_state_status':m.recall(np.eye(3,dtype=np.int64))[0],
       'interpretation':'Some future answers remain exact despite full-state ambiguity; this does not restore erased past information.'}


def experiment_learned_esre_pipeline(rng,out):
    p=101;n=8;a=rng.integers(p,size=n);b=rng.integers(p,size=n)
    omega=(np.outer(a,b)-np.outer(b,a))%p
    truth=CentralExtension(omega,p)
    count=n*(n-1) # twice the number of independent alternating coefficients
    probes=[];values=[]
    for _ in range(count):
        u,v=rng.integers(p,size=(2,n));probes.append(wedge_row(u,v,p));values.append(truth.commutator(u,v))
    mem=RelationalMemory(np.array(probes),np.array(values),p)
    learned=learn_from_relations(mem,n)
    assert learned is not None
    q,ops=affine_extension_operators(learned.omega,p)
    state=np.r_[rng.integers(p,size=n),int(rng.integers(p)),1]
    m0=np.eye(n+2,dtype=np.int64)[[n,n+1]]
    result=weave(q,ops,Memory(m0,m0@state%p,p),oracle=lambda row:int(row@state)%p,
                 observation_budget=n,erasure_budget=3)
    damaged=result.capsule.erase([1,2,3]);status,restored=damaged.recover()
    result.offspring.seed=restored
    names=list(ops);correct=classical=0;tests=2000
    for _ in range(tests):
        word=tuple(rng.choice(names,size=int(rng.integers(1,65))))
        answer=result.offspring.run(word)
        # Independent conventional group composition implementation.
        sx,sz=state[:n].copy(),int(state[n])
        for action in word:
            u=np.zeros(n,dtype=np.int64);u[int(action[1:])]=1 if action[0]=='+' else -1
            sx,sz=learned.multiply((sx,sz),(u,0))
        # Ground truth uses independently retained true omega.
        tx,tz=state[:n].copy(),int(state[n])
        for action in word:
            u=np.zeros(n,dtype=np.int64);u[int(action[1:])]=1 if action[0]=='+' else -1
            tx,tz=truth.multiply((tx,tz),(u,0))
        correct+=int(int(answer[0])==tz);classical+=int(sz==tz)
    payload={'format':'axiomesh-frozen-v0.2','program':result.offspring.json_object(include_seed=False),
             'memory':damaged.json_object()}
    path=out/'frozen_erased_seed.json';path.write_text(json.dumps(payload,indent=2))
    env=dict(__import__('os').environ);env['PYTHONPATH']=str(ROOT/'src')
    word='+0,+1,-0,-1,+2'
    proc=subprocess.run([sys.executable,'-m','axiomesh.cli',str(path),'--word',word],env=env,capture_output=True,text=True,check=True)
    fresh=json.loads(proc.stdout)
    expected=result.offspring.run(tuple(word.split(','))).tolist()
    assert fresh['output']==expected
    # Fresh seed is absent; generation of the model matrices has already occurred.
    actual_bytes=len(json.dumps(payload,separators=(',',':')).encode())
    full_model=FrozenModel(p,state,ops,q).json_object()
    full_bytes=len(json.dumps(full_model,separators=(',',':')).encode())
    return {'ambient_dimension':n+2,'omega_rank':rank_mod(omega,p),
      'supplied_alternating_family_parameters':n*(n-1)//2,'mixed_probes':count,'primitive_oracle_actions':4*count,
      'learned_omega_exact':bool(np.array_equal(learned.omega,omega)),
      'quotient_rank':result.closure.rank,'initial_state_measurements':2,'additional_state_measurements':result.acquisitions,
      'stored_seed_code_symbols':len(result.capsule.shares),'deleted_seed_symbols':3,'state_recovery':status,
      'test_words':tests,'weave_correct':correct,'conventional_pooled_group_correct':classical,
      'fresh_process':fresh,'serialized_frozen_payload_bytes':actual_bytes,
      'serialized_uncoded_dense_source_bytes':full_bytes,
      'limitations':'Algebraic family, action coordinates and observation language supplied. Constant coordinate is encoded and counted. JSON byte comparison excludes offline compiler and source training archive; strong quotient compiler can match.'}


def experiment_operator_excision(rng):
    p=101;r=4;h=rng.integers(p,size=(r,r));cap=Capsule.encode(h.ravel(),p,4)
    # Decoder below receives only rank and surviving relations, not original h.
    damaged=cap.erase([1,2,3,4]);status,reconstructed=damaged.recover()
    return {'matrix_shape':[r,r],'stored_symbols':len(cap.shares),'deleted_symbols':4,
       'status':status,'exact_operator':bool(np.array_equal(reconstructed.reshape(r,r),h)),
       'baseline':'Conventional polynomial erasure code exactly matches. Additional metadata must survive.'}


def experiment_damage_property(rng):
    trials=200;false=0;exact=ambiguous=0
    p=3;d=4
    for _ in range(trials):
        m=rng.integers(p,size=(int(rng.integers(0,6)),d));q=rng.integers(p,size=(2,d));x=rng.integers(p,size=d)
        memory=Memory(m,m@x%p,p);status,y,v=memory.recall(q)
        # Enumerate the entire compatible world fiber, not just the true state.
        worlds=np.array(list(__import__('itertools').product(range(p),repeat=d)),dtype=np.int64)
        compatible=worlds[np.all((worlds@m.T-m@x)%p==0,axis=1)]
        answers=compatible@q.T%p;identifiable=bool(np.all(answers==answers[0]))
        exact+=status=='exact';ambiguous+=status=='ambiguous'
        false+=int((status=='exact')!=identifiable)
        if status=='exact':false+=int(not np.array_equal(y,q@x%p))
    return {'trials':trials,'worlds_enumerated_per_trial':p**d,'exact':exact,'ambiguous':ambiguous,
            'incorrect_certificates':false}



def experiment_recursive_fracture(rng,out):
    p=101;d=9;q=np.eye(d,dtype=np.int64)[:1];ops={}
    for j in range(d-1):
        t=np.eye(d,dtype=np.int64);t[j,j+1]=1;ops[f't{j}']=t
    x=rng.integers(p,size=d)
    source=Memory(np.eye(d,dtype=np.int64),x,p)
    tree=fractalize(q,ops,source,max_depth=3)
    path=out/'recursive_fracture.json';path.write_text(json.dumps(tree,indent=2))
    restored=regenerate_tree(json.loads(path.read_text()))
    observations=[];nodes=0;max_depth=0;stored=0
    def visit(node,depth):
        nonlocal nodes,max_depth,stored
        nodes+=1;max_depth=max(max_depth,depth)
        item=node['memory'] if node['kind']=='leaf' else node['tether']
        rows=np.asarray(item['matrix'],dtype=np.int64).reshape(-1,item['width'])
        observations.extend(rows);stored+=len(item['rhs'])
        for child in node.get('children',[]):visit(child,depth+1)
    visit(tree,0)
    correct=checks_for_model(restored.offspring,q,ops,x,p,rng,n=300)
    # Two-child minimal seam demonstration.
    cq,cops=chain(12);cx=rng.integers(p,size=12)
    split=split_with_tether(cq,cops,Memory(np.eye(12,dtype=np.int64),cx,p),[['a'],['b']])
    return {'nodes':nodes,'depth':max_depth,'raw_state_symbols':stored,
        'independent_state_symbols':rank_mod(np.asarray(observations),p),
        'source_behavior_rank':restored.closure.rank,'test_words':300,'correct':correct,
        'serialized_tree_bytes':len(path.read_bytes()),
        'minimal_tether_example':{'parent_rank':split.parent_rank,'child_union_rank':split.child_union_rank,
                                  'tether_symbols':split.tether_symbols},
        'qualification':'The physical tree duplicates shared coordinates. Nine independent symbols do not mean nine total stored symbols; the raw tree stores sixteen plus substantial program/map metadata.'}

def main():
    ap=argparse.ArgumentParser(description=__doc__);ap.add_argument('--seed',type=int,default=20261007)
    ap.add_argument('--output',type=Path,default=ROOT/'results');args=ap.parse_args()
    args.output.mkdir(parents=True,exist_ok=True);rng=np.random.default_rng(args.seed);start=time.perf_counter()
    results={'version':'0.2.0','seed':args.seed,'scope':'Finite exact CPU experiments, not general AI or transformer benchmarks.',
        'environment':{'python':platform.python_version(),'numpy':np.__version__,'platform':platform.platform()},
        'counterexample':experiment_counterexample(),
        'closure_and_frozen':experiment_closure_and_frozen(rng),
        'erasure_recovery':experiment_erasures(rng),
        'recursive_curriculum':experiment_curriculum(rng),
        'cross_chart':experiment_gauge(rng),
        'bundle_scheduler':experiment_bundle_scheduler(),
        'partial_execution':experiment_partial_execution(),
        'learned_esre_pipeline':experiment_learned_esre_pipeline(rng,args.output),
        'operator_excision':experiment_operator_excision(rng),
        'exhaustive_identifiability':experiment_damage_property(rng),
        'recursive_fracture':experiment_recursive_fracture(rng,args.output)}
    results['elapsed_seconds']=time.perf_counter()-start
    (args.output/'results.json').write_text(json.dumps(results,indent=2),encoding='utf8')
    print(json.dumps({'result_file':str(args.output/'results.json'),'elapsed_seconds':results['elapsed_seconds'],
        'learned_pipeline':results['learned_esre_pipeline'],'scheduler':results['bundle_scheduler']},indent=2))

if __name__=='__main__':main()