From 71f09cedc8e0d846409ca4ea3614e46bbf9f833a Mon Sep 17 00:00:00 2001 From: Ruge Lin Date: Sat, 26 Sep 2026 12:01:01 +0800 Subject: [PATCH] Resolve the six-label operator implication by an exact positive-norm certificate The uncontracted condition from Note18 is redundant: the real symmetric cubic trace identities through order five and the positive metric imply G(9Q_x+24336 ad_x-2704 ad_Gx)G=0 for every exterior input x. Calculate the complete Gram of three six-index tensors; its exact kernel is (1,1,-1). Three scalar contractions are fixed by a nonsingular three-row fifth-trace system. Only the non-alternating fifth trace is used, so the disputed five-form coefficient is eliminated before the proof begins. Add Note24, a complete reproducible graph-reduction certificate and 95 exact scoped checks. Preserve every existing main file and pending branch. This is a positive-metric implication, not complex ideal membership, formal verification, independent expert review, novelty clearance, or a classification of the original interaction tensor. No manuscript or outreach. --- .../operator-factorization-closure.yml | 101 +++++ checks/operator_factorization_graphs.py | 383 ++++++++++++++++++ checks/verify_operator_factorization.py | 294 ++++++++++++++ research/24_operator_factorization_closure.md | 247 +++++++++++ results/operator_factorization_additions.json | 31 ++ results/operator_factorization_report.sha256 | 1 + 6 files changed, 1057 insertions(+) create mode 100644 .github/workflows/operator-factorization-closure.yml create mode 100644 checks/operator_factorization_graphs.py create mode 100644 checks/verify_operator_factorization.py create mode 100644 research/24_operator_factorization_closure.md create mode 100644 results/operator_factorization_additions.json create mode 100644 results/operator_factorization_report.sha256 diff --git a/.github/workflows/operator-factorization-closure.yml b/.github/workflows/operator-factorization-closure.yml new file mode 100644 index 0000000..fff6630 --- /dev/null +++ b/.github/workflows/operator-factorization-closure.yml @@ -0,0 +1,101 @@ +name: Operator factorization closure +on: + push: + branches: [research/operator-factorization-closure, main] + pull_request: + branches: [main] +permissions: + contents: read +jobs: + verify: + runs-on: ubuntu-24.04 + timeout-minutes: 5 + env: + OPENBLAS_NUM_THREADS: '1' + OMP_NUM_THREADS: '1' + MKL_NUM_THREADS: '1' + PYTHONDONTWRITEBYTECODE: '1' + steps: + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 + with: + ref: 09e3f98ad79034eefab43f4fb9ea432368fc19e7 + path: baseline + persist-credentials: false + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 + with: + path: candidate + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 + with: + python-version: '3.13.5' + - run: python3 -m pip install 'numpy==2.3.5' + - name: Frozen baseline and additive payload + run: | + python3 - <<'PYCODE' + import hashlib,json,pathlib,subprocess + b,c=pathlib.Path('baseline'),pathlib.Path('candidate') + names=subprocess.check_output(['git','-C',str(b),'ls-files','-z']).decode().split('\0') + for name in filter(None,names): + if (b/name).read_bytes()!=(c/name).read_bytes(): + raise RuntimeError('Changed baseline file: '+name) + m=json.loads((c/'results/operator_factorization_additions.json').read_text()) + for e in m['files']: + raw=(c/e['path']).read_bytes() + if len(raw)!=e['bytes'] or hashlib.sha256(raw).hexdigest()!=e['sha256']: + raise RuntimeError('Addition hash mismatch: '+e['path']) + print('BASELINE_PRESERVED and ADDITIONS_VERIFIED') + PYCODE + - name: Strict replay and separate unchanged portability policy + shell: bash + run: | + set -euo pipefail + for tree in baseline candidate; do + ( + cd "$tree" + if python3 verify.py >/tmp/operator-strict.out 2>/tmp/operator-strict.err; then + strict=PASS + else + strict=FAIL_RECOGNIZED_FLOAT_REPORT + case "$(tail -n 1 /tmp/operator-strict.err)" in + "RuntimeError: prior average toy differs from recorded report under None"|"RuntimeError: prior pair toy differs from recorded report under None") ;; + *) cat /tmp/operator-strict.err; exit 1 ;; + esac + fi + echo "STRICT_REPLAY $tree $strict" + cat /tmp/operator-strict.err + python3 checks/replay_portability.py >/tmp/operator-portability.json + TREE="$tree" python3 - <<'PYCODE' + import json,os + r=json.load(open('/tmp/operator-portability.json')) + print('PORTABILITY',os.environ['TREE'],r['status']) + print('ALL_REPORTS_BYTE_IDENTICAL',os.environ['TREE'],r['all_reports_byte_identical']) + print('DIFFERING_FLOAT_LEAVES',sum(x['different_float_leaves'] for x in r['reports'])) + PYCODE + test -z "$(git status --porcelain)" + ) + done + - name: Exact certificate in all three modes + shell: bash + run: | + set -euo pipefail + cd candidate + python3 checks/verify_operator_factorization.py >/tmp/operator-normal.json + python3 -O checks/verify_operator_factorization.py >/tmp/operator-O.json + python3 -OO checks/verify_operator_factorization.py >/tmp/operator-OO.json + cmp /tmp/operator-normal.json /tmp/operator-O.json + cmp /tmp/operator-normal.json /tmp/operator-OO.json + python3 - <<'PYCODE' + import hashlib,json,pathlib + raw=pathlib.Path('/tmp/operator-normal.json').read_bytes() + expected=pathlib.Path('results/operator_factorization_report.sha256').read_text().strip() + if hashlib.sha256(raw).hexdigest()!=expected: + raise RuntimeError('Exact report fingerprint differs') + r=json.loads(raw) + print('NEW_CHECKS',r['checks'],r['status']) + print('SMALL_GRAM',r['certificate']['small_Gram']) + print('INDEPENDENCE',r['six_label_operator_condition_independent']) + print('LARGEST_SQUARE',r['largest_explicit_matrix_dimension']) + print('REPORT_SHA256',expected) + PYCODE + git diff --check + test -z "$(git status --porcelain)" diff --git a/checks/operator_factorization_graphs.py b/checks/operator_factorization_graphs.py new file mode 100644 index 0000000..f2294ba --- /dev/null +++ b/checks/operator_factorization_graphs.py @@ -0,0 +1,383 @@ +"""Exact tensor-contraction certificate for the six-label operator identity. + +A monomial is a graph of copies of one REAL symmetric cubic C and Kronecker +contractions. Its value is a finite Einstein sum. The reduction rules are the +stated trace identities; their numerical coefficients are hypotheses, not +learned from a small example. Boundary projections are explicit finite signed +averages. This is a reproducible symbolic certificate, not a proof-assistant +formalization or a construction of the 196883-dimensional multiplication. + +Only Python's standard library is needed for the symbolic certificate. +The independent direct-matrix controls in the caller use NumPy object arrays. +""" +from fractions import Fraction as Q +from collections import defaultdict,Counter +from functools import lru_cache +from itertools import combinations, permutations +import itertools + +# Each C is a trivalent vertex; negative integers are fixed external labels. +# An edge contracts two indices using the positive Euclidean metric. +# Graph isomorphisms rename dummy indices only. + +D=196883; KAPPA=Q(13858,3); NU=Q(899); ALPHA=Q(496,3); BETA=Q(-116); U=Q(965,9); V=Q(40,3); GAMMA=Q(1,3) +# Exterior vectors a,...,f supply six distinguished one-valent boundary vertices -1..-6. +COUNTER=itertools.count(100) +def fresh():return next(COUNTER) + +def addterms(*polys):return sum(polys,[]) +def times(p,q):return [(a*b,cs+ds,es+fs) for a,cs,es in p for b,ds,fs in q] +def scale(p,a):return [(a*c,vs,ds) for c,vs,ds in p if a*c] +def wedge(a,b,i,j):return [(Q(1),(),((i,a),(j,b))),(Q(-1),(),((i,b),(j,a)))] +def leftL(a,x,i,j): + k=fresh();return [(Q(1),((a,i,k),),())], x(k,j) +def Dact(a,x,i,j): + k=fresh();l=fresh() + return addterms(times([(Q(1),((a,i,k),),())],x(k,j)),times(x(i,l),[(Q(1),((a,l,j),),())])) +def F(x,i,j): + k,l,t=fresh(),fresh(),fresh() + return times([(Q(1),((t,i,k),(t,l,j)),())],x(k,l)) +def G(x,i,j):return addterms(F(x,i,j),scale(x(i,j),GAMMA)) +def mul(x,y,i,j): + k=fresh();return times(x(i,k),y(k,j)) +def ad(x,y,i,j):return addterms(mul(x,y,i,j),scale(mul(y,x,i,j),-1)) + +def canon_edges(n,edges): + edges=tuple(sorted(tuple(sorted(e)) for e in edges));return _canon(n,edges) +@lru_cache(None) +def _canon(n,edges): + adj={i:[] for i in range(n)} + for a,b in edges: + if a>=0:adj[a].append(b) + if b>=0:adj[b].append(a) + # canonical partition refinement; boundary vertices keep distinct names + def refine(part): + while True: + colors={v:k for k,cell in enumerate(part) for v in cell} + new=[] + for cell in part: + groups=defaultdict(list) + for v in cell: + sig=tuple(sorted(((-1,x) if x<0 else (0,colors[x])) for x in adj[v])) + groups[sig].append(v) + for sig in sorted(groups):new.append(tuple(groups[sig])) + if len(new)==len(part):return tuple(new) + part=tuple(new) + def rec(part): + part=refine(part) + if len(part)==n: + mp={v:i for i,(v,) in enumerate(part)} + return tuple(sorted(tuple(sorted((mp.get(a,a),mp.get(b,b)))) for a,b in edges)) + idx=next(i for i,c in enumerate(part) if len(c)>1);cell=part[idx] + vals=[] + for v in cell: + pp=part[:idx]+((v,),tuple(x for x in cell if x!=v))+part[idx+1:] + vals.append(rec(pp)) + return min(vals) + if n==0:return (0,edges) + return (n,rec((tuple(range(n)),))) + +def normalize(cs,delta,free=tuple(range(-6,0)),loop_dimension=D): + # Union the index variables related by Kronecker deltas. + parent={} + def root(x): + if x not in parent:parent[x]=x + if parent[x]!=x:parent[x]=root(parent[x]) + return parent[x] + def union(a,b): + a,b=root(a),root(b) + if a!=b:parent[b]=a + for t in cs: + for x in t:root(x) + for a,b in delta:union(a,b) + # all six boundary indices must occur once in a full monomial + for x in free:root(x) + ends=defaultdict(list) + for i,t in enumerate(cs): + for x in t:ends[root(x)].append(i) + for x in free:ends[root(x)].append(x) + coefficient=Q(1);edges=[] + for r in {root(x) for x in parent}: + vv=ends[r] + if len(vv)==0:coefficient*=loop_dimension + elif len(vv)==2: + edges.append(tuple(vv)) + else:raise ValueError(('bad degree',vv,cs,delta)) + return coefficient,canon_edges(len(cs),edges) + +def combine(poly,free=tuple(range(-6,0))): + out=defaultdict(Q) + for c,cs,de in poly: + if c: + f,g=normalize(cs,de,free);out[g]+=c*f + return {g:c for g,c in out.items() if c} + +def graph_tensors(g): + n,edges=g;cs=[[] for _ in range(n)];de=[] + for k,(a,b) in enumerate(edges): + if a<0 and b<0:de.append((a,b));continue + idx=a if a<0 else 1000+k + if a>=0:cs[a].append(idx) + if b>=0:cs[b].append(idx) + return tuple(map(tuple,cs)),tuple(de) + +def cycles(g,maxlen=4): + n,edges=g;cnt=Counter(edges) + loops=[(a,) for a,b in edges if a==b and a>=0] + if loops:return sorted(set(loops)) + doubles=[(a,b) for (a,b),c in cnt.items() if a>=0 and b>=0 and c>=2] + if doubles:return sorted(doubles) + adj={i:set() for i in range(n)} + for a,b in edges: + if a>=0 and b>=0:adj[a].add(b);adj[b].add(a) + found=set() + def go(path,target): + if len(path)==target: + if path[0] in adj[path[-1]]:found.add(min(tuple(path),tuple([path[0]]+list(reversed(path[1:]))))) + return + for nxt in sorted(adj[path[-1]]): + if nxt>path[0] and nxt not in path:go(path+[nxt],target) + for size in range(3,maxlen+1): + for i in range(n):go([i],size) + if found:return sorted(found) + return [] + +def replace_cycle(g,cyc): + if len(cyc)==1:return {} + cs,de=graph_tensors(g);free=tuple(sorted({v for e in g[1] for v in e if v<0}));cycle_indices=[] + k=len(cyc) + if k==2: + shared=list((Counter(cs[cyc[0]]) & Counter(cs[cyc[1]])).elements()) + cycle_indices=shared[:2] + else: + for i in range(k): + shared=set(cs[cyc[i]]) & set(cs[cyc[(i+1)%k]]) + if len(shared)!=1:raise ValueError('cycle shared') + cycle_indices.append(next(iter(shared))) + slots=[] + for i,v in enumerate(cyc): + rem=list(cs[v]) + if k==2: + for t in cycle_indices:rem.remove(t) + else: + rem.remove(cycle_indices[i]);rem.remove(cycle_indices[(i-1)%k]) + if len(rem)!=1:raise ValueError('remaining') + slots.append(rem[0]) + base=tuple(c for i,c in enumerate(cs) if i not in cyc) + if k==2: + return combine([(KAPPA,base,de+((slots[0],slots[1]),))],free) + if k==3: + return combine([(NU,base+(tuple(slots),),de)],free) + a,b,c,d=slots;t=99999 + terms=[(ALPHA,base+((a,b,t),(c,d,t)),de),(ALPHA,base+((a,d,t),(b,c,t)),de), + (BETA,base+((a,c,t),(b,d,t)),de), + (U,base,de+((a,b),(c,d))),(U,base,de+((a,d),(b,c))),(V,base,de+((a,c),(b,d)))] + return combine(terms,free) + +REDUCTION_COUNTS=Counter() +REDUCTION_DAG={} +@lru_cache(None) +def reduce(g): + cy=cycles(g) + if not cy:return {g:Q(1)} + cc=cy[0];REDUCTION_COUNTS[len(cc)]+=1 + step=replace_cycle(g,cc) + REDUCTION_DAG[g]=(cc,step) + result=defaultdict(Q) + for gg,ccoeff in step.items(): + for hh,dd in reduce(gg).items():result[hh]+=ccoeff*dd + return {g:c for g,c in result.items() if c} + +def reduce_poly(poly): + """Use only the degree-one through degree-four local trace identities.""" + out=defaultdict(Q) + for g,c in poly.items(): + for h,a in reduce(g).items():out[h]+=c*a + return {g:c for g,c in out.items() if c} + +def residual(): + x=lambda i,j:wedge(-1,-2,i,j) + y=lambda i,j:wedge(-3,-4,i,j) + z=lambda i,j:wedge(-5,-6,i,j) + gy=lambda i,j:G(y,i,j) + gz=lambda i,j:G(z,i,j) + gx=lambda i,j:G(x,i,j) + first=lambda i,j:Dact(-1,lambda k,l:G(lambda p,q:Dact(-2,gy,p,q),k,l),i,j) + second=lambda i,j:Dact(-2,lambda k,l:G(lambda p,q:Dact(-1,gy,p,q),k,l),i,j) + q=lambda i,j:addterms(first(i,j),scale(second(i,j),-1)) + op=lambda i,j:addterms(scale(q(i,j),9),scale(ad(x,gy,i,j),24336),scale(ad(gx,gy,i,j),-2704)) + i,j=fresh(),fresh() + return combine(scale(times(gz(i,j),op(j,i)),Q(-1,2))) + + + +# Boundary character: alternate within each pair, and between last two pairs. +def permmap(bits,exchange): + labels=list(range(-1,-7,-1));sign=1 + for j,b in enumerate(bits): + if b:labels[2*j],labels[2*j+1]=labels[2*j+1],labels[2*j];sign*=-1 + if exchange:labels[2:4],labels[4:6]=labels[4:6],labels[2:4];sign*=-1 + return {-(i+1):v for i,v in enumerate(labels)},sign +GROUP=[permmap(bits,e) for bits in itertools.product((0,1),repeat=3) for e in (0,1)] +@lru_cache(None) +def bcanon(g): + n,ed=g;best=None;sgn=None + for p,s in GROUP: + new=canon_edges(n,[(p.get(a,a),p.get(b,b)) for a,b in ed]) + if best is None or newp[j] for i in range(len(p)) for j in range(i+1,len(p))) +PERMS=[] +for p in permutations(range(1,5)): + seq=(0,)+p + if seq[1]. + + O is Q_x, ad_x, or ad_(Gx), in that order. The exterior inner product + is half Frobenius, equivalently -tr(XY)/2 on skew matrices. + """ + x=lambda i,j:wedge(-1,-2,i,j) + y=lambda i,j:wedge(-3,-4,i,j) + z=lambda i,j:wedge(-5,-6,i,j) + gy=lambda i,j:G(y,i,j) + gz=lambda i,j:G(z,i,j) + gx=lambda i,j:G(x,i,j) + if kind=='Q': + first=lambda i,j:Dact(-1,lambda k,l:G(lambda p,q:Dact(-2,gy,p,q),k,l),i,j) + second=lambda i,j:Dact(-2,lambda k,l:G(lambda p,q:Dact(-1,gy,p,q),k,l),i,j) + op=lambda i,j:addterms(first(i,j),scale(second(i,j),-1)) + elif kind=='x':op=lambda i,j:ad(x,gy,i,j) + elif kind=='Gx':op=lambda i,j:ad(gx,gy,i,j) + else:raise ValueError('Unknown operator component') + i,j=fresh(),fresh() + return combine(scale(times(gz(i,j),op(j,i)),Q(-1,2))) + +def norm_polynomial(first,second,loop_dimension=D): + """Exact inner product of boundary-projected six-index tensors.""" + poly=defaultdict(Q) + for g,c in first.items(): + for h,a in second.items(): + for perm,sign in GROUP: + fac,gg=glue(g,h,perm,loop_dimension=loop_dimension) + poly[gg]+=c*a*Q(sign,16)*fac + return {g:c for g,c in poly.items() if c} + +# The three irreducible closed graphs that survive the short-cycle reduction. +# Labels are vertex indices, not group elements. Each has degree three. +EMPTY=(0,()) +P10=(10,((0,1),(0,2),(0,3),(1,4),(1,5),(2,6),(2,7),(3,8),(3,9), + (4,6),(4,8),(5,7),(5,9),(6,9),(7,8))) +A12=(12,((0,1),(0,2),(0,3),(1,4),(1,5),(2,6),(2,7),(3,8),(3,9), + (4,6),(4,8),(5,7),(5,9),(6,10),(7,11),(8,11),(9,10),(10,11))) +B12=(12,((0,1),(0,2),(0,3),(1,4),(1,5),(2,6),(2,8),(3,7),(3,9), + (4,6),(4,11),(5,7),(5,10),(6,10),(7,11),(8,9),(8,11),(9,10))) +PENTAGON=(0,1,4,6,2) +SCALAR_GRAPHS=(EMPTY,P10,A12,B12) + +def solve_system(matrix,rhs): + """Small exact Gaussian elimination, with singularity detection.""" + n=len(rhs);rows=[list(map(Q,row))+[Q(b)] for row,b in zip(matrix,rhs)] + determinant=Q(1) + for k in range(n): + pivot=next((j for j in range(k,n) if rows[j][k]),None) + if pivot is None:raise ArithmeticError('Singular certificate system') + if pivot!=k:rows[k],rows[pivot]=rows[pivot],rows[k];determinant=-determinant + p=rows[k][k];determinant*=p;rows[k]=[x/p for x in rows[k]] + for j in range(n): + if j!=k: + p=rows[j][k] + rows[j]=[a-p*b for a,b in zip(rows[j],rows[k])] + return [row[-1] for row in rows],determinant + +def encode_graph(g): return {'vertices':g[0],'edges':[list(e) for e in g[1]]} +def encode_poly(poly): + return [{'coefficient':str(c),'graph':encode_graph(g)} for g,c in sorted(poly.items()) if c] + +def build_certificate(): + """Recompute all diagrams, short-cycle reductions, and the three trace-five rows.""" + components=[project(component(kind)) for kind in ('Q','x','Gx')] + relations=[fifth_relation(g,PENTAGON) for g in SCALAR_GRAPHS[1:]] + for row in relations: + if set(row)-set(SCALAR_GRAPHS):raise ArithmeticError('Unresolved scalar contraction') + mat=[[row.get(g,Q(0)) for g in SCALAR_GRAPHS[1:]] for row in relations] + rhs=[-row.get(EMPTY,Q(0)) for row in relations] + sol,determinant=solve_system(mat,rhs) + values={EMPTY:Q(1),**dict(zip(SCALAR_GRAPHS[1:],sol))} + inner=[];reduced=[];raw=[] + for i in range(3): + rr=[];pp=[];rawrow=[] + for j in range(3): + polynomial=norm_polynomial(components[i],components[j]) + red=reduce_poly(polynomial) + if set(red)-set(values):raise ArithmeticError('Unresolved Gram contraction') + rr.append(sum((c*values[g] for g,c in red.items()),Q(0))) + pp.append(red);rawrow.append(polynomial) + inner.append(rr);reduced.append(pp);raw.append(rawrow) + factors=(Q(9,2704),Q(9),Q(1)) + common=Q(107700439863024387072) + gram=[[inner[i][j]*factors[i]*factors[j]/common for j in range(3)] for i in range(3)] + return {'components':components,'relations':relations,'relation_matrix':mat,'relation_rhs':rhs, + 'relation_determinant':determinant,'values':values,'raw_gram':raw,'reduced_gram':reduced, + 'unscaled_gram':inner,'rescaling':factors,'common_factor':common,'small_gram':gram} diff --git a/checks/verify_operator_factorization.py b/checks/verify_operator_factorization.py new file mode 100644 index 0000000..f16b093 --- /dev/null +++ b/checks/verify_operator_factorization.py @@ -0,0 +1,294 @@ +#!/usr/bin/env python3 +"""Exact six-label factorization certificate plus independent small controls. + +The symbolic proof uses the declared cubic trace equations, not numerical +Monster data. Controls evaluate unrestricted small real cubics directly and +must NOT be presented as extremal CFTs or as satisfying the physical inputs. +NumPy object arrays perform integer/Fraction contractions without roundoff. +""" +from __future__ import annotations +from collections import defaultdict, Counter +from fractions import Fraction as F +from itertools import combinations, permutations +from functools import lru_cache +import json +import random +import numpy as np +import operator_factorization_graphs as g + +BASE='09e3f98ad79034eefab43f4fb9ea432368fc19e7' +LABELS=[] +LARGEST_ARRAY_ENTRIES=0 +LARGEST_MATRIX_DIMENSION=0 + +def need(ok,label): + if not bool(ok):raise RuntimeError(label) + LABELS.append(label) + +def keep_size(a): + global LARGEST_ARRAY_ENTRIES,LARGEST_MATRIX_DIMENSION + LARGEST_ARRAY_ENTRIES=max(LARGEST_ARRAY_ENTRIES,int(a.size)) + if a.ndim==2 and a.shape[0]==a.shape[1]: + LARGEST_MATRIX_DIMENSION=max(LARGEST_MATRIX_DIMENSION,a.shape[0]) + return a + +def symmetric_cubic(d,seed): + rng=random.Random(seed);C=np.zeros((d,d,d),dtype=object) + for i in range(d): + for j in range(i,d): + for k in range(j,d): + value=rng.randint(-2,3) + for p in set(permutations((i,j,k))):C[p]=value + return keep_size(C) + +class ClosedGraphEvaluator: + """Independent dense contraction, with its own greedy contraction ordering.""" + def __init__(self,C):self.C=C;self.cache={} + def value(self,graph): + if graph in self.cache:return self.cache[graph] + vertices,edges=graph + if any(a<0 or b<0 for a,b in edges):raise ValueError('Only closed graphs here') + incident=[[] for _ in range(vertices)] + for idx,(a,b) in enumerate(edges):incident[a].append(idx);incident[b].append(idx) + arrays=[] + for labels in incident: + if len(labels)!=3:raise ValueError('Nontrivalent input') + A=self.C.copy();labels=list(labels) + while len(set(labels))1) + i,j=[k for k,x in enumerate(labels) if x==repeated] + A=np.trace(A,axis1=i,axis2=j);labels=[x for k,x in enumerate(labels) if k not in (i,j)] + arrays.append((keep_size(np.asarray(A,dtype=object)),labels)) + scalar=F(1) + while arrays: + scalars=[i for i,(a,labels) in enumerate(arrays) if not labels] + if scalars: + for i in reversed(scalars):scalar*=arrays.pop(i)[0].item() + continue + if len(arrays)==1:raise ValueError('Uncontracted edge') + options=[] + for i,(a,la) in enumerate(arrays): + for j in range(i+1,len(arrays)): + b,lb=arrays[j];shared=set(la)&set(lb) + if shared: + rank=len(la)+len(lb)-2*len(shared) + options.append((rank,-len(shared),i,j)) + if not options:raise ValueError('Disconnected non-scalar remainder') + _,_,i,j=min(options);a,la=arrays[i];b,lb=arrays[j] + shared=sorted(set(la)&set(lb));axesA=[la.index(x) for x in shared];axesB=[lb.index(x) for x in shared] + c=keep_size(np.tensordot(a,b,axes=(axesA,axesB))) + labels=[x for x in la if x not in shared]+[x for x in lb if x not in shared] + arrays.pop(j);arrays.pop(i);arrays.append((c,labels)) + self.cache[graph]=scalar + return scalar + def polynomial(self,poly):return sum((a*self.value(k) for k,a in poly.items()),F(0)) + +def explicit_tensor_gram(C): + """Direct matrices: no tensor graph generator, trace rules, or source coefficients.""" + d=len(C);L=[keep_size(C[i].copy()) for i in range(d)] + pairs=list(combinations(range(d),2));wedges=[] + for a,b in pairs: + X=np.zeros((d,d),dtype=object);X[a,b]=1;X[b,a]=-1;wedges.append(keep_size(X)) + def field(X):return sum((A@X@A for A in L),np.zeros((d,d),dtype=object)) + def G(X):return field(X)+F(1,3)*X + def D(a,X):return L[a]@X+X@L[a] + def ad(A,X):return A@X-X@A + values=[] + for (a,b),X in zip(pairs,wedges): + for Y in wedges: + GY=G(Y) + QY=D(a,G(D(b,GY)))-D(b,G(D(a,GY))) + ops=(QY,ad(X,GY),ad(G(X),GY)) + for Z in wedges: + GZ=G(Z) + values.append([-F(1,2)*np.trace(GZ@op) for op in ops]) + # Tensor coefficients are defined for six ORDERED field indices. Each unit + # exterior triple occurs 2^3 times; no normalized-Frobenius factor is used. + M=[[8*sum((v[i]*v[j] for v in values),F(0)) for j in range(3)] for i in range(3)] + return M,len(values) + +def expand_boundary(poly): + out=defaultdict(F) + for graph,c in poly.items(): + n,edges=graph + for perm,sign in g.GROUP: + h=g.canon_edges(n,[(perm.get(a,a),perm.get(b,b)) for a,b in edges]) + out[h]+=c*F(sign,16) + return {k:v for k,v in out.items() if v} + +def graph_controls(certificate): + # Prove that the signed boundary averaging changes none of the three + # actual component tensors, not merely that their projected norms vanish. + for kind in ('Q','x','Gx'): + raw=g.component(kind) + need(expand_boundary(raw)==raw,f'boundary:{kind}_exact_pair_antisymmetries') + need(expand_boundary(g.project(raw))==raw,f'boundary:{kind}_canonical_orbits_reconstruct_original') + need(len(g.GROUP)==16,'boundary:16_signed_permutations') + need(len(g.PERMS)==12,'fifth:12_dihedral_trace_representatives') + # Isomorphic relabelling is only dummy-index renaming. + examples=list(certificate['raw_gram'][0][0])[:12]+list(g.SCALAR_GRAPHS[1:]) + rng=random.Random(240026) + for i,graph in enumerate(examples): + n,edges=graph;perm=list(range(n));rng.shuffle(perm) + relabelled=[(perm[a] if a>=0 else a,perm[b] if b>=0 else b) for a,b in edges] + need(g.canon_edges(n,relabelled)==graph,f'graph:dummy_relabelling_{i}') + records=[] + for d,seed in ((2,17),(3,28)): + C=symmetric_cubic(d,seed);evaluator=ClosedGraphEvaluator(C) + direct,count=explicit_tensor_gram(C) + for i in range(3): + for j in range(i,3): + raw=g.norm_polynomial(certificate['components'][i],certificate['components'][j],loop_dimension=d) + result=evaluator.polynomial(raw) + need(result==direct[i][j],f'direct:d{d}_component_Gram_{i}{j}') + kernel=(F(9),F(24336),F(-2704)) + residual=sum((kernel[i]*direct[i][j]*kernel[j] for i in range(3) for j in range(3)),F(0)) + if d==2: + need(residual==0,'control:d2_one_dimensional_exterior_has_zero_skew_action') + else: + need(residual>0,f'negative:d{d}_arbitrary_cubic_does_not_satisfy_factorization') + records.append({'dimension':d,'exterior_triples_tested':count, + 'exact_direct_Gram':direct,'residual_norm_squared':residual, + 'closed_graphs_independently_evaluated':len(evaluator.cache), + 'satisfies_physical_trace_inputs':False}) + return records + +def fifth_projection_controls(): + """Check the full-versus-primary subtraction independently with block matrices.""" + C=symmetric_cubic(5,515);d=len(C);eye=np.eye(d,dtype=object) + L=[C[i] for i in range(d)] + def traceword(mats): + X=np.eye(len(mats[0]),dtype=object) + for A in mats:X=X@A + return np.trace(X) + def features(labels,multiplication,metric_vectors): + # Every vector space here is positive with an explicit invariant product. + def product(a,b):return multiplication(a)@b + def H(a,b,c,d,e):return product(a,b)@product(c,product(d,e)) + T=[F(0),F(0),F(0)];Ma=F(0);Mn=F(0) + vectors=[metric_vectors[i] for i in labels] + for k in range(5): + a,b,c,dd,e=vectors[k:]+vectors[:k] + T[0]+=H(a,b,c,dd,e);T[1]+=H(a,dd,c,b,e);T[2]+=H(a,e,c,b,dd) + Ma+=(a@b)*(c@product(dd,e));Mn+=(a@c)*(b@product(dd,e)) + return T,Ma,Mn + def primary_matrix(a):return sum((a[i]*L[i] for i in range(d)),np.zeros((d,d),dtype=object)) + primary_vectors=[eye[:,i] for i in range(d)] + tuples=[tuple(range(5)),(0,0,1,2,4),(4,3,2,3,1),(1,1,1,1,2)] + for s in (F(1),F(1,2),F(1,3)): + gamma=s*s + R=[] + for i in range(d): + A=np.zeros((d+1,d+1),dtype=object);A[0,i+1]=s;A[i+1,0]=s;A[1:,1:]=L[i] + R.append(keep_size(A)) + Rt=s*np.eye(d+1,dtype=object) + def full_matrix(a):return a[0]*Rt+sum((a[i+1]*R[i] for i in range(d)),np.zeros((d+1,d+1),dtype=object)) + fv=[np.concatenate((np.asarray([0],dtype=object),e)) for e in primary_vectors] + for idx,labels in enumerate(tuples): + T,Ma,Mn=features(labels,primary_matrix,primary_vectors) + U,fa,fn=features(labels,full_matrix,fv) + need(U==[T[0]+2*gamma*Ma,T[1]+2*gamma*Mn,T[2]+gamma*(Ma+Mn)], + f'projection:s{s}_tree_scalar_terms_{idx}') + difference=traceword([R[i] for i in labels])-traceword([L[i] for i in labels]) + need(difference==gamma*T[0]+gamma*gamma*Ma,f'projection:s{s}_cyclic_block_trace_{idx}') + full=30*U[0]+4*U[1]-22*U[2]+8*fa+8*fn + projected=(30-gamma)*T[0]+4*T[1]-22*T[2]+(8+38*gamma-gamma*gamma)*Ma+(8-14*gamma)*Mn + need(full-projected==difference,f'projection:s{s}_all_primary_fifth_coefficients_{idx}') + need((30-F(1,3),8+38*F(1,3)-F(1,9),8-14*F(1,3))==(F(89,3),F(185,9),F(10,3)), + 'projection:physical_fifth_coefficients') + # The entire tree-and-metric RHS has zero total alternating part. This test + # has five independent external basis labels, not an automatic d<5 zero. + alt=F(0) + for labels in permutations(range(5)): + T,Ma,Mn=features(labels,primary_matrix,primary_vectors) + alt+=g.sgn(labels)*(F(89,3)*T[0]+4*T[1]-22*T[2]+F(185,9)*Ma+F(10,3)*Mn) + need(alt==0,'fifth:all120_permutations_cancel_non_alternating_RHS') + return {'block_matrix_dimension':6,'scalar_couplings_tested':['1','1/2','1/3'], + 'tuple_count_per_coupling':len(tuples),'alternation_terms':120, + 'tested_fifth_trace_identity_on_unknown_physical_cubic':False} + +def certificate_checks(c): + expected=[[17069,221,17290],[221,349,570],[17290,570,17860]] + need(c['small_gram']==expected,'certificate:exact_small_Gram') + need(c['relation_determinant']==F(11,18),'certificate:three_scalar_relations_nonsingular') + expected_values=[-F(78155392232087354080,81),F(370415245037399715987080,243),-F(833649013146827440152746,243)] + for i,(graph,want) in enumerate(zip(g.SCALAR_GRAPHS[1:],expected_values)): + need(c['values'][graph]==want,f'certificate:closed_invariant_{i}') + need(sum((a*c['values'][h] for h,a in c['relations'][i].items()),F(0))==0, + f'certificate:scalar_relation_{i}_substituted') + need(c['common_factor']>0,'certificate:positive_Gram_scale') + K=c['small_gram'];z=[1,1,-1] + need([sum(a*b for a,b in zip(row,z)) for row in K]==[0,0,0],'certificate:zero_residual_vector') + need(K[0][0]*K[1][1]-K[0][1]**2==5908240,'certificate:positive_two_by_two_minor') + need(K[2]==[a+b for a,b in zip(K[0],K[1])],'certificate:third_tensor_equals_sum_in_positive_space') + need((F(2704,9)*9,9*2704)==(2704,24336),'normalization:restore_original_operator_coefficients') + coeff=(F(9),F(24336),F(-2704));M=c['unscaled_gram'] + need(sum(coeff[i]*M[i][j]*coeff[j] for i in range(3) for j in range(3))==0, + 'certificate:unscaled_operator_residual_norm_zero') + # The short-cycle identities alone leave unreduced invariants: no claim + # that merely stopping a rewrite proves independence from those identities. + residual=defaultdict(F) + for i in range(3): + for j in range(3): + for h,a in c['reduced_gram'][i][j].items():residual[h]+=coeff[i]*coeff[j]*a + residual={h:a for h,a in residual.items() if a} + need(len(residual)==4,'scope:three_unresolved_invariants_before_fifth_relations') + need(sum(a*c['values'][h] for h,a in residual.items())==0,'certificate:all_four_remaining_terms_cancel') + need(max(n for n,edges in g.REDUCTION_DAG)<=16,'scope:no_graph_above_sixteen_cubic_vertices') + for n in (2,3,4): + need(g.REDUCTION_COUNTS[n]>0,f'certificate:trace_order_{n}_used') + return residual + +def serialized_certificate(c,residual): + dag=[{'input':g.encode_graph(graph),'cycle':list(cycle),'replacement':g.encode_poly(step)} + for graph,(cycle,step) in sorted(g.REDUCTION_DAG.items())] + return {'source_constants':{'d':g.D,'kappa':str(g.KAPPA),'nu':str(g.NU), + 'fourth':[str(x) for x in (g.ALPHA,g.BETA,g.U,g.V)], + 'projected_non_alternating_fifth':['89/3','4','-22','185/9','10/3']}, + 'component_order':['Q_x','ad_x','ad_Gx'], + 'six_index_components':[g.encode_poly(p) for p in c['components']], + 'rescaling':[str(x) for x in c['rescaling']], + 'raw_Gram_polynomials':[[g.encode_poly(p) for p in row] for row in c['raw_gram']], + 'short_cycle_Gram_reductions':[[g.encode_poly(p) for p in row] for row in c['reduced_gram']], + 'scalar_graphs':[g.encode_graph(h) for h in g.SCALAR_GRAPHS], + 'pentagon':list(g.PENTAGON), + 'three_fifth_relations':[g.encode_poly(row) for row in c['relations']], + 'scalar_relation_matrix':c['relation_matrix'],'scalar_relation_rhs':c['relation_rhs'], + 'scalar_relation_determinant':c['relation_determinant'], + 'scalar_graph_values':[str(c['values'][h]) for h in g.SCALAR_GRAPHS], + 'unscaled_Gram':c['unscaled_gram'],'positive_common_scale':c['common_factor'], + 'small_Gram':c['small_gram'],'kernel_vector':[1,1,-1], + 'original_residual_coefficients':[9,24336,-2704], + 'residual_before_fifth':g.encode_poly(residual), + 'all_short_cycle_steps':dag} + +def strings(o): + if isinstance(o,F):return str(o) + if isinstance(o,dict):return {str(k):strings(v) for k,v in o.items()} + if isinstance(o,(tuple,list)):return [strings(v) for v in o] + if isinstance(o,np.integer):return int(o) + return o + +def main(): + certificate=g.build_certificate() + residual=certificate_checks(certificate) + graph=graph_controls(certificate) + projection=fifth_projection_controls() + report={'status':'PASS: exact positive-norm implication certificate and scoped controls', + 'base_commit':BASE,'checks':len(LABELS),'labels':LABELS, + 'certificate':serialized_certificate(certificate,residual), + 'direct_small_cubic_controls':graph,'fifth_normalization_controls':projection, + 'largest_explicit_matrix_dimension':LARGEST_MATRIX_DIMENSION, + 'largest_numeric_tensor_entries':LARGEST_ARRAY_ENTRIES, + 'largest_symbolic_graph_vertices':max(h[0] for row in certificate['raw_gram'] for poly in row for h in poly), + 'short_cycle_reduction_steps':len(g.REDUCTION_DAG), + 'arithmetic':'integers and fractions; no floating tolerances', + 'full_Monster_tensor_constructed':False,'Monster_character_data_used':False, + 'six_label_operator_condition_independent':'NO: implied by stated traces and positive metric', + 'uses_disputed_alternating_five_form_coefficient':False, + 'real_positive_metric_required_for_zero_norm_implication':True, + 'source_theorems_formally_verified':False,'independent_expert_review':False, + 'full_physical_selection_or_novelty_claim':False} + print(json.dumps(strings(report),indent=2,sort_keys=True)) + +if __name__=='__main__':main() diff --git a/research/24_operator_factorization_closure.md b/research/24_operator_factorization_closure.md new file mode 100644 index 0000000..bbdbd83 --- /dev/null +++ b/research/24_operator_factorization_closure.md @@ -0,0 +1,247 @@ +# The uncontracted mixed-action condition is already forced + +**Date:** 26 September 2026. **Read base:** `09e3f98ad79034eefab43f4fb9ea432368fc19e7`. +**Intended additive branch:** `research/operator-factorization-closure`. + +## 1. Result: settle the outstanding implication, rather than add another moment + +The six-label operator condition introduced in Note18 is a consequence of the earlier real cubic trace identities through order five and the positive metric. It is **not an independent selection condition** on admissible physical interaction tensors. This answers the implication question left unresolved in Notes18–23. It does not classify the tensors or select the Monster uniquely. + +The simplification is to calculate one positive squared mismatch instead of comparing every matrix entry. After rescaling three six-index tensors, their exact Gram matrix is a positive scalar times + +$$ +\begin{pmatrix} +17069&221&17290\\ +221&349&570\\ +17290&570&17860 +\end{pmatrix}. +$$ + +Its third row is the sum of its first two, so the squared norm of the first tensor plus the second minus the third is zero. Positive definiteness of the real tensor inner product makes the tensors equal. The nonzero two-by-two minor is 5908240, so this is their only linear relation up to scale. + +The Gram calculation is a finite exact contraction certificate, not a numerical evaluation of a known Monster tensor. Three scalar contractions, fixed by three instances of the non-alternating fifth trace, finish the reduction. Their coefficient matrix has determinant 11/18. The entire reduction record is emitted by the checker. + +No value of the disputed coefficient of the alternating five-form is used: that term is eliminated before the calculation starts. No additional weight-nine Ward identity, canonical thermal field, state-readout theorem or pure-state witness is an input to this implication proof. + +The conclusion is for **real symmetric cubics in a positive Euclidean space**. The argument is a positive sum-of-squares implication, not a claim of membership in the ordinary complex polynomial ideal. Over an indefinite or complex bilinear metric a zero square would not suffice. + +## 2. Physical question and precise algebraic premises + +The owner seeks a physical reason for the Monster's exceptional role, not recognition of an imposed symmetry. The ongoing admissible class is nontrivial simple unitary strongly rational bosonic holomorphic chiral CFTs, with no weight-one currents, minimizing positive central charge. These are declared restrictions and an extremality criterion, not universal physical necessities or a demonstrated RG mechanism. Prior modular/design results give c=24 and the lower trace inputs used here, without assuming a Monster action [H, M]. + +The theorem itself is algebraic. Let C be a real fully symmetric cubic on V=R^d with its positive inner product. Put (L_a)_{ij}=C(a,e_i,e_j), mu(a,b)=L_a b, and + +$$d=196883,\quad\kappa=13858/3,\quad\nu=899.$$ + +Assume the following identities for all external vectors: + +$$\operatorname{tr}L_a=0,\qquad +\operatorname{tr}(L_aL_b)=\kappa\langle a,b\rangle,\qquad +\operatorname{tr}(L_aL_bL_c)=\nu C(a,b,c).\tag{A1--A3}$$ + +The fourth trace is + +$$\begin{aligned} +\operatorname{tr}(L_aL_bL_cL_e)={}&\alpha\bigl(\langle\mu(a,b),\mu(c,e)\rangle+ +\langle\mu(a,e),\mu(b,c)\rangle\bigr)\\ +&+\beta\langle\mu(a,c),\mu(b,e)\rangle\\ +&+u\bigl(\langle a,b\rangle\langle c,e\rangle+ +\langle a,e\rangle\langle b,c\rangle\bigr) ++v\langle a,c\rangle\langle b,e\rangle, +\end{aligned}\tag{A4}$$ + +where (alpha,beta,u,v)=(496/3,-116,965/9,40/3). These are the primary-projected coefficients in main Note02, rather than the full V2 constants. + +For five vectors define primary-only trees + +$$H(a,b;c;d,e)=\langle\mu(a,b),\mu(c,\mu(d,e))\rangle,$$ + +$$T_1=\operatorname{Cyc}H(1,2;3;4,5),\quad +T_2=\operatorname{Cyc}H(1,4;3;2,5),\quad +T_3=\operatorname{Cyc}H(1,5;3;2,4),$$ + +$$M_a=\operatorname{Cyc}\langle1,2\rangle C(3,4,5),\qquad +M_n=\operatorname{Cyc}\langle1,3\rangle C(2,4,5).$$ + +Cyc is the sum of five rotations, not their average. Alt5 is the normalized signed average over all120 permutations. The fifth input is only + +$$\boxed{\operatorname{tr}(L_1L_2L_3L_4L_5) +-\operatorname{Alt}_5\operatorname{tr}(L_1L_2L_3L_4L_5) +=\frac{89}{3}T_1+4T_2-22T_3+\frac{185}{9}M_a+\frac{10}{3}M_n.}\tag{A5}$$ + +This is an explicit polynomial identity in C. It contains no unspecified alternating tensor. The known existence of an admissible cubic is not established by the checker; it is supplied by the known moonshine theory and the source framework. Small controls below do not pretend to satisfy these exceptional numerical premises. + +## 3. Why A5 is independent of the five-form normalization dispute + +For the full weight-two algebra write R_a as the block matrix + +$$R_a=\begin{pmatrix}0&s a^T\\s a&L_a\end{pmatrix},\qquad s^2=\gamma=1/3.$$ + +Let the full-product trees be denoted by a superscript full. Direct block multiplication and scalar-direction separation give + +$$T_1^{\rm full}=T_1+2\gamma M_a,\quad +T_2^{\rm full}=T_2+2\gamma M_n,\quad +T_3^{\rm full}=T_3+\gamma(M_a+M_n),$$ + +$$\operatorname{tr}(R_1\cdots R_5)-\operatorname{tr}(L_1\cdots L_5) +=\gamma T_1+\gamma^2M_a.\tag{1}$$ + +The full non-alternating fifth-trace coefficients are (30,4,-22,8,8) [M, Corollary4.1]. The separate coefficient r multiplying its alternating five-form is immaterial: taking Alt5 and subtracting removes r times that form for **any** convention. Each tree or metric-times-cubic structure has zero total alternation because it has a symmetric pair. + +After (1), the projected coefficients are + +$$(30-\gamma,\ 4,\ -22,\ 8+38\gamma-\gamma^2,\ 8-14\gamma),$$ + +which at gamma=1/3 give A5. Thus neither choosing26 nor choosing52 is part of this proof. This does not rehabilitate PR12's false condition; it uses the safe portion of the trace identity that never involved that convention. + +The checker independently verifies all the scalar-block subtraction formulas using ordinary block matrices for arbitrary small symmetric cubics at three rational values of s. These controls test the conversion, not the exceptional trace theorem itself. Its fifth-form alternation check uses five independent external labels and all120 permutations. + +## 4. The operator condition to be proved + +Identify a wedge b with ab^T-ba^T and use half the Frobenius product on skew matrices. Define + +$$F(X)=\sum_iL_iXL_i,\quad G=F_-+I/3,\quad +\mathcal D_a(X)=L_aX+XL_a.$$ + +A1--A4 imply G^2=282G, so G=282Pi for an orthogonal projector Pi. For + +$$x=\sum_{a0.\tag{4}$$ + +Consequently + +$$\|A+B-C_0\|^2=0.$$ + +The metric is positive and the tensors are real, so A+B=C0 component by component. Multiply by2704 and use that decomposable exterior vectors span wedge^2 V. This proves (2) for all x and all matrix elements. + +The leading two-by-two minor of the displayed integer matrix is5908240>0. Thus A and B are linearly independent and C0=A+B is the unique linear relation among these three tensors, up to overall scale. This uniqueness is limited to this specified three-dimensional ansatz. It does not classify all multilinear identities or the cubic itself. + +The proof is not the assertion that a small set of physical examples has zero residual. It calculates the universal norm from A1--A5 and then uses positivity. It proves implication on the physical real solution set; it does not exhibit a polynomial ideal-membership certificate over an arbitrary complex field. + +## 6. Exact contraction certificate for equation (4) + +A graph represents an Einstein contraction of copies of the fully symmetric cubic C. Every internal vertex has degree three; an edge contracts two indices; six labelled one-valent boundaries represent the six external fields. Closed graphs are scalars. An isolated contracted delta loop contributes d. Dummy-index graph isomorphisms are only a notation reduction, not additional algebraic hypotheses. + +A1 deletes a self-trace loop. A2 collapses a two-edge loop with factor kappa; A3 collapses a triangle with factor nu. A4 replaces a square by its three two-vertex pairings and three delta pairings, with the coefficients displayed in A4. These rules strictly reduce the number of cubic vertices. The complete emitted certificate records every local replacement, with the selected cycle and exact coefficients. + +After expanding the norms of (3), these reductions leave only the empty contraction and three closed cubic graphs, denoted P,A12,B12. Their edge lists are below; graph vertices are numbered from0, and have nothing to do with group elements. + +``` +P (10 vertices): +01 02 03 14 15 26 27 38 39 46 48 57 59 69 78 + +A12 (12 vertices): +01 02 03 14 15 26 27 38 39 46 48 57 59 (6,10) (7,11) +(8,11) (9,10) (10,11) + +B12 (12 vertices): +01 02 03 14 15 26 28 37 39 46 (4,11) 57 (5,10) (6,10) +(7,11) 89 (8,11) (9,10) +``` + +Apply A5 to the pentagon (0,1,4,6,2) in each graph. Normalized alternating traces can be expanded over12 representatives of S5/D5, because trace is cyclic and reversal-invariant for real symmetric matrices and reversal of five labels is even. Reduce the resulting short cycles by A1--A4. The three equations, with their constants retained, are + +$$\frac{11}{12}P+\frac{214927328638240223720}{243}=0,$$ + +$$\frac{155}{9}P+\frac56A12+\frac16B12 +-\frac{497099520224112030008927}{729}=0,$$ + +$$-\frac{224}{9}P+\frac16A12+\frac56B12 ++\frac{1881408102488381175074405}{729}=0.\tag{5}$$ + +The coefficient matrix has determinant11/18, so the values are fixed: + +$$P=-\frac{78155392232087354080}{81},\quad +A12=\frac{370415245037399715987080}{243},\quad +B12=-\frac{833649013146827440152746}{243}.$$ + +These signed contractions are not themselves squared norms; their negative values do not violate positivity. + +For a shorter check of the final cancellation, the unscaled residual in (2), paired with exterior inputs as above, has squared norm + +$$\begin{aligned} +&922900921397634135853733913856 ++60784328448P\\ +&\hspace{12mm}-103063104A12+206126208B12=0.\tag{6} +\end{aligned}$$ + +The stronger full Gram result (4), not just this one zero, is emitted by the same reduction. The report includes the original boundary tensor expansions, every raw scalar Gram polynomial, its short-cycle reduction, the three fifth-trace contexts and the136 local short-cycle replacements. No unreduced invariant is assigned a value by comparison with the desired answer. The only numerical inputs are d and A1--A5. + +The largest symbolic graph has16 cubic vertices. This is a bound on the complexity of an index-contraction proof, not a16-dimensional physical model. The actual field space stays symbolic throughout. + +## 7. Physical interpretation: the two routes already agree + +For the previously established onto map B from exterior pairs to weight-three primaries, G=B^dagger B=282Pi. The corrected mixed action reads + +$$H_a\simeq\frac{282}{104}\Pi\mathcal D_a\Pi.$$ + +Using the normalized descendant identification L_-1/2, the primary compression of the full mode commutator includes the excursion term + +$$\pi_3 B(a,b)_{(2)}\pi_3 +=[H_a,H_b]+\frac14(b_ab_b^\dagger-b_bb_a^\dagger),\qquad b_a(v)=B(a,v).\tag{7}$$ + +The separately reconstructed primary3,3,3 law gives + +$$B^\dagger K_{Bz}B=\frac1{36}G\operatorname{ad}_{Gz}G.$$ + +Substitution of the two actions into (7) produced the proposed extra condition (2). The present result proves that it is already forced by the preceding trace system. Every real positive candidate satisfying A1--A5 passes this particular compatibility test. It cannot eliminate additional candidates or be counted as independent evidence of unique physical selection. + +The physical action formulas retain their previously recorded source and normalization obligations. The new pure-algebra implication does not depend on accepting their derivations: it proves exactly the displayed equation from A1--A5. It also does not extend a primary-projected commutator into a Lie algebra or justify imposing Jacobi on the truncated primary product. + +An apparently new uncontracted restriction has therefore collapsed to a positive norm identity. The remaining selection problem is not an ever-growing list of variants of (2): it is whether the real positive cubic solutions of the original trace system are unique up to field-basis change, or which genuinely independent higher OPE information distinguishes them. This note constructs no competing solution and supplies no classification theorem. + +## 8. Tests, preservation and limits + +The checker has95 labelled exact checks. It recomputes the certificate rather than loading the3x3 Gram as a premise. It independently evaluates the original tensor contractions on arbitrary small cubics by two routes: direct matrix actions and dense Einstein contractions with a separate contraction order. These agree on all six independent Gram entries in dimensions2 and3. The dimension-three control does NOT obey the desired operator law, as expected because it does not satisfy A1--A5. In dimension two the exterior space is one-dimensional and its skew action vanishes identically; this is a boundary control, not a physical countermodel. + +Separate generic block-matrix controls at dimension six verify full-to-primary fifth-trace subtraction for three scalar couplings, and all120 permutations check the vanishing alternating part of its tree RHS. All tests use integers and fractions, including NumPy object-array contractions. There is no floating tolerance. Largest explicit square matrix:6x6. Largest numerical tensor:729 entries. No Monster character data, representation, or full extremal tensor is constructed. + +A symbolic contraction proof implemented in ordinary Python is not proof-assistant formal verification, an independent specialist review, or comprehensive priority clearance. The source trace theorems remain inputs. The complete certificate is intended to make a fresh mathematical and code audit possible rather than replace it. Its use of a positive metric is essential and openly stated. + +The supplied preceding pure-state checkpoint was preserved and replayed: all13 payload hashes and all119 checks under normal/-O/-OO agree. The present proof does not need the state-readout result. The historical main, all pending branches and old evidence are to be preserved. Runtime Git networking failed at DNS resolution; local new checks are not a local checkout/replay of live main. Any remote verification outcome is recorded separately only after actual execution and log inspection. No archived report or tolerance may be changed to conceal a mismatch. + +No manuscript, release, outreach, physical implementation, efficient algorithm, new general trace theorem, independent selection axiom, or moonshine uniqueness is claimed. + +## Primary sources and read depth + +[M] A. Matsuo, *Norton's Trace Formulae for the Griess Algebra of a Vertex Operator Algebra with Larger Symmetry*, arXiv:math/0007169v1, Corollary4.1, Note4.2 and Remark4.3. Printed page16 was visually inspected in this continuation; Remark4.3's extension to rational holomorphic c24 theories with the stated shape was read in parsed text. The lower trace formulas and the NON-ALTERNATING fifth identity are used. The disputed numerical coefficient of the five-form is eliminated, not adopted. The entire underlying Casimir proof is not independently rederived here. +https://arxiv.org/abs/math/0007169 + +[H] G. Hoehn, *Conformal Designs based on Vertex Operator Algebras*, arXiv:math/0701626v1. The project inherits Theorem3.1 and the design-to-trace replacement recorded in Note12. This source remains the reason the trace system is applicable without assuming a Monster action, not a theorem proved by this graph calculation. +https://arxiv.org/abs/math/0701626 + +Project inputs: main Note02, section3.1 for the projected fourth trace; Note12 for the physical-source interface; pending Note18 at commit9254b954ed7e3d1fb2033175e66552fdf0092823 for the exact unresolved equation; the supplied fifth-trace reconstruction for an independent audit of the non-alternating coefficients. No complete original Norton1996 chapter was obtained or reviewed in this continuation. A scoped search is not a novelty certificate. No downloaded paper or font is bundled. diff --git a/results/operator_factorization_additions.json b/results/operator_factorization_additions.json new file mode 100644 index 0000000..5078b7b --- /dev/null +++ b/results/operator_factorization_additions.json @@ -0,0 +1,31 @@ +{ + "base_commit": "09e3f98ad79034eefab43f4fb9ea432368fc19e7", + "files": [ + { + "bytes": 17631, + "path": "research/24_operator_factorization_closure.md", + "sha256": "e67e6834eeebb582845043e16de2879b89c789415de096b403827d5526827c29" + }, + { + "bytes": 14726, + "path": "checks/operator_factorization_graphs.py", + "sha256": "aa4c666edf49757bdf76ba6f041f5e9ff78af73e2211e6bcab733773cc949963" + }, + { + "bytes": 15946, + "path": "checks/verify_operator_factorization.py", + "sha256": "71e83666d87171ae0c09eb326e2d317ce52be74ea6858f5805d91c8410bfca49" + }, + { + "bytes": 65, + "path": "results/operator_factorization_report.sha256", + "sha256": "01788baa2285df3f94c20903f22e6de66ebb2d91d412520066b30774e985c2b4" + }, + { + "bytes": 4504, + "path": ".github/workflows/operator-factorization-closure.yml", + "sha256": "9cdcf3fb9c906c1cb431511b461809470f6a0757731b9659a7b92210d15bd9c5" + } + ], + "scope": "Six additions only; every existing main file and all pending PRs remain unchanged. This manifest excludes itself. The exact full certificate is emitted by the new checker; the repository stores its fingerprint." +} diff --git a/results/operator_factorization_report.sha256 b/results/operator_factorization_report.sha256 new file mode 100644 index 0000000..48dbd0d --- /dev/null +++ b/results/operator_factorization_report.sha256 @@ -0,0 +1 @@ +3c508a61056b9a0c7f4a0f9a660932a2ecdc84d6f386238d69402507211cd753