Reproducible source and supporting text for the associated calculation.
View complete source excerpt
"""Exact integer Clifford commutants and real invariant clock constructions."""
import hashlib
import itertools
import json
from pathlib import Path
import sys
import subprocess
import numpy as np
ROOT = Path(__file__).resolve().parent.parent
HERE = Path(__file__).resolve().parent
checks = 0
def require(condition):
global checks
assert condition
checks += 1
def tensor(factors):
result = np.array([[1]])
for factor in factors:
result = np.kron(result, factor)
return result
I = np.eye(2, dtype=np.int64)
X = np.array([[0, 1], [1, 0]], dtype=np.int64)
Z = np.diag([1, -1])
J = np.array([[0, -1], [1, 0]], dtype=np.int64)
Y = 1j * J
gamma = []
for k in range(5):
for middle in (X, Y):
gamma.append(tensor([Z] * k + [middle] + [I] * (4 - k)))
eye32 = np.eye(32, dtype=np.int64)
for i in range(10):
for j in range(10):
require(np.array_equal(gamma[i] @ gamma[j] + gamma[j] @ gamma[i],
(2 if i == j else 0) * eye32))
positive = [i for i in range(32) if i.bit_count() % 2 == 0]
def realify(a):
require(np.all(a.real == np.rint(a.real)))
require(np.all(a.imag == np.rint(a.imag)))
return np.block([[a.real, -a.imag], [a.imag, a.real]]).astype(np.int64)
generators = [realify((gamma[i] @ gamma[i + 1])[np.ix_(positive, positive)])
for i in range(9)]
for g in generators:
require(np.array_equal(g.T, -g))
require(np.array_equal(g @ g, -eye32))
# The 4^5 real Pauli tensor words are an orthogonal basis of all real
# endomorphisms. Clifford adjoint conjugations diagonalize on this basis.
words = list(itertools.product(range(4), repeat=5))
basis = np.array([tensor([(I, X, Z, J)[i] for i in w]) for w in words])
skew = np.array([sum(i == 3 for i in w) % 2 == 1 for w in words])
require(basis.shape == (1024, 32, 32))
for i, b in enumerate(basis):
require(np.array_equal(b.T, (-1 if skew[i] else 1) * b))
require(np.array_equal(b @ b.T, eye32))
surviving = np.ones(1024, dtype=bool)
ambient_j = np.kron(J, np.eye(16, dtype=np.int64))
ambient = []
expected = {2: (512, 256), 3: (256, 136), 4: (128, 72),
5: (64, 36), 6: (32, 16), 7: (16, 6),
8: (8, 2), 9: (4, 1), 10: (2, 1)}
for d, g in enumerate(generators, 2):
commute = np.all(basis @ g == g @ basis, axis=(1, 2))
anticommute = np.all(basis @ g == -(g @ basis), axis=(1, 2))
require(np.all(commute | anticommute))
surviving &= commute
dimensions = (int(surviving.sum()), int((surviving & skew).sum()))
require(dimensions == expected[d])
require(np.array_equal(ambient_j @ g, g @ ambient_j))
ambient.append(dict(depth=d, real_commutant_dimension=dimensions[0],
skew_commutant_dimension=dimensions[1],
ambient_complex_structure_survives=True))
# Quaternion units on real R^4: an explicit family of invariant clocks.
units = [np.kron(J, I), np.kron(Z, J), np.kron(X, J)]
eye4 = np.eye(4, dtype=np.int64)
for i, a in enumerate(units):
require(np.array_equal(a.T, -a))
for j, b in enumerate(units):
require(np.array_equal(a @ b + b @ a, (-2 if i == j else 0) * eye4))
for a in itertools.product(range(-2, 3), repeat=3):
b = sum((x * u for x, u in zip(a, units)), np.zeros((4, 4), dtype=np.int64))
require(np.array_equal(b @ b, -sum(x*x for x in a) * eye4))
for c in ((1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 2, -1)):
k = sum((x * u for x, u in zip(c, units)), np.zeros((4, 4), dtype=np.int64))
require(-int(np.trace(b @ k)) == 4 * sum(x*y for x, y in zip(a, c)))
# Quaternionic J reversal is an internal symmetry, not a distinguished
# antiparticle operation. Two copies of a real carrier also admit a clock.
require(np.array_equal(units[1] @ units[0] @ units[1].T, -units[0]))
for n in (1, 8, 16):
b = np.kron(J, np.eye(n, dtype=np.int64))
c = np.kron(Z, np.eye(n, dtype=np.int64))
require(np.array_equal(c @ c, np.eye(2*n, dtype=np.int64)))
require(np.array_equal(c @ b @ c, -b))
require(np.array_equal(b @ b, -np.eye(2*n, dtype=np.int64)))
# Real irreducible spin modules: type from the real even Clifford algebra.
types = {0: 'R', 1: 'R', 2: 'C', 3: 'H', 4: 'H', 5: 'H', 6: 'C', 7: 'R'}
minimal = [dict(depth=d, type=types[d % 8],
skew_dimension={'R': 0, 'C': 1, 'H': 3}[types[d % 8]])
for d in range(1, 13)]
selected = [r['depth'] for r in minimal if r['depth'] <= 10 and r['skew_dimension']]
require(selected == [2, 3, 4, 5, 6, 10])
sources = {'experiments/spinor-clock-commutants.py': hashlib.sha256(Path(__file__).read_bytes()).hexdigest()}
report = dict(checks_passed=checks, verification_scope="portable exact algebra", sources=sources,
arithmetic='integer int64; all matrix entries and products in bounded small integers',
minimal_modules=minimal, ambient_half_spin_restrictions=ambient,
selected_minimal_depths=selected,
assumptions=['Spin(d) is a candidate rotation representation, not derived particle spin.',
'Ambient carrier is one realified complex half-spin representation of Spin(10).',
'Real matrix components describe fields; physical coordinates remain R10.'])
(HERE / 'spinor-clock-commutants-results.json').write_text(json.dumps(report, indent=2) + '\n')
# A small, separately evaluated exact rank certificate for the quaternionic
# commutant. The left and right actions are distinct real matrix algebras.
left = [np.kron(I, J), np.kron(J, Z), np.kron(J, X)]
skew_basis = []
for i in range(4):
for j in range(i + 1, 4):
b = np.zeros((4, 4), dtype=np.int64)
b[i, j], b[j, i] = 1, -1
skew_basis.append(b)
constraints = np.array([np.concatenate([(b @ l - l @ b).ravel() for l in left])
for b in skew_basis]).T
job = dict(assumptions=report['assumptions'] + [
'The 48 by 6 matrix constrains a real skew operator to commute with left quaternion multiplication.',
'Nullity three supplies the quaternionic clock axes; it does not identify colour or weak interaction.'],
sources=sources,
jobs=[dict(name='quaternionic-invariant-skew-forms', operation='matrix',
matrix=constraints.tolist()),
dict(name='normalized-clock-positive-metric', operation='matrix',
matrix=np.eye(4, dtype=np.int64).tolist())])
(HERE / 'spinor-clock-commutants-matrix.json').write_text(json.dumps(job, indent=2) + '\n')
print(json.dumps(report, indent=2))