Blame for lean/OAI/GroupTheory/UniversalGroup/MarkerMachine.lean

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