LeanProofs.Bivectors.CommutatorTable
DefinitionGrade4_LeanProofs_Bivectors_CommutatorTableclifford-algebraleanproofs-grade4rosetta
Foundational definitions and structural lemmas from LeanProofs.Bivectors.CommutatorTable, required by the selected LeanProofs theorem graph.
Definition code
/-
Complete Bivector Commutation Table for Cl(1,3).
Paper reference: Appendix A (Table 1).
Rust reference: bivector_field.rs build_sta_cache() → comm_dense[6][6][6]
Convention:
Index 0: γ₀₁ (E₁) Index 3: γ₂₃ (B₁)
Index 1: γ₀₂ (E₂) Index 4: γ₃₁ (B₂)
Index 2: γ₀₃ (E₃) Index 5: γ₁₂ (B₃)
-/
import Definitions.Def_Grade4_LeanProofs_Foundations_BasisElements
import Definitions.Def_Grade4_LeanProofs_Bivectors_CommutatorProperties
namespace LeanProofsGrade4P2M
noncomputable section
open BivectorProofs
/-! ## Generic helpers for 4-gamma products
Every commutator [γ_ab, γ_cd] requires computing γ_a γ_b γ_c γ_d.
The strategy:
1. Use associativity to regroup
2. Anticommute the middle pair to bring shared indices together
3. Apply γ_μ² = ±1
4. Simplify signs
-/
/-! ## Product helpers: γ_ab · γ_cd for all needed pairs
Each product is proved by:
1. Reassociate to expose adjacent gamma factors
2. Anticommute using γ_i γ_j = -γ_j γ_i (i ≠ j)
3. Apply γ_μ² = ±1
4. Simplify signs
-/
-- Helper: γ₀γ₁γ₀γ₂ = -γ₁₂ (already proved pattern)
-- γ₀₁ · γ₀₃: γ₀γ₁γ₀γ₃ = -(γ₀²)(γ₁γ₃) = -(γ₁γ₃) = γ₃γ₁ = γ₃₁
-- γ₀₂ · γ₀₃: γ₀γ₂γ₀γ₃ = -(γ₂γ₃) = -γ₂₃
-- Hodge dual: γ₀₁ · γ₂₃ = γ₀γ₁γ₂γ₃ (all distinct, no simplification via squares)
-- γ₂₃ · γ₀₁ = γ₂γ₃γ₀γ₁ = (−1)⁴ rearrangements... = same thing
-- So [γ₀₁, γ₂₃] = 0 because all 4 indices are distinct and the products are equal.
theorem prod_0123 : γ01 * γ23 = gamma 0 * gamma 1 * gamma 2 * gamma 3 := by
unfold γ01 γ23 gammaProd; simp only [mul_assoc]
theorem prod_2301 : γ23 * γ01 = gamma 0 * gamma 1 * gamma 2 * gamma 3 := by
unfold γ23 γ01 gammaProd
have h20 : gamma 2 * gamma 0 = -(gamma 0 * gamma 2) := gamma_anticomm_ne (by decide)
have h30 : gamma 3 * gamma 0 = -(gamma 0 * gamma 3) := gamma_anticomm_ne (by decide)
have h31 : gamma 3 * gamma 1 = -(gamma 1 * gamma 3) := gamma_anticomm_ne (by decide)
have h21 : gamma 2 * gamma 1 = -(gamma 1 * gamma 2) := gamma_anticomm_ne (by decide)
-- γ₂γ₃γ₀γ₁: need 4 swaps to get to γ₀γ₁γ₂γ₃
-- swap γ₃,γ₀: γ₂(-γ₀γ₃)γ₁ = -γ₂γ₀γ₃γ₁
-- swap γ₂,γ₀: -(-γ₀γ₂)γ₃γ₁ = γ₀γ₂γ₃γ₁
-- swap γ₃,γ₁: γ₀γ₂(-γ₁γ₃) = -γ₀γ₂γ₁γ₃
-- swap γ₂,γ₁: -γ₀(-γ₁γ₂)γ₃ = γ₀γ₁γ₂γ₃
calc gamma 2 * gamma 3 * (gamma 0 * gamma 1)
= gamma 2 * (gamma 3 * gamma 0) * gamma 1 := by simp only [mul_assoc]
_ = gamma 2 * (-(gamma 0 * gamma 3)) * gamma 1 := by rw [h30]
_ = -(gamma 2 * (gamma 0 * gamma 3) * gamma 1) := by simp only [mul_neg, neg_mul]
_ = -(gamma 2 * gamma 0 * gamma 3 * gamma 1) := by simp only [← mul_assoc]
_ = -(-(gamma 0 * gamma 2) * gamma 3 * gamma 1) := by rw [h20]
_ = gamma 0 * gamma 2 * gamma 3 * gamma 1 := by simp only [neg_neg, neg_mul]
_ = gamma 0 * gamma 2 * (gamma 3 * gamma 1) := by simp only [mul_assoc]
_ = gamma 0 * gamma 2 * (-(gamma 1 * gamma 3)) := by rw [h31]
_ = -(gamma 0 * gamma 2 * (gamma 1 * gamma 3)) := by simp only [mul_neg]
_ = -(gamma 0 * gamma 2 * gamma 1 * gamma 3) := by simp only [← mul_assoc]
_ = -(gamma 0 * (gamma 2 * gamma 1) * gamma 3) := by simp only [mul_assoc]
_ = -(gamma 0 * (-(gamma 1 * gamma 2)) * gamma 3) := by rw [h21]
_ = gamma 0 * (gamma 1 * gamma 2) * gamma 3 := by simp only [mul_neg, neg_mul, neg_neg]
_ = gamma 0 * gamma 1 * gamma 2 * gamma 3 := by simp only [← mul_assoc]
-- Similarly for the other two Hodge dual pairs
/-! ## Cross-coupling products: γ₀ᵢ · γⱼₖ where one spacelike index is shared -/
-- γ₀₁ · γ₃₁: γ₀γ₁γ₃γ₁ = γ₀γ₃(γ₁)² (after anticommuting γ₁ past γ₃)
-- wait: γ₁γ₃ = -γ₃γ₁, so γ₀(γ₁γ₃)γ₁ = γ₀(-γ₃γ₁)γ₁ = -γ₀γ₃(γ₁²) = -γ₀γ₃(-1) = γ₀γ₃
-- γ₀₁ · γ₁₂: γ₀γ₁γ₁γ₂ = γ₀(γ₁²)γ₂ = γ₀(-1)γ₂ = -γ₀γ₂ = -γ₀₂
/-! ## Commutator assembly: combine forward and reverse products -/
theorem comm_from_prods_zero {a b c : STA} (hfwd : a * b = c) (hrev : b * a = c) :
⟦a, b⟧ = 0 := by
simp only [comm_def]; rw [hfwd, hrev]; abel
/-! ## The complete commutation table -/
-- ═══════════════════════════════════════════════════════════════
-- Electric-Electric commutators: [E_i, E_j] = ±2 B_k
-- ═══════════════════════════════════════════════════════════════
-- ═══════════════════════════════════════════════════════════════
-- Hodge-dual commutators: [E_k, B_k] = 0
-- ═══════════════════════════════════════════════════════════════
/-- [γ₀₁, γ₂₃] = 0 — Hodge-dual bivectors commute. -/
theorem comm_γ01_γ23 : ⟦γ01, γ23⟧ = 0 :=
comm_from_prods_zero prod_0123 prod_2301
-- ═══════════════════════════════════════════════════════════════
-- Electric-Magnetic cross couplings
-- ═══════════════════════════════════════════════════════════════
-- ═══════════════════════════════════════════════════════════════
-- Cross-coupling product helpers (remaining)
-- ═══════════════════════════════════════════════════════════════
-- ═══════════════════════════════════════════════════════════════
-- Remaining cross couplings (proved)
-- ═══════════════════════════════════════════════════════════════
-- ═══════════════════════════════════════════════════════════════
-- Magnetic-Magnetic commutators
--
-- NOTE ON SIGN CONVENTION: The paper's Appendix A shows the commutation
-- table for Cl(3,1) in math convention (γᵢ²=+1, γ₀²=-1), despite
-- writing "Cl_{3,1} with signature +---". Our code implements Cl(1,3)
-- (γ₀²=+1, γᵢ²=-1), which is the same physical metric but a different
-- Clifford algebra. The magnetic-magnetic products involve γᵢ² which
-- differ by sign between the two algebras, so these 3 entries have
-- OPPOSITE sign from the paper's Appendix A table.
--
-- The bivector Lie algebra so(3,1) is the same in both conventions —
-- only the embedding into the Clifford algebra changes.
-- ═══════════════════════════════════════════════════════════════
-- γ₂₃·γ₃₁ = γ₂(γ₃²)γ₁ = γ₂(-1)γ₁ = -(γ₂γ₁) = γ₁γ₂ = γ₁₂
-- γ₃₁·γ₂₃ = γ₃γ₁γ₂γ₃: swap γ₃ past γ₁ (-), past γ₂ (-), then γ₃²=-1
-- = (+1)·γ₁γ₂·(-1) = -γ₁₂
-- γ₂₃·γ₁₂ = γ₂γ₃γ₁γ₂: swap γ₃ past γ₁ (-), then γ₂² via inner pair
-- γ₁₂·γ₂₃ = γ₁(γ₂²)γ₃ = γ₁(-1)γ₃ = -(γ₁γ₃) = γ₃γ₁ = γ₃₁
-- γ₃₁·γ₁₂ = γ₃(γ₁²)γ₂ = γ₃(-1)γ₂ = -(γ₃γ₂) = γ₂γ₃ = γ₂₃
-- γ₁₂·γ₃₁ = γ₁γ₂γ₃γ₁: swap γ₂ past γ₃ (-), then swap γ₂ past γ₁... hmm
-- Easier: swap γ₁ (leftmost) past γ₂, γ₃ to reach γ₂γ₃γ₁γ₁ = γ₂γ₃(γ₁²) = γ₂γ₃(-1) = -γ₂₃
-- Actually: move rightmost γ₁ to the left.
-- γ₁·γ₂·γ₃·γ₁. Swap γ₃,γ₁: -(γ₁·γ₂·γ₁·γ₃). Swap γ₂,γ₁: -(γ₁·(-(γ₁·γ₂))·γ₃) = γ₁²·γ₂·γ₃ = (-1)·γ₂₃ = -γ₂₃
/-! ## Public geometric-product table
The commutator proofs above require the individual ordered products. Export
them here as a reusable API for statements that distinguish the full
associative product from its Lie bracket. The three disjoint-index products
are left in their explicit four-gamma form so this module does not depend on
the later `Pseudoscalar` definition.
-/
-- ═══════════════════════════════════════════════════════════════
-- Diagonal entries (zero by antisymmetry)
-- ═══════════════════════════════════════════════════════════════
end
end LeanProofsGrade4P2M
Source