C01.2 · Computations

The house-rewrite specification is: construct the two Cayley–Dickson tensors from the displayed quaternion rule; solve all derivation equations; check closure; compute the adjoint Killing form and transpose Cartan eigenspaces; and resolve the simultaneous weights of the two displayed Zorn derivations. The negative control is a rotation in the \(e_1,e_2\) plane that preserves the norm but fails the Leibniz identity. This prevents “norm-skew” from being mistaken for “derivation.”

All rank, inertia and root calculations are exact. The quaternion action sample is explicitly finite and does not stand in for the argument over all unit quaternions.

The command actually executed was: ```sh python CHATGPT_D1258_C01_2_CHECKS_S310.py ``` Settings: exact SymPy rational/symbolic arithmetic; no floating-point tolerances, no external numerical data files, no network calls, no optimized Python (`-O`). The coordinates and formulas above are the scientific inputs. Runtime versions are printed in stdout. The script SHA-256 is `977d375637e85aa02d107921820b4e5fbbfeb821b0e892eb81b87f7e697c32ec`; stdout SHA-256 is `04936c05c90ed1a7cac55a71cfba11c4babfbe6d2dd1adc69790261ff0461b26`. An identical-process rerun is a reproducibility check, not the independent house implementation required by the contract.

Complete standalone code: ```python """D1258 C01.2. Declarative object: derivations of the stated CD algebra."""

from itertools import product, combinations, permutations from collections import Counter import json import platform import sympy as S if not __debug__: raise SystemExit("Do not use -O: assertions are required.") def report(key, value): print(key + " = " + str(value)) def va(x,y): return tuple(a+b for a,b in zip(x,y)) def vn(x): return tuple(-a for a in x) def vs(x,y): return va(x,vn(y)) def sc(k,x): return tuple(k*a for a in x) def dot(x,y): return sum(a*b for a,b in zip(x,y)) def cross(x,y): return (x[1]*y[2]-x[2]*y[1],x[2]*y[0]-x[0]*y[2],x[0]*y[1]-x[1]*y[0]) def qm(p,r): a,b,c,d=p; e,f,g,h=r return (a*e-b*f-c*g-d*h,a*f+b*e+c*h-d*g, a*g-b*h+c*e+d*f,a*h+b*g-c*f+d*e) def qb(p): return (p[0],-p[1],-p[2],-p[3]) O_NAMES=("1","e1","e2","e3","f1","f2","f3","l") OB=[tuple(S.Integer(i==j) for i in range(8)) for j in range(8)] OZ=(S.Integer(0),)*8 def obar(x): return (x[0],)+vn(x[1:]) def omul(x,y,epsilon=1): # Same basis as D1256: f_i=-e_i*l, not +e_i*l. p=x[:4]; q=(x[7],)+vn(x[4:7]) r=y[:4]; s=(y[7],)+vn(y[4:7]) first=va(qm(p,r),sc(epsilon,qm(qb(s),q))) second=va(qm(s,p),qm(q,qb(r))) return first+vn(second[1:])+(second[0],) def onorm(x,epsilon=1): return sum(a*a for a in x[:4])-epsilon*sum(a*a for a in x[4:]) def to_zorn(x): return (x[0]+x[7],)+va(x[1:4],x[4:7])+vs(x[4:7],x[1:4])+(x[0]-x[7],) def from_zorn(z): a=z[0]; u=z[1:4]; v=z[4:7]; b=z[7] return ((a+b)/2,)+sc(S.Rational(1,2),vs(u,v))+sc(S.Rational(1,2),va(u,v))+((a-b)/2,) def zmul(z,w): a=z[0]; u=z[1:4]; v=z[4:7]; b=z[7] c=w[0]; U=w[1:4]; V=w[4:7]; d=w[7] return (a*c+dot(u,V),)+va(va(sc(a,U),sc(d,u)),cross(v,V))+vs(va(sc(c,v),sc(b,V)),cross(u,U))+(dot(v,U)+b*d,) def zero_vector(v): return all(S.expand(a)==0 for a in v) def inertia(M): """Exact rational symmetric congruence elimination; no eigenvalue tolerance.""" A=S.Matrix(M); assert A==A.T positive=negative=null=0 while A.rows: k=next((i for i in range(A.rows) if A[i,i]!=0),None) if k is None: pair=next(((i,j) for i in range(A.rows) for j in range(i+1,A.rows) if A[i,j]!=0),None) if pair is None: null+=A.rows; break i,j=pair P=S.eye(A.rows); P[j,i]=1 A=P.T*A*P k=i inds=[k]+[i for i in range(A.rows) if i!=k] A=A.extract(inds,inds); d=A[0,0] assert d.is_positive or d.is_negative positive+=int(bool(d>0)); negative+=int(bool(d<0)) v=A[1:,0]; A=A[1:,1:]-(v*v.T)/d return (positive,negative,null)

def derivation_system(epsilon): table=[[omul(x,y,epsilon) for y in OB] for x in OB] # D_{row,column}: D acts on column vectors. rows=[] for i,j,k in product(range(8), repeat=3): eq=[0]*64 for m in range(8): eq[k*8+m]+=table[i][j][m] eq[m*8+i]-=table[m][j][k] eq[m*8+j]-=table[i][m][k] rows.append(eq) A=S.Matrix(rows) ns=A.nullspace() ds=[S.Matrix(8,8,list(v)) for v in ns] for D in ds: assert A*S.Matrix(list(D))==S.zeros(A.rows,1) return A,ds def flat(D): return S.Matrix(list(D)) def coordinates(ds): B=S.Matrix.hstack(*[flat(D) for D in ds]) ix=list(B.T.rref()[1]); C=B.extract(ix,range(B.cols)).inv() def coord(M): z=C*flat(M).extract(ix,[0]) assert B*z==flat(M) return z return coord report("environment", {"python":platform.python_version(),"sympy":S.__version__}) report("data_basis","Declared CD definition; no banked arrays; all arithmetic exact.") for eps,label in [(1,"split"),(-1,"compact")]: A,ds=derivation_system(eps); d=len(ds) coord=coordinates(ds) norm=S.diag(*[onorm(e,eps) for e in OB]) assert all(D[:,0]==S.zeros(8,1) for D in ds) assert all(D.T*norm+norm*D==S.zeros(8) for D in ds) ads=[S.Matrix.hstack(*[coord(D*E-E*D) for E in ds]) for D in ds] K=S.Matrix(d,d,lambda i,j:S.trace(ads[i]*ads[j])) rep=S.Matrix(d,d,lambda i,j:S.trace(ds[i]*ds[j])) assert K==4*rep theta=S.Matrix.hstack(*[coord(-D.T) for D in ds]) assert theta**2==S.eye(d) kdim=len((theta-S.eye(d)).nullspace()) pdim=len((theta+S.eye(d)).nullspace()) report(label+".derivation_system_shape",A.shape) report(label+".derivation_rank_nullity",(64-d,d)) report(label+".unit_fixed_and_norm_skew",True) report(label+".closed_commutator_pairs",d*d) report(label+".Killing_equals_4_trace8",True) report(label+".Killing_inertia(+,-,0)",inertia(K)) report(label+".Cartan_dimensions(k,p)",(kdim,pdim)) report(label+".norm_inertia(+,-,0)",inertia(norm)) if eps==1: split_ds=ds # A split Cartan directly from native Zorn scaling u->H u,v->-H v. C=S.Matrix.hstack(*[S.Matrix(to_zorn(e)) for e in OB]) Hs=[] for h in [(1,-1,0),(0,1,-1)]: Hs.append(C.inv()*S.diag(0,*h,*[-a for a in h],0)*C) adsH=[S.Matrix.hstack(*[coord(H*D-D*H) for D in ds]) for H in Hs] weights=[] for v1 in range(-3,4): for v2 in range(-3,4): m=len((adsH[0]-v1*S.eye(d)).col_join(adsH[1]-v2*S.eye(d)).nullspace()) if m: weights.append(((v1,v2),m)) assert sum(m for _,m in weights)==d report("split.Cartan_joint_weights",weights) report("split.Cartan_centralizer_dimension",dict(weights)[(0,0)]) KC=S.Matrix(2,2,lambda i,j:4*S.trace(Hs[i]*Hs[j])) lens=Counter() for w,m in weights: if w!=(0,0):lens[(S.Matrix([w])*KC.inv()*S.Matrix(w))[0]]+=m report("split.Cartan_Killing_matrix",KC.tolist()) report("split.root_squared_lengths_multiplicities",sorted(lens.items())) # Negative control: norm-preserving linear map need not be a derivation. D=S.diag(0,0,0,0,0,0,0,0) D[1,2]=1; D[2,1]=-1 assert D.T*S.diag(1,1,1,1,-1,-1,-1,-1)+S.diag(1,1,1,1,-1,-1,-1,-1)*D==S.zeros(8) def leibniz(D,x,y): return vs(tuple(D*S.Matrix(omul(x,y))), va(omul(tuple(D*S.Matrix(x)),y),omul(x,tuple(D*S.Matrix(y))))) w=next((i,j,leibniz(D,OB[i],OB[j])) for i,j in product(range(8),repeat=2) if not zero_vector(leibniz(D,OB[i],OB[j]))) report("negative_control.norm_skew_not_derivation",w) # Quaternion automorphism family F_{a,b}(p,q)=(a p a^-1,b q a^-1). units=[(S.Integer(1),0,0,0),(0,S.Integer(1),0,0),(0,0,S.Integer(1),0),(0,0,0,S.Integer(1))] units+=[tuple(-t for t in u) for u in units.copy()] def F(x,a,b): p=x[:4]; q=(x[7],)+vn(x[4:7]) P=qm(qm(a,p),qb(a)); Q=qm(qm(b,q),qb(a)) return P+vn(Q[1:])+(Q[0],) tests=0; kernels=[] for a,b in product(units,repeat=2): if all(F(e,a,b)==e for e in OB):kernels.append((a,b)) for x,y in product(OB,repeat=2): assert F(omul(x,y),a,b)==omul(F(x,a,b),F(y,a,b)); tests+=1 report("quaternion_action.finite_basis_product_checks",tests) report("quaternion_action.finite_sample_kernel",kernels) report("dimensions.half_pair",(4,8)) count=0 for x,y in product(OB,repeat=2): assert zero_vector(vs(from_zorn(zmul(to_zorn(x),to_zorn(y))),omul(x,y))) count+=1 report("CD_Zorn.all_basis_pairs",count) report("source_status","No labels changed; full banked embedding alignment NOT VERIFIED.") ```

