lean/OAI/Algebra/Finitistic/Selection/GroupSelection.lean

import Mathlib.GroupTheory.Commutator.Basic
import Mathlib.GroupTheory.PresentedGroup
import Mathlib.Tactic.Group
import Mathlib.Tactic.FinCases
import Lean.Elab.Tactic.Omega

namespace OAI
/-! Group identities used in Section 2 of v5s9.15. -/

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