lean/OAI/GroupTheory/UniversalGroup/StackMachines.lean

import OAI.GroupTheory.UniversalGroup.MarkerMachine

namespace OAI

universe u v w x

namespace Higman.IntegerStack
variable {E : Type*}

def code (b : ℤ) (d : E → ℤ) : List E → ℤ
  | [] => 1
  | e :: s => b * code b d s + d e

@[simp] theorem code_nil (b : ℤ) (d : E → ℤ) : code b d [] = 1 := rfl
@[simp] theorem code_cons (b : ℤ) (d : E → ℤ) (e : E) (s : List E) :
    code b d (e :: s) = b * code b d s + d e := rfl

variable (b : ℤ) (d : E → ℤ) (hb : 2 ≤ b)
  (hd : ∀ e, 2 ≤ d e ∧ d e < b)

include hd

lemma push_mod (e : E) (z : ℤ) : (b * z + d e) % b = d e := by
  rw [Int.add_emod,Int.mul_emod_right,zero_add,Int.emod_emod,
    Int.emod_eq_of_lt (by have := (hd e).1; omega) (hd e).2]

include hb

lemma push_ne_empty (e : E) (z : ℤ) : b * z + d e ≠ 1 := by
  intro h
  have he := congrArg (fun x : ℤ ↦ x % b) h
  rw [push_mod b d hd,Int.emod_eq_of_lt (by omega) (by omega)] at he
  have := (hd e).1
  omega

lemma push_injective (hdinj : Function.Injective d) {e f : E} {z w : ℤ}
    (h : b * z + d e = b * w + d f) : e = f ∧ z = w := by
  have he := congrArg (fun x : ℤ ↦ x % b) h
  rw [push_mod b d hd,push_mod b d hd] at he
  have hef := hdinj he
  subst f
  refine ⟨rfl,?_⟩
  have hm : b * z = b * w := by omega
  exact mul_left_cancel₀ (by omega : b ≠ 0) hm

theorem decode_push (hdinj : Function.Injective d) (e : E) (z : ℤ) (s : List E) :
    b * z + d e = code b d s ↔ ∃ t, s = e :: t ∧ z = code b d t := by
  cases s with
  | nil => simp [push_ne_empty b d hb hd e z]
  | cons f t =>
    constructor
    · intro h
      obtain ⟨hef,hzt⟩ := push_injective b d hb hd hdinj h
      subst f
      exact ⟨t,rfl,hzt⟩
    · rintro ⟨u,hu,hz⟩
      cases hu
      simp [hz]

theorem code_injective (hdinj : Function.Injective d) : Function.Injective (code b d) := by
  intro s
  induction s with
  | nil =>
    intro t h
    cases t with
    | nil => rfl
    | cons e t => exact False.elim (push_ne_empty b d hb hd e (code b d t) h.symm)
  | cons e s ih =>
    intro t h
    obtain ⟨u,rfl,hu⟩ := (decode_push b d hb hd hdinj e (code b d s) t).mp h
    exact congrArg (List.cons e) (ih hu)

theorem code_pos (s : List E) : 0 < code b d s := by
  induction s with
  | nil => simp
  | cons e s ih =>
    have hm : 0 < b * code b d s := mul_pos (by omega) ih
    have hh := (hd e).1
    rw [code_cons]
    omega

end Higman.IntegerStack

namespace Higman.HistoryMachine
variable {E : Type*} {C : Type*} {D : E → Type*}

inductive Run (input output : (e : E) → D e → C) (initial : C) : List E → C → Prop
  | start : Run input output initial [] initial
  | step {s : List E} (e : E) (z : D e) :
      Run input output initial s (input e z) → Run input output initial (e :: s) (output e z)

variable (input output : (e : E) → D e → C) (initial : C)

@[simp] theorem run_nil (c : C) : Run input output initial [] c ↔ c = initial := by
  constructor
  · intro h
    cases h
    rfl
  · rintro rfl
    exact Run.start

