Download data/lean/OAI/GroupTheory/UniversalGroup/MarkerMachine.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 19.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/GroupTheory/UniversalGroup/MarkerMachine.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/GroupTheory/UniversalGroup/MarkerMachine.lean
-
curl -L -o MarkerMachine.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/GroupTheory/UniversalGroup/MarkerMachine.lean
19.2 kB
| import OAI.GroupTheory.UniversalGroup.Markers | |
| namespace OAI | |
| universe u v w x | |
| namespace Higman.FreeBasis | |
| section | |
| variable {X : Type*} | |
| noncomputable def erase (S : Set X) : FreeGroup X β* FreeGroup X := by | |
| classical | |
| exact FreeGroup.lift (fun x β¦ if x β S then FreeGroup.of x else 1) | |
| open Classical in | |
| @[simp] theorem erase_of (S : Set X) (x : X) : erase S (FreeGroup.of x) = | |
| if x β S then FreeGroup.of x else 1 := by | |
| classical | |
| simp [erase] | |
| abbrev span (S : Set X) : Subgroup (FreeGroup X) := Subgroup.closure (FreeGroup.of '' S) | |
| theorem erase_eq_self_iff (S : Set X) (g : FreeGroup X) : erase S g = g β g β span S := by | |
| classical | |
| constructor | |
| Β· intro hg | |
| have hle : (erase S).range β€ span S := by | |
| rw [erase,FreeGroup.range_lift_eq_closure] | |
| apply (Subgroup.closure_le _).mpr | |
| rintro _ β¨x,rflβ© | |
| by_cases hx : x β S | |
| Β· simp only [hx,ite_true] | |
| exact Subgroup.subset_closure β¨x,hx,rflβ© | |
| Β· simp only [hx,ite_false] | |
| exact Subgroup.one_mem _ | |
| exact hle β¨g,hgβ© | |
| Β· have hle : span S β€ (erase S).eqLocus (MonoidHom.id _) := by | |
| apply (Subgroup.closure_le _).mpr | |
| rintro _ β¨x,hx,rflβ© | |
| change erase S (FreeGroup.of x) = FreeGroup.of x | |
| simp [hx] | |
| exact fun hg β¦ hle hg | |
| theorem erase_comp (S T : Set X) : (erase S).comp (erase T) = erase (S β© T) := by | |
| classical | |
| apply FreeGroup.ext_hom | |
| intro x | |
| by_cases hxS : x β S <;> by_cases hxT : x β T <;> simp [hxS,hxT] | |
| theorem span_inter (S T : Set X) : span S β span T = span (S β© T) := by | |
| apply le_antisymm | |
| Β· intro g hg | |
| apply (erase_eq_self_iff _ _).mp | |
| rw [β erase_comp] | |
| change erase S (erase T g) = g | |
| rw [(erase_eq_self_iff T g).mpr hg.2,(erase_eq_self_iff S g).mpr hg.1] | |
| Β· exact le_inf (Subgroup.closure_mono (Set.image_mono Set.inter_subset_left)) | |
| (Subgroup.closure_mono (Set.image_mono Set.inter_subset_right)) | |
| theorem of_mem_span_iff (S : Set X) (x : X) : FreeGroup.of x β span S β x β S := by | |
| classical | |
| constructor | |
| Β· intro h | |
| by_contra hx | |
| have he := (erase_eq_self_iff S (FreeGroup.of x)).mpr h | |
| simp only [erase_of,hx,ite_false] at he | |
| exact FreeGroup.of_ne_one x he.symm | |
| Β· intro hx | |
| exact Subgroup.subset_closure β¨x,hx,rflβ© | |
| end | |
| variable {X : Type*} {G : Type*} [Group G] | |
| theorem map_span_inf (d : FreeGroup X β* G) (r : G β* FreeGroup X) | |
| (hr : r.comp d = MonoidHom.id _) (U V : Set X) (A : Subgroup G) | |
| (hsupport : A.map r β€ span U) | |
| (hletters : β x β U, d (FreeGroup.of x) β A) : | |
| (span V).map d β A = (span (V β© U)).map d := by | |
| apply le_antisymm | |
| Β· rintro g β¨β¨w,hw,rflβ©,hAβ© | |
| refine β¨w,?_,rflβ© | |
| rw [β span_inter] | |
| refine β¨hw,?_β© | |
| have hh := hsupport (Subgroup.mem_map.mpr β¨d w,hA,rflβ©) | |
| change w β span U | |
| simpa only [β MonoidHom.comp_apply,hr,MonoidHom.id_apply] using hh | |
| Β· apply le_inf | |
| Β· exact Subgroup.map_mono (Subgroup.closure_mono (Set.image_mono Set.inter_subset_left)) | |
| Β· rw [span,MonoidHom.map_closure] | |
| apply (Subgroup.closure_le _).mpr | |
| rintro _ β¨_,β¨x,hx,rflβ©,rflβ© | |
| exact hletters x hx.2 | |
| end Higman.FreeBasis | |
| namespace Higman.DecoratedMarker | |
| open Monoid Coprod | |
| variable {G : Type u} [Group G] {T : Type v} [Group T] {Q : Type w} | |
| theorem eq_inclusion_of_right_eq_one (x : Base G T Q) (hx : (test x).right = 1) : | |
| x = inclusion (test x).left := by | |
| apply (decomposition (G := G) (T := T) (Q := Q)).injective | |
| change test x = test (inclusion (test x).left) | |
| rw [β MonoidHom.comp_apply,test_comp] | |
| apply SemidirectProduct.ext | |
| Β· rfl | |
| Β· exact hx | |
| end Higman.DecoratedMarker | |
| namespace Higman.MarkerEmbedding | |
| section | |
| open Monoid Coprod DecoratedMarker | |
| variable {G : Type u} [Group G] {D : Type v} [Group D] | |
| {T : Type w} [Group T] {P Q : Type*} | |
| @[simp] theorem test_embedding (f : D β* T) (o : P β T) (q : P β Q) | |
| (w : P β G) (x : Base G D P) : | |
| test (embedding f o q w x) = | |
| SemidirectProduct.map (kernelMap f o q w) f (kernelMap_shift f o q w) (test x) := by | |
| change (test.comp inverse) _ = _ | |
| rw [test_comp_inverse] | |
| rfl | |
| @[simp] theorem embedding_inclusion (f : D β* T) (o : P β T) (q : P β Q) | |
| (w : P β G) (x : Kernel G D P) : | |
| embedding f o q w (inclusion x) = inclusion (kernelMap f o q w x) := by | |
| simp only [embedding,MonoidHom.comp_apply] | |
| rw [β MonoidHom.comp_apply (test : Base G D P β* _),test_comp] | |
| simp | |
| theorem kernel_intersection (f : D β* T) (hf : Function.Injective f) | |
| (o : P β T) (q : P β Q) (w : P β G) (R : Subgroup (Kernel G T Q)) : | |
| R.map inclusion β (embedding f o q w).range = | |
| (R β (kernelMap f o q w).range).map inclusion := by | |
| apply le_antisymm | |
| Β· rintro _ β¨β¨a,ha,rflβ©,β¨x,hxβ©β© | |
| have hxright : (test x).right = 1 := by | |
| apply hf | |
| have he := congrArg (fun y : Base G T Q β¦ (test y).right) hx | |
| simp only [test_embedding,SemidirectProduct.map_right] at he | |
| rw [β MonoidHom.comp_apply,test_comp] at he | |
| simpa only [SemidirectProduct.right_inl,map_one] using he | |
| have hx' := eq_inclusion_of_right_eq_one x hxright | |
| refine β¨a,β¨ha,?_β©,rflβ© | |
| refine β¨(test x).left,?_β© | |
| apply inclusion_injective | |
| rw [β embedding_inclusion,β hx'] | |
| exact hx | |
| Β· rintro _ β¨a,β¨ha,β¨x,hxβ©β©,rflβ© | |
| refine β¨β¨a,ha,rflβ©,inclusion x,?_β© | |
| rw [embedding_inclusion,hx] | |
| lemma projection_kernelMap (f : D β* T) (o : P β T) (q : P β Q) (w : P β G) : | |
| (Coprod.snd : Kernel G T Q β* FreeGroup (T Γ Q)).comp (kernelMap f o q w) = | |
| (FreeGroup.map (index f o q)).comp (Coprod.snd : Kernel G D P β* _) := by | |
| apply Coprod.hom_ext | |
| Β· apply MonoidHom.ext | |
| intro g | |
| simp | |
| Β· apply FreeGroup.ext_hom | |
| intro x | |
| simp | |
| lemma range_projection_support (f : D β* T) (o : P β T) (q : P β Q) (w : P β G) : | |
| (kernelMap f o q w).range.map Coprod.snd β€ FreeBasis.span (Set.range (index f o q)) := by | |
| rintro _ β¨_,β¨x,rflβ©,rflβ© | |
| have he := DFunLike.congr_fun (projection_kernelMap f o q w) x | |
| change Coprod.snd (kernelMap f o q w x) β FreeBasis.span (Set.range (index f o q)) | |
| rw [show Coprod.snd (kernelMap f o q w x) = FreeGroup.map (index f o q) (Coprod.snd x) from he] | |
| have hm : FreeGroup.map (index f o q) (Coprod.snd x) β (FreeGroup.map (index f o q)).range := | |
| β¨Coprod.snd x,rflβ© | |
| simpa only [FreeGroup.range_map,FreeBasis.span] using hm | |
| lemma decorated_letter_mem_range (f : D β* T) (o : P β T) (q : P β Q) (w : P β G) | |
| (v : T Γ Q β G) (x : T Γ Q) (hx : x β Set.range (index f o q)) : | |
| DecoratedFreeBasis.inclusion v (FreeGroup.of x) β (kernelMap f o q w).range := by | |
| obtain β¨β¨d,pβ©,rflβ© := hx | |
| refine β¨inl (v (index f o q (d,p)) * (w p)β»ΒΉ) * inr (FreeGroup.of (d,p)),?_β© | |
| simp [mul_assoc] | |
| theorem decorated_kernel_intersection (f : D β* T) (o : P β T) (q : P β Q) | |
| (w : P β G) (v : T Γ Q β G) (V : Set (T Γ Q)) : | |
| (FreeBasis.span V).map (DecoratedFreeBasis.inclusion v) β (kernelMap f o q w).range = | |
| (FreeBasis.span (V β© Set.range (index f o q))).map (DecoratedFreeBasis.inclusion v) := | |
| FreeBasis.map_span_inf (DecoratedFreeBasis.inclusion v) Coprod.snd | |
| (DecoratedFreeBasis.projection_comp v) (Set.range (index f o q)) V _ | |
| (range_projection_support f o q w) (decorated_letter_mem_range f o q w v) | |
| def decoratedSubgroup (v : T Γ Q β G) (V : Set (T Γ Q)) : Subgroup (Base G T Q) := | |
| (FreeBasis.span V).map (inclusion.comp (DecoratedFreeBasis.inclusion v)) | |
| theorem decorated_intersection (f : D β* T) (hf : Function.Injective f) | |
| (o : P β T) (q : P β Q) (w : P β G) (v : T Γ Q β G) (V : Set (T Γ Q)) : | |
| decoratedSubgroup v V β (embedding f o q w).range = | |
| decoratedSubgroup v (V β© Set.range (index f o q)) := by | |
| rw [decoratedSubgroup,β Subgroup.map_map,kernel_intersection f hf o q w, | |
| decorated_kernel_intersection,Subgroup.map_map] | |
| rfl | |
| theorem decoratedSubgroup_eq_closure (v : T Γ Q β G) (V : Set (T Γ Q)) : | |
| decoratedSubgroup v V = | |
| Subgroup.closure ((fun x : T Γ Q β¦ coefficient (v x) * marker x.1 x.2) '' V) := by | |
| rw [decoratedSubgroup,FreeBasis.span,MonoidHom.map_closure,Set.image_image] | |
| congr 1 | |
| end | |
| open DecoratedMarker | |
| variable {G : Type u} [Group G] {T : Type v} [Group T] {Q : Type w} | |
| {D : Type*} [Group D] {P : Type*} | |
| def pullDecoration (f : D β* T) (o : P β T) (q : P β Q) (w : P β G) | |
| (v : T Γ Q β G) (x : D Γ P) : G := v (index f o q x) * (w x.2)β»ΒΉ | |
| @[simp] lemma embedding_decorated (f : D β* T) (o : P β T) (q : P β Q) (w : P β G) | |
| (v : T Γ Q β G) (x : D Γ P) : | |
| embedding f o q w (coefficient (pullDecoration f o q w v x) * marker x.1 x.2) = | |
| coefficient (v (index f o q x)) * marker (index f o q x).1 (index f o q x).2 := by | |
| rw [map_mul,embedding_coefficient,embedding_marker,β mul_assoc,β map_mul] | |
| simp [pullDecoration,index] | |
| lemma map_decoratedSubgroup (f : D β* T) (o : P β T) (q : P β Q) (w : P β G) | |
| (v : T Γ Q β G) (W : Set (D Γ P)) : | |
| (decoratedSubgroup (pullDecoration f o q w v) W).map (embedding f o q w) = | |
| decoratedSubgroup v (index f o q '' W) := by | |
| rw [decoratedSubgroup_eq_closure,MonoidHom.map_closure,decoratedSubgroup_eq_closure] | |
| simp only [Set.image_image,embedding_decorated] | |
| theorem comap_decoratedSubgroup [Nonempty P] (f : D β* T) (hf : Function.Injective f) | |
| (o : P β T) (q : P β Q) (w : P β G) (hi : Function.Injective (index f o q)) | |
| (v : T Γ Q β G) (V : Set (T Γ Q)) : | |
| (decoratedSubgroup v V).comap (embedding f o q w) = | |
| decoratedSubgroup (pullDecoration f o q w v) (index f o q β»ΒΉ' V) := by | |
| apply Subgroup.map_injective (embedding_injective f hf o q w hi) | |
| rw [Subgroup.map_comap_eq,inf_comm,decorated_intersection f hf, | |
| map_decoratedSubgroup,Set.image_preimage_eq_inter_range] | |
| end Higman.MarkerEmbedding | |
| namespace Higman.PartialIso | |
| variable {H : Type u} [Group H] {G : Type u} [Group G] | |
| noncomputable def ofEmbeddings (i j : H β* G) (hi : Function.Injective i) | |
| (hj : Function.Injective j) : PartialIso G where | |
| source := i.range | |
| target := j.range | |
| equiv := (MonoidHom.ofInjective hi).symm.trans (MonoidHom.ofInjective hj) | |
| @[simp] theorem ofEmbeddings_apply (i j : H β* G) (hi : Function.Injective i) | |
| (hj : Function.Injective j) (x : H) : | |
| ((ofEmbeddings i j hi hj).equiv (MonoidHom.ofInjective hi x) : G) = j x := by | |
| change j ((MonoidHom.ofInjective hi).symm ((MonoidHom.ofInjective hi) x)) = j x | |
| rw [MulEquiv.symm_apply_apply] | |
| lemma ofEmbeddings_invariant_iff (i j : H β* G) (hi : Function.Injective i) | |
| (hj : Function.Injective j) (R : Subgroup G) : | |
| (ofEmbeddings i j hi hj).Invariant R β R.comap i = R.comap j := by | |
| constructor | |
| Β· intro h | |
| ext x | |
| simpa only [ofEmbeddings_apply,MonoidHom.ofInjective_apply,Subgroup.mem_comap] using | |
| (h (MonoidHom.ofInjective hi x)).symm | |
| Β· intro h a | |
| obtain β¨x,rflβ© := (MonoidHom.ofInjective hi).surjective a | |
| rw [ofEmbeddings_apply] | |
| change x β R.comap j β x β R.comap i | |
| rw [h] | |
| end Higman.PartialIso | |
| namespace Higman.MarkerMachine | |
| open DecoratedMarker MarkerEmbedding | |
| structure Edge (G T : Type u) [Group G] [Group T] (Q : Type u) where | |
| Domain : Type u | |
| [domainGroup : Group Domain] | |
| inputLinear : Domain β* T | |
| outputLinear : Domain β* T | |
| input_injective : Function.Injective inputLinear | |
| output_injective : Function.Injective outputLinear | |
| inputOffset : T | |
| outputOffset : T | |
| inputState : Q | |
| outputState : Q | |
| weight : G | |
| attribute [instance] Edge.domainGroup | |
| variable {G T Q : Type u} [Group G] [Group T] | |
| namespace Edge | |
| variable (e : Edge G T Q) | |
| def input (d : e.Domain) : T Γ Q := (e.inputLinear d * e.inputOffset,e.inputState) | |
| def output (d : e.Domain) : T Γ Q := (e.outputLinear d * e.outputOffset,e.outputState) | |
| def inputMap : Base G e.Domain Unit β* Base G T Q := | |
| embedding e.inputLinear (fun _ β¦ e.inputOffset) (fun _ β¦ e.inputState) (fun _ β¦ 1) | |
| def outputMap : Base G e.Domain Unit β* Base G T Q := | |
| embedding e.outputLinear (fun _ β¦ e.outputOffset) (fun _ β¦ e.outputState) (fun _ β¦ e.weight) | |
| lemma input_index_injective : Function.Injective | |
| (index e.inputLinear (fun _ : Unit β¦ e.inputOffset) (fun _ β¦ e.inputState)) := | |
| index_injective e.inputLinear e.input_injective _ _ (Function.injective_of_subsingleton _) | |
| lemma output_index_injective : Function.Injective | |
| (index e.outputLinear (fun _ : Unit β¦ e.outputOffset) (fun _ β¦ e.outputState)) := | |
| index_injective e.outputLinear e.output_injective _ _ (Function.injective_of_subsingleton _) | |
| lemma inputMap_injective : Function.Injective e.inputMap := | |
| embedding_injective e.inputLinear e.input_injective _ _ _ e.input_index_injective | |
| lemma outputMap_injective : Function.Injective e.outputMap := | |
| embedding_injective e.outputLinear e.output_injective _ _ _ e.output_index_injective | |
| noncomputable def partialIso : PartialIso (Base G T Q) := | |
| PartialIso.ofEmbeddings e.inputMap e.outputMap e.inputMap_injective e.outputMap_injective | |
| lemma inputMap_decorated (v : G) (d : e.Domain) : | |
| e.inputMap (coefficient v * marker d ()) = | |
| coefficient v * marker (e.input d).1 (e.input d).2 := by | |
| simp [inputMap,input] | |
| lemma outputMap_decorated (v : G) (d : e.Domain) : | |
| e.outputMap (coefficient v * marker d ()) = | |
| coefficient (v * e.weight) * marker (e.output d).1 (e.output d).2 := by | |
| simp [outputMap,output,map_mul,mul_assoc] | |
| end Edge | |
| end Higman.MarkerMachine | |
| namespace Higman.MarkerEmbedding | |
| open DecoratedMarker | |
| variable {G : Type u} [Group G] {T : Type v} [Group T] {Q : Type w} | |
| lemma decoratedSubgroup_congr {v w : T Γ Q β G} {V : Set (T Γ Q)} | |
| (h : β x β V, v x = w x) : decoratedSubgroup v V = decoratedSubgroup w V := by | |
| rw [decoratedSubgroup_eq_closure,decoratedSubgroup_eq_closure] | |
| congr 1 | |
| apply Set.image_congr | |
| intro x hx | |
| rw [h x hx] | |
| end Higman.MarkerEmbedding | |
| namespace Higman.MarkerMachine.Edge | |
| open DecoratedMarker MarkerEmbedding | |
| variable {G T Q : Type u} [Group G] [Group T] (e : Edge G T Q) | |
| theorem invariant (v : T Γ Q β G) (V : Set (T Γ Q)) | |
| (hV : β d, e.input d β V β e.output d β V) | |
| (hv : β d, e.input d β V β v (e.output d) = v (e.input d) * e.weight) : | |
| e.partialIso.Invariant (decoratedSubgroup v V) := by | |
| rw [partialIso,PartialIso.ofEmbeddings_invariant_iff] | |
| unfold inputMap outputMap | |
| rw [comap_decoratedSubgroup e.inputLinear e.input_injective _ _ _ e.input_index_injective, | |
| comap_decoratedSubgroup e.outputLinear e.output_injective _ _ _ e.output_index_injective] | |
| have he : index e.inputLinear (fun _ : Unit β¦ e.inputOffset) (fun _ β¦ e.inputState) β»ΒΉ' V = | |
| index e.outputLinear (fun _ : Unit β¦ e.outputOffset) (fun _ β¦ e.outputState) β»ΒΉ' V := by | |
| ext x | |
| exact hV x.1 | |
| rw [β he] | |
| apply decoratedSubgroup_congr | |
| rintro β¨d,pβ© hd | |
| change v (e.input d) * (1 : G)β»ΒΉ = v (e.output d) * e.weightβ»ΒΉ | |
| change e.input d β V at hd | |
| rw [hv d hd] | |
| simp | |
| lemma invariant_decorated_iff (R : Subgroup (Base G T Q)) (hR : e.partialIso.Invariant R) | |
| (a : G) (d : e.Domain) : | |
| coefficient (a * e.weight) * marker (e.output d).1 (e.output d).2 β R β | |
| coefficient a * marker (e.input d).1 (e.input d).2 β R := by | |
| have hh := hR (MonoidHom.ofInjective e.inputMap_injective (coefficient a * marker d ())) | |
| change ((PartialIso.ofEmbeddings e.inputMap e.outputMap _ _).equiv | |
| (MonoidHom.ofInjective e.inputMap_injective (coefficient a * marker d ())) : | |
| Base G T Q) β R β _ at hh | |
| simpa only [PartialIso.ofEmbeddings_apply,MonoidHom.ofInjective_apply, | |
| inputMap_decorated,outputMap_decorated] using hh | |
| lemma source_fg [Group.IsFinitelyPresented G] [Group.IsFinitelyPresented e.Domain] : | |
| e.partialIso.source.FG := by | |
| have : Group.IsFinitelyPresented (G Γ e.Domain) := finitelyPresented_prod | |
| obtain β¨n,p,hp,_β© := Group.IsFinitelyPresented.out (G := Base G e.Domain Unit) | |
| have : Group.FG (Base G e.Domain Unit) := Group.fg_of_surjective hp | |
| exact (Group.fg_iff_subgroup_fg e.inputMap.range).mp inferInstance | |
| end Higman.MarkerMachine.Edge | |
| namespace Higman.MarkerMachine | |
| open DecoratedMarker MarkerEmbedding | |
| variable {G T Q : Type u} [Group G] [Group T] | |
| inductive Reach (es : List (Edge G T Q)) (seed : T Γ Q) : T Γ Q β Prop | |
| | start : Reach es seed seed | |
| | forward (e : Edge G T Q) (he : e β es) (d : e.Domain) : | |
| Reach es seed (e.input d) β Reach es seed (e.output d) | |
| | backward (e : Edge G T Q) (he : e β es) (d : e.Domain) : | |
| Reach es seed (e.output d) β Reach es seed (e.input d) | |
| lemma reach_iff (es : List (Edge G T Q)) (seed : T Γ Q) (e : Edge G T Q) (he : e β es) | |
| (d : e.Domain) : Reach es seed (e.input d) β Reach es seed (e.output d) := | |
| β¨Reach.forward e he d,Reach.backward e he dβ© | |
| def word (v : T Γ Q β G) (c : T Γ Q) : Base G T Q := | |
| coefficient (v c) * marker c.1 c.2 | |
| theorem orbit_eq (es : List (Edge G T Q)) (seed : T Γ Q) (v : T Γ Q β G) | |
| (hv : β e β es, β d, Reach es seed (e.input d) β | |
| v (e.output d) = v (e.input d) * e.weight) : | |
| Orbit.subgroup (es.map Edge.partialIso) {word v seed} = | |
| decoratedSubgroup v {c | Reach es seed c} := by | |
| apply le_antisymm | |
| Β· apply Orbit.minimal | |
| Β· rintro x (rfl : x = word v seed) | |
| rw [decoratedSubgroup_eq_closure] | |
| exact Subgroup.subset_closure β¨seed,Reach.start,rflβ© | |
| Β· intro p hp | |
| obtain β¨e,he,rflβ© := List.mem_map.mp hp | |
| exact e.invariant v _ (reach_iff es seed e he) (hv e he) | |
| Β· rw [decoratedSubgroup_eq_closure] | |
| apply (Subgroup.closure_le _).mpr | |
| rintro _ β¨c,hc,rflβ© | |
| change word v c β Orbit.subgroup (es.map Edge.partialIso) {word v seed} | |
| induction hc with | |
| | start => exact Orbit.subset _ _ (Set.mem_singleton _) | |
| | forward e he d hr ih => | |
| have hinv := Orbit.invariant (es.map Edge.partialIso) {word v seed} e.partialIso | |
| (List.mem_map.mpr β¨e,he,rflβ©) | |
| change coefficient (v (e.output d)) * marker (e.output d).1 (e.output d).2 β _ | |
| rw [hv e he d hr] | |
| exact (e.invariant_decorated_iff _ hinv (v (e.input d)) d).mpr ih | |
| | backward e he d hr ih => | |
| have hinv := Orbit.invariant (es.map Edge.partialIso) {word v seed} e.partialIso | |
| (List.mem_map.mpr β¨e,he,rflβ©) | |
| apply (e.invariant_decorated_iff _ hinv (v (e.input d)) d).mp | |
| rw [β hv e he d (Reach.backward e he d hr)] | |
| exact ih | |
| theorem benign [Group.IsFinitelyPresented G] [Group.IsFinitelyPresented T] [Finite Q] | |
| (es : List (Edge G T Q)) (hD : β e β es, Group.IsFinitelyPresented e.Domain) | |
| (seed : T Γ Q) (v : T Γ Q β G) | |
| (hv : β e β es, β d, Reach es seed (e.input d) β | |
| v (e.output d) = v (e.input d) * e.weight) : | |
| IsBenign (decoratedSubgroup v {c | Reach es seed c}) := by | |
| have : Group.IsFinitelyPresented (G Γ T) := finitelyPresented_prod | |
| rw [β orbit_eq es seed v hv] | |
| apply Orbit.benign _ _ _ (Set.finite_singleton _) | |
| intro p hp | |
| obtain β¨e,he,rflβ© := List.mem_map.mp hp | |
| have := hD e he | |
| exact e.source_fg | |
| end Higman.MarkerMachine | |
| end OAI | |