#!/usr/bin/env python3
# Cross-Form Learning Consequence Experiment
# Frozen protocol v0.2 implementation. EXPOSED DEVELOPMENT ONLY.
from __future__ import annotations
import csv, hashlib, json, math, os, platform, shutil, sys, time, zipfile
from datetime import datetime, timezone
from itertools import combinations
from pathlib import Path
import numpy as np

PROTOCOL="CROSS_FORM_CONSEQUENCE_PROTOCOL_v0_2_FROZEN"
IMPL="CROSS_FORM_CONSEQUENCE_NUMPY_v0_2_PUBLIC_RELEASE"
SEEDS=tuple(range(205001,205009)); D=16; K=4; NEP=128
E_N=128; E_TEST=1024; Q_N=64; Q_TEST=1024
EPOCHS=4; ETA_E=.10; ETA_Q=.10; CPS=(0,2,4,8,16,32,64)
HI=3.; LO=1.; TOL=1e-12
MASKS=tuple(combinations(range(D),K))
NS={"mask":101,"erule":102,"etrain":103,"eorder":104,"etest":105,
    "qrule":106,"qsup":107,"qorder":108,"qtest":109,"shuffle":110,
    "wmask":111,"wrule":112,"wtrain":113,"worder":114,"rand":115}

def sig(z):
    z=np.asarray(z,dtype=np.float64); o=np.empty_like(z)
    m=z>=0; o[m]=1/(1+np.exp(-z[m])); e=np.exp(z[~m]); o[~m]=e/(1+e)
    return o

def ll(z,y): return float(np.mean(np.logaddexp(0,z)-y*z))

def ev(w,X,y,true=None):
    z=X@w; out={"accuracy":float(np.mean((z>=0)==y)),"log_loss":ll(z,y),
               "w_norm":float(np.linalg.norm(w))}
    if true is not None:
        a=np.linalg.norm(w); b=np.linalg.norm(true)
        out["cos_true_rule"]=float(w@true/(a*b)) if a and b else 0.
    return out

def ah(a):
    a=np.ascontiguousarray(a); h=hashlib.sha256()
    h.update(str(a.dtype).encode()); h.update(repr(a.shape).encode()); h.update(a.tobytes())
    return h.hexdigest()

def fh(path):
    h=hashlib.sha256()
    with open(path,"rb") as f:
        for b in iter(lambda:f.read(1<<20),b""): h.update(b)
    return h.hexdigest()

def jd(obj,path): Path(path).write_text(json.dumps(obj,indent=2,sort_keys=True)+"\n",encoding="utf-8")

def jlines(rows,path):
    with open(path,"w",encoding="utf-8") as f:
        for r in rows: f.write(json.dumps(r,sort_keys=True,separators=(",",":"))+"\n")

def wcsv(rows,path):
    rows=list(rows)
    if not rows: Path(path).write_text("",encoding="utf-8"); return
    with open(path,"w",newline="",encoding="utf-8") as f:
        w=csv.DictWriter(f,fieldnames=list(rows[0])); w.writeheader(); w.writerows(rows)

def crng(seed,ep,name):
    code=NS[name]; entropy=[int(seed),int(ep),int(code)]
    ss=np.random.SeedSequence(entropy); state=ss.generate_state(4,dtype=np.uint32)
    rng=np.random.Generator(np.random.PCG64(np.random.SeedSequence(entropy)))
    return rng,{"top_seed":seed,"episode":ep,"namespace":name,"namespace_code":code,
                "seedsequence_entropy":entropy,"generated_state_u32":[int(x) for x in state]}

def mask_from(ix):
    m=np.zeros(D,dtype=np.int8); m[np.asarray(ix,dtype=int)]=1; return m

def target_mask(rng,used):
    for i in rng.permutation(len(MASKS)):
        c=MASKS[int(i)]
        if c not in used: used.add(c); return mask_from(c)
    raise RuntimeError("no unused mask")

def wrong_mask(rng,M):
    c=np.flatnonzero(M==0); return mask_from(sorted(map(int,rng.choice(c,K,replace=False))))

def rule(rng,M):
    a=np.flatnonzero(M); w=np.zeros(D)
    w[a]=rng.choice([-1.,1.],K)*rng.uniform(.75,1.25,K); return w/np.linalg.norm(w)

