#!/usr/bin/env python3 """Reconstruct the complete 68-variable inverse-parameter quartic. All arithmetic is exact. The stored matrix and pivot are specified invertible row operations, not a new optimization search. Only unchanged native detector rows are read from the pinned retained source. The independent checker rebuilds all rows without that table or this producer. """ from pathlib import Path from fractions import Fraction as Q from collections import defaultdict from hashlib import sha256 from math import gcd,lcm from itertools import permutations import argparse,json HERE=Path(__file__).resolve().parent ROOT=HERE.parents[2] def clean(p): return {m: Q(c) for m, c in p.items() if c} def add(*polys): result = defaultdict(Q) for p in polys: for m, c in p.items(): result[m] += c return clean(result) def scale(p, c): return clean({m: c*v for m, v in p.items()}) def multiply(p, q): result = defaultdict(Q) for (j, m), c in p.items(): for (k, n), d in q.items(): result[j+k, tuple(sorted(m+n))] += c*d return clean(result) def square(p): return multiply(p, p) def variable(name): return {(0, (name,)): Q(1)} def kplus(*values): return tuple(add(*(v[j] for v in values)) for j in range(2)) def ktimes(x, y): return (add(multiply(x[0], y[0]), scale(multiply(x[1], y[1]), 2)), add(multiply(x[0], y[1]), multiply(x[1], y[0]))) def ksquare(x): return ktimes(x, x) def kminus(x, y): return (add(x[0], scale(y[0], -1)), add(x[1], scale(y[1], -1))) def rational(p): return (p, {}) def field(name): return (variable(name+'.0'), variable(name+'.1')) def conjugate(x): return (x[0], scale(x[1], -1)) ONE={(0,()):Q(1)} PARAM={(1,()):Q(1)} def kc(a,b=0):return(scale(ONE,a),scale(ONE,b)) def km(k,z):return (scale(z[0],k),scale(z[1],k)) def build(output): basis={'referenceMatrix':[[1,1,0,0],[-1,-2,0,0],[3,4,-1,1],[-7,-9,0,1]],'constantPivot':37} D=kc(11,-6);a0=kc(1,1);c0=kc(4,-2);delta0=kc(-23,17) parent_path=ROOT/'computation/quartic/abc74_v46/quadratic-family.json';raw=parent_path.read_bytes();parent=json.loads(raw) assert sha256(raw).hexdigest()=='44499a87b0188f64d7e6d2c01046883a19326c40fa9956dcf31a1eb6e7a142dc' blocks=[] for j in range(2): blocks.append([x['name'] for x in parent['coordinates'] if x['name'].startswith(f'detector{j}.') and x['name']!=f'detector{j}.argument']) assert list(map(len,blocks))==[18,18] field_names=['reference.u','reference.w','reference.v','pair.S','pair.T','numerator.f','numerator.g','pair.h','pair.d','product.first','product.second','comparison.firstSquare','comparison.secondSquare'] names=['input','slope']+[f'{x}.{i}' for x in field_names[:3] for i in range(2)]+['pair.a.0']+[f'{x}.{i}' for x in field_names[3:] for i in range(2)]+['height.betaSquare','height.betaFourth','detector1.argument']+blocks[0]+blocks[1] assert len(names)==len(set(names))==68 ids={n:i+1 for i,n in enumerate(names)} oldnames={c['id']:c['name'] for c in parent['coordinates']} rows=[] def primitive(p): p={(j,tuple(sorted(ids[n] if isinstance(n,str) else n for n in m))):Q(c) for (j,m),c in p.items() if c} den=lcm(*(c.denominator for c in p.values()));cont=gcd(*(int(den*c) for c in p.values()));sign=1 if p[min(p)]>0 else -1 return {m:sign*int(den*c)//cont for m,c in p.items()} def put(name,p):rows.append((name,primitive(p))) def putk(name,p): for i in range(2):put(f'{name}.{i}',p[i]) uH,wH,vH=(field(x) for x in field_names[:3]);s,t,F,G,h,d=(field(x) for x in field_names[3:9]);J,K=(field(x) for x in field_names[9:11]);C2,I2=(field(x) for x in field_names[11:]);a_real=variable('pair.a.0') S=kminus(kminus(vH,c0),ktimes(a0,uH));TH=kplus(kminus(ktimes(a0,wH),vH),c0) b2=variable('height.betaSquare');b4=variable('height.betaFourth') putk('reference.product',kminus(ktimes(a0,ktimes(uH,wH)),kc(1))) putk('reference.unit',kminus(ktimes(vH,kminus(kminus(vH,ktimes(a0,kplus(uH,wH))),km(2,c0))),delta0)) # The specified unimodular basis is part of the exact polynomial definition. ref_mons=sorted(set(m for _,p in rows for m in p)) matrix=[[int(z) for z in row] for row in basis['referenceMatrix']] assert len(matrix)==4 and all(len(row)==4 for row in matrix) determinant=0 for perm in permutations(range(4)): inversions=sum(perm[i]>perm[j] for i in range(4) for j in range(i+1,4)) z=(-1)**inversions for i in range(4):z*=matrix[i][perm[i]] determinant+=z assert determinant in (-1,1) reference=rows rows=[] for i,coeffs in enumerate(matrix): p=defaultdict(Q) for coefficient,(_,rr) in zip(coeffs,reference): for monomial,z in rr.items():p[monomial]+=coefficient*z rows.append((f'reference.primitive.{i+1}',primitive(dict(p)))) # The translated secant chart keeps both reciprocals and only the rational trace output. p=kplus(h,s,t) put('pair.differenceReal',add(a_real,scale(ktimes(h,p)[0],-1))) putk('pair.firstProduct',kminus(d,ktimes(p,F))) putk('pair.secant',kplus(ktimes(D,kplus(F,G)),km(-1,ktimes(kminus(s,t),h)),ksquare(t))) putk('pair.secondProduct',kminus(d,ktimes(G,h))) putk('pair.scale',kplus(rational(b4),km(-1,ktimes(d,kminus(s,t))),ktimes(D,ktimes(F,G)))) putk('product.first',kminus(ktimes(vH,J),ktimes(uH,F)));putk('product.second',kminus(ktimes(vH,K),ktimes(wH,G))) putk('comparison.first',kminus(C2,ksquare(kminus(s,S)))) putk('comparison.second',kminus(I2,ksquare(kminus(t,TH)))) put('height.betaSquare',add(b2,scale(square(variable('input')),-1))) put('height.betaFourth',add(b4,scale(square(b2),-1))) put('detector1.argument',add(variable('detector1.argument'),scale(variable('slope'),-1),scale(PARAM,-1),scale(square(b4),-1),scale(square(a_real),-4))) assert len(rows)==24 changes={} for j in range(2): w=variable(f'detector{j}.inverseWeight') for number,comp,prod in [(1,C2,J),(2,conjugate(I2),conjugate(K))]: A1=field(f'detector{j}.factor{number}') eq=kminus(ktimes(rational(w),A1),kplus(rational(square(w)),ktimes(rational(w),comp),ksquare(prod))) for i in range(2):changes[f'detector{j}.factor{number}.{i}']=eq[i] for row in parent['residuals']: name=row['name'] if not name.startswith('detector') or name=='detector1.argument':continue p=changes.get(name) if p is None:p={(t['parameterPower'],tuple(oldnames[i] for i in t['monomial'])):Q(t['coefficient']) for t in row['terms']} put(name,p) assert len(rows)==56 assert {i for _,p in rows for _,m in p for i in m}==set(range(1,69)) def expand(rs): pp=defaultdict(int) for _,p in rs: assert max(len(m) for _,m in p)<=2 for (j,m),x in p.items(): for (k,n),y in p.items():pp[j+k,tuple(sorted(m+n))]+=x*y return {m:c for m,c in pp.items() if c} def ser(p):return [{'parameterPower':j,'monomial':list(m),'coefficient':str(z)} for (j,m),z in sorted(p.items())] # Fixed unit-constant pivot; no search occurs during reconstruction. base=rows[:];pivot=basis['constantPivot']-1;pp=base[pivot][1] assert pp.get((0,()),0)==1 rows=[];constant_ops=[] for i,(name,p) in enumerate(base): mul=p.get((0,()),0) if i!=pivot else 0 qq=p.copy() if mul: for key,z in pp.items():qq[key]=qq.get(key,0)-mul*z qq={m:z for m,z in qq.items() if z} content=gcd(*qq.values());sign=1 if qq[min(qq)]>0 else -1 rows.append((name,primitive(qq))) constant_ops.append({'row':i+1,'pivotMultiple':mul,'content':content,'sign':sign}) basis['constantOperations']=constant_ops poly=expand(rows);profiles=defaultdict(dict) for (j,m),z in poly.items():profiles[m][j]=z fixed=max(abs(p[0]) for p in profiles.values() if set(p)=={0}) assert profiles[()]=={0:1,2:1} assert poly[0,(1,1,1,1)]==1 assert gcd(*poly.values())==1 assert fixed==3554 for p in profiles.values(): if 1 in p: assert abs(p[1])<=8 and p[1]*p.get(0,0)>=0 assert 81**2+1>=abs(p[1]*81+p.get(0,0)) elif 2 in p:assert p=={0:1,2:1} system={'format':'integer-quadratic-family-translated-secants68-v65','variables':68,'inputCoordinate':1,'fixedParameter':{'symbol':'B','quantified':False,'domain':'fixed odd integer B>=81','sufficientThresholdEffective':False},'coordinates':[{'id':i+1,'name':n} for i,n in enumerate(names)],'residuals':[{'id':i+1,'name':n,'terms':ser(p)} for i,(n,p) in enumerate(rows)]} polynomial={'variables':68,'degree':4,'terms':ser(poly)} report={'status':'EXACT_CONDITIONAL_SPECIFICATION','variables':68,'quadraticRows':56,'degree':4,'constantCoefficient':'B^2+1','largestFixedCoefficient':fixed,'exactHeight':'B^2+1','coordinateMonomials':len(profiles),'parameterSeparatedTerms':len(poly),'content':1,'referenceMatrix':basis['referenceMatrix'],'constantPivot':pivot+1,'constantOperations':constant_ops,'parentSha256':sha256(raw).hexdigest(),'candidateIndexLabel':'relative to R0, integer','height':'2*a.0=X^2 Tr x(A); a.1 is eliminated with its unique defining row','comparison':'s-S and conjugate(t-TH), no retained ratios','additionalFiniteDifference':'(0,0), with index zero; covered by soundness','eliminatedOutput':'pair.a.1=(h*(h+s+t)).1, no other consumer'} system['parentQuadraticSha256']=sha256(raw).hexdigest() system['coordinateConvention']='beta=X; reference uH,wH,vH are automatic units; six pair field coordinates s,t,F,G,h,d and the rational output a.0 encode the difference via a secant after translation by (0,0) on the X-scaled curve; Tr(a) is the scaled trace; pole input is native b=w*tau^2.' polynomial.update(format='integer-quartic-family-translated-secants68-v65',inputCoordinate=1,fixedParameter=system['fixedParameter'],coordinates=system['coordinates']) report.update(parameterThresholdEffective=False,heightAbsorption='602/679',extraGuards=0,ordinaryMonomialsForEveryBAtLeast81=len(profiles),integerContentForEveryIntegerB=1,scope='Defining quartic under ordinary rational abc and the elliptic-group, simultaneous-prime, trace-height and simultaneous congruent-twist premises stated in the companion paper. B is fixed odd, at least81 and sufficiently large; no numerical sufficient threshold is asserted.') out=output;out.mkdir(parents=True,exist_ok=True) for name,obj in [('quadratic-family.json',system),('polynomial-family.json',polynomial),('construction-report.json',report),('basis-transformation.json',basis)]: (out/name).write_text(json.dumps(obj,indent=2)+'\n') print(json.dumps({k:v for k,v in report.items() if k not in ['referenceMatrix','constantOperations']},indent=2)) return report if __name__=='__main__': parser=argparse.ArgumentParser(description=__doc__) parser.add_argument('--output',type=Path,default=HERE) build(parser.parse_args().output)