math / data /lean /OAI /Algebra /Finitistic /Selection /FinitePresentation.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
24.1 kB
import OAI.Algebra.Finitistic.Selection.GroupSelection
import Mathlib.GroupTheory.FinitelyPresentedGroup
import Mathlib.Tactic.DeriveFintype
namespace OAI
open scoped commutatorElement
namespace LittleFinitistic.FinitePresentation
/-! Target: Group.IsFinitelyPresented Presentation.AuxiliaryGroup.
Section 2, Lemma group-finite-presentation. No finite-presentation hypothesis
is permitted on the target group. Diagonal W generators are redundant.
-/
section Orbit
variable {G : Type*} [Group G]
def orbit (t x : G) (r : ℤ) : G := t ^ r * x * (t ^ r)⁻¹
@[simp] theorem orbit_zero (t x : G) : orbit t x 0 = x := by simp [orbit]
theorem orbit_add (t x : G) (a b : ℤ) :
orbit t (orbit t x b) a = orbit t x (a+b) := by
simp only [orbit, zpow_add, mul_inv_rev]
group
theorem orbit_commute (t q x : G) (h : Commute t q) (a : ℤ) :
t * orbit q x a * t⁻¹ = orbit q (t*x*t⁻¹) a := by
have hc := h.zpow_right a
simp only [orbit]
calc
t * (q^a*x*(q^a)⁻¹) * t⁻¹ = (t*q^a)*x*(q^a)⁻¹*t⁻¹ := by group
_ = (q^a*t)*x*(q^a)⁻¹*t⁻¹ := by rw [hc.eq]
_ = q^a*(t*x)*((q^a)⁻¹*t⁻¹) := by group
_ = q^a*(t*x)*(t⁻¹*(q^a)⁻¹) := by rw [hc.inv_inv.eq]
_ = q^a*(t*x*t⁻¹)*(q^a)⁻¹ := by group
theorem orbit_covariance (t q x : G) (h : Commute t q) (d : ℤ)
(hx : t*x*t⁻¹ = orbit q x d) (a : ℤ) :
t * orbit q x a * t⁻¹ = orbit q x (a+d) := by
rw [orbit_commute t q x h a, hx, orbit_add]
theorem family_zpow (t : G) (f : ℤ → G) (d : ℤ)
(h : ∀ r, t*f r*t⁻¹ = f (r+d)) (n r : ℤ) :
orbit t (f r) n = f (r+n*d) := by
induction n using Int.induction_on with
| zero => simp
| succ n ih =>
have he : (↑n + 1 : ℤ) = 1 + ↑n := by omega
rw [he, ← orbit_add, ih]
change t^ (1:ℤ) * _ * (t^(1:ℤ))⁻¹ = _
simp only [zpow_one, h]
congr 1
ring
| pred n ih =>
have hi := h (r + (-↑n - 1)*d)
have he : r + (-↑n - 1)*d+d = r+(-↑n)*d := by ring
rw [he] at hi
have he' : (-↑n - 1 : ℤ) = -1 + -↑n := by omega
rw [he', ← orbit_add, ih, ← hi]
simp only [orbit, zpow_neg_one, inv_inv]
group
end Orbit
abbrev Lattice := Fin 3 → ℤ
def coord (i : Fin 3) (r : ℤ) : Lattice := fun h => if h=i then r else 0
def wtU (i : Fin 3) (n : Lattice) := -n i
def wtV (i : Fin 3) (n : Lattice) := n i
def wtW (i j : Fin 3) (n : Lattice) := n i-n j
/- Each theorem supplies the integral preimage in the corresponding table row. -/
theorem table_UU (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
∃ n : Lattice, wtU i n = r ∧ wtU j n = s := by
refine ⟨coord i (-r) + coord j (-s), ?_⟩
simp [wtU, coord, hij, hij.symm]
theorem table_VV (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
∃ n : Lattice, wtV i n = r ∧ wtV j n = s := by
refine ⟨coord i r + coord j s, ?_⟩
simp [wtV, coord, hij, hij.symm]
theorem table_UV (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
∃ n : Lattice, wtU i n = r ∧ wtV j n = s := by
refine ⟨coord i (-r) + coord j s, ?_⟩
simp [wtU, wtV, coord, hij, hij.symm]
theorem table_WU (i j h : Fin 3) (hij : i ≠ j) (hhi : h ≠ i) (r s : ℤ) :
∃ n : Lattice, wtW i j n = r ∧ wtU h n = s := by
by_cases hhj : h=j
· subst h
refine ⟨coord i (r-s) + coord j (-s), ?_⟩
simp [wtW, wtU, coord, hij, hij.symm]
· refine ⟨coord i r + coord h (-s), ?_⟩
simp [wtW, wtU, coord, hij.symm, hhi, (Ne.symm hhi), (Ne.symm hhj)]
theorem table_WV (i j h : Fin 3) (hij : i ≠ j) (hhj : h ≠ j) (r s : ℤ) :
∃ n : Lattice, wtW i j n = r ∧ wtV h n = s := by
by_cases hhi : h=i
· subst h
refine ⟨coord i s + coord j (s-r), ?_⟩
simp [wtW, wtV, coord, hij, hij.symm]
· refine ⟨coord i r + coord h s, ?_⟩
simp [wtW, wtV, coord, hij.symm, hhi, (Ne.symm hhi), (Ne.symm hhj)]
theorem table_UW (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
∃ n : Lattice, wtU i n = r ∧ wtW i j n = s := by
refine ⟨coord i (-r) + coord j (-r-s), ?_⟩
simp [wtU, wtW, coord, hij, hij.symm]
theorem table_WV_output (i j : Fin 3) (hij : i ≠ j) (r s : ℤ) :
∃ n : Lattice, wtW i j n = r ∧ wtV j n = s := by
refine ⟨coord i (r+s) + coord j s, ?_⟩
simp [wtW, wtV, coord, hij, hij.symm]
section Torus
variable {G : Type*} [Group G]
def torus (T : Fin 3 → G) (n : Lattice) : G := T 0 ^ n 0 * T 1 ^ n 1 * T 2 ^ n 2
theorem family_torus (T : Fin 3 → G) (f : ℤ → G) (d : Fin 3 → ℤ)
(hf : ∀ l r, T l * f r * (T l)⁻¹ = f (r+d l)) (n : Lattice) (r : ℤ) :
torus T n * f r * (torus T n)⁻¹ =
f (r + n 0*d 0 + n 1*d 1 + n 2*d 2) := by
have he : torus T n * f r * (torus T n)⁻¹ =
orbit (T 0) (orbit (T 1) (orbit (T 2) (f r) (n 2)) (n 1)) (n 0) := by
simp only [torus, orbit]
group
rw [he, family_zpow _ _ _ (hf 2), family_zpow _ _ _ (hf 1),
family_zpow _ _ _ (hf 0)]
congr 1
ring
theorem torus_U (T : Fin 3 → G) (U : Fin 3 → ℤ → G)
(hf : ∀ l i r, T l * U i r * (T l)⁻¹ = U i (r-if l=i then 1 else 0))
(n : Lattice) (i : Fin 3) (r : ℤ) :
torus T n * U i r * (torus T n)⁻¹ = U i (r+wtU i n) := by
have h := family_torus T (U i) (fun l => -(if l=i then 1 else 0))
(fun l r => by simpa only [sub_eq_add_neg] using hf l i r) n r
convert h using 2; fin_cases i <;> simp [wtU]
theorem torus_V (T : Fin 3 → G) (V : Fin 3 → ℤ → G)
(hf : ∀ l i r, T l * V i r * (T l)⁻¹ = V i (r+if l=i then 1 else 0))
(n : Lattice) (i : Fin 3) (r : ℤ) :
torus T n * V i r * (torus T n)⁻¹ = V i (r+wtV i n) := by
have h := family_torus T (V i) (fun l => if l=i then 1 else 0)
(fun l r => hf l i r) n r
convert h using 2; fin_cases i <;> simp [wtV]
theorem torus_W (T : Fin 3 → G) (W : Fin 3 → Fin 3 → ℤ → G)
(hf : ∀ l i j r, T l * W i j r * (T l)⁻¹ =
W i j (r+(if l=i then 1 else 0)-if l=j then 1 else 0))
(n : Lattice) (i j : Fin 3) (r : ℤ) :
torus T n * W i j r * (torus T n)⁻¹ = W i j (r+wtW i j n) := by
have h := family_torus T (W i j) (fun l => (if l=i then 1 else 0)-(if l=j then 1 else 0))
(fun l r => by simpa only [add_sub_assoc] using hf l i j r) n r
convert h using 2; fin_cases i <;> fin_cases j <;> simp [wtW] <;> ring
end Torus
/-- Intermediate data: covariance plus only zero-argument algebraic relations.
This is constructed below from a finite presented group, not postulated for it. -/
structure CovariantData (G : Type*) [Group G] where
T : Fin 3 → G
U : Fin 3 → ℤ → G
V : Fin 3 → ℤ → G
W : Fin 3 → Fin 3 → ℤ → G
TT : ∀ i j, Commute (T i) (T j)
TU : ∀ l i a, T l * U i a * (T l)⁻¹ = U i (a-if l=i then 1 else 0)
TV : ∀ l i a, T l * V i a * (T l)⁻¹ = V i (a+if l=i then 1 else 0)
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 : ∀ i a, W i i a = 1
square : ∀ i, U i 0 * U i 0 = 1
UU : ∀ i j, i ≠ j → Commute (U i 0) (U j 0)
VV : ∀ i j, i ≠ j → Commute (V i 0) (V j 0)
UV : ∀ i j, i ≠ j → Commute (U i 0) (V j 0)
WU : ∀ i j h, h ≠ i → Commute (W i j 0) (U h 0)
WV : ∀ i j h, h ≠ j → Commute (W i j 0) (V h 0)
UWout : ∀ i j, i ≠ j → ⁅U i 0,W i j 0⁆ = U j 0
WVout : ∀ i j, i ≠ j → ⁅W i j 0,V j 0⁆ = V i 0
namespace CovariantData
variable {G : Type*} [Group G] (D : CovariantData G)
def act (n : Lattice) : G ≃* G := MulAut.conj (torus D.T n)
@[simp] theorem act_U (n : Lattice) (i : Fin 3) (a : ℤ) :
D.act n (D.U i a) = D.U i (a+wtU i n) := torus_U D.T D.U D.TU n i a
@[simp] theorem act_V (n : Lattice) (i : Fin 3) (a : ℤ) :
D.act n (D.V i a) = D.V i (a+wtV i n) := torus_V D.T D.V D.TV n i a
@[simp] theorem act_W (n : Lattice) (i j : Fin 3) (a : ℤ) :
D.act n (D.W i j a) = D.W i j (a+wtW i j n) := torus_W D.T D.W D.TW n i j a
/-- All infinite relators follow from the finite zero-argument patterns. -/
def toSelection : SelectionGroupData G where
T := D.T
U := D.U
V := D.V
W := D.W
commute_TT := D.TT
conj_TU := D.TU
conj_TV := D.TV
conj_TW := D.TW
diagonal_W := D.diagonal
square_U i a := by
have ha : wtU i (coord i (-a)) = a := by simp [wtU, coord]
have h := congrArg (D.act (coord i (-a))) (D.square i)
simpa only [map_mul, map_one, act_U, zero_add, ha] using h
commute_UU i j a b hij := by
obtain ⟨n, ha, hb⟩ := table_UU i j hij a b
have h := (D.UU i j hij).map (D.act n)
simpa only [act_U, zero_add, ha, hb] using h
commute_VV i j a b hij := by
obtain ⟨n, ha, hb⟩ := table_VV i j hij a b
have h := (D.VV i j hij).map (D.act n)
simpa only [act_V, zero_add, ha, hb] using h
commute_UV i j a b hij := by
obtain ⟨n, ha, hb⟩ := table_UV i j hij a b
have h := (D.UV i j hij).map (D.act n)
simpa only [act_U, act_V, zero_add, ha, hb] using h
commute_WU i j h a b hhi := by
by_cases hij : i=j
· subst j
rw [D.diagonal]
exact Commute.one_left _
· obtain ⟨n, ha, hb⟩ := table_WU i j h hij hhi a b
have hh := (D.WU i j h hhi).map (D.act n)
simpa only [act_U, act_W, zero_add, ha, hb] using hh
commute_WV i j h a b hhj := by
by_cases hij : i=j
· subst j
rw [D.diagonal]
exact Commute.one_left _
· obtain ⟨n, ha, hb⟩ := table_WV i j h hij hhj a b
have hh := (D.WV i j h hhj).map (D.act n)
simpa only [act_V, act_W, zero_add, ha, hb] using hh
commutator_UW i j a b hij := by
obtain ⟨n, ha, hb⟩ := table_UW i j hij a b
have hout : wtU j n = a+b := by dsimp [wtU, wtW] at *; omega
have h := congrArg (D.act n) (D.UWout i j hij)
simpa only [map_commutatorElement, act_U, act_W, zero_add, ha, hb, hout] using h
commutator_WV i j a b hij := by
obtain ⟨n, ha, hb⟩ := table_WV_output i j hij a b
have hout : wtV i n = a+b := by dsimp [wtV, wtW] at *; omega
have h := congrArg (D.act n) (D.WVout i j hij)
simpa only [map_commutatorElement, act_V, act_W, zero_add, ha, hb, hout] using h
end CovariantData
/-- Finitely many seed values. Diagonal W seeds will be killed. -/
structure SeedValues (G : Type*) where
T : Fin 3 → G
u : Fin 3 → G
v : Fin 3 → G
w : Fin 3 → Fin 3 → G
structure SeedData (G : Type*) [Group G] extends SeedValues G where
TT : ∀ i j, Commute (T i) (T j)
Tu : ∀ l i, T l*u i*(T l)⁻¹ = orbit (T i) (u i) (if l=i then 1 else 0)
Tv : ∀ l i, T l*v i*(T l)⁻¹ = orbit (T i) (v i) (if l=i then 1 else 0)
Tw : ∀ l i j, T l*w i j*(T l)⁻¹ =
orbit (T i) (w i j) ((if l=i then 1 else 0)-(if l=j then 1 else 0))
diagonal : ∀ i, w i i = 1
square : ∀ i, u i*u i = 1
UU : ∀ i j, i ≠ j → Commute (u i) (u j)
VV : ∀ i j, i ≠ j → Commute (v i) (v j)
UV : ∀ i j, i ≠ j → Commute (u i) (v j)
WU : ∀ i j h, h ≠ i → Commute (w i j) (u h)
WV : ∀ i j h, h ≠ j → Commute (w i j) (v h)
UWout : ∀ i j, i ≠ j → ⁅u i,w i j⁆ = u j
WVout : ∀ i j, i ≠ j → ⁅w i j,v j⁆ = v i
namespace SeedData
variable {G : Type*} [Group G] (D : SeedData G)
def toCovariant : CovariantData G where
T := D.T
U i r := orbit (D.T i) (D.u i) (-r)
V i r := orbit (D.T i) (D.v i) r
W i j r := orbit (D.T i) (D.w i j) r
TT := D.TT
TU l i a := by
rw [orbit_covariance _ _ _ (D.TT l i) _ (D.Tu l i)]
congr 1
omega
TV l i a := orbit_covariance _ _ _ (D.TT l i) _ (D.Tv l i) a
TW l i j a := by
rw [orbit_covariance _ _ _ (D.TT l i) _ (D.Tw l i j)]
congr 1
omega
diagonal i a := by simp [orbit, D.diagonal]
square i := by simpa using D.square i
UU i j h := by simpa using D.UU i j h
VV i j h := by simpa using D.VV i j h
UV i j h := by simpa using D.UV i j h
WU i j h hh := by simpa using D.WU i j h hh
WV i j h hh := by simpa using D.WV i j h hh
UWout i j h := by simpa using D.UWout i j h
WVout i j h := by simpa using D.WVout i j h
def toSelection : SelectionGroupData G := D.toCovariant.toSelection
end SeedData
inductive SeedGenerator where
| T : Fin 3 → SeedGenerator
| U : Fin 3 → SeedGenerator
| V : Fin 3 → SeedGenerator
| W : Fin 3 → Fin 3 → SeedGenerator
deriving DecidableEq, Fintype
inductive Rule where
| TT : Fin 3 → Fin 3 → Rule
| Tu : Fin 3 → Fin 3 → Rule
| Tv : Fin 3 → Fin 3 → Rule
| Tw : Fin 3 → Fin 3 → Fin 3 → Rule
| diagonal : Fin 3 → Rule
| square : Fin 3 → Rule
| UU : Fin 3 → Fin 3 → Rule
| VV : Fin 3 → Fin 3 → Rule
| UV : Fin 3 → Fin 3 → Rule
| WU : Fin 3 → Fin 3 → Fin 3 → Rule
| WV : Fin 3 → Fin 3 → Fin 3 → Rule
| UWout : Fin 3 → Fin 3 → Rule
| WVout : Fin 3 → Fin 3 → Rule
deriving DecidableEq, Fintype
/-- Finite seed equation patterns. Vacuous index combinations give 1=1. -/
def equation {G : Type*} [Group G] (D : SeedValues G) : Rule → G × G
| .TT i j => (D.T i*D.T j, D.T j*D.T i)
| .Tu l i => (D.T l*D.u i*(D.T l)⁻¹, orbit (D.T i) (D.u i) (if l=i then 1 else 0))
| .Tv l i => (D.T l*D.v i*(D.T l)⁻¹, orbit (D.T i) (D.v i) (if l=i then 1 else 0))
| .Tw l i j => (D.T l*D.w i j*(D.T l)⁻¹,
orbit (D.T i) (D.w i j) ((if l=i then 1 else 0)-(if l=j then 1 else 0)))
| .diagonal i => (D.w i i, 1)
| .square i => (D.u i*D.u i, 1)
| .UU i j => if i≠j then (D.u i*D.u j, D.u j*D.u i) else (1,1)
| .VV i j => if i≠j then (D.v i*D.v j, D.v j*D.v i) else (1,1)
| .UV i j => if i≠j then (D.u i*D.v j, D.v j*D.u i) else (1,1)
| .WU i j h => if h≠i then (D.w i j*D.u h, D.u h*D.w i j) else (1,1)
| .WV i j h => if h≠j then (D.w i j*D.v h, D.v h*D.w i j) else (1,1)
| .UWout i j => if i≠j then (⁅D.u i,D.w i j⁆, D.u j) else (1,1)
| .WVout i j => if i≠j then (⁅D.w i j,D.v j⁆, D.v i) else (1,1)
def freeSeeds : SeedValues (FreeGroup SeedGenerator) where
T i := FreeGroup.of (.T i)
u i := FreeGroup.of (.U i)
v i := FreeGroup.of (.V i)
w i j := FreeGroup.of (.W i j)
def evalSeeds {G : Type*} (D : SeedValues G) : SeedGenerator → G
| .T i => D.T i
| .U i => D.u i
| .V i => D.v i
| .W i j => D.w i j
theorem equation_evaluate {G : Type*} [Group G] (D : SeedValues G) (r : Rule) :
FreeGroup.lift (evalSeeds D) (equation freeSeeds r).1 = (equation D r).1 ∧
FreeGroup.lift (evalSeeds D) (equation freeSeeds r).2 = (equation D r).2 := by
cases r <;> dsimp only [equation] <;> (try split_ifs) <;> simp [orbit, freeSeeds, evalSeeds]
def relator (r : Rule) : FreeGroup SeedGenerator :=
(equation freeSeeds r).1 * (equation freeSeeds r).2⁻¹
def finiteRelators : Set (FreeGroup SeedGenerator) := Set.range relator
abbrev Model := PresentedGroup finiteRelators
instance : Finite finiteRelators := Set.finite_range relator
instance : Group.IsFinitelyPresented Model := inferInstance
def modelValues : SeedValues Model where
T i := PresentedGroup.of (.T i)
u i := PresentedGroup.of (.U i)
v i := PresentedGroup.of (.V i)
w i j := PresentedGroup.of (.W i j)
theorem model_equation (r : Rule) :
(equation modelValues r).1 = (equation modelValues r).2 := by
have hm : FreeGroup.lift (evalSeeds modelValues) = PresentedGroup.mk finiteRelators := by
apply FreeGroup.ext_hom
intro s
cases s <;> rfl
have h := PresentedGroup.mk_eq_mk_of_mul_inv_mem (rels := finiteRelators)
(x := (equation freeSeeds r).1) (y := (equation freeSeeds r).2) ⟨r,rfl⟩
obtain ⟨h₁,h₂⟩ := equation_evaluate modelValues r
rw [hm] at h₁ h₂
exact h₁.symm.trans (h.trans h₂)
def modelSeedData : SeedData Model where
toSeedValues := modelValues
TT i j := by simpa [equation, Commute, SemiconjBy] using model_equation (.TT i j)
Tu l i := model_equation (.Tu l i)
Tv l i := model_equation (.Tv l i)
Tw l i j := model_equation (.Tw l i j)
diagonal i := model_equation (.diagonal i)
square i := model_equation (.square i)
UU i j h := by simpa [equation, h, Commute, SemiconjBy] using model_equation (.UU i j)
VV i j h := by simpa [equation, h, Commute, SemiconjBy] using model_equation (.VV i j)
UV i j h := by simpa [equation, h, Commute, SemiconjBy] using model_equation (.UV i j)
WU i j h hh := by simpa [equation, hh, Commute, SemiconjBy] using model_equation (.WU i j h)
WV i j h hh := by simpa [equation, hh, Commute, SemiconjBy] using model_equation (.WV i j h)
UWout i j h := by simpa [equation, h] using model_equation (.UWout i j)
WVout i j h := by simpa [equation, h] using model_equation (.WVout i j)
/-- The homomorphism from the supplied infinite presentation to the finite model. -/
def toModel : Presentation.AuxiliaryGroup →* Model :=
Presentation.ofData modelSeedData.toSelection
section OriginalSeeds
variable {G : Type*} [Group G] (D : SelectionGroupData G)
@[simp] theorem selection_U_orbit (i : Fin 3) (a : ℤ) :
orbit (D.T i) (D.U i 0) (-a) = D.U i a := by
have h := family_zpow (D.T i) (D.U i) (-1)
(fun r => by simpa only [ite_true, sub_eq_add_neg] using D.conj_TU i i r) (-a) 0
simpa using h
@[simp] theorem selection_V_orbit (i : Fin 3) (a : ℤ) :
orbit (D.T i) (D.V i 0) a = D.V i a := by
have h := family_zpow (D.T i) (D.V i) 1
(fun r => by simpa only [ite_true] using D.conj_TV i i r) a 0
simpa using h
@[simp] theorem selection_W_orbit (i j : Fin 3) (a : ℤ) :
orbit (D.T i) (D.W i j 0) a = D.W i j a := by
by_cases hij : i=j
· subst j
simp [orbit, D.diagonal_W]
· have h := family_zpow (D.T i) (D.W i j) 1
(fun r => by simpa [hij] using D.conj_TW i i j r) a 0
simpa using h
/-- The original presentation satisfies each of the finite seed equations. -/
def originalSeeds : SeedData G where
T := D.T
u i := D.U i 0
v i := D.V i 0
w i j := D.W i j 0
TT := D.commute_TT
Tu l i := by
have h := D.conj_TU l i 0
have hh := selection_U_orbit D i (-(if l=i then 1 else 0))
simp only [neg_neg] at hh
rw [hh]
simpa using h
Tv l i := by
rw [selection_V_orbit]
simpa using D.conj_TV l i 0
Tw l i j := by
rw [selection_W_orbit]
simpa using D.conj_TW l i j 0
diagonal i := D.diagonal_W i 0
square i := D.square_U i 0
UU i j h := D.commute_UU i j 0 0 h
VV i j h := D.commute_VV i j 0 0 h
UV i j h := D.commute_UV i j 0 0 h
WU i j h hh := D.commute_WU i j h 0 0 hh
WV i j h hh := D.commute_WV i j h 0 0 hh
UWout i j h := by simpa using D.commutator_UW i j 0 0 h
WVout i j h := by simpa using D.commutator_WV i j 0 0 h
end OriginalSeeds
theorem seed_equation {G : Type*} [Group G] (D : SeedData G) (r : Rule) :
(equation D.toSeedValues r).1 = (equation D.toSeedValues r).2 := by
cases r with
| TT i j => exact (D.TT i j).eq
| Tu l i => exact D.Tu l i
| Tv l i => exact D.Tv l i
| Tw l i j => exact D.Tw l i j
| diagonal i => exact D.diagonal i
| square i => exact D.square i
| UU i j =>
by_cases h : i≠j
· simpa only [equation, ite_eq_left h] using (D.UU i j h).eq
· simp [equation, h]
| VV i j =>
by_cases h : i≠j
· simpa only [equation, ite_eq_left h] using (D.VV i j h).eq
· simp [equation, h]
| UV i j =>
by_cases h : i≠j
· simpa only [equation, ite_eq_left h] using (D.UV i j h).eq
· simp [equation, h]
| WU i j k =>
by_cases h : k≠i
· simpa only [equation, ite_eq_left h] using (D.WU i j k h).eq
· simp [equation, h]
| WV i j k =>
by_cases h : k≠j
· simpa only [equation, ite_eq_left h] using (D.WV i j k h).eq
· simp [equation, h]
| UWout i j => by_cases h : i≠j <;> simp [equation, h, (D.UWout i j)]
| WVout i j => by_cases h : i≠j <;> simp [equation, h, (D.WVout i j)]
/-- Universal evaluation of the finite presentation in any proved seed data. -/
def modelLift {G : Type*} [Group G] (D : SeedData G) : Model →* G :=
PresentedGroup.toGroup (f := evalSeeds D.toSeedValues) (by
intro r hr
obtain ⟨s,rfl⟩ := hr
dsimp only [relator]
rw [map_mul, map_inv, (equation_evaluate D.toSeedValues s).1,
(equation_evaluate D.toSeedValues s).2, seed_equation D s, mul_inv_cancel])
@[simp] theorem modelLift_of {G : Type*} [Group G] (D : SeedData G) (s : SeedGenerator) :
modelLift D (PresentedGroup.of s) = evalSeeds D.toSeedValues s := PresentedGroup.toGroup.of _
def fromModel : Model →* Presentation.AuxiliaryGroup :=
modelLift (originalSeeds Presentation.data)
@[simp] theorem map_orbit {G H : Type*} [Group G] [Group H] (f : G →* H)
(t x : G) (a : ℤ) : f (orbit t x a) = orbit (f t) (f x) a := by simp [orbit]
@[simp] theorem toModel_T (i : Fin 3) :
toModel (Presentation.data.T i) = modelValues.T i :=
Presentation.ofData_of modelSeedData.toSelection (.T i)
@[simp] theorem toModel_U (i : Fin 3) (a : ℤ) :
toModel (Presentation.data.U i a) = orbit (modelValues.T i) (modelValues.u i) (-a) :=
Presentation.ofData_of modelSeedData.toSelection (.U i a)
@[simp] theorem toModel_V (i : Fin 3) (a : ℤ) :
toModel (Presentation.data.V i a) = orbit (modelValues.T i) (modelValues.v i) a :=
Presentation.ofData_of modelSeedData.toSelection (.V i a)
@[simp] theorem toModel_W (i j : Fin 3) (a : ℤ) :
toModel (Presentation.data.W i j a) = orbit (modelValues.T i) (modelValues.w i j) a :=
Presentation.ofData_of modelSeedData.toSelection (.W i j a)
@[simp] theorem fromModel_T (i : Fin 3) :
fromModel (modelValues.T i) = Presentation.data.T i :=
modelLift_of (originalSeeds Presentation.data) (.T i)
@[simp] theorem fromModel_u (i : Fin 3) :
fromModel (modelValues.u i) = Presentation.data.U i 0 :=
modelLift_of (originalSeeds Presentation.data) (.U i)
@[simp] theorem fromModel_v (i : Fin 3) :
fromModel (modelValues.v i) = Presentation.data.V i 0 :=
modelLift_of (originalSeeds Presentation.data) (.V i)
@[simp] theorem fromModel_w (i j : Fin 3) :
fromModel (modelValues.w i j) = Presentation.data.W i j 0 :=
modelLift_of (originalSeeds Presentation.data) (.W i j)
theorem fromModel_toModel : fromModel.comp toModel = MonoidHom.id Presentation.AuxiliaryGroup := by
apply PresentedGroup.ext
intro s
cases s with
| T i =>
change fromModel (toModel (Presentation.data.T i)) = Presentation.data.T i
simp
| U i a =>
change fromModel (toModel (Presentation.data.U i a)) = Presentation.data.U i a
simp
| V i a =>
change fromModel (toModel (Presentation.data.V i a)) = Presentation.data.V i a
simp
| W i j a =>
change fromModel (toModel (Presentation.data.W i j a)) = Presentation.data.W i j a
simp
theorem toModel_fromModel : toModel.comp fromModel = MonoidHom.id Model := by
apply PresentedGroup.ext
intro s
cases s with
| T i =>
change toModel (fromModel (modelValues.T i)) = modelValues.T i
simp
| U i =>
change toModel (fromModel (modelValues.u i)) = modelValues.u i
simp
| V i =>
change toModel (fromModel (modelValues.v i)) = modelValues.v i
simp
| W i j =>
change toModel (fromModel (modelValues.w i j)) = modelValues.w i j
simp
/-- Equivalence of the explicit finite presentation and the supplied infinite presentation. -/
def presentationEquiv : Model ≃* Presentation.AuxiliaryGroup where
toFun := fromModel
invFun := toModel
left_inv x := DFunLike.congr_fun toModel_fromModel x
right_inv x := DFunLike.congr_fun fromModel_toModel x
map_mul' := fromModel.map_mul
/-- Section 2, Lemma group-finite-presentation, for the exact supplied AuxiliaryGroup. -/
theorem auxiliaryGroup_isFinitelyPresented :
Group.IsFinitelyPresented Presentation.AuxiliaryGroup :=
Group.IsFinitelyPresented.equiv presentationEquiv
/-- The finite model retains the three redundant diagonal W generators. -/
theorem seedGenerator_card : Fintype.card SeedGenerator = 18 := by decide
/-- Number of indexed finite equation patterns, including tautological cases. -/
theorem rule_card : Fintype.card Rule = 159 := by decide +kernel
theorem model_isFinitelyPresented : Group.IsFinitelyPresented Model := inferInstance
end LittleFinitistic.FinitePresentation
end OAI