@[simp] theorem run_cons (e : E) (s : List E) (c : C) :
    Run input output initial (e :: s) c ↔
      ∃ z : D e, c = output e z ∧ Run input output initial s (input e z) := by
  constructor
  · intro h
    cases h with
    | step e z h => exact ⟨z,rfl,h⟩
  · rintro ⟨z,rfl,h⟩
    exact Run.step e z h

def Reach (b : ℤ) (digit : E → ℤ) (c : C) (history : ℤ) : Prop :=
  ∃ s, Run input output initial s c ∧ history = IntegerStack.code b digit s

variable (b : ℤ) (digit : E → ℤ) (hb : 2 ≤ b)
  (hd : ∀ e, 2 ≤ digit e ∧ digit e < b) (hinj : Function.Injective digit)

lemma reach_start : Reach input output initial b digit initial 1 := ⟨[],Run.start,rfl⟩

include hb hd hinj in

theorem reach_step_iff (hout : ∀ e, Function.Injective (output e)) (e : E) (z : D e)
    (h : ℤ) :
    Reach input output initial b digit (output e z) (b * h + digit e) ↔
      Reach input output initial b digit (input e z) h := by
  constructor
  · rintro ⟨s,hs,he⟩
    obtain ⟨t,rfl,ht⟩ := (IntegerStack.decode_push b digit hb hd hinj e h s).mp he
    obtain ⟨y,hy,hr⟩ := (run_cons input output initial e t (output e z)).mp hs
    have hzy : z = y := hout e hy
    subst y
    exact ⟨t,hr,ht⟩
  · rintro ⟨s,hs,rfl⟩
    exact ⟨e :: s,Run.step e z hs,rfl⟩

variable {G : Type*} [Group G]

def value (weight : E → G) : List E → G
  | [] => 1
  | e :: s => value weight s * weight e

noncomputable def decoration (weight : E → G) (h : ℤ) : G := by
  classical
  exact if hh : ∃ s, h = IntegerStack.code b digit s then value weight hh.choose else 1

include hb hd hinj in
@[simp] theorem decoration_code (weight : E → G) (s : List E) :
    decoration b digit weight (IntegerStack.code b digit s) = value weight s := by
  classical
  unfold decoration
  split_ifs with h
  · have he : h.choose = s :=
      IntegerStack.code_injective b digit hb hd hinj h.choose_spec.symm
    rw [he]
  · exact False.elim (h ⟨s,rfl⟩)

include hb hd hinj in
lemma decoration_step (weight : E → G) (e : E) (z : D e) (h : ℤ)
    (hr : Reach input output initial b digit (input e z) h) :
    decoration b digit weight (b * h + digit e) = decoration b digit weight h * weight e := by
  obtain ⟨s,_,rfl⟩ := hr
  rw [← IntegerStack.code_cons,decoration_code b digit hb hd hinj,
    decoration_code b digit hb hd hinj]
  rfl

end Higman.HistoryMachine

namespace Higman.RecordedMachine

section
open MarkerMachine
abbrev Counter := Multiplicative ℤ

def scale (b : ℤ) : Counter →* Counter where
  toFun x := Multiplicative.ofAdd (b * x.toAdd)
  map_one' := by simp
  map_mul' x y := by simp [mul_add]

lemma scale_injective (b : ℤ) (hb : b ≠ 0) : Function.Injective (scale b) := by
  intro x y h
  change x.toAdd = y.toAdd
  exact mul_left_cancel₀ hb (congrArg Multiplicative.toAdd h)

variable {G T Q : Type u} [Group G]

def augment (c : T × Q) (h : ℤ) : (T × Counter) × Q := ((c.1,Multiplicative.ofAdd h),c.2)
def forget (c : (T × Counter) × Q) : T × Q := (c.1.1,c.2)
def history (c : (T × Counter) × Q) : ℤ := c.1.2.toAdd

