math / data /lean /OAI /Algebra /Finitistic /Selection /GroupSelection.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
16 kB
import Mathlib.GroupTheory.Commutator.Basic
import Mathlib.GroupTheory.PresentedGroup
import Mathlib.Tactic.Group
import Mathlib.Tactic.FinCases
import Lean.Elab.Tactic.Omega
namespace OAI
open scoped commutatorElement
namespace LittleFinitistic
section GroupTransfer
variable {G : Type*} [Group G]
/-- The commutator transfer identity establishing independence of the
internal index in the paper's central involutions. -/
theorem commutator_transfer (x y v u w : G)
(hu : x*y = u*y*x) (hw : y*v = w*v*y)
(hxv : Commute x v) (hwu : Commute w u) (hwv : Commute w v) :
⁅x,w⁆ = ⁅u,v⁆ := by
have hconj : y*x*y⁻¹ = u⁻¹*x := by
apply (mul_left_cancel_iff (a := u)).mp
calc
u*(y*x*y⁻¹) = (u*y*x)*y⁻¹ := by group
_ = (x*y)*y⁻¹ := by rw [← hu]
_ = u*(u⁻¹*x) := by group
have hmove : x*w*v*y = u*w*v*y*x := by
calc
x*w*v*y = x*(y*v) := by rw [hw]; group
_ = (x*y)*v := by group
_ = (u*y*x)*v := by rw [hu]
_ = u*y*(v*x) := by simp only [mul_assoc, hxv.eq]
_ = u*(y*v)*x := by group
_ = u*w*v*y*x := by rw [hw]; group
have hxw : x*w = u*w*v*u⁻¹*v⁻¹*x := by
calc
x*w = (x*w*v*y)*y⁻¹*v⁻¹ := by group
_ = (u*w*v*y*x)*y⁻¹*v⁻¹ := by rw [hmove]
_ = u*w*v*(y*x*y⁻¹)*v⁻¹ := by group
_ = u*w*v*(u⁻¹*x)*v⁻¹ := by rw [hconj]
_ = u*w*v*u⁻¹*(v⁻¹*x) := by simp only [mul_assoc]; rw [hxv.inv_right.eq]
_ = u*w*v*u⁻¹*v⁻¹*x := by group
have hwc : Commute w (v*u⁻¹*v⁻¹) := by
simpa only [mul_assoc] using hwv.mul_right (hwu.inv_right.mul_right hwv.inv_right)
calc
⁅x,w⁆ = x*w*x⁻¹*w⁻¹ := rfl
_ = u*w*v*u⁻¹*v⁻¹*w⁻¹ := by rw [hxw]; group
_ = u*(w*(v*u⁻¹*v⁻¹))*w⁻¹ := by group
_ = u*((v*u⁻¹*v⁻¹)*w)*w⁻¹ := by rw [hwc.eq]
_ = ⁅u,v⁆ := by simp only [commutatorElement_def]; group
/-- A central commutator of an involution has order dividing two. -/
theorem central_commutator_involution (x y : G) (hx : x*x = 1)
(hc : Commute x ⁅x,y⁆) : ⁅x,y⁆ * ⁅x,y⁆ = 1 := by
calc
⁅x,y⁆ * ⁅x,y⁆ = x * ⁅x,y⁆ * x⁻¹ * ⁅x,y⁆ := by rw [hc.eq]; group
_ = ⁅x*x,y⁆ := (commutatorElement_mul_left_eq_conj_mul x x y).symm
_ = 1 := by rw [hx]; exact commutatorElement_one_left y
end GroupTransfer
/-- The relators used for the off-diagonal generators in Section 2. The
presentation and its finite-presentation reduction are separate obligations. -/
structure SelectionGroupData (G : Type*) [Group G] where
T : Fin 3 → G
U : Fin 3 → ℤ → G
V : Fin 3 → ℤ → G
W : Fin 3 → Fin 3 → ℤ → G
square_U : ∀ i a, U i a * U i a = 1
commute_UU : ∀ i j a b, i ≠ j → Commute (U i a) (U j b)
commute_VV : ∀ i j a b, i ≠ j → Commute (V i a) (V j b)
commute_UV : ∀ i j a b, i ≠ j → Commute (U i a) (V j b)
commute_WU : ∀ i j h a b, h ≠ i → Commute (W i j a) (U h b)
commute_WV : ∀ i j h a b, h ≠ j → Commute (W i j a) (V h b)
commutator_UW : ∀ i j a b, i ≠ j → ⁅U i a, W i j b⁆ = U j (a+b)
commutator_WV : ∀ i j a b, i ≠ j → ⁅W i j a, V j b⁆ = V i (a+b)
commute_TT : ∀ i j, Commute (T i) (T j)
conj_TU : ∀ l i a, T l * U i a * (T l)⁻¹ = U i (a - if l=i then 1 else 0)
conj_TV : ∀ l i a, T l * V i a * (T l)⁻¹ = V i (a + if l=i then 1 else 0)
conj_TW : ∀ l i j a, T l * W i j a * (T l)⁻¹ =
W i j (a + (if l=i then 1 else 0) - if l=j then 1 else 0)
diagonal_W : ∀ i a, W i i a = 1
namespace SelectionGroupData
variable {G : Type*} [Group G] (D : SelectionGroupData G)
theorem split_transfer (i j : Fin 3) (a b c d : ℤ)
(hij : i ≠ j) (hsum : a+b = c+d) :
⁅D.U i a, D.V i b⁆ = ⁅D.U j c, D.V j d⁆ := by
have hU : D.U i a * D.W i j (c-a) =
D.U j c * D.W i j (c-a) * D.U i a := by
have h := D.commutator_UW i j a (c-a) hij
have hc : a + (c-a) = c := by omega
rw [hc] at h
rw [← h]
simp [commutatorElement_def, mul_assoc]
have hV : D.W i j (c-a) * D.V j d =
D.V i b * D.V j d * D.W i j (c-a) := by
have h := D.commutator_WV i j (c-a) d hij
have hb : c-a+d = b := by omega
rw [hb] at h
rw [← h]
simp [commutatorElement_def, mul_assoc]
exact commutator_transfer (D.U i a) (D.W i j (c-a)) (D.V j d)
(D.U j c) (D.V i b) hU hV (D.commute_UV i j a d hij)
(D.commute_UV j i c b hij.symm).symm (D.commute_VV i j b d hij)
theorem splitting_independent (i j : Fin 3) (a b c d : ℤ)
(hsum : a+b = c+d) : ⁅D.U i a,D.V i b⁆ = ⁅D.U j c,D.V j d⁆ := by
obtain ⟨k, hki, hkj⟩ := Fin.exists_ne_and_ne_of_two_lt i j (by decide)
calc
⁅D.U i a,D.V i b⁆ = ⁅D.U k 0,D.V k (a+b)⁆ :=
D.split_transfer i k a b 0 (a+b) hki.symm (by omega)
_ = ⁅D.U j c,D.V j d⁆ :=
D.split_transfer k j 0 (a+b) c d hkj (by omega)
def centralZ (N : ℤ) : G := ⁅D.U 0 0,D.V 0 N⁆
theorem centralZ_eq (N : ℤ) (i : Fin 3) (a b : ℤ) (h : a+b=N) :
D.centralZ N = ⁅D.U i a,D.V i b⁆ := by
exact D.splitting_independent 0 i 0 N a b (by omega)
theorem centralZ_commute_U (N : ℤ) (h : Fin 3) (a : ℤ) :
Commute (D.centralZ N) (D.U h a) := by
obtain ⟨i, hih, _⟩ := Fin.exists_ne_and_ne_of_two_lt h h (by decide)
rw [D.centralZ_eq N i 0 N (by omega), commutatorElement_def]
have hU := D.commute_UU i h 0 a hih
have hV := (D.commute_UV h i a N hih.symm).symm
exact ((hU.mul_left hV).mul_left hU.inv_left).mul_left hV.inv_left
theorem centralZ_commute_V (N : ℤ) (h : Fin 3) (a : ℤ) :
Commute (D.centralZ N) (D.V h a) := by
obtain ⟨i, hih, _⟩ := Fin.exists_ne_and_ne_of_two_lt h h (by decide)
rw [D.centralZ_eq N i 0 N (by omega), commutatorElement_def]
have hU := D.commute_UV i h 0 a hih
have hV := D.commute_VV i h N a hih
exact ((hU.mul_left hV).mul_left hU.inv_left).mul_left hV.inv_left
theorem centralZ_commute_W (N : ℤ) (i j : Fin 3) (a : ℤ) :
Commute (D.centralZ N) (D.W i j a) := by
obtain ⟨h, hhi, hhj⟩ := Fin.exists_ne_and_ne_of_two_lt i j (by decide)
rw [D.centralZ_eq N h 0 N (by omega), commutatorElement_def]
have hU := (D.commute_WU i j h a 0 hhi).symm
have hV := (D.commute_WV i j h a N hhj).symm
exact ((hU.mul_left hV).mul_left hU.inv_left).mul_left hV.inv_left
theorem centralZ_involution (N : ℤ) : D.centralZ N * D.centralZ N = 1 := by
apply central_commutator_involution (D.U 0 0) (D.V 0 N) (D.square_U 0 0)
exact (D.centralZ_commute_U N 0 0).symm
theorem centralZ_commute_T (N : ℤ) (l : Fin 3) : Commute (D.centralZ N) (D.T l) := by
have hconj : D.T l * D.centralZ N * (D.T l)⁻¹ = D.centralZ N := by
rw [centralZ, conjugate_commutatorElement, D.conj_TU, D.conj_TV]
exact (D.centralZ_eq N 0 _ _ (by omega)).symm
show D.centralZ N * D.T l = D.T l * D.centralZ N
calc
D.centralZ N * D.T l = (D.T l * D.centralZ N * (D.T l)⁻¹) * D.T l := by rw [hconj]
_ = D.T l * D.centralZ N := by group
end SelectionGroupData
namespace Presentation
inductive Generator where
| T : Fin 3 → Generator
| U : Fin 3 → ℤ → Generator
| V : Fin 3 → ℤ → Generator
| W : Fin 3 → Fin 3 → ℤ → Generator
private abbrev t (i : Fin 3) := FreeGroup.of (Generator.T i)
private abbrev u (i : Fin 3) (a : ℤ) := FreeGroup.of (Generator.U i a)
private abbrev v (i : Fin 3) (a : ℤ) := FreeGroup.of (Generator.V i a)
private abbrev w (i j : Fin 3) (a : ℤ) := FreeGroup.of (Generator.W i j a)
/-- Explicit equation patterns of the paper's infinite presentation.
Diagonal W generators are set to one, so the total-index notation introduces
no additional group generators compared with the manuscript. -/
inductive Equation : FreeGroup Generator → FreeGroup Generator → Prop where
| squareU (i a) : Equation (u i a * u i a) 1
| commuteUU (i j a b) (h : i ≠ j) : Equation (u i a * u j b) (u j b * u i a)
| commuteVV (i j a b) (h : i ≠ j) : Equation (v i a * v j b) (v j b * v i a)
| commuteUV (i j a b) (h : i ≠ j) : Equation (u i a * v j b) (v j b * u i a)
| commuteWU (i j h a b) (hhi : h ≠ i) : Equation (w i j a * u h b) (u h b * w i j a)
| commuteWV (i j h a b) (hhj : h ≠ j) : Equation (w i j a * v h b) (v h b * w i j a)
| commutatorUW (i j a b) (h : i ≠ j) : Equation ⁅u i a,w i j b⁆ (u j (a+b))
| commutatorWV (i j a b) (h : i ≠ j) : Equation ⁅w i j a,v j b⁆ (v i (a+b))
| commuteTT (i j) : Equation (t i * t j) (t j * t i)
| conjTU (l i a) : Equation (t l * u i a * (t l)⁻¹) (u i (a-if l=i then 1 else 0))
| conjTV (l i a) : Equation (t l * v i a * (t l)⁻¹) (v i (a+if l=i then 1 else 0))
| conjTW (l i j a) : Equation (t l * w i j a * (t l)⁻¹)
(w i j (a+(if l=i then 1 else 0)-if l=j then 1 else 0))
| diagonalW (i a) : Equation (w i i a) 1
def relators : Set (FreeGroup Generator) := {r | ∃ a b, Equation a b ∧ r=a*b⁻¹}
abbrev AuxiliaryGroup := PresentedGroup relators
private theorem equation_holds {a b : FreeGroup Generator} (h : Equation a b) :
PresentedGroup.mk relators a = PresentedGroup.mk relators b :=
PresentedGroup.mk_eq_mk_of_mul_inv_mem ⟨a,b,h,rfl⟩
def data : SelectionGroupData AuxiliaryGroup where
T i := PresentedGroup.of (.T i)
U i a := PresentedGroup.of (.U i a)
V i a := PresentedGroup.of (.V i a)
W i j a := PresentedGroup.of (.W i j a)
square_U i a := by simpa [u, PresentedGroup.of] using equation_holds (.squareU i a)
commute_UU i j a b h := by
simpa [u, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteUU i j a b h)
commute_VV i j a b h := by
simpa [v, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteVV i j a b h)
commute_UV i j a b h := by
simpa [u,v, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteUV i j a b h)
commute_WU i j h a b hhi := by
simpa [w,u, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteWU i j h a b hhi)
commute_WV i j h a b hhj := by
simpa [w,v, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteWV i j h a b hhj)
commutator_UW i j a b h := by
simpa [u,w, PresentedGroup.of] using equation_holds (.commutatorUW i j a b h)
commutator_WV i j a b h := by
simpa [w,v, PresentedGroup.of] using equation_holds (.commutatorWV i j a b h)
commute_TT i j := by
simpa [t, PresentedGroup.of, Commute, SemiconjBy] using equation_holds (.commuteTT i j)
conj_TU l i a := by simpa [t,u,PresentedGroup.of] using equation_holds (.conjTU l i a)
conj_TV l i a := by simpa [t,v,PresentedGroup.of] using equation_holds (.conjTV l i a)
conj_TW l i j a := by simpa [t,w,PresentedGroup.of] using equation_holds (.conjTW l i j a)
diagonal_W i a := by simpa [w,PresentedGroup.of] using equation_holds (.diagonalW i a)
def z (N : ℤ) : AuxiliaryGroup := data.centralZ N
theorem z_involution (N : ℤ) : z N * z N = 1 := data.centralZ_involution N
theorem z_central (N : ℤ) (g : AuxiliaryGroup) : Commute (z N) g := by
have hg : g ∈ Subgroup.closure (Set.range (PresentedGroup.of : Generator → AuxiliaryGroup)) := by
rw [PresentedGroup.closure_range_of]
trivial
induction hg using Subgroup.closure_induction with
| mem g hg =>
obtain ⟨s,rfl⟩ := hg
cases s with
| T i => exact data.centralZ_commute_T N i
| U i a => exact data.centralZ_commute_U N i a
| V i a => exact data.centralZ_commute_V N i a
| W i j a => exact data.centralZ_commute_W N i j a
| one => exact Commute.one_right _
| mul a b ha hb ia ib => exact ia.mul_right ib
| inv a ha ia => exact ia.inv_right
def evaluate {G : Type*} [Group G] (D : SelectionGroupData G) : Generator → G
| .T i => D.T i
| .U i a => D.U i a
| .V i a => D.V i a
| .W i j a => D.W i j a
theorem evaluate_equation {G : Type*} [Group G] (D : SelectionGroupData G)
{a b : FreeGroup Generator} (h : Equation a b) :
FreeGroup.lift (evaluate D) a = FreeGroup.lift (evaluate D) b := by
cases h with
| squareU i a => simpa [u,evaluate] using D.square_U i a
| commuteUU i j a b h => simpa [u,evaluate] using (D.commute_UU i j a b h).eq
| commuteVV i j a b h => simpa [v,evaluate] using (D.commute_VV i j a b h).eq
| commuteUV i j a b h => simpa [u,v,evaluate] using (D.commute_UV i j a b h).eq
| commuteWU i j h a b hh => simpa [w,u,evaluate] using (D.commute_WU i j h a b hh).eq
| commuteWV i j h a b hh => simpa [w,v,evaluate] using (D.commute_WV i j h a b hh).eq
| commutatorUW i j a b h => simpa [u,w,evaluate] using D.commutator_UW i j a b h
| commutatorWV i j a b h => simpa [w,v,evaluate] using D.commutator_WV i j a b h
| commuteTT i j => simpa [t,evaluate] using (D.commute_TT i j).eq
| conjTU l i a => simpa [t,u,evaluate] using D.conj_TU l i a
| conjTV l i a => simpa [t,v,evaluate] using D.conj_TV l i a
| conjTW l i j a => simpa [t,w,evaluate] using D.conj_TW l i j a
| diagonalW i a => simpa [w,evaluate] using D.diagonal_W i a
def ofData {G : Type*} [Group G] (D : SelectionGroupData G) : AuxiliaryGroup →* G :=
PresentedGroup.toGroup (f := evaluate D) (by
intro r hr
obtain ⟨a,b,h,rfl⟩ := hr
rw [map_mul,map_inv,evaluate_equation D h,mul_inv_cancel])
@[simp] theorem ofData_of {G : Type*} [Group G] (D : SelectionGroupData G) (s : Generator) :
ofData D (PresentedGroup.of s) = evaluate D s := PresentedGroup.toGroup.of _
def shiftData {G : Type*} [Group G] (D : SelectionGroupData G) (k : ℤ) :
SelectionGroupData G where
T := D.T
U i a := D.U i (a+k)
V := D.V
W := D.W
square_U i a := D.square_U i (a+k)
commute_UU i j a b h := D.commute_UU i j (a+k) (b+k) h
commute_VV := D.commute_VV
commute_UV i j a b h := D.commute_UV i j (a+k) b h
commute_WU i j h a b hh := D.commute_WU i j h a (b+k) hh
commute_WV := D.commute_WV
commutator_UW i j a b h := by
simpa only [add_assoc,add_comm k b] using D.commutator_UW i j (a+k) b h
commutator_WV := D.commutator_WV
commute_TT := D.commute_TT
conj_TU l i a := by
simpa only [add_sub_assoc,sub_add_eq_add_sub] using D.conj_TU l i (a+k)
conj_TV := D.conj_TV
conj_TW := D.conj_TW
diagonal_W := D.diagonal_W
def shiftHom (k : ℤ) : AuxiliaryGroup →* AuxiliaryGroup := ofData (shiftData data k)
@[simp] theorem shiftHom_T (k : ℤ) (i : Fin 3) : shiftHom k (data.T i) = data.T i := by
simp [shiftHom,data,shiftData,evaluate]
@[simp] theorem shiftHom_U (k : ℤ) (i : Fin 3) (a : ℤ) :
shiftHom k (data.U i a) = data.U i (a+k) := by
simp [shiftHom,data,shiftData,evaluate]
@[simp] theorem shiftHom_V (k : ℤ) (i : Fin 3) (a : ℤ) :
shiftHom k (data.V i a) = data.V i a := by
simp [shiftHom,data,shiftData,evaluate]
@[simp] theorem shiftHom_W (k : ℤ) (i j : Fin 3) (a : ℤ) :
shiftHom k (data.W i j a) = data.W i j a := by
simp [shiftHom,data,shiftData,evaluate]
theorem shiftHom_comp (k l : ℤ) : (shiftHom k).comp (shiftHom l) = shiftHom (l+k) := by
apply PresentedGroup.ext
intro s
cases s <;> simp [MonoidHom.comp_apply,shiftHom,shiftData,data,evaluate,add_assoc]
theorem shiftHom_zero : shiftHom 0 = MonoidHom.id AuxiliaryGroup := by
apply PresentedGroup.ext
intro s
cases s <;> simp [shiftHom,shiftData,data,evaluate]
def shiftAut (k : ℤ) : AuxiliaryGroup ≃* AuxiliaryGroup where
toFun := shiftHom k
invFun := shiftHom (-k)
left_inv a := by
have h := DFunLike.congr_fun (shiftHom_comp (-k) k) a
simpa only [add_neg_cancel,shiftHom_zero,MonoidHom.id_apply,MonoidHom.comp_apply] using h
right_inv a := by
have h := DFunLike.congr_fun (shiftHom_comp k (-k)) a
simpa only [neg_add_cancel,shiftHom_zero,MonoidHom.id_apply,MonoidHom.comp_apply] using h
map_mul' := (shiftHom k).map_mul
theorem shiftAut_z (k N : ℤ) : shiftAut k (z N) = z (N+k) := by
change shiftHom k ⁅data.U 0 0,data.V 0 N⁆ = data.centralZ (N+k)
rw [map_commutatorElement,shiftHom_U,shiftHom_V,zero_add]
exact (data.centralZ_eq (N+k) 0 k N (by omega)).symm
end Presentation
end LittleFinitistic
end OAI