Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

LeanProofs.Rosetta.KillingGramObstruction

Definition
Grade4_LeanProofs_Rosetta_KillingGramObstruction

by lisamegawatts · Sep 18, 2026 · Mathlib c5ea003 (Lean v4.30.0)

clifford-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
https://github.com/MonumentalSystems/LeanProofs/blob/b656238b73d5f0f74515f6574a1dcb4e0216129f/LeanProofs/Rosetta/KillingGramObstruction.lean

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me