import Mathlib
import OAI.Computability.VertexCover.PCP.ConstraintGraph
import OAI.Computability.VertexCover.Encoding.Runtime
import OAI.Computability.VertexCover.Encoding.MachineComposition
import OAI.Computability.VertexCover.Reduction.GridBudget

namespace OAI

section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
                            
section

namespace VertexCover.Machine
open Turing
open Turing.TM2
attribute [local instance] FinTM2.kFin FinTM2.ΛFin FinTM2.σFin

namespace Compose

variable (A B : FinTM2)

abbrev K := A.K ⊕ (B.K ⊕ Unit)
abbrev Γ : K A B → Type
  | .inl k => A.Γ k
  | .inr (.inl k) => B.Γ k
  | .inr (.inr _) => Bool
abbrev Λ := A.Λ ⊕ (B.Λ ⊕ Bool)
abbrev State := A.σ × B.σ × Option Bool

instance : Fintype (State A B) := inferInstanceAs (Fintype (A.σ × B.σ × Option Bool))

abbrev Cfg := Turing.TM2.Cfg (Γ A B) (Λ A B) (State A B)
abbrev Stmt := Turing.TM2.Stmt (Γ A B) (Λ A B) (State A B)

abbrev first (k : A.K) : K A B := .inl k
abbrev second (k : B.K) : K A B := .inr (.inl k)
abbrev temporary : K A B := .inr (.inr ())
abbrev transfer (b : Bool) : Λ A B := .inr (.inr b)

def firstStatement : A.Stmt → Stmt A B
  | .push k f p => .push (first A B k) (fun s => f s.1) (firstStatement p)
  | .peek k f p => .peek (first A B k) (fun s x => (f s.1 x, s.2)) (firstStatement p)
  | .pop k f p => .pop (first A B k) (fun s x => (f s.1 x, s.2)) (firstStatement p)
  | .load f p => .load (fun s => (f s.1, s.2)) (firstStatement p)
  | .branch f p q => .branch (fun s => f s.1) (firstStatement p) (firstStatement q)
  | .goto f => .goto (fun s => .inl (f s.1))
  | .halt => .goto (fun _ => transfer A B false)

def secondStatement : B.Stmt → Stmt A B
  | .push k f p => .push (second A B k) (fun s => f s.2.1) (secondStatement p)
  | .peek k f p => .peek (second A B k)
      (fun s x => (s.1, f s.2.1 x, s.2.2)) (secondStatement p)
  | .pop k f p => .pop (second A B k)
      (fun s x => (s.1, f s.2.1 x, s.2.2)) (secondStatement p)
  | .load f p => .load (fun s => (s.1, f s.2.1, s.2.2)) (secondStatement p)
  | .branch f p q => .branch (fun s => f s.2.1) (secondStatement p) (secondStatement q)
  | .goto f => .goto (fun s => .inr (.inl (f s.2.1)))
  | .halt => .halt

variable (outA : A.Γ A.k₁ ≃ Bool) (inB : B.Γ B.k₀ ≃ Bool)

def program : Λ A B → Stmt A B
  | .inl l => firstStatement A B (A.m l)
  | .inr (.inl l) => secondStatement A B (B.m l)
  | .inr (.inr false) =>
      .pop (first A B A.k₁) (fun s x => (s.1, s.2.1, x.map outA))
        (.branch (fun s => s.2.2.isSome)
          (.push (temporary A B) (fun s => s.2.2.getD false)
            (.goto (fun _ => transfer A B false)))
          (.goto (fun _ => transfer A B true)))
  | .inr (.inr true) =>
      .pop (temporary A B) (fun s x => (s.1, s.2.1, x))
        (.branch (fun s => s.2.2.isSome)
          (.push (second A B B.k₀) (fun s => inB.symm (s.2.2.getD false))
            (.goto (fun _ => transfer A B true)))
          (.goto (fun _ => .inr (.inl B.main))))

abbrev machine : FinTM2 where
  K := K A B
  k₀ := first A B A.k₀
  k₁ := second A B B.k₁
  Γ := Γ A B
  Λ := Λ A B
  main := .inl A.main
  σ := State A B
  initialState := (A.initialState, B.initialState, none)
  m := program A B outA inB
  Γk₀Fin := A.Γk₀Fin

