lean/OAI/Computability/VertexCover/Machines/Loop.lean

import Mathlib
import OAI.Computability.VertexCover.Machines.Pair

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 Turing.TM2
open UniqueGames.Foundations.Complexity
attribute [local instance] FinTM2.kFin FinTM2.ΛFin FinTM2.σFin

namespace Loop
variable (A : FinTM2)
abbrev K := A.K ⊕ Bool
abbrev Γ := MachineEmbedding.Alphabet A.Γ (fun _ : Bool => Bool)
abbrev Λ := A.Λ ⊕ Fin 3
abbrev State := A.σ × Bool × Option Bool
abbrev Cfg := Turing.TM2.Cfg (Γ A) (Λ A) (State A)
abbrev Stmt := Turing.TM2.Stmt (Γ A) (Λ A) (State A)
abbrev temporary : K A := .inr false
abbrev output : K A := .inr true
abbrev phase (i : Fin 3) : Λ A := .inr i
abbrev haltTarget : Option (Λ A) := some (phase A 0)
abbrev tapes := @MachineEmbedding.tapes A.K Bool A.Γ (fun _ => Bool)

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

def extra : Fin 3 → Stmt A
  | i => if i = 0 then
      .pop (.inl A.k₁) (fun s x => (s.1, (x.map outA).getD false, none))
        (.goto (fun _ => phase A 1))
    else if i = 1 then
      .pop (.inl A.k₁) (fun s x => (s.1, s.2.1, x.map outA))
        (.branch (fun s => s.2.2.isSome)
          (.push (temporary A) (fun s => s.2.2.getD false)
            (.goto (fun _ => phase A 1)))
          (.goto (fun _ => phase A 2)))
    else
      .pop (temporary A) (fun s x => (s.1, s.2.1, x))
        (.branch (fun s => s.2.2.isSome)
          (.branch (fun s => s.2.1)
            (.push (.inl A.k₀) (fun s => inA.symm (s.2.2.getD false))
              (.goto (fun _ => phase A 2)))
            (.push (output A) (fun s => s.2.2.getD false)
              (.goto (fun _ => phase A 2))))
          (.branch (fun s => s.2.1)
            (.load (fun _ => (A.initialState,false,none)) (.goto (fun _ => .inl A.main)))
            (.load (fun _ => (A.initialState,false,none)) .halt)))

abbrev program := MachineEmbedding.program (haltTarget A) A.m (extra A inA outA)

abbrev machine : FinTM2 where
  K := K A
  Γ := Γ A
  k₀ := .inl A.k₀
  k₁ := output A
  Λ := Λ A
  σ := State A
  main := .inl A.main
  initialState := (A.initialState,false,none)
  m := program A inA outA
  Γk₀Fin := A.Γk₀Fin

open Compose (tapeOnly tapeOnly_nil tapeOnly_self tapeOnly_update init_tapes halt_tapes)

def extraTapes (temp out : List Bool) : Bool → List Bool
  | false => temp
  | true => out

@[simp] theorem extraTapes_false (temp out : List Bool) : extraTapes temp out false = temp := rfl
@[simp] theorem extraTapes_true (temp out : List Bool) : extraTapes temp out true = out := rfl

theorem tapes_update_extra (ta : ∀ k, List (A.Γ k)) (tb : Bool → List Bool)
    (j : Bool) (s : List Bool) :
    tapes A ta (Function.update tb j s) = Function.update (tapes A ta tb) (.inr j) s := by
  funext k
  rcases k with k | k
  · simp [tapes, MachineEmbedding.tapes, Function.update]
  · by_cases h : k = j
    · subst k; simp [tapes, MachineEmbedding.tapes]
    · simp [tapes, MachineEmbedding.tapes, Function.update, h]

theorem update_extra_false (a b c : List Bool) :
    Function.update (extraTapes a b) false c = extraTapes c b := by
  funext k; cases k <;> simp [extraTapes]

