lean/OAI/GroupTheory/UniversalGroup/StackPrograms.lean

import OAI.GroupTheory.UniversalGroup.StackMachines

namespace OAI

universe u v w x

namespace Higman.AffineStack

section
open MarkerMachine
abbrev Counter := Multiplicative ℤ

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

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

inductive Op (Γ : Type)
  | push (a : Γ) | pop (a : Γ) | peek (a : Γ) | empty | idle

variable {Γ G Q : Type} [Group G]

def Op.Rel : Op Γ → List Γ → List Γ → Prop
  | .push a, s, t => t = a :: s
  | .pop a, s, t => s = a :: t
  | .peek a, s, t => s = t ∧ ∃ r, s = a :: r
  | .empty, s, t => s = [] ∧ t = []
  | .idle, s, t => s = t

def localEdge (b : ℤ) (digit : Γ → ℤ) (hb : b ≠ 0) (p q : Q) (w : G) :
    Op Γ → Edge G Counter Q
  | .push a => ⟨Counter, MonoidHom.id _, scale b, Function.injective_id,
      scale_injective b hb, 1, Multiplicative.ofAdd (digit a),p,q,w⟩
  | .pop a => ⟨Counter, scale b, MonoidHom.id _, scale_injective b hb,
      Function.injective_id, Multiplicative.ofAdd (digit a),1,p,q,w⟩
  | .peek a => ⟨Counter, scale b, scale b, scale_injective b hb,
      scale_injective b hb, Multiplicative.ofAdd (digit a),Multiplicative.ofAdd (digit a),p,q,w⟩
  | .empty => ⟨PUnit,1,1,Function.injective_of_subsingleton _,Function.injective_of_subsingleton _,
      Multiplicative.ofAdd 1,Multiplicative.ofAdd 1,p,q,w⟩
  | .idle => ⟨Counter, MonoidHom.id _,MonoidHom.id _,Function.injective_id,
      Function.injective_id,1,1,p,q,w⟩

instance localEdge_finitelyPresented (b : ℤ) (digit : Γ → ℤ) (hb : b ≠ 0) (p q : Q) (w : G)
    (o : Op Γ) : Group.IsFinitelyPresented (localEdge b digit hb p q w o).Domain := by
  cases o with
  | empty => exact inferInstanceAs (Group.IsFinitelyPresented PUnit)
  | push a | pop a | peek a | idle => exact inferInstanceAs (Group.IsFinitelyPresented Counter)

variable (b : ℤ) (digit : Γ → ℤ) (hb : 2 ≤ b)
  (hd : ∀ a, 2 ≤ digit a ∧ digit a < b) (hi : Function.Injective digit)

def encode (s : List Γ) : Counter := Multiplicative.ofAdd (IntegerStack.code b digit s)

include hb hd hi in
lemma encode_injective : Function.Injective (encode b digit) :=
  fun _ _ h ↦ IntegerStack.code_injective b digit hb hd hi (congrArg Multiplicative.toAdd h)

include hb hd hi in

theorem local_sound (p q : Q) (w : G) (o : Op Γ)
    (x : (localEdge b digit (by omega) p q w o).Domain) (s : List Γ)
    (h : (localEdge b digit (by omega) p q w o).inputLinear x *
      (localEdge b digit (by omega) p q w o).inputOffset = encode b digit s) :
    ∃ t, (localEdge b digit (by omega) p q w o).outputLinear x *
      (localEdge b digit (by omega) p q w o).outputOffset = encode b digit t ∧ o.Rel s t := by
  cases o with
  | push a =>
    change x * 1 = encode b digit s at h
    simp only [mul_one] at h
    subst x
    exact ⟨a::s,rfl,rfl⟩
  | pop a =>
    change Counter at x
    have hh : b*x.toAdd + digit a = IntegerStack.code b digit s :=
      congrArg Multiplicative.toAdd h
    obtain ⟨t,rfl,ht⟩ := (IntegerStack.decode_push b digit hb hd hi a x.toAdd s).mp hh
    refine ⟨t,?_,rfl⟩
    change x * 1 = encode b digit t
    rw [mul_one]
    exact Multiplicative.toAdd.injective ht
  | peek a =>
    change Counter at x
    have hh : b*x.toAdd + digit a = IntegerStack.code b digit s :=
      congrArg Multiplicative.toAdd h
    obtain ⟨t,ht,_⟩ := (IntegerStack.decode_push b digit hb hd hi a x.toAdd s).mp hh
    exact ⟨s,h,rfl,t,ht⟩
  | empty =>
    have hh : encode b digit [] = encode b digit s := by
      change (1 : Counter) * encode b digit [] = encode b digit s at h
      simpa only [one_mul] using h
    have hs : s = [] := (encode_injective b digit hb hd hi hh).symm
    exact ⟨[],rfl,hs,rfl⟩
  | idle => exact ⟨s,h,rfl⟩