def tapes (ta : ∀ k, List (A.Γ k)) (tb : ∀ k, List (B.Γ k)) (temp : List Bool) :
    ∀ k, List (Γ A B k)
  | .inl k => ta k
  | .inr (.inl k) => tb k
  | .inr (.inr _) => temp

@[simp] theorem tapes_first (ta : ∀ k, List (A.Γ k)) (tb : ∀ k, List (B.Γ k))
    (t : List Bool) (k : A.K) : tapes A B ta tb t (first A B k) = ta k := rfl
@[simp] theorem tapes_second (ta : ∀ k, List (A.Γ k)) (tb : ∀ k, List (B.Γ k))
    (t : List Bool) (k : B.K) : tapes A B ta tb t (second A B k) = tb k := rfl
@[simp] theorem tapes_temporary (ta : ∀ k, List (A.Γ k)) (tb : ∀ k, List (B.Γ k))
    (t : List Bool) : tapes A B ta tb t (temporary A B) = t := rfl

theorem tapes_update_first (ta : ∀ k, List (A.Γ k)) (tb : ∀ k, List (B.Γ k))
    (t : List Bool) (k : A.K) (v : List (A.Γ k)) :
    tapes A B (Function.update ta k v) tb t =
      Function.update (tapes A B ta tb t) (first A B k) v := by
  funext j
  rcases j with j | (j | j)
  · by_cases h : j = k
    · subst j; simp [tapes, first]
    · simp [tapes, first, Function.update, h]
  · simp [tapes, first, Function.update]
  · simp [tapes, first, Function.update]

theorem tapes_update_second (ta : ∀ k, List (A.Γ k)) (tb : ∀ k, List (B.Γ k))
    (t : List Bool) (k : B.K) (v : List (B.Γ k)) :
    tapes A B ta (Function.update tb k v) t =
      Function.update (tapes A B ta tb t) (second A B k) v := by
  funext j
  rcases j with j | (j | j)
  · simp [tapes, second, Function.update]
  · by_cases h : j = k
    · subst j; simp [tapes, second]
    · simp [tapes, second, Function.update, h]
  · simp [tapes, second, Function.update]

theorem tapes_update_temporary (ta : ∀ k, List (A.Γ k)) (tb : ∀ k, List (B.Γ k))
    (t v : List Bool) :
    tapes A B ta tb v = Function.update (tapes A B ta tb t) (temporary A B) v := by
  funext j
  rcases j with j | (j | j)
  · simp [tapes, temporary, Function.update]
  · simp [tapes, temporary, Function.update]
  · cases j; simp [tapes, temporary]

def firstCfg (state : B.σ) (flag : Option Bool)
    (tb : ∀ k, List (B.Γ k)) (temp : List Bool) (c : A.Cfg) : Cfg A B where
  l := some (c.l.elim (transfer A B false) Sum.inl)
  var := (c.var, state, flag)
  stk := tapes A B c.stk tb temp

def secondCfg (state : A.σ) (flag : Option Bool)
    (ta : ∀ k, List (A.Γ k)) (temp : List Bool) (c : B.Cfg) : Cfg A B where
  l := c.l.map (fun l => .inr (.inl l))
  var := (state, c.var, flag)
  stk := tapes A B ta c.stk temp

theorem first_stepAux (b : B.σ) (flag : Option Bool)
    (tb : ∀ k, List (B.Γ k)) (temp : List Bool)
    (q : A.Stmt) (s : A.σ) (ta : ∀ k, List (A.Γ k)) :
    stepAux (firstStatement A B q) (s, b, flag) (tapes A B ta tb temp) =
      firstCfg A B b flag tb temp (stepAux q s ta) := by
  induction q generalizing s ta with
  | push k f p ih =>
    simp only [firstStatement, stepAux, tapes_first]
    rw [← tapes_update_first]
    exact ih s _
  | peek k f p ih =>
    simpa only [firstStatement, stepAux, tapes_first] using ih (f s (ta k).head?) ta
  | pop k f p ih =>
    simp only [firstStatement, stepAux, tapes_first]
    rw [← tapes_update_first]
    exact ih (f s (ta k).head?) _
  | load f p ih => simpa only [firstStatement, stepAux] using ih (f s) ta
  | branch f p q ihp ihq =>
    cases h : f s with
    | false => simpa only [firstStatement, stepAux, h, Bool.cond_false] using ihq s ta
    | true => simpa only [firstStatement, stepAux, h, Bool.cond_true] using ihp s ta
  | goto f => rfl
  | halt => rfl