theorem update_extra_true (a b c : List Bool) :
    Function.update (extraTapes a b) true c = extraTapes a c := by
  funext k; cases k <;> simp [extraTapes]

abbrev embedded (c : A.Cfg) : Cfg A :=
  MachineEmbedding.configuration (haltTarget A) (false,none) (extraTapes [] []) c

def cfg1 (mode : Bool) (s : List (A.Γ A.k₁)) (temp : List Bool)
    (flag : Option Bool) : Cfg A where
  l := some (phase A 1)
  var := (A.initialState,mode,flag)
  stk := tapes A (tapeOnly A.k₁ s) (extraTapes temp [])

def cfg2true (s : List (A.Γ A.k₀)) (temp : List Bool) (flag : Option Bool) : Cfg A where
  l := some (phase A 2)
  var := (A.initialState,true,flag)
  stk := tapes A (tapeOnly A.k₀ s) (extraTapes temp [])

def cfg2false (s temp : List Bool) (flag : Option Bool) : Cfg A where
  l := some (phase A 2)
  var := (A.initialState,false,flag)
  stk := tapes A (fun _ => []) (extraTapes temp s)

theorem cfg_ext {c c' : Cfg A} (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 halt_label (s : List (A.Γ A.k₁)) : (haltList A s).l = none := rfl

theorem halt_var (s : List (A.Γ A.k₁)) : (haltList A s).var = A.initialState := rfl

theorem cfg0_step (mode : Bool) (s : List Bool) :
    (machine A inA outA).step (embedded A (haltList A ((mode::s).map outA.symm))) =
      some (cfg1 A mode (s.map outA.symm) [] none) := by
  change step (program A inA outA) _ = _
  simp only [embedded, MachineEmbedding.configuration, halt_tapes, halt_label, halt_var,
    MachineEmbedding.label, haltTarget, phase, step, program, MachineEmbedding.program,
    extra, ↓reduceIte, stepAux, MachineEmbedding.tapes_inl, List.map_cons, tapeOnly_self,
    List.head?_cons, List.tail_cons, Option.map_some, Equiv.apply_symm_apply, Option.getD_some]
  rw [← MachineEmbedding.tapes_update, tapeOnly_update]
  rfl

theorem cfg1_cons (mode : Bool) (x : A.Γ A.k₁) (xs : List (A.Γ A.k₁))
    (temp : List Bool) (flag : Option Bool) :
    (machine A inA outA).step (cfg1 A mode (x::xs) temp flag) =
      some (cfg1 A mode xs (outA x::temp) (some (outA x))) := by
  change step (program A inA outA) _ = _
  simp only [cfg1, step, program, MachineEmbedding.program, phase, extra, Fin.reduceEq,
    ↓reduceIte, stepAux, MachineEmbedding.tapes_inl, tapeOnly_self,
    List.head?_cons, List.tail_cons, Option.map_some, Option.isSome_some,
    Bool.cond_true, Option.getD_some]
  rw [← MachineEmbedding.tapes_update, tapeOnly_update]
  simp only [temporary, MachineEmbedding.tapes_inr, extraTapes_false]
  rw [← tapes_update_extra, update_extra_false]

theorem cfg1_nil_true (temp : List Bool) (flag : Option Bool) :
    (machine A inA outA).step (cfg1 A true [] temp flag) =
      some (cfg2true A [] temp none) := by
  change step (program A inA outA) _ = _
  simp only [cfg1, step, program, MachineEmbedding.program, phase, extra, Fin.reduceEq,
    ↓reduceIte, stepAux, MachineEmbedding.tapes_inl, tapeOnly_self,
    List.head?_nil, List.tail_nil, Option.map_none, Option.isSome_none, Bool.cond_false]
  rw [← MachineEmbedding.tapes_update, tapeOnly_update]
  simp only [tapeOnly_nil, cfg2true]

theorem cfg1_nil_false (temp : List Bool) (flag : Option Bool) :
    (machine A inA outA).step (cfg1 A false [] temp flag) =
      some (cfg2false A [] temp none) := by
  change step (program A inA outA) _ = _
  simp only [cfg1, step, program, MachineEmbedding.program, phase, extra, Fin.reduceEq,
    ↓reduceIte, stepAux, MachineEmbedding.tapes_inl, tapeOnly_self,
    List.head?_nil, List.tail_nil, Option.map_none, Option.isSome_none, Bool.cond_false]
  rw [← MachineEmbedding.tapes_update, tapeOnly_update]
  simp only [tapeOnly_nil, cfg2false]

theorem cfg2true_cons (x : Bool) (xs : List Bool) (s : List (A.Γ A.k₀)) (flag : Option Bool) :
    (machine A inA outA).step (cfg2true A s (x::xs) flag) =
      some (cfg2true A (inA.symm x::s) xs (some x)) := by
  change step (program A inA outA) _ = _
  simp only [cfg2true, step, program, MachineEmbedding.program, phase, extra, Fin.reduceEq,
    ↓reduceIte, stepAux, temporary, MachineEmbedding.tapes_inr, extraTapes_false,
    List.head?_cons, List.tail_cons, Option.isSome_some, Bool.cond_true, Option.getD_some]
  rw [← tapes_update_extra, update_extra_false]
  simp only [MachineEmbedding.tapes_inl, tapeOnly_self]
  rw [← MachineEmbedding.tapes_update, tapeOnly_update]

theorem cfg2false_cons (x : Bool) (xs s : List Bool) (flag : Option Bool) :
    (machine A inA outA).step (cfg2false A s (x::xs) flag) =
      some (cfg2false A (x::s) xs (some x)) := by
  change step (program A inA outA) _ = _
  simp only [cfg2false, step, program, MachineEmbedding.program, phase, extra, Fin.reduceEq,
    ↓reduceIte, stepAux, temporary, MachineEmbedding.tapes_inr, extraTapes_false,
    List.head?_cons, List.tail_cons, Option.isSome_some, Bool.cond_true, Bool.cond_false,
    Option.getD_some]
  rw [← tapes_update_extra, update_extra_false]
  simp only [output, MachineEmbedding.tapes_inr, extraTapes_true]
  rw [← tapes_update_extra, update_extra_true]

theorem initial_eq (s : List (A.Γ A.k₀)) :
    embedded A (initList A s) = initList (machine A inA outA) s := by
  apply cfg_ext A
  · rfl
  · rfl
  · rw [init_tapes]
    change tapes A (initList A s).stk (extraTapes [] []) = _
    rw [init_tapes]
    funext k
    rcases k with k | k
    · by_cases h : k = A.k₀
      · subst k; simp [tapes, MachineEmbedding.tapes, tapeOnly]
      · simp [tapes, MachineEmbedding.tapes, tapeOnly, Function.update, h]
    · cases k <;> simp [tapes, MachineEmbedding.tapes, tapeOnly, Function.update, extraTapes]

theorem cfg2true_nil (s : List (A.Γ A.k₀)) (flag : Option Bool) :
    (machine A inA outA).step (cfg2true A s [] flag) =
      some (initList (machine A inA outA) s) := by
  rw [← initial_eq]
  change step (program A inA outA) _ = _
  simp only [cfg2true, step, program, MachineEmbedding.program, phase, extra, Fin.reduceEq,
    ↓reduceIte, stepAux, temporary, MachineEmbedding.tapes_inr, extraTapes_false,
    List.head?_nil, List.tail_nil, Option.isSome_none, Bool.cond_true, Bool.cond_false]
  rw [← tapes_update_extra, update_extra_false]
  simp only [embedded, MachineEmbedding.configuration, init_tapes]
  rfl

theorem cfg2false_nil (s : List Bool) (flag : Option Bool) :
    (machine A inA outA).step (cfg2false A s [] flag) =
      some (haltList (machine A inA outA) s) := by
  change step (program A inA outA) _ = _
  simp only [cfg2false, step, program, MachineEmbedding.program, phase, extra, Fin.reduceEq,
    ↓reduceIte, stepAux, temporary, MachineEmbedding.tapes_inr, extraTapes_false,
    List.head?_nil, List.tail_nil, Option.isSome_none, Bool.cond_false]
  rw [← tapes_update_extra, update_extra_false]
  congr 1
  apply cfg_ext A
  · rfl
  · rfl
  · rw [halt_tapes]
    funext k
    rcases k with k | k
    · simp [tapes, MachineEmbedding.tapes, tapeOnly, output, Function.update]
    · cases k <;> simp [tapes, MachineEmbedding.tapes, tapeOnly, output, Function.update, extraTapes]
def cfg1_run_true (s : List (A.Γ A.k₁)) (temp : List Bool) (flag : Option Bool) :
    @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (cfg1 A true s temp flag)
      (some (cfg2true A [] ((s.map outA).reverse ++ temp) none)) (s.length+1) := by
  induction s generalizing temp flag with
  | nil => exact Pair.oneStep _ _ _ (cfg1_nil_true A inA outA temp flag)
  | cons x xs ih =>
    have e₁ := Pair.oneStep _ _ _ (cfg1_cons A inA outA true x xs temp flag)
    have e₂ := ih (outA x::temp) (some (outA x))
    simpa only [List.map_cons, List.reverse_cons, List.append_assoc,
      List.singleton_append, List.length_cons] using
      StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁ e₂

def cfg1_run_false (s : List (A.Γ A.k₁)) (temp : List Bool) (flag : Option Bool) :
    @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (cfg1 A false s temp flag)
      (some (cfg2false A [] ((s.map outA).reverse ++ temp) none)) (s.length+1) := by
  induction s generalizing temp flag with
  | nil => exact Pair.oneStep _ _ _ (cfg1_nil_false A inA outA temp flag)
  | cons x xs ih =>
    have e₁ := Pair.oneStep _ _ _ (cfg1_cons A inA outA false x xs temp flag)
    have e₂ := ih (outA x::temp) (some (outA x))
    simpa only [List.map_cons, List.reverse_cons, List.append_assoc,
      List.singleton_append, List.length_cons] using
      StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁ e₂

def cfg2true_run (temp : List Bool) (s : List (A.Γ A.k₀)) (flag : Option Bool) :
    @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (cfg2true A s temp flag)
      (some (initList (machine A inA outA) ((temp.map inA.symm).reverse ++ s)))
      (temp.length+1) := by
  induction temp generalizing s flag with
  | nil => exact Pair.oneStep _ _ _ (cfg2true_nil A inA outA s flag)
  | cons x xs ih =>
    have e₁ := Pair.oneStep _ _ _ (cfg2true_cons A inA outA x xs s flag)
    have e₂ := ih (inA.symm x::s) (some x)
    simpa only [List.map_cons, List.reverse_cons, List.append_assoc,
      List.singleton_append, List.length_cons] using
      StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁ e₂

def cfg2false_run (temp s : List Bool) (flag : Option Bool) :
    @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (cfg2false A s temp flag)
      (some (haltList (machine A inA outA) (temp.reverse ++ s))) (temp.length+1) := by
  induction temp generalizing s flag with
  | nil => exact Pair.oneStep _ _ _ (cfg2false_nil A inA outA s flag)
  | cons x xs ih =>
    have e₁ := Pair.oneStep _ _ _ (cfg2false_cons A inA outA x xs s flag)
    have e₂ := ih (x::s) (some x)
    simpa only [List.reverse_cons, List.append_assoc, List.singleton_append, List.length_cons] using
      StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₁ e₂

open MachineComposition (embeddedExecution)

def bodyRun (mode : Bool) (input next : List Bool) (n : ℕ)
    (h : TM2OutputsInTime A (input.map inA.symm) (some ((mode::next).map outA.symm)) n) :
    @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (initList (machine A inA outA) (input.map inA.symm))
      (some (cfg1 A mode (next.map outA.symm) [] none)) (n+1) := by
  have e := embeddedExecution (haltTarget A) (false,none) (extraTapes [] []) A.m
    (extra A inA outA) h
  change @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
    (embedded A (initList A (input.map inA.symm)))
    (some (embedded A (haltList A ((mode::next).map outA.symm)))) n at e
  rw [initial_eq] at e
  have all := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e
    (Pair.oneStep _ _ _ (cfg0_step A inA outA mode next))
  exact { all with steps_le_m := by have hh := all.steps_le_m; omega }

def restart (input next : List Bool) (n : ℕ)
    (h : TM2OutputsInTime A (input.map inA.symm) (some ((true::next).map outA.symm)) n) :
    @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (initList (machine A inA outA) (input.map inA.symm))
      (some (initList (machine A inA outA) (next.map inA.symm)))
      (n+1+2*(next.length+1)) := by
  have e₀ := bodyRun A inA outA true input next n h
  have e₁ : @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (cfg1 A true (next.map outA.symm) [] none)
      (some (cfg2true A [] next.reverse none)) (next.length+1) := by
    simpa only [List.map_map, Function.comp_def, Equiv.apply_symm_apply, List.map_id',
      List.append_nil, List.length_map] using
      cfg1_run_true A inA outA (next.map outA.symm) [] none
  have e₂ : @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (cfg2true A [] next.reverse none)
      (some (initList (machine A inA outA) (next.map inA.symm))) (next.length+1) := by
    simpa only [List.map_reverse, List.reverse_reverse, List.append_nil, List.length_reverse] using
      cfg2true_run A inA outA next.reverse [] none
  have all := StateTransition.EvalsToInTime.trans _ _ _ _ _ _
    (StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₀ e₁) e₂
  exact { all with steps_le_m := by have hh := all.steps_le_m; omega }

def finish (input next : List Bool) (n : ℕ)
    (h : TM2OutputsInTime A (input.map inA.symm) (some ((false::next).map outA.symm)) n) :
    TM2OutputsInTime (machine A inA outA) (input.map inA.symm) (some next)
      (n+1+2*(next.length+1)) := by
  have e₀ := bodyRun A inA outA false input next n h
  have e₁ : @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (cfg1 A false (next.map outA.symm) [] none)
      (some (cfg2false A [] next.reverse none)) (next.length+1) := by
    simpa only [List.map_map, Function.comp_def, Equiv.apply_symm_apply, List.map_id',
      List.append_nil, List.length_map] using
      cfg1_run_false A inA outA (next.map outA.symm) [] none
  have e₂ : @StateTransition.EvalsToInTime (Cfg A) (machine A inA outA).step
      (cfg2false A [] next.reverse none)
      (some (haltList (machine A inA outA) next)) (next.length+1) := by
    simpa only [List.reverse_reverse, List.append_nil, List.length_reverse] using
      cfg2false_run A inA outA next.reverse [] none
  have all := StateTransition.EvalsToInTime.trans _ _ _ _ _ _
    (StateTransition.EvalsToInTime.trans _ _ _ _ _ _ e₀ e₁) e₂
  exact { all with steps_le_m := by have hh := all.steps_le_m; omega }

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

end Loop

inductive BoundedRun {α : Type} (e : α → List Bool) (body : α → Bool × α) (bound : ℕ) :
    α → α → ℕ → Prop
  | stop (a : α) (size : (e a).length ≤ bound) (done : (body a).1 = false) :
      BoundedRun e body bound a (body a).2 1
  | next (a z : α) (n : ℕ) (size : (e a).length ≤ bound) (more : (body a).1 = true)
      (tail : BoundedRun e body bound (body a).2 z n) :
      BoundedRun e body bound a z (n+1)

noncomputable def loopCost {α : Type} {e : α → List Bool} {body : α → Bool × α}
    (c : TM2ComputableInPolyTime e (fun p : Bool × α => p.1 :: e p.2) body) : Polynomial ℕ :=
  c.time + 1 + Polynomial.C 2 *
    (Polynomial.X + Polynomial.C (Runtime.programPushBound c.tm) * c.time + 1)

theorem loopCost_bound {α : Type} {e : α → List Bool} {body : α → Bool × α}
    (c : TM2ComputableInPolyTime e (fun p : Bool × α => p.1 :: e p.2) body)
    (a : α) (B : ℕ) (ha : (e a).length ≤ B) :
    c.time.eval (e a).length + 1 + 2*((e (body a).2).length + 1) ≤ (loopCost c).eval B := by
  have ho := Runtime.encodedOutputLength c a
  simp only [Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_X,
    List.length_cons] at ho
  have ht := MachineComposition.natPolynomial_eval_mono c.time ha
  have hp := Nat.mul_le_mul_left (Runtime.programPushBound c.tm) ht
  simp only [loopCost, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C,
    Polynomial.eval_X, Polynomial.eval_one]
  omega

theorem boundedRun_execution {α : Type} {e : α → List Bool} {body : α → Bool × α}
    (c : TM2ComputableInPolyTime e (fun p : Bool × α => p.1 :: e p.2) body)
    {B : ℕ} {a z : α} {n : ℕ} (h : BoundedRun e body B a z n) :
    Nonempty (TM2OutputsInTime (Loop.machine c.tm c.inputAlphabet c.outputAlphabet)
      ((e a).map c.inputAlphabet.symm) (some (e z)) (n*(loopCost c).eval B)) := by
  induction h with
  | stop a ha stop =>
    have ho := c.outputsFun a
    simp only [stop] at ho
    have run := Loop.finish c.tm c.inputAlphabet c.outputAlphabet (e a) (e (body a).2)
      (c.time.eval (e a).length) ho
    refine ⟨{ run with steps_le_m := ?_ }⟩
    simpa only [one_mul] using run.steps_le_m.trans (loopCost_bound c a B ha)
  | next a z n ha more tail ih =>
    obtain ⟨ih⟩ := ih
    have ho := c.outputsFun a
    simp only [more] at ho
    have run := Loop.restart c.tm c.inputAlphabet c.outputAlphabet (e a) (e (body a).2)
      (c.time.eval (e a).length) ho
    have all := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ run ih
    refine ⟨{ all with steps_le_m := ?_ }⟩
    have h := all.steps_le_m
    have hb := loopCost_bound c a B ha
    rw [Nat.add_mul]
    omega

noncomputable def Poly.loop {α : Type} {e : α → List Bool} {body : α → Bool × α}
    (c : Poly e (fun p : Bool × α => p.1 :: e p.2) body)
    (result : α → α) (size count : Polynomial ℕ)
    (spec : ∀ a, ∃ n, n ≤ count.eval (e a).length ∧
      BoundedRun e body (size.eval (e a).length) a (result a) n) : Poly e e result where
  computation := {
    tm := Loop.machine c.computation.tm c.computation.inputAlphabet c.computation.outputAlphabet
    inputAlphabet := c.computation.inputAlphabet
    outputAlphabet := Equiv.refl Bool
    time := count * (loopCost c.computation).comp size
    outputsFun := fun a => Classical.choice (by
      simp only [show (Equiv.refl Bool).invFun = id from rfl, List.map_id]
      obtain ⟨n, hn, run⟩ := spec a
      obtain ⟨execution⟩ := boundedRun_execution c.computation run
      refine ⟨{ execution with steps_le_m := ?_ }⟩
      simp only [Polynomial.eval_mul, Polynomial.eval_comp]
      exact execution.steps_le_m.trans (Nat.mul_le_mul_right _ hn)) }
  finiteAlphabet := Loop.finiteAlphabet _ _ _ c.finiteAlphabet

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