@[simp] lemma forget_augment (c : T × Q) (h : ℤ) : forget (augment c h) = c := rfl
@[simp] lemma history_augment (c : T × Q) (h : ℤ) : history (augment c h) = h := rfl
@[simp] lemma augment_forget (c : (T × Counter) × Q) : augment (forget c) (history c) = c := rfl

variable [Group T]

def edge (e : Edge G T Q) (b digit : ℤ) (hb : b ≠ 0) : Edge G (T × Counter) Q where
  Domain := e.Domain × Counter
  inputLinear := e.inputLinear.prodMap (MonoidHom.id Counter)
  outputLinear := e.outputLinear.prodMap (scale b)
  input_injective := by
    intro x y h
    exact Prod.ext (e.input_injective (congrArg Prod.fst h)) (congrArg (fun p : T × Counter ↦ p.2) h)
  output_injective := by
    intro x y h
    exact Prod.ext (e.output_injective (congrArg Prod.fst h))
      (scale_injective b hb (congrArg Prod.snd h))
  inputOffset := (e.inputOffset,1)
  outputOffset := (e.outputOffset,Multiplicative.ofAdd digit)
  inputState := e.inputState
  outputState := e.outputState
  weight := e.weight

@[simp] lemma edge_input (e : Edge G T Q) (b digit : ℤ) (hb : b ≠ 0) (d : e.Domain) (h : Counter) :
    (edge e b digit hb).input (d,h) = augment (e.input d) h.toAdd := by
  change ((e.inputLinear d, h) * (e.inputOffset, 1), e.inputState) = _
  simp only [Prod.mul_def, mul_one]
  rfl
@[simp] lemma edge_output (e : Edge G T Q) (b digit : ℤ) (hb : b ≠ 0) (d : e.Domain) (h : Counter) :
    (edge e b digit hb).output (d,h) =
      augment (e.output d) (b * h.toAdd + digit) := rfl

variable {E : Type u} [Fintype E] (edges : E → Edge G T Q)
  (b : ℤ) (digit : E → ℤ) (hb : 2 ≤ b)

noncomputable def edgeList : List (Edge G (T × Counter) Q) :=
  Finset.univ.toList.map (fun e ↦ edge (edges e) b (digit e) (by omega))

lemma mem_edgeList (e : E) : edge (edges e) b (digit e) (by omega) ∈ edgeList edges b digit hb := by
  classical
  exact List.mem_map.mpr ⟨e,Finset.mem_toList.mpr (Finset.mem_univ _),rfl⟩

lemma of_mem_edgeList (a : Edge G (T × Counter) Q) (ha : a ∈ edgeList edges b digit hb) :
    ∃ e, a = edge (edges e) b (digit e) (by omega) := by
  obtain ⟨e,_,rfl⟩ := List.mem_map.mp ha
  exact ⟨e,rfl⟩

variable (seed : T × Q)

def Forward (c : (T × Counter) × Q) : Prop :=
  HistoryMachine.Reach (fun e ↦ (edges e).input) (fun e ↦ (edges e).output) seed b digit
    (forget c) (history c)

omit [Fintype E] in
lemma forward_start : Forward edges b digit seed (augment seed 1) :=
  HistoryMachine.reach_start _ _ _ _ _

variable (hd : ∀ e, 2 ≤ digit e ∧ digit e < b) (hinj : Function.Injective digit)

lemma output_injective (e : Edge G T Q) : Function.Injective e.output := by
  intro x y h
  exact e.output_injective (mul_right_cancel (congrArg Prod.fst h))

include hb hd hinj in
omit [Fintype E] in
lemma forward_edge (e : E) (d : (edges e).Domain) (h : ℤ) :
    Forward edges b digit seed (augment ((edges e).output d) (b*h + digit e)) ↔
      Forward edges b digit seed (augment ((edges e).input d) h) :=
  HistoryMachine.reach_step_iff _ _ _ b digit hb hd hinj
    (fun e ↦ output_injective (edges e)) e d h