theorem second_stepAux (a : A.σ) (flag : Option Bool)
    (ta : ∀ k, List (A.Γ k)) (temp : List Bool)
    (q : B.Stmt) (s : B.σ) (tb : ∀ k, List (B.Γ k)) :
    stepAux (secondStatement A B q) (a, s, flag) (tapes A B ta tb temp) =
      secondCfg A B a flag ta temp (stepAux q s tb) := by
  induction q generalizing s tb with
  | push k f p ih =>
    simp only [secondStatement, stepAux, tapes_second]
    rw [← tapes_update_second]
    exact ih s _
  | peek k f p ih =>
    simpa only [secondStatement, stepAux, tapes_second] using ih (f s (tb k).head?) tb
  | pop k f p ih =>
    simp only [secondStatement, stepAux, tapes_second]
    rw [← tapes_update_second]
    exact ih (f s (tb k).head?) _
  | load f p ih => simpa only [secondStatement, stepAux] using ih (f s) tb
  | branch f p q ihp ihq =>
    cases h : f s with
    | false => simpa only [secondStatement, stepAux, h, Bool.cond_false] using ihq s tb
    | true => simpa only [secondStatement, stepAux, h, Bool.cond_true] using ihp s tb
  | goto f => rfl
  | halt => rfl

theorem first_step (b : B.σ) (flag : Option Bool)
    (tb : ∀ k, List (B.Γ k)) (temp : List Bool) (c c' : A.Cfg)
    (h : A.step c = some c') :
    (machine A B outA inB).step (firstCfg A B b flag tb temp c) =
      some (firstCfg A B b flag tb temp c') := by
  rcases c with ⟨l,s,ta⟩
  cases l with
  | none => simp [FinTM2.step, step] at h
  | some l =>
    have hc : stepAux (A.m l) s ta = c' := Option.some.inj h
    rw [← hc]
    change some (stepAux (firstStatement A B (A.m l)) (s,b,flag) (tapes A B ta tb temp)) = _
    exact congrArg some (first_stepAux A B b flag tb temp (A.m l) s ta)

theorem second_step (a : A.σ) (flag : Option Bool)
    (ta : ∀ k, List (A.Γ k)) (temp : List Bool) (c c' : B.Cfg)
    (h : B.step c = some c') :
    (machine A B outA inB).step (secondCfg A B a flag ta temp c) =
      some (secondCfg A B a flag ta temp c') := by
  rcases c with ⟨l,s,tb⟩
  cases l with
  | none => simp [FinTM2.step, step] at h
  | some l =>
    have hc : stepAux (B.m l) s tb = c' := Option.some.inj h
    rw [← hc]
    change some (stepAux (secondStatement A B (B.m l)) (a,s,flag) (tapes A B ta tb temp)) = _
    exact congrArg some (second_stepAux A B a flag ta temp (B.m l) s tb)

def tapeOnly {K : Type} {Γ : K → Type} [DecidableEq K] (k : K) (s : List (Γ k)) :
    ∀ j, List (Γ j) := Function.update (fun _ => []) k s

@[simp] theorem tapeOnly_self {K : Type} {Γ : K → Type} [DecidableEq K]
    (k : K) (s : List (Γ k)) : tapeOnly k s k = s := Function.update_self _ _ _

@[simp] theorem tapeOnly_nil {K : Type} {Γ : K → Type} [DecidableEq K]
    (k : K) : tapeOnly (Γ := Γ) k [] = fun _ => [] := Function.update_eq_self _ _

@[simp] theorem tapeOnly_update {K : Type} {Γ : K → Type} [DecidableEq K]
    (k : K) (s t : List (Γ k)) : Function.update (tapeOnly k s) k t = tapeOnly k t :=
  Function.update_idem _ _ _

def bridgeOne (s : List (A.Γ A.k₁)) (temp : List Bool) (flag : Option Bool) : Cfg A B where
  l := some (transfer A B false)
  var := (A.initialState, B.initialState, flag)
  stk := tapes A B (tapeOnly A.k₁ s) (fun _ => []) temp

def bridgeTwo (temp : List Bool) (s : List (B.Γ B.k₀)) (flag : Option Bool) : Cfg A B where
  l := some (transfer A B true)
  var := (A.initialState, B.initialState, flag)
  stk := tapes A B (fun _ => []) (tapeOnly B.k₀ s) temp

theorem bridgeOne_cons (x : A.Γ A.k₁) (xs : List (A.Γ A.k₁)) (temp : List Bool)
    (flag : Option Bool) :
    (machine A B outA inB).step (bridgeOne A B (x::xs) temp flag) =
      some (bridgeOne A B xs (outA x::temp) (some (outA x))) := by
  change step (program A B outA inB) _ = _
  simp only [bridgeOne, step, program, stepAux, tapes_first,
    tapeOnly_self, List.head?_cons, List.tail_cons, Option.map_some, Option.isSome_some,
    Bool.cond_true, Option.getD_some]
  rw [← tapes_update_first, tapeOnly_update]
  simp only [tapes_temporary]
  rw [← tapes_update_temporary]

theorem bridgeOne_nil (temp : List Bool) (flag : Option Bool) :
    (machine A B outA inB).step (bridgeOne A B [] temp flag) =
      some (bridgeTwo A B temp [] none) := by
  change step (program A B outA inB) _ = _
  simp only [bridgeOne, step, program, stepAux, tapes_first,
    tapeOnly_self, List.head?_nil, List.tail_nil, Option.map_none, Option.isSome_none,
    Bool.cond_false]
  rw [← tapes_update_first, tapeOnly_update]
  simp only [tapeOnly_nil, bridgeTwo]

theorem bridgeTwo_cons (x : Bool) (xs : List Bool) (s : List (B.Γ B.k₀))
    (flag : Option Bool) :
    (machine A B outA inB).step (bridgeTwo A B (x::xs) s flag) =
      some (bridgeTwo A B xs (inB.symm x::s) (some x)) := by
  change step (program A B outA inB) _ = _
  simp only [bridgeTwo, step, program, stepAux, tapes_temporary,
    List.head?_cons, List.tail_cons, Option.isSome_some, Bool.cond_true, Option.getD_some]
  rw [← tapes_update_temporary]
  simp only [tapes_second, tapeOnly_self]
  rw [← tapes_update_second, tapeOnly_update]

theorem init_tapes (M : FinTM2) (s : List (M.Γ M.k₀)) :
    (initList M s).stk = tapeOnly M.k₀ s := by
  funext k
  by_cases h : k = M.k₀
  · subst k; simp [initList, tapeOnly]
  · simp [initList, tapeOnly, Function.update, h]

theorem halt_tapes (M : FinTM2) (s : List (M.Γ M.k₁)) :
    (haltList M s).stk = tapeOnly M.k₁ s := by
  funext k
  by_cases h : k = M.k₁
  · subst k; simp [haltList, tapeOnly]
  · simp [haltList, tapeOnly, Function.update, h]

theorem bridgeTwo_nil (s : List (B.Γ B.k₀)) (flag : Option Bool) :
    (machine A B outA inB).step (bridgeTwo A B [] s flag) =
      some (secondCfg A B A.initialState none (fun _ => []) [] (Turing.initList B s)) := by
  change step (program A B outA inB) _ = _
  simp only [bridgeTwo, step, program, stepAux, tapes_temporary,
    List.head?_nil, List.tail_nil, Option.isSome_none, Bool.cond_false]
  rw [← tapes_update_temporary]
  simp only [secondCfg, init_tapes]
  rfl

private def oneStep {S : Type} (step : S → Option S) (a b : S) (h : step a = some b) :
    StateTransition.EvalsToInTime step a (some b) 1 where
  steps := 1
  evals_in_steps := h
  steps_le_m := le_rfl

def bridgeOne_run (s : List (A.Γ A.k₁)) (temp : List Bool) (flag : Option Bool) :
    @StateTransition.EvalsToInTime (Cfg A B) (machine A B outA inB).step
      (bridgeOne A B s temp flag)
      (some (bridgeTwo A B ((s.map outA).reverse ++ temp) [] none)) (s.length + 1) := by
  induction s generalizing temp flag with
  | nil =>
    exact oneStep _ _ _ (bridgeOne_nil A B outA inB temp flag)
  | cons x xs ih =>
    have e₁ := oneStep _ _ _ (bridgeOne_cons A B outA inB x xs temp flag)
    have e₂ := ih (outA x :: temp) (some (outA x))
    have both := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁ e₂
    simpa only [List.map_cons, List.reverse_cons, List.append_assoc,
      List.singleton_append, List.length_cons] using both

def bridgeTwo_run (temp : List Bool) (s : List (B.Γ B.k₀)) (flag : Option Bool) :
    @StateTransition.EvalsToInTime (Cfg A B) (machine A B outA inB).step
      (bridgeTwo A B temp s flag)
      (some (secondCfg A B A.initialState none (fun _ => []) []
        (Turing.initList B ((temp.map inB.symm).reverse ++ s)))) (temp.length + 1) := by
  induction temp generalizing s flag with
  | nil => exact oneStep _ _ _ (bridgeTwo_nil A B outA inB s flag)
  | cons x xs ih =>
    have e₁ := oneStep _ _ _ (bridgeTwo_cons A B outA inB x xs s flag)
    have e₂ := ih (inB.symm x :: s) (some x)
    have both := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁ e₂
    simpa only [List.map_cons, List.reverse_cons, List.append_assoc,
      List.singleton_append, List.length_cons] using both

theorem cfg_ext {c c' : Cfg A B} (hl : c.l = c'.l)
    (hs : c.var = c'.var) (ht : c.stk = c'.stk) : c = c' := by
  rcases c with ⟨l,s,t⟩
  rcases c' with ⟨l',s',t'⟩
  cases hl; cases hs; cases ht
  rfl

theorem first_initial (s : List (A.Γ A.k₀)) :
    firstCfg A B B.initialState none (fun _ => []) [] (Turing.initList A s) =
      Turing.initList (machine A B outA inB) s := by
  apply cfg_ext A B
  · rfl
  · rfl
  · rw [init_tapes]
    change tapes A B (initList A s).stk (fun _ => []) [] = _
    rw [init_tapes]
    funext k
    rcases k with k | (k | k)
    · by_cases h : k = A.k₀
      · subst k; simp [machine, tapes, tapeOnly, first]
      · simp [machine, tapes, tapeOnly, first, Function.update, h]
    · simp [machine, tapes, tapeOnly, first, Function.update]
    · simp [machine, tapes, tapeOnly, first, Function.update]

theorem first_halted (s : List (A.Γ A.k₁)) :
    firstCfg A B B.initialState none (fun _ => []) [] (Turing.haltList A s) =
      bridgeOne A B s [] none := by
  simp only [firstCfg, halt_tapes, bridgeOne]
  rfl

theorem second_halted (s : List (B.Γ B.k₁)) :
    secondCfg A B A.initialState none (fun _ => []) [] (Turing.haltList B s) =
      Turing.haltList (machine A B outA inB) s := by
  apply cfg_ext A B
  · rfl
  · rfl
  · rw [halt_tapes]
    change tapes A B (fun _ => []) (haltList B s).stk [] = _
    rw [halt_tapes]
    funext k
    rcases k with k | (k | k)
    · simp [machine, tapes, tapeOnly, second, Function.update]
    · by_cases h : k = B.k₁
      · subst k; simp [machine, tapes, tapeOnly, second]
      · simp [machine, tapes, tapeOnly, second, Function.update, h]
    · simp [machine, tapes, tapeOnly, second, Function.update]

open UniqueGames.Foundations.Complexity.MachineComposition

def outputs (input : List (A.Γ A.k₀)) (middle : List Bool) (output : List (B.Γ B.k₁))
    (n₁ n₂ : ℕ)
    (h₁ : Turing.TM2OutputsInTime A input (some (middle.map outA.symm)) n₁)
    (h₂ : Turing.TM2OutputsInTime B (middle.map inB.symm) (some output) n₂) :
    Turing.TM2OutputsInTime (machine A B outA inB) input (some output)
      (n₁ + 2 * (middle.length + 1) + n₂) := by
  have e₁ := liftExecutionInTime A.step (machine A B outA inB).step
    (firstCfg A B B.initialState none (fun _ => []) [])
    (first_step A B outA inB B.initialState none (fun _ => []) []) h₁
  rw [first_initial, first_halted] at e₁
  have e₂ : @StateTransition.EvalsToInTime (Cfg A B) (machine A B outA inB).step
      (bridgeOne A B (middle.map outA.symm) [] none)
      (some (bridgeTwo A B middle.reverse [] none)) (middle.length+1) := by
    simpa only [List.map_map, Equiv.apply_symm_apply, Function.comp_def,
      List.map_id_fun, List.map_id, List.map_id', List.append_nil, List.length_map] using
      bridgeOne_run A B outA inB (middle.map outA.symm) [] none
  have e₃ : @StateTransition.EvalsToInTime (Cfg A B) (machine A B outA inB).step
      (bridgeTwo A B middle.reverse [] none)
      (some (secondCfg A B A.initialState none (fun _ => []) []
        (initList B (middle.map inB.symm)))) (middle.length+1) := by
    simpa only [List.map_reverse, List.reverse_reverse, List.append_nil, List.length_reverse] using
      bridgeTwo_run A B outA inB middle.reverse [] none
  have e₄ := liftExecutionInTime B.step (machine A B outA inB).step
    (secondCfg A B A.initialState none (fun _ => []) [])
    (second_step A B outA inB A.initialState none (fun _ => []) []) h₂
  rw [second_halted] at e₄
  have e₁₂ := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁ e₂
  have e₁₂₃ := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁₂ e₃
  have all := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁₂₃ e₄
  exact { all with steps_le_m := by have hh := all.steps_le_m; omega }

theorem finiteAlphabet (hA : ∀ k, Finite (A.Γ k)) (hB : ∀ k, Finite (B.Γ k)) :
    ∀ k, Finite ((machine A B outA inB).Γ k) := by
  rintro (k | (k | k))
  · exact hA k
  · exact hB k
  · exact inferInstanceAs (Finite Bool)

end Compose

open UniqueGames.Foundations.Complexity

noncomputable def compose {α β γ : Type}
    {eα : α → List Bool} {eβ : β → List Bool} {eγ : γ → List Bool}
    {f : α → β} {g : β → γ}
    (c₁ : Turing.TM2ComputableInPolyTime eα eβ f)
    (c₂ : Turing.TM2ComputableInPolyTime eβ eγ g) :
    Turing.TM2ComputableInPolyTime eα eγ (g ∘ f) where
  tm := Compose.machine c₁.tm c₂.tm c₁.outputAlphabet c₂.inputAlphabet
  inputAlphabet := c₁.inputAlphabet
  outputAlphabet := c₂.outputAlphabet
  time := MachineComposition.compositionPolynomial c₁.time c₂.time
    (Polynomial.X + Polynomial.C (Runtime.programPushBound c₁.tm)*c₁.time)
  outputsFun a := by
    have run := Compose.outputs c₁.tm c₂.tm c₁.outputAlphabet c₂.inputAlphabet
      ((eα a).map c₁.inputAlphabet.symm) (eβ (f a)) ((eγ (g (f a))).map c₂.outputAlphabet.symm)
      (c₁.time.eval (eα a).length) (c₂.time.eval (eβ (f a)).length)
      (c₁.outputsFun a) (c₂.outputsFun (f a))
    refine { run with steps_le_m := ?_ }
    exact run.steps_le_m.trans
      (MachineComposition.compositionBudget_le _ _ _ _ _ (Runtime.encodedOutputLength c₁ a))

theorem compose_finite {α β γ : Type}
    {eα : α → List Bool} {eβ : β → List Bool} {eγ : γ → List Bool}
    {f : α → β} {g : β → γ}
    (c₁ : Turing.TM2ComputableInPolyTime eα eβ f)
    (c₂ : Turing.TM2ComputableInPolyTime eβ eγ g)
    (h₁ : ∀ k, Finite (c₁.tm.Γ k)) (h₂ : ∀ k, Finite (c₂.tm.Γ k)) :
    ∀ k, Finite ((compose c₁ c₂).tm.Γ k) :=
  Compose.finiteAlphabet c₁.tm c₂.tm c₁.outputAlphabet c₂.inputAlphabet h₁ h₂

end VertexCover.Machine
end


end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end

end OAI