Actual stdout (not an expected-output fixture): ```text environment = {'python': '3.13.5', 'sympy': '1.14.0'} data_basis = Declared CD definition; no banked arrays; all arithmetic exact. split.derivation_system_shape = (512, 64) split.derivation_rank_nullity = (50, 14) split.unit_fixed_and_norm_skew = True split.closed_commutator_pairs = 196 split.Killing_equals_4_trace8 = True split.Killing_inertia(+,-,0) = (8, 6, 0) split.Cartan_dimensions(k,p) = (6, 8) split.norm_inertia(+,-,0) = (4, 4, 0) split.Cartan_joint_weights = [((-2, 1), 1), ((-1, -1), 1), ((-1, 0), 1), ((-1, 1), 1), ((-1, 2), 1), ((0, -1), 1), ((0, 0), 2), ((0, 1), 1), ((1, -2), 1), ((1, -1), 1), ((1, 0), 1), ((1, 1), 1), ((2, -1), 1)] split.Cartan_centralizer_dimension = 2 split.Cartan_Killing_matrix = [[16, -8], [-8, 16]] split.root_squared_lengths_multiplicities = [(1/12, 6), (1/4, 6)] compact.derivation_system_shape = (512, 64) compact.derivation_rank_nullity = (50, 14) compact.unit_fixed_and_norm_skew = True compact.closed_commutator_pairs = 196 compact.Killing_equals_4_trace8 = True compact.Killing_inertia(+,-,0) = (0, 14, 0) compact.Cartan_dimensions(k,p) = (14, 0) compact.norm_inertia(+,-,0) = (8, 0, 0) negative_control.norm_skew_not_derivation = (1, 4, (0, 0, 0, 0, 0, 0, 1, 0)) quaternion_action.finite_basis_product_checks = 4096 quaternion_action.finite_sample_kernel = [((1, 0, 0, 0), (1, 0, 0, 0)), ((-1, 0, 0, 0), (-1, 0, 0, 0))] dimensions.half_pair = (4, 8) CD_Zorn.all_basis_pairs = 64 source_status = No labels changed; full banked embedding alignment NOT VERIFIED. ```