"""AP five-arm finite certificate with measured baseline-void variance. Bits: baseline, main2, main3, weaker probe, stronger probe (X=1: q=1-v, covered/defect; X=0: void/open). Input exactly alpha, groups[{outcomes}], contract{step,ratio_error}. Exactly two preparations. Affine source-rate probes and common environment/target factor are externally valid contracts. No kernel or external variance budget needed. 18 Bernoulli frequencies, fixed design, iid complete five-arm repeats per group. Numerical80-digit Decimal with guards, NOT formal interval arithmetic. alpha>=2e-30, n<=1e18, 1e-6<=step<=.5,0<=ratio_error<=1. """ import argparse,json from pathlib import Path from decimal import Decimal,localcontext from log_core import log_certificate from paired_core import number,radius,serializable,GUARD,MAX_N KEYS=tuple(f'{i:05b}' for i in range(32)) def probe_certificate(data): if not isinstance(data,dict) or set(data)!={'alpha','groups','contract'}:raise ValueError('exactly alpha, groups, contract required') alpha=number(data['alpha'],'alpha',Decimal('2e-30'),Decimal(1)) if alpha==1:raise ValueError('alpha must be less than1') co=data['contract'] if not isinstance(co,dict) or set(co)!={'step','ratio_error'}:raise ValueError('step and ratio_error required') step=number(co['step'],'step',Decimal('1e-6'),Decimal('.5')) eps=number(co['ratio_error'],'ratio error',Decimal(0),Decimal(1)) groups=data['groups'] if not isinstance(groups,list) or len(groups)!=2:raise ValueError('two preparation groups required') marg=[] for g in groups: if not isinstance(g,dict) or set(g)!={'outcomes'}:raise ValueError('outcomes required') counts=g['outcomes'] if not isinstance(counts,dict) or set(counts)-set(KEYS):raise ValueError('five-bit outcomes required') if any(type(v)is not int or v<0 for v in counts.values()):raise ValueError('nonnegative integer counts required') if not 1<=sum(counts.values())<=MAX_N:raise ValueError('unsupported replicate count') c={} for k,v in counts.items():c[k[:3]]=c.get(k[:3],0)+v marg.append({'outcomes':c}) with localcontext() as ctx: ctx.prec=80 #10 old frequencies spend10/18 alpha;8 new frequencies spend8/18 alpha. raw=log_certificate({'alpha':alpha*Decimal(5)/9,'groups':marg}) raw.pop('conditional_zero_rank_exclusion',None) raw['scope']='simultaneous intervals for mean log responses under fixed-design iid complete repeats; null rejection uses the outer affine contract' t=(Decimal(36)/alpha).ln()+GUARD probe=[] for g,base in zip(groups,raw['groups']): n=base['n'];sn=t/n;vh=base['baseline_void'];vr=base['baseline_radius'] vlo,vhi=max(Decimal(0),vh-vr),min(Decimal(1),vh+vr) resp={} for label,i in (('weaker',3),('stronger',4)): pp=Decimal(sum(v for k,v in g['outcomes'].items() if int(k[i])-int(k[0])==1))/n pm=Decimal(sum(v for k,v in g['outcomes'].items() if int(k[i])-int(k[0])==-1))/n dh=pp-pm;dr=radius(pp,sn)+radius(pm,sn);dl,du=dh-dr,dh+dr safe=vlo>0 and vlo-du>0 if safe: vals=[(1-d/v).ln() for d in (dl,du) for v in (vlo,vhi)] lo,hi=min(vals)-GUARD,max(vals)+GUARD else:lo,hi=Decimal('-Infinity'),Decimal('Infinity') resp[label]=dict(response=dh,response_radius=dr,safe=safe,log_lower=lo,log_upper=hi) safe=all(x['safe'] for x in resp.values()) dlo=sum(x['log_lower'] for x in resp.values())-GUARD if safe else Decimal('-Infinity') du=sum(x['log_upper'] for x in resp.values())+GUARD if safe else Decimal('Infinity') probe.append(dict(responses=resp,dispersion_lower=dlo,dispersion_upper=du,shape_exclusion=safe and du<0)) shape=any(p['shape_exclusion'] for p in probe) safe=all(r['safe'] for g in raw['groups'] for r in g['responses'].values()) and all(all(r['safe'] for r in p['responses'].values()) for p in probe) scope='AP externally valid affine source-rate probes, common mixed law/target factor and calibration ratio; no kernel certification inferred' if not safe or shape: return dict(alpha=alpha,base_log_interval=raw,probes=probe,variance_upper=None,null_upper_bound=None,margin_lower=Decimal('-Infinity'),shape_exclusion=shape,rank_exclusion=False,affine_probe_null_exclusion=shape,scope=scope) K=[max(Decimal(0),p['dispersion_upper'].exp()-1)+GUARD for p in probe] K=[k/(step*step)+GUARD for k in K] U=[max(Decimal(0),-g['responses'][3]['log_lower']) for g in raw['groups']] E=[u.exp()+GUARD for u in U];M=[u+e*k/2+GUARD for e,u,k in zip(E,U,K)] bound=U[1]*E[0]*K[0]/8+eps*(U[1]*M[0]+U[0]*M[1])+GUARD margin=raw['lower']-bound-GUARD return dict(alpha=alpha,base_log_interval=raw,probes=probe,variance_upper=K,log_response_upper=U,null_upper_bound=bound,margin_lower=margin,shape_exclusion=False,rank_exclusion=margin>0,affine_probe_null_exclusion=margin>0,scope=scope) def main(): p=argparse.ArgumentParser(description=__doc__);p.add_argument('input',type=Path);a=p.parse_args() try:r=probe_certificate(json.loads(a.input.read_text())) except(ValueError,OSError)as exc:p.exit(2,f'Invalid input: {exc}\n') print(json.dumps(serializable(r),indent=2)) if __name__=='__main__':main()