def data(rng,n,w,order_rng=None):
    h=rng.normal(size=(n//2,D)); X=np.r_[h,-h].astype(np.float64); y=((X@w)>=0).astype(np.int8)
    r=order_rng if order_rng is not None else rng; q=r.permutation(n); return X[q],y[q]

def topk(w):
    i=np.arange(D); order=np.lexsort((i,-np.abs(w))); return mask_from(order[:K])

def trainE(X,y,rng):
    w=np.zeros(D)
    for _ in range(EPOCHS):
        for j in rng.permutation(len(y)):
            x=X[j]; p=float(sig(np.array([w@x]))[0]); w-=ETA_E*(p-float(y[j]))*x
    return w

def qup(w,x,y,S,audit):
    p=float(sig(np.array([w@x]))[0]); g=(p-float(y))*x
    if S is None: b=g
    else:
        m=np.where(S==1,HI,LO); br=m*g; ng=np.linalg.norm(g); nb=np.linalg.norm(br)
        b=br*(ng/nb) if ng>0 and nb>0 else g
        if ng>0 and nb>0:
            err=abs(np.linalg.norm(b)-ng); audit["n"]+=1; audit["maxerr"]=max(audit["maxerr"],float(err))
            if not math.isclose(np.linalg.norm(b),ng,rel_tol=1e-12,abs_tol=1e-12):
                raise AssertionError("gradient norm mismatch")
    w=w-ETA_Q*b
    if not np.all(np.isfinite(w)): raise FloatingPointError("nonfinite weights")
    return w

def runQ(w0,X,y,Xt,yt,W,S):
    w=w0.copy(); rows=[]; audit={"n":0,"maxerr":0.}
    rows.append({"support":0,**ev(w,Xt,yt,W)})
    for i in range(Q_N):
        w=qup(w,X[i],int(y[i]),S,audit)
        if i+1 in CPS[1:]: rows.append({"support":i+1,**ev(w,Xt,yt,W)})
    if tuple(r["support"] for r in rows)!=CPS: raise AssertionError("checkpoints")
    return rows,audit

def auc(delta):
    x=np.array(CPS,float); y=np.array(delta,float)
    area=np.trapezoid(y,x) if hasattr(np,"trapezoid") else np.trapz(y,x)
    return float(area/64.)

def episode(seed,ep,used):
    cs=[]
    def R(name):
        r,c=crng(seed,ep,name); cs.append(c); return r
    M=target_mask(R("mask"),used); MW=wrong_mask(R("wmask"),M)
    if M.sum()!=K or MW.sum()!=K or int(M@MW)!=0: raise AssertionError("mask contract")
    WE=rule(R("erule"),M); WQ=rule(R("qrule"),M); WW=rule(R("wrule"),MW)

    re=R("etrain"); ro=R("eorder"); XE,yE=data(re,E_N,WE,ro)
    # Recreate eorder RNG for epoch permutations, independent of data-shuffle call sequence.
    reord,_=crng(seed,ep,"eorder")
    XEt,yEt=data(R("etest"),E_TEST,WE)

    XQ,yQ=data(R("qsup"),Q_N,WQ,R("qorder")); XQt,yQt=data(R("qtest"),Q_TEST,WQ)
    XW,yW=data(R("wtrain"),E_N,WW); rword=R("worder")

    wE=trainE(XE,yE,reord); pretr=ev(wE,XE,yE,WE); prete=ev(wE,XEt,yEt,WE); ST=topk(wE)
    rsh=R("shuffle"); yS=yE[rsh.permutation(E_N)]
    rshord,_=crng(seed,ep,"eorder"); wS=trainE(XE,yS,rshord); SS=topk(wS)
    wW=trainE(XW,yW,rword); SW=topk(wW)
    RR=R("rand"); SR=mask_from(sorted(map(int,RR.choice(np.arange(D),K,replace=False))))
    SO=M.copy()
    for s in (ST,SS,SW,SR,SO):
        if s.sum()!=K: raise AssertionError("S cardinality")

    zero=np.zeros(D); post=ev(zero,XEt,yEt,WE)
    if not math.isclose(post["accuracy"],.5,abs_tol=TOL): raise AssertionError("destruction invariant")

    C={}; A={}
    C["T"],A["T"]=runQ(zero,XQ,yQ,XQt,yQt,WQ,ST)
    C["N"],A["N"]=runQ(zero,XQ,yQ,XQt,yQt,WQ,None)
    C["0"],A["0"]=runQ(zero,XQ,yQ,XQt,yQt,WQ,None)
    C["S"],A["S"]=runQ(zero,XQ,yQ,XQt,yQt,WQ,SS)
    C["W"],A["W"]=runQ(zero,XQ,yQ,XQt,yQt,WQ,SW)
    C["R"],A["R"]=runQ(zero,XQ,yQ,XQt,yQt,WQ,SR)
    C["O"],A["O"]=runQ(zero,XQ,yQ,XQt,yQt,WQ,SO)
    C["P"],A["P"]=runQ(wE,XQ,yQ,XQt,yQt,WQ,None)

    md=0.
    for a,b in zip(C["N"],C["0"]):
        for k in ("accuracy","log_loss","w_norm","cos_true_rule"): md=max(md,abs(a[k]-b[k]))
    if md>TOL: raise AssertionError(f"N/0 leakage {md}")
    for c in ("T","S","W","R","O"):
        if A[c]["n"]!=Q_N: raise AssertionError(f"{c} structured updates")

    sc=float(WE@WQ/(np.linalg.norm(WE)*np.linalg.norm(WQ))); ac=abs(sc)
    ov={"true_overlap":int(ST@M),"shuf_overlap":int(SS@M),"wrong_overlap":int(SW@M),
        "rand_overlap":int(SR@M),"oracle_overlap":int(SO@M)}
    by={c:{r["support"]:r for r in v} for c,v in C.items()}
    td=[by["T"][s]["accuracy"]-by["N"][s]["accuracy"] for s in CPS]
    od=[by["O"][s]["accuracy"]-by["N"][s]["accuracy"] for s in CPS]
    ta,oa=auc(td),auc(od)

    rows=[]
    for c,v in C.items():
        for r in v:
            rows.append({"seed":seed,"episode":ep,"condition":c,**r,"signed_cos_E_Q":sc,
                         "abs_cos_E_Q":ac,**ov})

    hashes=[]
    objs={"M":M,"M_wrong":MW,"W_E":WE,"W_Q":WQ,"W_wrong":WW,"E_train_X":XE,"E_train_y":yE,
          "E_test_X":XEt,"E_test_y":yEt,"Q_support_X":XQ,"Q_support_y":yQ,"Q_test_X":XQt,
          "Q_test_y":yQt,"wrong_E_train_X":XW,"wrong_E_train_y":yW,"shuffled_E_y":yS,
          "S_truehist":ST,"S_shuf":SS,"S_wrong":SW,"S_rand":SR,"S_oracle":SO}
    for n,a in objs.items():
        a=np.asarray(a); hashes.append({"seed":seed,"episode":ep,"object":n,"sha256":ah(a),
                                       "dtype":str(a.dtype),"shape":list(a.shape)})

    audit={"seed":seed,"episode":ep,"M":M.tolist(),"M_wrong":MW.tolist(),"W_E":WE.tolist(),
           "W_Q":WQ.tolist(),"W_wrong":WW.tolist(),"w_E_final":wE.tolist(),"w_shuf_final":wS.tolist(),
           "w_wrong_final":wW.tolist(),"S_truehist":ST.tolist(),"S_shuf":SS.tolist(),
           "S_wrong":SW.tolist(),"S_rand":SR.tolist(),"S_oracle":SO.tolist(),
           "E_train_accuracy_pre_destroy":pretr["accuracy"],"E_test_accuracy_pre_destroy":prete["accuracy"],
           "E_test_log_loss_pre_destroy":prete["log_loss"],"E_test_accuracy_post_reset":post["accuracy"],
           "signed_cos_E_Q":sc,"abs_cos_E_Q":ac,"overlaps":ov,"N_vs_0_max_abs_diff":md,
           "q_gradient_audits":A,"transformed_minus_neutral_auc":ta,"oracle_minus_neutral_auc":oa,
           "transformed_recovery_fraction":ta/oa if oa>0 else None}

    summ={"seed":seed,"episode":ep,"E_train_accuracy":pretr["accuracy"],"E_test_accuracy":prete["accuracy"],
          "E_test_log_loss":prete["log_loss"],"E_post_reset_accuracy":post["accuracy"],
          "signed_cos_E_Q":sc,"abs_cos_E_Q":ac,**ov,"exact_mask_recovery":int(ov["true_overlap"]==K),
          "N_vs_0_max_abs_diff":md,"transformed_minus_neutral_auc":ta,"oracle_minus_neutral_auc":oa,
          "transformed_recovery_fraction":ta/oa if oa>0 else ""}

    leak=[]
    eye=np.eye(D)
    for i in np.flatnonzero(M):
        leak.append((np.r_[ST.astype(float),eye[int(i)]].tolist(),int(WE[int(i)]>0)))
    return rows,audit,hashes,cs,summ,leak

def seed_summary(seed,rows,es):
    out=[]
    for c in ("T","N","0","S","W","R","O","P"):
        for s in CPS:
            rr=[r for r in rows if r["condition"]==c and r["support"]==s]
            for m in ("accuracy","log_loss","w_norm","cos_true_rule"):
                v=np.array([r[m] for r in rr],float)
                out.append({"seed":seed,"condition":c,"support":s,"metric":m,"mean":v.mean(),
                            "median":np.median(v),"std":v.std(),"min":v.min(),"max":v.max(),"n":len(v)})
    ms=("E_train_accuracy","E_test_accuracy","E_test_log_loss","E_post_reset_accuracy","signed_cos_E_Q",
        "abs_cos_E_Q","true_overlap","shuf_overlap","wrong_overlap","rand_overlap","oracle_overlap",
        "exact_mask_recovery","N_vs_0_max_abs_diff","transformed_minus_neutral_auc","oracle_minus_neutral_auc")
    for m in ms:
        v=np.array([e[m] for e in es],float)
        out.append({"seed":seed,"condition":"EPISODE","support":"","metric":m,"mean":np.nanmean(v),
                    "median":np.nanmedian(v),"std":np.nanstd(v),"min":np.nanmin(v),"max":np.nanmax(v),
                    "n":int(np.isfinite(v).sum())})
    return out

def decoder(train,test):
    X=np.array([x for x,y in train],float); y=np.array([y for x,y in train],float)
    Xt=np.array([x for x,y in test],float); yt=np.array([y for x,y in test],float)
    mu=X.mean(0); X=np.c_[X-mu,np.ones(len(X))]; Xt=np.c_[Xt-mu,np.ones(len(Xt))]
    w=np.zeros(X.shape[1])
    for _ in range(600):
        pr=sig(X@w); g=X.T@(pr-y)/len(y); g[:-1]+=1e-3*w[:-1]; w-=.2*g
    acc=float(np.mean(((Xt@w)>=0)==yt)); base=float(max(yt.mean(),1-yt.mean()))
    return {"test_accuracy":acc,"majority_baseline":base,"n_train":len(y),"n_test":len(yt)}

def aggregate(ps,leaks):
    cross=[]
    keys=sorted(set((r["condition"],str(r["support"]),r["metric"]) for r in ps))
    for c,s,m in keys:
        rr=[r for r in ps if r["condition"]==c and str(r["support"])==s and r["metric"]==m]
        v=np.array([r["mean"] for r in rr],float)
        cross.append({"condition":c,"support":s,"metric":m,"mean_of_seed_means":np.nanmean(v),
                      "std_of_seed_means":np.nanstd(v),"min_seed_mean":np.nanmin(v),
                      "max_seed_mean":np.nanmax(v),"n_seeds":len(v)})
    tr=[]; te=[]
    for s in SEEDS: (tr if s<=205006 else te).extend(leaks[s])
    dec=decoder(tr,te)
    mem=[]; signs=[]
    for feat,y in tr+te:
        f=np.array(feat); i=int(np.argmax(f[D:])); mem.append(f[i]); signs.append(y)
    corr=float(np.corrcoef(mem,signs)[0,1]) if np.std(mem)>0 and np.std(signs)>0 else None
    return {"cross_seed_summaries":cross,
            "leakage_audit":{"membership_vs_sign_pearson":corr,"heldout_sign_decoder":dec,
              "interpretation":"Diagnostic only; S is expected to encode support, not E-specific sign content."},
            "development_outcome_category":"UNASSIGNED_REQUIRES_REVIEW_NO_NUMERICAL_MATERIALITY_GATE"}

def runseed(seed,sd):
    sd.mkdir(parents=True,exist_ok=False); used=set(); rows=[]; audits=[]; hashes=[]; childs=[]; es=[]; leaks=[]
    al=[]; t=time.time()
    for ep in range(NEP):
        try:r,a,h,c,e,l=episode(seed,ep,used)
        except Exception as ex:
            al.append(f"FAIL seed={seed} episode={ep}: {type(ex).__name__}: {ex}")
            Path(sd/"ASSERTION_LOG.txt").write_text("\n".join(al)+"\n",encoding="utf-8"); raise
        rows+=r; audits.append(a); hashes+=h; childs+=c; es.append(e); leaks+=l; al.append(f"PASS seed={seed} episode={ep}")
    if len(used)!=NEP: raise AssertionError("mask uniqueness")
    ps=seed_summary(seed,rows,es)
    wcsv(rows,sd/"EPISODE_RESULTS.csv"); wcsv(es,sd/"EPISODE_SUMMARY.csv"); wcsv(ps,sd/"PER_SEED_SUMMARY.csv")
    jlines(audits,sd/"STATE_AUDIT.jsonl"); jlines(hashes,sd/"DATA_HASHES.jsonl"); jlines(childs,sd/"CHILD_SEEDS.jsonl")
    Path(sd/"ASSERTION_LOG.txt").write_text("\n".join(al)+"\n",encoding="utf-8")
    rt=time.time()-t
    jd({"seed":seed,"episodes":NEP,"unique_target_masks":len(used),"conditions":list("TN0SWROP"),
        "checkpoints":list(CPS),"runtime_seconds":rt,"status":"COMPLETE"},sd/"SEED_MANIFEST.json")
    return rows,es,ps,leaks,rt

def config(sha):
    return {"status":"FROZEN_EXPOSED_DEVELOPMENT_ONLY","protocol":PROTOCOL,
            "implementation":IMPL,"implementation_sha256":sha,"seeds":list(SEEDS),"episodes_per_seed":NEP,
            "d":D,"k":K,"E_train_n":E_N,"E_test_n":E_TEST,"E_epochs":EPOCHS,"eta_E":ETA_E,
            "Q_support_n":Q_N,"Q_test_n":Q_TEST,"eta_Q":ETA_Q,"checkpoints":list(CPS),
            "structured_raw_weights":{"selected":HI,"unselected":LO},
            "normalization":"per-step structured biased-gradient L2 equals ordinary gradient L2 at condition current state",
            "transform":"top-k abs(final E fast weights), lower-index exact tie break",
            "Q_relation":"independent W_Q on same M; no cosine rejection, stratification, or exclusion",
            "qualification_seeds":None,"promotion_gates":None,
            "claim_boundary":"instrument-level cross-form consequence only; no learned persistence-form selection."}

def selftest():
    assert len(MASKS)==1820
    assert np.all(np.isfinite(sig(np.array([-1000.,0.,1000.]))))
    r,a,h,c,e,l=episode(999991,0,set())
    assert len(r)==8*len(CPS) and math.isclose(a["E_test_accuracy_post_reset"],.5,abs_tol=TOL)
    assert a["N_vs_0_max_abs_diff"]<=TOL
    print("SELF_TEST_PASS\nNo frozen exposed seed was opened.")

def main():
    if "--self-test" in sys.argv:selftest(); return 0
    out=Path("/mnt/data")
    if "--output-root" in sys.argv:
        i=sys.argv.index("--output-root"); out=Path(sys.argv[i+1]).expanduser().resolve()
    sp=Path(__file__).resolve(); sha=fh(sp); stamp=datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
    rd=out/f"cross_form_consequence_v0_2_run_{stamp}"; rd.mkdir(parents=True)
    jd(config(sha),rd/"CONFIG.json")
    Path(rd/"PROTOCOL_REFERENCE.txt").write_text(f"{PROTOCOL}\nImplementation: {IMPL}\nSHA256: {sha}\n",encoding="utf-8")
    Path(rd/"ENVIRONMENT.txt").write_text(
        f"UTC_START={datetime.now(timezone.utc).isoformat()}\npython={sys.version.replace(os.linesep,' ')}\n"
        f"numpy={np.__version__}\nplatform={platform.platform()}\nmachine={platform.machine()}\nimplementation_sha256={sha}\n",
        encoding="utf-8")
    allr=[]; alles=[]; allps=[]; leaks={}; sm=[]; logs=[]; t=time.time()
    for s in SEEDS:
        r,e,p,l,rt=runseed(s,rd/f"seed_{s}"); allr+=r; alles+=e; allps+=p; leaks[s]=l
        sm.append({"seed":s,"episodes":NEP,"runtime_seconds":rt,"status":"COMPLETE"})
        msg=f"COMPLETE seed={s} episodes={NEP} runtime_sec={rt:.3f}"; print(msg,flush=True); logs.append(msg)
    ag=aggregate(allps,leaks); ag.update({"protocol":PROTOCOL,"implementation_sha256":sha,"seeds":list(SEEDS),
        "episodes_total":len(alles),"runtime_seconds_total":time.time()-t,"seed_manifests":sm,
        "scientific_status":"EXPOSED_DEVELOPMENT_ONLY_NO_PROMOTION_CLASSIFICATION"})
    wcsv(allr,rd/"EPISODE_RESULTS.csv"); wcsv(alles,rd/"EPISODE_SUMMARY.csv"); wcsv(allps,rd/"PER_SEED_SUMMARY.csv")
    jd(ag,rd/"AGGREGATE_SUMMARY.json"); jd({"frozen_exposed_seeds":list(SEEDS),"episodes_per_seed":NEP,
       "total_episodes":len(alles),"all_complete":True,"seed_manifests":sm},rd/"SEED_MANIFEST.json")
    Path(rd/"STDOUT.txt").write_text("\n".join(logs)+"\n",encoding="utf-8")
    mx=max(e["N_vs_0_max_abs_diff"] for e in alles)
    ok=all(math.isclose(e["E_post_reset_accuracy"],.5,abs_tol=TOL) for e in alles)
    Path(rd/"ASSERTION_LOG.txt").write_text(
        f"PASS seeds_complete={len(SEEDS)}/{len(SEEDS)}\nPASS episodes_complete={len(alles)}/{len(SEEDS)*NEP}\n"
        f"PASS max_N_vs_0_abs_diff={mx:.17g}\nPASS all_post_reset_E_accuracy_0p5={ok}\n",encoding="utf-8")
    for fn in ("STATE_AUDIT.jsonl","DATA_HASHES.jsonl","CHILD_SEEDS.jsonl"):
        with open(rd/fn,"w",encoding="utf-8") as o:
            for s in SEEDS:
                with open(rd/f"seed_{s}"/fn,encoding="utf-8") as i: shutil.copyfileobj(i,o)
    sh=[]
    for q in sorted(rd.rglob("*")):
        if q.is_file() and q.name!="FILE_SHA256.json": sh.append({"relative_path":str(q.relative_to(rd)),"sha256":fh(q),"size":q.stat().st_size})
    jd(sh,rd/"FILE_SHA256.json")
    zp=out/f"{rd.name}.zip"
    with zipfile.ZipFile(zp,"w",zipfile.ZIP_DEFLATED,compresslevel=6) as z:
        for q in sorted(rd.rglob("*")):
            if q.is_file(): z.write(q,str(q.relative_to(rd)))
    zsha=fh(zp); Path(str(zp)+".sha256").write_text(f"{zsha}  {zp.name}\n",encoding="utf-8")
    print(f"RUN_DIR={rd}\nRESULT_ZIP={zp}\nRESULT_ZIP_SHA256={zsha}\nSTATUS=EXPOSED_DEVELOPMENT_COMPLETE_NO_PROMOTION_CLASSIFICATION")
    return 0

if __name__=="__main__": raise SystemExit(main())