| 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 |
|
|
|
|
| / |
| 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 |
|
|
| / |
| 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 |
|
|
| / |
| 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 |
|
|
| / |
| 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) |
|
|
| / |
| 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 |
|
|
| / |
| 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)] |
|
|
| / |
| 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 |
|
|
| / |
| 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 |
| |
