TFPT scientific source excerpt
Original repository path: experiments/theory-contracts/seam-positive-kernel-search-20261015/source_charge_checks.py
Original file SHA-256: c5f5d7704dfc283b577e0aeee31d9875d4d90b1c7b6e4596037920b7d3cf5902
Inclusive original lines: 1-200
Line numbers below refer to the original source.
This bounded excerpt is source evidence; it is not a new proof/checker run.
Conversation metadata and personal execution details are omitted where indicated.

000001 | """Scoped all-word charge obstruction and original finite source controls.
000002 | 
000003 | The obstruction assumes the explicitly stated primitive field inventory and
000004 | symmetry action. It is not a universal no-go for the original P1 source.
000005 | """
000006 | from __future__ import annotations
000007 | import argparse
000008 | import hashlib
000009 | import importlib.util
000010 | import json
000011 | from pathlib import Path
000012 | import sys
000013 | import numpy as np
000014 | 
000015 | ROOT = Path(__file__).resolve().parents[3]
000016 | VERIFICATION = ROOT/'verification'
000017 | 
000018 | 
000019 | def need(condition, label, checks):
000020 |     if not bool(condition):
000021 |         raise ArithmeticError('Failed: '+label)
000022 |     checks.append(label)
000023 | 
000024 | 
000025 | def load_original(name):
000026 |     path = VERIFICATION/(name+'.py')
000027 |     sys.path.insert(0, str(VERIFICATION))
000028 |     spec = importlib.util.spec_from_file_location('_source_'+name, path)
000029 |     module = importlib.util.module_from_spec(spec)
000030 |     spec.loader.exec_module(module)
000031 |     return module, {'path':str(path.relative_to(ROOT)),
000032 |                     'sha256':hashlib.sha256(path.read_bytes()).hexdigest()}
000033 | 
000034 | 
000035 | def add(a,b):
000036 |     return ((a[0]+b[0])%2,(a[1]+b[1])%2)
000037 | 
000038 | 
000039 | def assess_expression(expr):
000040 |     """Assess a JSON expression under the declared source inventory.
000041 | 
000042 |     Nodes use {op: primitive, name: ...}, {op: proposed_sector_insertion,
000043 |     source_ref: ...}, {op: product|sum, args: [...]}, or
000044 |     {op: adjoint|derivative, arg: ...}. This only checks tags and types.
000045 |     """
000046 |     primitive_tags = {'matter_spinor': (1, 1), 'tensor_boson': (0, 0),
000047 |                       'scalar_quarter_current': (0, 0)}
000048 |     count = 0
000049 | 
000050 |     def visit(node, depth):
000051 |         nonlocal count
000052 |         count += 1
000053 |         if count > 100 or depth > 24 or type(node) is not dict:
000054 |             raise ValueError('invalid expression or complexity limit')
000055 |         op = node.get('op')
000056 |         if type(op) is not str:
000057 |             raise ValueError('operation must be a string')
000058 |         if op == 'primitive':
000059 |             if set(node) != {'op', 'name'} or type(node['name']) is not str:
000060 |                 raise ValueError('malformed primitive')
000061 |             name = node['name']
000062 |             if name == 'clifford_vector':
000063 |                 raise ValueError('Clifford vector is an internal operator, not a local field')
000064 |             if name not in primitive_tags:
000065 |                 raise ValueError('unknown primitive')
000066 |             return {primitive_tags[name]}, True
000067 |         if op == 'proposed_sector_insertion':
000068 |             if (set(node) != {'op', 'source_ref'} or type(node['source_ref']) is not str
000069 |                     or not node['source_ref'].strip()):
000070 |                 raise ValueError('proposed sector requires a nonempty source_ref string')
000071 |             # Its type is not established by its name. Overapproximate all
000072 |             # four tags so composition cannot create a false exclusion.
000073 |             return {(0, 0), (0, 1), (1, 0), (1, 1)}, False
000074 |         if op in ('adjoint', 'derivative'):
000075 |             if set(node) != {'op', 'arg'}:
000076 |                 raise ValueError('malformed unary expression')
000077 |             return visit(node['arg'], depth + 1)
000078 |         if op in ('product', 'sum'):
000079 |             if set(node) != {'op', 'args'} or type(node['args']) is not list or not node['args']:
000080 |                 raise ValueError('malformed composite expression')
000081 |             tags, bound = ({(0, 0)} if op == 'product' else set()), True
000082 |             for item in node['args']:
000083 |                 child_tags, child_bound = visit(item, depth + 1)
000084 |                 bound = bound and child_bound
000085 |                 tags = ({add(a, b) for a in tags for b in child_tags}
000086 |                         if op == 'product' else tags | child_tags)
000087 |             return tags, bound
000088 |         raise ValueError('unknown operation')
000089 | 
000090 |     try:
000091 |         tags, bound = visit(expr, 1)
000092 |     except (ValueError, RecursionError) as error:
000093 |         return {'possible_target_tag': False, 'source_binding_verified': False,
000094 |                 'verdict': 'typing_error', 'reason': str(error),
000095 |                 'candidate_physical_proof': False}
000096 |     possible = (0, 1) in tags
000097 |     return {'possible_target_tag': possible, 'source_binding_verified': False,
000098 |             'tags': [list(tag) for tag in sorted(tags)],
000099 |             'sector_insertion_status': None if bound else 'unverified_original_binding',
000100 |             'verdict': ('excluded_scoped' if not possible else 'needs_original_source'),
000101 |             'candidate_physical_proof': False}
000102 | 
000103 | 
000104 | def pauli_clifford_10():
000105 |     """Exact 0/±1/±i Clifford action on the 32-dimensional spinor space."""
000106 |     identity=np.eye(2,dtype=complex)
000107 |     x=np.array([[0,1],[1,0]],complex)
000108 |     y=np.array([[0,-1j],[1j,0]],complex)
000109 |     z=np.diag([1,-1]).astype(complex)
000110 |     output=[]
000111 |     for j in range(5):
000112 |         for a in (x,y):
000113 |             factors=[z if k<j else a if k==j else identity for k in range(5)]
000114 |             matrix=factors[0]
000115 |             for factor in factors[1:]: matrix=np.kron(matrix,factor)
000116 |             output.append(matrix)
000117 |     return output
000118 | 
000119 | 
000120 | def check():
000121 |     checks=[]
000122 |     # A word's pair of symmetry eigenvalues is the additive homomorphism
000123 |     # from the free *-word monoid to Z2 x Z2; conjugation leaves each tag.
000124 |     generators=[(1,1),(0,0)]
000125 |     reachable={(0,0)}
000126 |     while True:
000127 |         enlarged=reachable | {add(x,g) for x in reachable for g in generators}
000128 |         if enlarged==reachable: break
000129 |         reachable=enlarged
000130 |     need(reachable=={(0,0),(1,1)},'primitive parity and central tag closure',checks)
000131 |     need((0,1) not in reachable,'bosonic spinor current tag excluded in this inventory',checks)
000132 |     need(add((1,1),(1,1))==(0,0),'two spinor source fields form neutral tag',checks)
000133 |     enlarged=reachable | {add(x,(0,1)) for x in reachable}
000134 |     need((0,1) in enlarged and len(enlarged)==4,'explicit disorder primitive removes this tag obstruction',checks)
000135 |     need(all(add(x,(0,0))==x for x in reachable),'neutral source insertions preserve tags',checks)
000136 |     need(all(add(x,x)==(0,0) for x in reachable),'adjoint has the same Z2 tags',checks)
000137 | 
000138 |     # Finite exact matrix realization: a 2π spin rotation is -I on spinors;
000139 |     # conjugation by it is +I on the Clifford vector.  This is not gamma_F.
000140 |     gammas=pauli_clifford_10(); eye32=np.eye(32,dtype=complex)
000141 |     need(all(np.array_equal(g@g,eye32) for g in gammas),'ten Clifford generators square to identity',checks)
000142 |     need(all(np.array_equal(gammas[i]@gammas[j]+gammas[j]@gammas[i],np.zeros((32,32)))
000143 |              for i in range(10) for j in range(i)), 'all ten Clifford generators anticommute',checks)
000144 |     z2=(gammas[0]@gammas[1])@(gammas[0]@gammas[1])
000145 |     need(np.array_equal(z2,-eye32),'central spin rotation acts as -I on spinors',checks)
000146 |     need(all(np.array_equal(z2@g@z2.conj().T,g) for g in gammas),
000147 |          'same central element conjugates Clifford vector trivially',checks)
000148 | 
000149 |     original, source = load_original('v252_full_finite_triple')
000150 |     # Integer complex entries remain exact under these small matrix products.
000151 |     y=np.array([[1,2j,0],[0,2,1],[1,0,3]],complex)
000152 |     mr=np.array([[1,0,1j],[0,2,0],[1j,0,3]],complex)
000153 |     D=original.full_D(y,y.conj(),y,y.conj(),mr)
000154 |     J=original.Kswap(); gamma=original.grading(); central=-np.eye(original.NH)
000155 |     need(original.NH==96 and D.shape==(96,96),'original v252 full 96 carrier',checks)
000156 |     need(np.array_equal(central@D,D@central),'central spin action commutes with full v252 D',checks)
000157 |     need(np.array_equal(central@J,J@central.conjugate()),'central spin action commutes with antilinear J',checks)
000158 |     need(not np.array_equal(central,gamma),'central spin action is not finite chirality gamma_F',checks)
000159 | 
000160 |     # Actual original E8 root generator; D8 integer and half-spinor classes.
000161 |     roots, roots_source=load_original('v1_e8_glue')
000162 |     values=roots.e8_roots()
000163 |     half=[r for r in values if np.all(np.abs(r)==0.5)]
000164 |     ints=[r for r in values if np.all(r==np.rint(r))]
000165 |     spin16_4=[r for r in half if sum(v<0 for v in r[:5])%2==0]
000166 |     need(len(ints)==112 and len(half)==128 and len(values)==240
000167 |          and all(int(2*r[0])%2==0 for r in ints)
000168 |          and all(int(2*r[0])%2==1 for r in half),
000169 |          'original E8 roots split 112 plus 128 with correct central-square signs',checks)
000170 |     need(len(spin16_4)==64 and len(half)-len(spin16_4)==64,
000171 |          'marked D5 spinor and conjugate each carry 64 roots',checks)
000172 |     need(len(ints)+8==120,'D8 even roots plus Cartan give 120',checks)
000173 | 
000174 |     # Ward illustration: invariant vacuum; charged field one-point vanishes,
000175 |     # neutral positive two-point can be nonzero.
000176 |     rotation=np.diag([1,1j]); vacuum=np.array([1,0],complex)
000177 |     X=np.array([[0,0],[1,0]],complex)
000178 |     one=vacuum.conj()@X@vacuum
000179 |     two=vacuum.conj()@X.conj().T@X@vacuum
000180 |     need(np.array_equal(rotation@vacuum,vacuum) and np.array_equal(rotation@X@rotation.conj().T,1j*X),
000181 |          'explicit invariant state and charge-one operator',checks)
000182 |     need(one==0 and two==1,'charged one-point zero but neutral two-point positive',checks)
000183 | 
000184 |     return {'schema':'tfpt.source-charge-obstruction.v1','status':'pass','checks':checks,
000185 |             'source_paths':[source,roots_source],
000186 |             'algebraic_argument':'The commuting parity and central involutions have product Pz². Every listed primitive is fixed by Pz², so all sums, products and adjoints of them are fixed; the fixed algebra is norm closed for a continuous symmetry action. A target of tag (0,1) changes sign and cannot be a nonzero element of that algebra. Equivariant derivations and neutral insertions preserve the conclusion when defined on that algebra.',
000187 |             'tag_class':[[0,0],[1,1]],'target_tag':[0,1],
000188 |             'explicit_escape_tag':[0,1],
000189 |             'ward_scope':'Invariant state and nontrivial character force a charged one-point to zero; neutral correlators need not vanish. The finite matrix example illustrates this identity and is not the physical TFPT state.',
000190 |             'source_scope':'Given primitive Grassmann Spin10 spinors and tensorial bosons, plus equivariant operations. A disorder/sector primitive may change this inventory. E8 current is bosonic; 16 internal spinor states are not 16 Majorana generators. The Spin action z²=-I96 is supplied on the v252 carrier, and commutation with D and J is checked; v252 alone does not derive that representation. z² on H_F is distinct from gamma_F and field parity.',
000191 |             'not_proved':['P1 source has only this inventory','all possible disorder sectors are absent',
000192 |                           'physical 3+1D matter, E8 current source or global P1 no-go'],
000193 |             'physical_source_identified':False,'fundamental_solution':False}
000194 | 
000195 | 
000196 | def main():
000197 |     parser=argparse.ArgumentParser(description=__doc__)
000198 |     parser.add_argument('--out',type=Path)
000199 |     claims = {
000200 |         'matter-word-spinor-current': 'even_matter_words_contain_bosonic_spinor_current',