include hd hinj in
lemma reach_implies_forward (c : (T × Counter) × Q)
    (hc : MarkerMachine.Reach (edgeList edges b digit hb) (augment seed 1) c) :
    Forward edges b digit seed c := by
  induction hc with
  | start => exact forward_start edges b digit seed
  | forward a ha d _ ih =>
    obtain ⟨e,rfl⟩ := of_mem_edgeList edges b digit hb a ha
    obtain ⟨d,h⟩ := d
    change Counter at h
    simpa only [edge_output] using
      (forward_edge edges b digit hb seed hd hinj e d h.toAdd).mpr
        (by simpa only [edge_input] using ih)
  | backward a ha d _ ih =>
    obtain ⟨e,rfl⟩ := of_mem_edgeList edges b digit hb a ha
    obtain ⟨d,h⟩ := d
    change Counter at h
    simpa only [edge_input] using
      (forward_edge edges b digit hb seed hd hinj e d h.toAdd).mp
        (by simpa only [edge_output] using ih)

lemma run_implies_reach {s : List E} {c : T × Q}
    (hc : HistoryMachine.Run (fun e ↦ (edges e).input) (fun e ↦ (edges e).output) seed s c) :
    MarkerMachine.Reach (edgeList edges b digit hb) (augment seed 1)
      (augment c (IntegerStack.code b digit s)) := by
  induction hc with
  | start => exact MarkerMachine.Reach.start
  | @step s e d hr ih =>
    have hh := MarkerMachine.Reach.forward (seed := augment seed 1)
      (edge (edges e) b (digit e) (by omega)) (mem_edgeList edges b digit hb e)
      (d,Multiplicative.ofAdd (IntegerStack.code b digit s))
    rw [edge_input,edge_output] at hh
    exact hh ih

lemma forward_implies_reach (c : (T × Counter) × Q) (hc : Forward edges b digit seed c) :
    MarkerMachine.Reach (edgeList edges b digit hb) (augment seed 1) c := by
  obtain ⟨s,hs,hh⟩ := hc
  have hr := run_implies_reach edges b digit hb seed hs
  rw [← hh,augment_forget] at hr
  exact hr

include hd hinj in

theorem reach_iff_forward (c : (T × Counter) × Q) :
    MarkerMachine.Reach (edgeList edges b digit hb) (augment seed 1) c ↔
      Forward edges b digit seed c :=
  ⟨reach_implies_forward edges b digit hb seed hd hinj c,
    forward_implies_reach edges b digit hb seed c⟩

end

open MarkerMachine DecoratedMarker MarkerEmbedding
variable {G T Q E : Type u} [Group G] [Group T] [Fintype E]
  (edges : E → Edge G T Q) (b : ℤ) (digit : E → ℤ) (hb : 2 ≤ b)
  (seed : T × Q) (hd : ∀ e, 2 ≤ digit e ∧ digit e < b) (hinj : Function.Injective digit)

noncomputable def decoration (c : (T × Counter) × Q) : G :=
  HistoryMachine.decoration b digit (fun e ↦ (edges e).weight) (history c)

include hd hinj in
lemma decoration_edge (a : Edge G (T × Counter) Q) (ha : a ∈ edgeList edges b digit hb)
    (d : a.Domain) (hr : MarkerMachine.Reach (edgeList edges b digit hb) (augment seed 1) (a.input d)) :
    decoration edges b digit (a.output d) = decoration edges b digit (a.input d) * a.weight := by
  obtain ⟨e,rfl⟩ := of_mem_edgeList edges b digit hb a ha
  obtain ⟨d,h⟩ := d
  have hf := reach_implies_forward edges b digit hb seed hd hinj _ hr
  rw [edge_input] at hf ⊢
  rw [edge_output]
  exact HistoryMachine.decoration_step (fun e ↦ (edges e).input) (fun e ↦ (edges e).output)
    seed b digit hb hd hinj
    (fun e ↦ (edges e).weight) e d h.toAdd hf