include hb in

theorem local_complete (p q : Q) (w : G) (o : Op Γ) (s t : List Γ) (h : o.Rel s t) :
    ∃ x : (localEdge b digit (by omega) p q w o).Domain,
      (localEdge b digit (by omega) p q w o).inputLinear x *
        (localEdge b digit (by omega) p q w o).inputOffset = encode b digit s ∧
      (localEdge b digit (by omega) p q w o).outputLinear x *
        (localEdge b digit (by omega) p q w o).outputOffset = encode b digit t := by
  cases o with
  | push a => exact ⟨encode b digit s, mul_one _, by cases h; rfl⟩
  | pop a => exact ⟨encode b digit t, by cases h; rfl, mul_one _⟩
  | peek a =>
    obtain ⟨rfl,r,rfl⟩ := h
    exact ⟨encode b digit r,rfl,rfl⟩
  | empty =>
    obtain ⟨rfl,rfl⟩ := h
    exact ⟨PUnit.unit,rfl,rfl⟩
  | idle => exact ⟨encode b digit s,mul_one _,by cases h; exact mul_one _⟩

end

section
open MarkerMachine
variable {K Γ G Q : Type} [DecidableEq K] [Group G]

abbrev Stores (K : Type) := K → Counter
abbrev Rest (k : K) := {j : K // j ≠ k} → Counter

def insertLinear {A : Type} [Group A] (k : K) (f : A →* Counter) :
    A × Rest k →* Stores K where
  toFun x j := if h : j = k then f x.1 else x.2 ⟨j,h⟩
  map_one' := by ext j; dsimp; split_ifs <;> simp
  map_mul' x y := by ext j; dsimp; split_ifs <;> simp

@[simp] lemma insertLinear_apply {A : Type} [Group A] (k : K) (f : A →* Counter)
    (x : A × Rest k) (j : K) : insertLinear k f x j =
      if h : j = k then f x.1 else x.2 ⟨j,h⟩ := rfl

lemma insertLinear_injective {A : Type} [Group A] (k : K) (f : A →* Counter)
    (hf : Function.Injective f) : Function.Injective (insertLinear k f) := by
  intro x y h
  apply Prod.ext
  · apply hf
    simpa [insertLinear] using congrFun h k
  · funext j
    simpa [insertLinear,j.property] using congrFun h j.val

def insertOffset (k : K) (a : Counter) : Stores K := fun j ↦ if j = k then a else 1

def liftEdge (k : K) (e : Edge G Counter Q) : Edge G (Stores K) Q where
  Domain := e.Domain × Rest k
  inputLinear := insertLinear k e.inputLinear
  outputLinear := insertLinear k e.outputLinear
  input_injective := insertLinear_injective k e.inputLinear e.input_injective
  output_injective := insertLinear_injective k e.outputLinear e.output_injective
  inputOffset := insertOffset k e.inputOffset
  outputOffset := insertOffset k e.outputOffset
  inputState := e.inputState
  outputState := e.outputState
  weight := e.weight

lemma liftEdge_finitelyPresented [Finite K] (k : K) (e : Edge G Counter Q)
    [Group.IsFinitelyPresented e.Domain] : Group.IsFinitelyPresented (liftEdge k e).Domain := by
  have : Group.IsFinitelyPresented (Rest k) := finitelyPresented_pi _ _
  exact finitelyPresented_prod

inductive Action (K Γ : Type)
  | onStack (k : K) (o : Op Γ) | idle

def Action.Rel : Action K Γ → (K → List Γ) → (K → List Γ) → Prop
  | .onStack k o, S, T => ∃ t, o.Rel (S k) t ∧ T = Function.update S k t
  | .idle, S, T => T = S

variable (b : ℤ) (digit : Γ → ℤ) (hb : 2 ≤ b)
  (hd : ∀ a, 2 ≤ digit a ∧ digit a < b) (hi : Function.Injective digit)

def encodeStores (S : K → List Γ) : Stores K := fun k ↦ encode b digit (S k)

def actionEdge (p q : Q) (w : G) : Action K Γ → Edge G (Stores K) Q
  | .onStack k o => liftEdge k (localEdge b digit (by omega) p q w o)
  | .idle => ⟨Stores K,MonoidHom.id _,MonoidHom.id _,Function.injective_id,
      Function.injective_id,1,1,p,q,w⟩

lemma action_finitelyPresented [Finite K] (p q : Q) (w : G) (a : Action K Γ) :
    Group.IsFinitelyPresented (actionEdge b digit hb p q w a).Domain := by
  cases a with
  | onStack k o => exact liftEdge_finitelyPresented _ _
  | idle => exact finitelyPresented_pi _ _

include hd hi in
theorem action_sound (p q : Q) (w : G) (a : Action K Γ)
    (x : (actionEdge b digit hb p q w a).Domain) (S : K → List Γ)
    (h : (actionEdge b digit hb p q w a).inputLinear x *
      (actionEdge b digit hb p q w a).inputOffset = encodeStores b digit S) :
    ∃ T, (actionEdge b digit hb p q w a).outputLinear x *
      (actionEdge b digit hb p q w a).outputOffset = encodeStores b digit T ∧ a.Rel S T := by
  cases a with
  | onStack k o =>
    change (localEdge b digit (by omega) p q w o).Domain × Rest k at x
    have input_eq (j : K) :
        (if hj : j = k then (localEdge b digit (by omega) p q w o).inputLinear x.1
          else x.2 ⟨j,hj⟩) *
        (if j = k then (localEdge b digit (by omega) p q w o).inputOffset else 1) =
          encode b digit (S j) := congrFun h j
    have hk : (localEdge b digit (by omega) p q w o).inputLinear x.1 *
        (localEdge b digit (by omega) p q w o).inputOffset = encode b digit (S k) := by
      simpa using input_eq k
    obtain ⟨t,ht,hr⟩ := local_sound b digit hb hd hi p q w o x.1 (S k) hk
    refine ⟨Function.update S k t,?_,t,hr,rfl⟩
    funext j
    change (if hj : j = k then (localEdge b digit (by omega) p q w o).outputLinear x.1
        else x.2 ⟨j,hj⟩) *
      (if j = k then (localEdge b digit (by omega) p q w o).outputOffset else 1) =
        encode b digit (Function.update S k t j)
    by_cases hj : j = k
    · subst j
      simpa using ht
    · simpa [hj] using input_eq j
  | idle => exact ⟨S,h,rfl⟩

theorem action_complete (p q : Q) (w : G) (a : Action K Γ) (S T : K → List Γ) (h : a.Rel S T) :
    ∃ x : (actionEdge b digit hb p q w a).Domain,
      (actionEdge b digit hb p q w a).inputLinear x *
        (actionEdge b digit hb p q w a).inputOffset = encodeStores b digit S ∧
      (actionEdge b digit hb p q w a).outputLinear x *
        (actionEdge b digit hb p q w a).outputOffset = encodeStores b digit T := by
  cases a with
  | onStack k o =>
    obtain ⟨t,hr,rfl⟩ := h
    obtain ⟨x,hs,ht⟩ := local_complete b digit hb p q w o (S k) t hr
    refine ⟨(x,fun j ↦ encode b digit (S j.val)),?_,?_⟩
    · funext j
      change (if j = k then (localEdge b digit (by omega) p q w o).inputLinear x
          else encode b digit (S j)) *
        (if j = k then (localEdge b digit (by omega) p q w o).inputOffset else 1) =
          encode b digit (S j)
      by_cases hj : j = k
      · subst j
        simpa using hs
      · simp [hj]
    · funext j
      change (if j = k then (localEdge b digit (by omega) p q w o).outputLinear x
          else encode b digit (S j)) *
        (if j = k then (localEdge b digit (by omega) p q w o).outputOffset else 1) =
          encode b digit (Function.update S k t j)
      by_cases hj : j = k
      · subst j
        simpa using ht
      · simp [hj]
  | idle => exact ⟨encodeStores b digit S,mul_one _,by cases h; exact mul_one _⟩

end

open MarkerMachine
variable {K Γ G Q : Type} [DecidableEq K] [Group G]
  (b : ℤ) (digit : Γ → ℤ) (hb : 2 ≤ b)

@[simp] lemma actionEdge_inputState (p q : Q) (w : G) (a : Action K Γ) :
    (actionEdge b digit hb p q w a).inputState = p := by
  cases a with
  | onStack k o => cases o <;> rfl
  | idle => rfl

@[simp] lemma actionEdge_outputState (p q : Q) (w : G) (a : Action K Γ) :
    (actionEdge b digit hb p q w a).outputState = q := by
  cases a with
  | onStack k o => cases o <;> rfl
  | idle => rfl

@[simp] lemma actionEdge_weight (p q : Q) (w : G) (a : Action K Γ) :
    (actionEdge b digit hb p q w a).weight = w := by
  cases a with
  | onStack k o => cases o <;> rfl
  | idle => rfl

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

include hb hd hi in
omit [DecidableEq K] in
lemma encodeStores_injective : Function.Injective (encodeStores (K := K) b digit) := by
  intro S T h
  funext k
  exact encode_injective b digit hb hd hi (congrFun h k)

end Higman.AffineStack

namespace Higman.StackProgram

section
open AffineStack MarkerMachine
variable {K Γ G Q E : Type} [DecidableEq K] [Group G]

structure Instruction (K Γ G Q : Type) where
  source : Q
  target : Q
  action : Action K Γ
  weight : G

def Instruction.edge (b : ℤ) (digit : Γ → ℤ) (hb : 2 ≤ b) (i : Instruction K Γ G Q) :
    Edge G (Stores K) Q := actionEdge b digit hb i.source i.target i.weight i.action

inductive Run (prog : E → Instruction K Γ G Q) (seed : (K → List Γ) × Q) :
    List E → ((K → List Γ) × Q) → Prop
  | start : Run prog seed [] seed
  | step {s : List E} (e : E) (S T : K → List Γ) (h : (prog e).action.Rel S T) :
      Run prog seed s (S,(prog e).source) → Run prog seed (e::s) (T,(prog e).target)

variable (prog : E → Instruction K Γ G Q) (seed : (K → List Γ) × Q)
  (b : ℤ) (digit : Γ → ℤ) (hb : 2 ≤ b)
  (hd : ∀ a, 2 ≤ digit a ∧ digit a < b) (hi : Function.Injective digit)

include hd hi in

theorem run_sound {s : List E} {c : Stores K × Q}
    (h : HistoryMachine.Run (fun e ↦ ((prog e).edge b digit hb).input)
      (fun e ↦ ((prog e).edge b digit hb).output) (encodeStores b digit seed.1,seed.2) s c) :
    ∃ S, encodeStores b digit S = c.1 ∧ Run prog seed s (S,c.2) := by
  induction h with
  | start => exact ⟨seed.1,rfl,Run.start⟩
  | @step s e x h ih =>
    obtain ⟨S,hS,hR⟩ := ih
    obtain ⟨T,hT,hr⟩ := action_sound b digit hb hd hi (prog e).source (prog e).target
      (prog e).weight (prog e).action x S hS.symm
    refine ⟨T,hT.symm,?_⟩
    simp only [Edge.input,Instruction.edge,actionEdge_inputState] at hR
    simpa only [Edge.output,Instruction.edge,actionEdge_outputState] using Run.step e S T hr hR

theorem run_complete {s : List E} {c : (K → List Γ) × Q} (h : Run prog seed s c) :
    HistoryMachine.Run (fun e ↦ ((prog e).edge b digit hb).input)
      (fun e ↦ ((prog e).edge b digit hb).output) (encodeStores b digit seed.1,seed.2)
      s (encodeStores b digit c.1,c.2) := by
  induction h with
  | start => exact HistoryMachine.Run.start
  | @step s e S T hr h ih =>
    obtain ⟨x,hS,hT⟩ := action_complete b digit hb (prog e).source (prog e).target
      (prog e).weight (prog e).action S T hr
    have hin : ((prog e).edge b digit hb).input x = (encodeStores b digit S,(prog e).source) := by
      apply Prod.ext hS
      exact actionEdge_inputState _ _ _ _ _ _ _
    have hout : ((prog e).edge b digit hb).output x = (encodeStores b digit T,(prog e).target) := by
      apply Prod.ext hT
      exact actionEdge_outputState _ _ _ _ _ _ _
    rw [← hout]
    apply HistoryMachine.Run.step (input := fun e ↦ ((prog e).edge b digit hb).input)
      (output := fun e ↦ ((prog e).edge b digit hb).output) e x
    rwa [hin]

def outputs (halt : Q) : Set G :=
  {g | ∃ s S, Run prog seed s (S,halt) ∧ g = HistoryMachine.value (fun e ↦ (prog e).weight) s}

end

open AffineStack MarkerMachine
variable {K Γ G Q E : Type} [DecidableEq K] [Group G]
  [Finite K] [Fintype Γ] [Finite Q] [Fintype E] [Group.IsFinitelyPresented G]
  (prog : E → Instruction K Γ G Q) (seed : (K → List Γ) × Q) (halt : Q)

theorem benign_outputs : IsBenign (Subgroup.closure (outputs prog seed halt)) := by
  classical
  let b : ℤ := Fintype.card Γ + 2
  let digit : Γ → ℤ := fun a ↦ ((Fintype.equivFin Γ a).val : ℤ) + 2
  have hb : 2 ≤ b := by dsimp [b]; omega
  have hd : ∀ a, 2 ≤ digit a ∧ digit a < b := by
    intro a
    have hh := (Fintype.equivFin Γ a).isLt
    dsimp [digit,b]
    constructor <;> omega
  have hi : Function.Injective digit := by
    intro a c h
    apply (Fintype.equivFin Γ).injective
    apply Fin.ext
    dsimp [digit] at h
    omega
  have : Group.IsFinitelyPresented (Stores K) := finitelyPresented_pi _ _
  have hp := RecordedMachine.benign_accepted (fun e ↦ (prog e).edge b digit hb)
    (encodeStores b digit seed.1,seed.2) halt
    (fun e ↦ action_finitelyPresented b digit hb (prog e).source (prog e).target
      (prog e).weight (prog e).action)
  have he : RecordedMachine.acceptedOutputs (fun e ↦ (prog e).edge b digit hb)
      (encodeStores b digit seed.1,seed.2) halt = outputs prog seed halt := by
    ext g
    constructor
    · rintro ⟨s,c,hs,hc,hg⟩
      obtain ⟨S,_,hR⟩ := run_sound prog seed b digit hb hd hi hs
      refine ⟨s,S,?_,?_⟩
      · rwa [hc] at hR
      · simpa only [Instruction.edge,actionEdge_weight] using hg
    · rintro ⟨s,S,hs,hg⟩
      refine ⟨s,(encodeStores b digit S,halt),run_complete prog seed b digit hb hs,rfl,?_⟩
      simpa only [Instruction.edge,actionEdge_weight] using hg
  rwa [he] at hp

end Higman.StackProgram

end OAI