LeanProofs.Rosetta.KillingGramObstruction
DefinitionGrade4_LeanProofs_Rosetta_KillingGramObstructionclifford-algebraleanproofs-grade4rosetta
Foundational definitions and structural lemmas from LeanProofs.Rosetta.KillingGramObstruction, required by the selected LeanProofs theorem graph.
Definition code
import Definitions.Def_Grade4_LeanProofs_Rosetta_CliffordInteractionObstruction
import Definitions.Def_Grade4_LeanProofs_LieStructure_KillingFormMatrix
import Mathlib.Tactic
namespace LeanProofsGrade4P2M
/-!
# G3K: Killing-Gram interaction obstruction
This module strengthens the G3X norm-only result. A pair of bivectors is
observed through its complete `2 x 2` Killing Gram data: both diagonal values
and the cross term. Exact orthogonal witnesses show that this richer metric
observation still need not determine either a commutator or the complete
ordered Clifford products.
The Killing form remains nondegenerate and retains its established signature.
The obstruction concerns sufficiency for a separately registered
multiplicative outcome, not validity of the bilinear form itself.
The coordinate model has two explicit realizations: Lorentz matrices compute
the Killing pairing, while Clifford bivectors compute the registered product.
No equality of the two associative products is assumed. Jordan--Lie data and
its exterior-coordinate image globally repair the complete Clifford outcome.
Nothing here establishes dynamics, predictive memory, causal feedback, a
cascade, a preferred orientation, or a physical field theory.
-/
namespace Rosetta.KillingGramObstruction
open BivectorProofs
open Rosetta.ObstructionToDescent
open Rosetta.CliffordInteractionObstruction
noncomputable section
/-! ## Registered six-coordinate model -/
/-- Coordinates ordered as `(K1,K2,K3,J1,J2,J3)`. -/
abbrev BivectorCoordinates := Fin 6 → ℝ
/-- Coordinate unit vector. -/
def basisCoordinate (i : Fin 6) : BivectorCoordinates :=
Pi.single i 1
def K1 : BivectorCoordinates := basisCoordinate 0
def J1 : BivectorCoordinates := basisCoordinate 3
/-- Clifford realization of the registered bivector coordinates. -/
def toClifford (x : BivectorCoordinates) : STA :=
x 0 • γ01 + x 1 • γ02 + x 2 • γ03 +
x 3 • γ23 + x 4 • γ31 + x 5 • γ12
/-- Lorentz vector-matrix realization used to compute the Killing pairing. -/
def toLorentzMatrix (x : BivectorCoordinates) : Matrix (Fin 4) (Fin 4) ℝ :=
x 0 • boostK₁ + x 1 • boostK₂ + x 2 • boostK₃ +
x 3 • rotJ₁ + x 4 • rotJ₂ + x 5 • rotJ₃
@[simp] theorem toClifford_K1 : toClifford K1 = γ01 := by
simp [toClifford, K1, basisCoordinate]
@[simp] theorem toClifford_J1 : toClifford J1 = γ23 := by
simp [toClifford, J1, basisCoordinate]
@[simp] theorem toLorentzMatrix_K1 : toLorentzMatrix K1 = boostK₁ := by
simp [toLorentzMatrix, K1, basisCoordinate]
@[simp] theorem toLorentzMatrix_J1 : toLorentzMatrix J1 = rotJ₁ := by
simp [toLorentzMatrix, J1, basisCoordinate]
theorem toClifford_neg (x : BivectorCoordinates) :
toClifford (-x) = -toClifford x := by
simp only [toClifford, Pi.neg_apply, neg_smul]
module
theorem toLorentzMatrix_neg (x : BivectorCoordinates) :
toLorentzMatrix (-x) = -toLorentzMatrix x := by
simp only [toLorentzMatrix, Pi.neg_apply, neg_smul]
module
/-! ## Actual Killing-Gram observation -/
/-- The registered `so(3,1)` Killing normalization `K(X,Y)=2 trace(XY)`. -/
def killingPair (x y : BivectorCoordinates) : ℝ :=
2 * matInner (toLorentzMatrix x) (toLorentzMatrix y)
/-- All three independent entries of the symmetric two-input Gram matrix. -/
def killingGram (state : BivectorCoordinates × BivectorCoordinates) :
ℝ × ℝ × ℝ :=
(killingPair state.1 state.1,
killingPair state.1 state.2,
killingPair state.2 state.2)
def cliffordOrderedProducts
(state : BivectorCoordinates × BivectorCoordinates) : STA × STA :=
algebraOrderedProducts (toClifford state.1, toClifford state.2)
/-! ## Exact registered Killing values -/
theorem killingPair_K1_K1 : killingPair K1 K1 = 4 := by
rw [killingPair, toLorentzMatrix_K1, matInner_K1_K1]
norm_num
theorem killingPair_J1_J1 : killingPair J1 J1 = -4 := by
rw [killingPair, toLorentzMatrix_J1, matInner_J1_J1]
norm_num
theorem killingPair_K1_J1 : killingPair K1 J1 = 0 := by
simp [killingPair, matInner_K1_J1]
theorem killingPair_neg_right (x y : BivectorCoordinates) :
killingPair x (-y) = -killingPair x y := by
unfold killingPair
rw [toLorentzMatrix_neg]
simp [matInner, matTrace]
ring
theorem killingPair_neg_both (x y : BivectorCoordinates) :
killingPair (-x) (-y) = killingPair x y := by
unfold killingPair
rw [toLorentzMatrix_neg, toLorentzMatrix_neg]
simp [matInner, matTrace]
/-! ## Noncommuting witness -/
/-! ## Orthogonal commuting/product witness -/
def hodgeLeft : BivectorCoordinates × BivectorCoordinates := (K1, J1)
def hodgeRight : BivectorCoordinates × BivectorCoordinates := (K1, -J1)
theorem hodgeLeft_killingGram : killingGram hodgeLeft = (4, 0, -4) := by
simp [killingGram, hodgeLeft, killingPair_K1_K1, killingPair_K1_J1,
killingPair_J1_J1]
theorem hodgeRight_killingGram : killingGram hodgeRight = (4, 0, -4) := by
change (killingPair K1 K1, killingPair K1 (-J1),
killingPair (-J1) (-J1)) = (4, 0, -4)
rw [killingPair_K1_K1, killingPair_neg_right, killingPair_K1_J1,
killingPair_neg_both, killingPair_J1_J1]
norm_num
theorem hodgeWitness_same_killingGram :
killingGram hodgeLeft = killingGram hodgeRight := by
rw [hodgeLeft_killingGram, hodgeRight_killingGram]
theorem hodgeWitness_different_clifford_products :
cliffordOrderedProducts hodgeLeft ≠ cliffordOrderedProducts hodgeRight := by
simpa [cliffordOrderedProducts, hodgeLeft, hodgeRight, toClifford_neg,
orderedProducts] using hodgeWitness_different_orderedProducts
def hodgeKillingGramObstruction :
DeterminationObstruction killingGram cliffordOrderedProducts where
left := hodgeLeft
right := hodgeRight
same_observation := hodgeWitness_same_killingGram
different_outcome := hodgeWitness_different_clifford_products
/-! ## Global representation-neutral repair -/
/-! ## Anti-cheat and boundary controls -/
end
end Rosetta.KillingGramObstruction
end LeanProofsGrade4P2M
Source