include hb hd hinj in

theorem benign_forward [Group.IsFinitelyPresented G] [Group.IsFinitelyPresented T] [Finite Q]
    (hD : ∀ e, Group.IsFinitelyPresented (edges e).Domain) :
    IsBenign (decoratedSubgroup (decoration edges b digit) {c | Forward edges b digit seed c}) := by
  have : Group.IsFinitelyPresented (T × Counter) := finitelyPresented_prod
  have he : {c | MarkerMachine.Reach (edgeList edges b digit hb) (augment seed 1) c} =
      {c | Forward edges b digit seed c} := by
    ext c
    exact reach_iff_forward edges b digit hb seed hd hinj c
  rw [← he]
  apply MarkerMachine.benign _ _ _ _ (decoration_edge edges b digit hb seed hd hinj)
  intro a ha
  obtain ⟨e,rfl⟩ := of_mem_edgeList edges b digit hb a ha
  have := hD e
  exact finitelyPresented_prod

end Higman.RecordedMachine

namespace Higman.MarkerEmbedding
open Monoid Coprod DecoratedMarker
variable {G T : Type u} {Q : Type*} [Group G] [Group T]

def coefficientProjection : Base G T Q →* G := Coprod.lift (MonoidHom.fst G T) 1

@[simp] lemma projection_coefficient (g : G) :
    coefficientProjection (coefficient g : Base G T Q) = g := by
  simp [coefficientProjection,coefficient]
@[simp] lemma projection_translation (t : T) :
    coefficientProjection (translation t : Base G T Q) = 1 := by
  simp [coefficientProjection,translation]
@[simp] lemma projection_marker (t : T) (q : Q) :
    coefficientProjection (marker t q : Base G T Q) = 1 := by
  simp [coefficientProjection,marker,translation]

lemma projection_surjective : Function.Surjective (coefficientProjection : Base G T Q →* G) :=
  fun g ↦ ⟨coefficient g,projection_coefficient g⟩

variable {Q : Type u}

