| import OAI.GroupTheory.Hyperbolic.FullChains |
|
|
| namespace OAI |
|
|
| namespace Release075.BlockPresentation |
| open CategoryTheory |
| variable {I B : Type} {r : ℕ} (d : BlockPresentation I B r) |
|
|
| def basePath : (a : d.Vertex) → (d.vertex .o ⟶ d.vertex a) |
| | .o => 𝟙 _ |
| | .v => d.treePathV |
| | .w => d.treePathW |
|
|
| private theorem based_comp_formula {C : Type*} [Groupoid C] {o a b c : C} |
| (A : o ⟶ a) (B : o ⟶ b) (C' : o ⟶ c) (f : a ⟶ b) (g : b ⟶ c) : |
| (MulOpposite.op (End.of (A ≫ f ≫ Groupoid.inv B)) : (End o)ᵐᵒᵖ) * |
| MulOpposite.op (End.of (B ≫ g ≫ Groupoid.inv C')) = |
| MulOpposite.op (End.of (A ≫ (f ≫ g) ≫ Groupoid.inv C')) := by |
| apply MulOpposite.unop_injective |
| change (A ≫ f ≫ Groupoid.inv B) ≫ (B ≫ g ≫ Groupoid.inv C') = _ |
| simp [Category.assoc,Groupoid.inv_eq_inv] |
|
|
| private theorem based_id_formula {C : Type*} [Groupoid C] {o a : C} (A : o ⟶ a) : |
| (1 : (End o)ᵐᵒᵖ) = MulOpposite.op (End.of (A ≫ (𝟙 a) ≫ Groupoid.inv A)) := by |
| apply MulOpposite.unop_injective |
| change 𝟙 _ = A ≫ (𝟙 a) ≫ Groupoid.inv A |
| simp |
|
|
| private theorem based_eq_id {C : Type*} [Groupoid C] {o a : C} (A : o ⟶ a) |
| (f : a ⟶ a) (h : A ≫ f ≫ Groupoid.inv A = 𝟙 o) : f = 𝟙 a := by |
| have hh := congrArg (fun f => Groupoid.inv A ≫ f ≫ A) h |
| simpa [Groupoid.inv_eq_inv,Category.assoc] using hh |
|
|
| theorem based_oriented_arrow {a c : Quiver.Symmetrify d.Vertex} (f : a ⟶ c) : |
| d.toFundamentalGroup (d.edgeValue (d.orientedLabel f)) = |
| MulOpposite.op (End.of (d.basePath a ≫ d.rawToFundamental.map f.toPath ≫ |
| Groupoid.inv (d.basePath c))) := by |
| change d.Arrow a c ⊕ d.Arrow c a at f |
| rcases f with f | f |
| · change d.Arrow a c at f |
| cases f with |
| | x e => exact d.toFundamentalGroup_edge (.inl e) |
| | l e => |
| have h := d.toFundamentalGroup_edge (.inr (.inl e)) |
| change d.toFundamentalGroup (d.edge (.inr (.inl e))) = |
| MulOpposite.op (End.of ((𝟙 _) ≫ d.pathL e ≫ Groupoid.inv d.treePathV)) |
| simpa only [Category.id_comp,basedEdge] using h |
| | rr e => |
| have h := d.toFundamentalGroup_edge (.inr (.inr e)) |
| change d.toFundamentalGroup (d.edge (.inr (.inr e))) = |
| MulOpposite.op (End.of ((𝟙 _) ≫ d.pathR e ≫ Groupoid.inv d.treePathW)) |
| simpa only [Category.id_comp,basedEdge] using h |
| · change d.Arrow c a at f |
| cases f with |
| | x e => |
| change d.toFundamentalGroup ((d.edge (.inl e))⁻¹) = _ |
| rw [map_inv,d.toFundamentalGroup_edge] |
| apply MulOpposite.unop_injective |
| change Groupoid.inv (d.treePathV ≫ d.pathX e ≫ Groupoid.inv d.treePathW) = |
| d.treePathW ≫ Groupoid.inv (d.pathX e) ≫ Groupoid.inv d.treePathV |
| simp [Groupoid.inv_eq_inv,Category.assoc] |
| | l e => |
| change d.toFundamentalGroup ((d.edge (.inr (.inl e)))⁻¹) = _ |
| rw [map_inv,d.toFundamentalGroup_edge] |
| apply MulOpposite.unop_injective |
| change Groupoid.inv (d.pathL e ≫ Groupoid.inv d.treePathV) = |
| d.treePathV ≫ Groupoid.inv (d.pathL e) ≫ Groupoid.inv (𝟙 _) |
| simp [Groupoid.inv_eq_inv] |
| | rr e => |
| change d.toFundamentalGroup ((d.edge (.inr (.inr e)))⁻¹) = _ |
| rw [map_inv,d.toFundamentalGroup_edge] |
| apply MulOpposite.unop_injective |
| change Groupoid.inv (d.pathR e ≫ Groupoid.inv d.treePathW) = |
| d.treePathW ≫ Groupoid.inv (d.pathR e) ≫ Groupoid.inv (𝟙 _) |
| simp [Groupoid.inv_eq_inv] |
|
|
| theorem based_rawWord {a c : Quiver.Symmetrify d.Vertex} (p : Quiver.Path a c) : |
| d.toFundamentalGroup (d.wordValue (d.rawWord p)) = |
| MulOpposite.op (End.of (d.basePath a ≫ d.rawToFundamental.map p ≫ |
| Groupoid.inv (d.basePath c))) := by |
| induction p with |
| | nil => |
| change 1 = MulOpposite.op (End.of (d.basePath a ≫ |
| d.rawToFundamental.map (𝟙 (d.rawVertex a)) ≫ Groupoid.inv (d.basePath a))) |
| exact (based_id_formula (d.basePath a)).trans |
| (congrArg (fun f : d.vertex a ⟶ d.vertex a => |
| MulOpposite.op (End.of (d.basePath a ≫ f ≫ Groupoid.inv (d.basePath a)))) |
| (CategoryTheory.Functor.map_id d.rawToFundamental (d.rawVertex a)).symm) |
| | @cons c e p f ih => |
| change d.toFundamentalGroup (d.wordValue (d.rawWord p ++ [d.orientedLabel f])) = _ |
| rw [wordValue_append,wordValue_cons,wordValue_nil,mul_one,map_mul,ih,d.based_oriented_arrow] |
| exact (based_comp_formula (d.basePath a) (d.basePath c) (d.basePath e) _ _).trans |
| (congrArg (fun z : d.vertex a ⟶ d.vertex e => |
| MulOpposite.op (End.of (d.basePath a ≫ z ≫ Groupoid.inv (d.basePath e)))) |
| (CategoryTheory.Functor.map_comp d.rawToFundamental |
| (show d.rawVertex a ⟶ d.rawVertex c from p) |
| (show d.rawVertex c ⟶ d.rawVertex e from f.toPath)).symm) |
|
|
| theorem rawWord_nullhomotopic {a : Quiver.Symmetrify d.Vertex} |
| (p : Quiver.Path a a) (h : d.wordValue (d.rawWord p) = 1) : |
| d.RawHomotopic p (𝟙 (d.rawVertex a)) := by |
| have hh := congrArg d.toFundamentalGroup h |
| rw [d.based_rawWord,map_one] at hh |
| have hu := congrArg MulOpposite.unop hh |
| change d.basePath a ≫ d.rawToFundamental.map p ≫ Groupoid.inv (d.basePath a) = 𝟙 _ at hu |
| apply (d.raw_equality_iff _ _).mp |
| exact (based_eq_id (d.basePath a) _ hu).trans |
| (CategoryTheory.Functor.map_id d.rawToFundamental (d.rawVertex a)).symm |
|
|
| end Release075.BlockPresentation |
|
|
| namespace Release075.BlockPresentation |
| open CategoryTheory |
| variable {I B : Type} {r : ℕ} (d : BlockPresentation I B r) |
|
|
| /-- The original oriented edges really are arrows in the symmetrified quiver. -/ |
| def rawEdge (e : d.OrientedEdge) : |
| (show Quiver.Symmetrify d.Vertex from d.edgeTarget (d.flipEdge e)) ⟶ |
| (show Quiver.Symmetrify d.Vertex from d.edgeTarget e) := by |
| rcases e with ⟨e,s⟩ |
| rcases e with x | l | rr <;> cases s |
| · exact Sum.inr (Arrow.x x) |
| · exact Sum.inl (Arrow.x x) |
| · exact Sum.inr (Arrow.l l) |
| · exact Sum.inl (Arrow.l l) |
| · exact Sum.inr (Arrow.rr rr) |
| · exact Sum.inl (Arrow.rr rr) |
| |
| @[simp] theorem orientedLabel_rawEdge (e : d.OrientedEdge) : |
| d.orientedLabel (d.rawEdge e) = e := by |
| rcases e with ⟨e,s⟩ |
| rcases e with x | l | rr <;> cases s <;> rfl |
| |
| theorem WordPath.exists_raw {a c : d.Vertex} {w : List d.OrientedEdge} |
| (h : Release075.WordPath d.flipEdge d.edgeTarget a c w) : |
| ∃ p : (d.rawVertex a ⟶ d.rawVertex c), d.rawWord p = w := by |
| induction h with |
| | nil a => exact ⟨𝟙 _,rfl⟩ |
| | cons e h ih => |
| obtain ⟨p,hp⟩ := ih |
| refine ⟨(d.rawEdge e).toPath ≫ p,?_⟩ |
| exact (d.rawWord_path_comp (d.rawEdge e).toPath p).trans |
| (congrArg₂ List.append |
| ((d.rawWord_toPath (d.rawEdge e)).trans |
| (congrArg (fun e => [e]) (d.orientedLabel_rawEdge e))) hp) |
|
|
| theorem typed_nullword_lifted_fillable {a : d.Vertex} {w : List d.OrientedEdge} |
| (ht : Release075.WordPath d.flipEdge d.edgeTarget a a w) |
| (hv : d.wordValue w = 1) (g : d.GroupType) : |
| Fillable d.liftedFlip d.liftedTarget d.LiftedFace (d.liftWord g w) := by |
| obtain ⟨p,rfl⟩ := WordPath.exists_raw d ht |
| exact d.nullhomotopic_lifted_fillable (d.rawWord_nullhomotopic p hv) g |
|
|
| end Release075.BlockPresentation |
|
|
| namespace Release075.BlockPresentation |
| attribute [local instance] Classical.propDecidable Classical.decEq |
| variable {I B : Type} {r : ℕ} (d : BlockPresentation I B r) |
|
|
| theorem wordValue_reverse (w : List d.OrientedEdge) : |
| d.wordValue (reverseWord d.flipEdge w) = (d.wordValue w)⁻¹ := by |
| induction w with |
| | nil => simp |
| | cons e w ih => simp [reverseWord_cons,ih,mul_inv_rev] |
|
|
| theorem exists_based_word (g : d.GroupType) : |
| ∃ w, WordPath d.flipEdge d.edgeTarget .o .o w ∧ d.wordValue w = g := by |
| let K : Subgroup d.GroupType := { |
| carrier := {g | ∃ w, WordPath d.flipEdge d.edgeTarget .o .o w ∧ d.wordValue w = g} |
| one_mem' := ⟨[],.nil _,rfl⟩ |
| mul_mem' := by |
| rintro g h ⟨u,hu,rfl⟩ ⟨v,hv,rfl⟩ |
| exact ⟨u++v,hu.append hv,d.wordValue_append u v⟩ |
| inv_mem' := by |
| rintro g ⟨w,hw,rfl⟩ |
| exact ⟨reverseWord d.flipEdge w,hw.reverse d.flipEdge_flipEdge,d.wordValue_reverse w⟩ } |
| apply PresentedGroup.generated_by d.relators K _ g |
| intro e |
| change ∃ w, WordPath d.flipEdge d.edgeTarget .o .o w ∧ d.wordValue w = d.edge e |
| rcases e with e | e | e |
| · refine ⟨[(d.treeL,true),(.inl e,true),(d.treeR,false)],?_,?_⟩ |
| · exact WordPath.cons (flip:=d.flipEdge) (color:=d.edgeTarget) (d.treeL,true) |
| (WordPath.cons (flip:=d.flipEdge) (color:=d.edgeTarget) (Sum.inl e,true) |
| (WordPath.cons (flip:=d.flipEdge) (color:=d.edgeTarget) (d.treeR,false) (WordPath.nil Vertex.o))) |
| · simp [wordValue,edgeValue,d.treeL_eq_one,d.treeR_eq_one] |
| · refine ⟨[(.inr (.inl e),true),(d.treeL,false)],?_,?_⟩ |
| · exact WordPath.cons (flip:=d.flipEdge) (color:=d.edgeTarget) |
| (.inr (.inl e),true) (WordPath.cons (flip:=d.flipEdge) (color:=d.edgeTarget) (d.treeL,false) (WordPath.nil Vertex.o)) |
| · simp [wordValue,edgeValue,d.treeL_eq_one] |
| · refine ⟨[(.inr (.inr e),true),(d.treeR,false)],?_,?_⟩ |
| · exact WordPath.cons (flip:=d.flipEdge) (color:=d.edgeTarget) |
| (.inr (.inr e),true) (WordPath.cons (flip:=d.flipEdge) (color:=d.edgeTarget) (d.treeR,false) (WordPath.nil Vertex.o)) |
| · simp [wordValue,edgeValue,d.treeR_eq_one] |
|
|
| theorem WordPath.shift {x y : d.LiftedVertex} {w : List d.LiftedEdge} |
| (hw : WordPath d.liftedFlip d.liftedTarget x y w) (g : d.GroupType) : |
| WordPath d.liftedFlip d.liftedTarget (d.shiftVertex g x) (d.shiftVertex g y) |
| (w.map (d.shiftEdge g)) := by |
| induction hw with |
| | nil x => exact .nil _ |
| | cons e hw ih => |
| have hh := WordPath.cons (flip:=d.liftedFlip) (color:=d.liftedTarget) (d.shiftEdge g e) ih |
| simpa only [List.map_cons,←d.shiftEdge_flip,d.shiftEdge_target] using hh |
|
|
| theorem WordPath.forget {x y : d.LiftedVertex} {w : List d.LiftedEdge} |
| (hw : WordPath d.liftedFlip d.liftedTarget x y w) : |
| WordPath d.flipEdge d.edgeTarget x.1 y.1 (w.map Prod.fst) := by |
| induction hw with |
| | nil x => exact .nil _ |
| | cons e hw ih => exact .cons e.1 ih |
|
|
| theorem WordPath.displacement {x y : d.LiftedVertex} {w : List d.LiftedEdge} |
| (hw : WordPath d.liftedFlip d.liftedTarget x y w) : |
| x.2 * d.wordValue (w.map Prod.fst) = y.2 := by |
| induction hw with |
| | nil x => simp |
| | cons e hw ih => |
| change (e.2*(d.edgeValue e.1)⁻¹) * |
| (d.edgeValue e.1 * d.wordValue (_:List d.OrientedEdge)) = _ |
| simpa only [mul_assoc,inv_mul_cancel_left,liftedTarget] using ih |
|
|
| theorem WordPath.liftWord_eq {x y : d.LiftedVertex} {w : List d.LiftedEdge} |
| (hw : WordPath d.liftedFlip d.liftedTarget x y w) : |
| d.liftWord x.2 (w.map Prod.fst) = w := by |
| induction hw with |
| | nil x => rfl |
| | cons e hw ih => |
| change d.liftWord (e.2 * (d.edgeValue e.1)⁻¹) (e.1::_) = e::_ |
| simpa only [liftWord_cons,inv_mul_cancel_right,Prod.mk.eta,liftedTarget] using congrArg (e::·) ih |
|
|
| theorem lifted_closed_fillable {x : d.LiftedVertex} {w : List d.LiftedEdge} |
| (hw : WordPath d.liftedFlip d.liftedTarget x x w) : |
| Fillable d.liftedFlip d.liftedTarget d.LiftedFace w := by |
| have hv : d.wordValue (w.map Prod.fst) = 1 := |
| mul_left_cancel ((WordPath.displacement d hw).trans (mul_one x.2).symm) |
| have hf := d.typed_nullword_lifted_fillable (WordPath.forget d hw) hv x.2 |
| rwa [WordPath.liftWord_eq d hw] at hf |
|
|
| theorem exists_lifted_path (g : d.GroupType) : |
| ∃ w, WordPath d.liftedFlip d.liftedTarget (.o,1) (.o,g) w := by |
| obtain ⟨w,hw,hv⟩ := d.exists_based_word g |
| exact ⟨d.liftWord 1 w,by simpa only [hv,one_mul] using d.liftWord_typed hw 1⟩ |
|
|
| theorem boundary₁_wordChain {x y : d.LiftedVertex} {w : List d.LiftedEdge} |
| (hw : WordPath d.liftedFlip d.liftedTarget x y w) : |
| d.boundary₁ (d.wordChain w) = Finsupp.single y 1 - Finsupp.single x 1 := by |
| induction hw with |
| | nil x => simp [wordChain] |
| | cons e hw ih => |
| change d.boundary₁ (d.edgeChain e + d.wordChain _) = _ |
| rw [map_add,d.boundary₁_edgeChain,ih] |
| abel |
|
|
| def powerWord (g : d.GroupType) (w : List d.LiftedEdge) : ℕ → List d.LiftedEdge |
| | 0 => [] |
| | n+1 => powerWord g w n ++ w.map (d.shiftEdge (g^n)) |
|
|
| @[simp] theorem powerWord_zero (g : d.GroupType) (w : List d.LiftedEdge) : |
| d.powerWord g w 0 = [] := rfl |
|
|
| theorem powerWord_succ (g : d.GroupType) (w : List d.LiftedEdge) (n : ℕ) : |
| d.powerWord g w (n+1) = d.powerWord g w n ++ w.map (d.shiftEdge (g^n)) := rfl |
|
|
| theorem powerWord_succ_left (g : d.GroupType) (w : List d.LiftedEdge) (n : ℕ) : |
| d.powerWord g w (n+1) = w ++ (d.powerWord g w n).map (d.shiftEdge g) := by |
| induction n with |
| | zero => simpa only [powerWord,pow_zero,List.nil_append,List.map_nil,List.append_nil] using |
| (List.map_id'' (d.shiftEdge_one) w) |
| | succ n ih => |
| rw [powerWord_succ] |
| conv_lhs => rw [ih] |
| conv_rhs => rw [powerWord_succ] |
| rw [List.map_append,List.map_map,List.append_assoc] |
| congr 2 |
| apply List.map_congr_left |
| intro e _ |
| simp only [Function.comp_def,←shiftEdge_mul,←pow_succ'] |
|
|
| theorem powerWord_typed (g : d.GroupType) {w : List d.LiftedEdge} |
| (hw : WordPath d.liftedFlip d.liftedTarget (.o,1) (.o,g) w) (n : ℕ) : |
| WordPath d.liftedFlip d.liftedTarget (.o,1) (.o,g^n) (d.powerWord g w n) := by |
| induction n with |
| | zero => simpa only [powerWord_zero,pow_zero] using |
| (WordPath.nil (flip:=d.liftedFlip) (color:=d.liftedTarget) (.o,1)) |
| | succ n ih => |
| rw [powerWord_succ] |
| apply ih.append |
| simpa only [shiftVertex,mul_one,pow_succ] using WordPath.shift d hw (g^n) |
|
|
| theorem powerWord_chain (g : d.GroupType) (w : List d.LiftedEdge) (n : ℕ) : |
| d.wordChain (d.powerWord g w n) = ∑ i ∈ Finset.range n, chainShift (g^i) (d.wordChain w) := by |
| induction n with |
| | zero => simp [wordChain] |
| | succ n ih => rw [powerWord_succ,wordChain_append,wordChain_shift,ih,Finset.sum_range_succ] |
|
|
| theorem powerWord_shift_rotate (g : d.GroupType) (w : List d.LiftedEdge) {n : ℕ} |
| (hn : 0 < n) (hg : g^n = 1) : |
| (d.powerWord g w n).map (d.shiftEdge g) = (d.powerWord g w n).rotate w.length := by |
| obtain ⟨k,rfl⟩ := Nat.exists_eq_succ_of_ne_zero hn.ne' |
| conv_rhs => rw [powerWord_succ_left,List.rotate_append_length_eq] |
| rw [powerWord_succ,List.map_append,List.map_map] |
| congr 1 |
| have he : (d.shiftEdge g) ∘ (d.shiftEdge (g^k)) = id := by |
| funext e |
| simp only [Function.comp_def,← shiftEdge_mul,← pow_succ',hg,shiftEdge_one,id_eq] |
| rw [he,List.map_id] |
|
|
| theorem powerWord_chain_norm (g : d.GroupType) (hg : IsOfFinOrder g) |
| [Fintype (Subgroup.zpowers g)] (w : List d.LiftedEdge) : |
| d.wordChain (d.powerWord g w (orderOf g)) = |
| FreeChain.subgroupNorm (Subgroup.zpowers g) (d.wordChain w) := by |
| rw [powerWord_chain] |
| simp only [FreeChain.subgroupNorm,LinearMap.sum_apply,LinearEquiv.coe_coe] |
| rw [← Equiv.sum_comp (finEquivZPowers hg)] |
| exact (Fin.sum_univ_eq_sum_range (fun i => chainShift (g^i) (d.wordChain w)) (orderOf g)).symm |
|
|
| end Release075.BlockPresentation |
|
|
| namespace Release075.FullFilling |
| variable {I B : Type} {r : ℕ} {d : BlockPresentation I B r} |
| variable {w w' : List d.LiftedEdge} |
| (D : FullFilling d.liftedFlip d.liftedTarget d.LiftedFace w) |
|
|
| theorem allTriangles_reword (hD : D.AllTriangles) (h : w = w') : |
| (D.reword h).AllTriangles := by subst w'; exact hD |
| |
| @[simp] theorem faceChain_reword (h : w = w') : (D.reword h).faceChain = D.faceChain := by |
| subst w'; rfl |
| |
| end Release075.FullFilling |
| |
| end OAI |
| |