theorem benign_output [Group.IsFinitelyPresented G] [Group.IsFinitelyPresented T]
    (v : T × Q → G) (V : Set (T × Q)) (hR : IsBenign (decoratedSubgroup v V)) (q : Q) :
    IsBenign (Subgroup.closure (v '' {c | c ∈ V ∧ c.2 = q})) := by
  have : Group.IsFinitelyPresented (G × T) := finitelyPresented_prod
  let f : Base G T Unit →* Base G T Q := embedding (MonoidHom.id T) (fun _ ↦ 1)
    (fun _ ↦ q) (fun _ ↦ 1)
  have hi : Function.Injective (index (MonoidHom.id T) (fun _ : Unit ↦ 1) (fun _ ↦ q)) :=
    index_injective _ Function.injective_id _ _ (Function.injective_of_subsingleton _)
  have hB := (hR.comap f).map_surjective
    (coefficientProjection : Base G T Unit →* G)
      (projection_surjective (G := G) (T := T) (Q := Unit))
  dsimp only [f] at hB
  rw [comap_decoratedSubgroup _ Function.injective_id _ _ _ hi,
    decoratedSubgroup_eq_closure,MonoidHom.map_closure] at hB
  have he : (coefficientProjection : Base G T Unit →* G) ''
      ((fun x : T × Unit ↦ coefficient
        (pullDecoration (MonoidHom.id T) (fun _ ↦ 1) (fun _ ↦ q) (fun _ ↦ 1) v x) *
          marker x.1 x.2) ''
        (index (MonoidHom.id T) (fun _ : Unit ↦ 1) (fun _ ↦ q) ⁻¹' V)) =
      v '' {c | c ∈ V ∧ c.2 = q} := by
    rw [Set.image_image]
    ext g
    constructor
    · rintro ⟨⟨t,p⟩,ht,rfl⟩
      refine ⟨(t,q),⟨?_,rfl⟩,?_⟩
      · simpa [index] using ht
      · simp [pullDecoration,index]
    · rintro ⟨⟨t,r⟩,⟨hc,hq⟩,rfl⟩
      change r = q at hq
      subst r
      refine ⟨(t,()),?_,?_⟩
      · simpa [index] using hc
      · simp [pullDecoration,index]
  rw [he] at hB
  exact hB

end Higman.MarkerEmbedding

namespace Higman.RecordedMachine
open MarkerMachine
variable {G T Q E : Type u} [Group G] [Group T]
  (edges : E → Edge G T Q) (seed : T × Q) (halt : Q)

def acceptedOutputs : Set G :=
  {g | ∃ s c, HistoryMachine.Run (fun e ↦ (edges e).input) (fun e ↦ (edges e).output)
    seed s c ∧ c.2 = halt ∧ g = HistoryMachine.value (fun e ↦ (edges e).weight) s}

variable [Fintype E] [Finite Q] [Group.IsFinitelyPresented G] [Group.IsFinitelyPresented T]

theorem benign_accepted (hD : ∀ e, Group.IsFinitelyPresented (edges e).Domain) :
    IsBenign (Subgroup.closure (acceptedOutputs edges seed halt)) := by
  classical
  let b : ℤ := Fintype.card E + 2
  let digit : E → ℤ := fun e ↦ ((Fintype.equivFin E e).val : ℤ) + 2
  have hb : 2 ≤ b := by dsimp [b]; omega
  have hd : ∀ e, 2 ≤ digit e ∧ digit e < b := by
    intro e
    have hh := (Fintype.equivFin E e).isLt
    dsimp [digit,b]
    constructor <;> omega
  have hi : Function.Injective digit := by
    intro e f h
    apply (Fintype.equivFin E).injective
    apply Fin.ext
    dsimp [digit] at h
    omega
  have : Group.IsFinitelyPresented (T × Counter) := finitelyPresented_prod
  have hp := MarkerEmbedding.benign_output (decoration edges b digit)
    {c | Forward edges b digit seed c}
    (benign_forward edges b digit hb seed hd hi hD) halt
  have he : decoration edges b digit ''
      {c | c ∈ {c | Forward edges b digit seed c} ∧ c.2 = halt} =
      acceptedOutputs edges seed halt := by
    ext g
    constructor
    · rintro ⟨c,⟨⟨s,hs,hh⟩,hc⟩,rfl⟩
      refine ⟨s,forget c,hs,hc,?_⟩
      dsimp [decoration]
      rw [hh,HistoryMachine.decoration_code b digit hb hd hi]
    · rintro ⟨s,c,hs,hc,rfl⟩
      refine ⟨augment c (IntegerStack.code b digit s),⟨?_,hc⟩,?_⟩
      · exact ⟨s,hs,rfl⟩
      · exact HistoryMachine.decoration_code b digit hb hd hi _ s
  rwa [he] at hp

end Higman.RecordedMachine

namespace Higman

theorem finitelyPresented_pi (I : Type u) [Finite I] (G : Type v) [Group G]
    [Group.IsFinitelyPresented G] : Group.IsFinitelyPresented (I → G) := by
  apply Finite.induction_empty_option _ _ _ I
  · intro A B e ih
    have := ih
    exact Group.IsFinitelyPresented.equiv (MulEquiv.arrowCongr e (MulEquiv.refl G))
  · infer_instance
  · intro A _ ih
    have := ih
    have : Group.IsFinitelyPresented (G × (A → G)) := finitelyPresented_prod
    let e : (Option A → G) ≃* G × (A → G) :=
      { Equiv.piOptionEquivProd with map_mul' := fun _ _ ↦ rfl }
    exact Group.IsFinitelyPresented.equiv e.symm

end Higman

end OAI