import OAI.Computability.Scheduling.RoutineCompiler

namespace OAI

universe u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15 u16 u17 u18 u19 u20 u21 u22 u23 u24 u25 u26 u27

section

namespace ThreeMachine.StackCompiler
open ThreeMachine.StackCompiler.Tree
namespace Data

def fold (f : Data → Data) (acc : Data) : Data → Data
  | .nil => acc
  | .pair a xs => fold f (f (.pair a acc)) xs

def foldCost (f : Data → Data) (c : Data → ℕ) (acc : Data) : Data → ℕ
  | .nil => 1
  | .pair a xs => c (.pair a acc) + foldCost f c (f (.pair a acc)) xs +
      20*((Data.pair a xs).size+acc.size+(f (.pair a acc)).size+1)

end Data
namespace Routine
variable {f : Data → Data} {c : Data → ℕ}

def foldStore (x acc xs : Data) : Fin 3 → Data := ![x,acc,xs]
@[simp] theorem foldStore_zero (x acc xs : Data) : foldStore x acc xs 0 = x := rfl
@[simp] theorem foldStore_one (x acc xs : Data) : foldStore x acc xs 1 = acc := rfl
@[simp] theorem foldStore_two (x acc xs : Data) : foldStore x acc xs 2 = xs := rfl

theorem foldStore_update_one (x acc xs y : Data) :
    Function.update (foldStore x acc xs) 1 y = foldStore x y xs := by
  funext i; fin_cases i <;> simp [foldStore]

theorem foldStore_update_two (x acc xs y : Data) :
    Function.update (foldStore x acc xs) 2 y = foldStore x acc y := by
  funext i; fin_cases i <;> simp [foldStore]

def foldBody (R : Routine f c) : Code (Fin 3 ⊕ R.Vars) :=
  .seq (.select true (.inr R.input) (.inl 2))
    (.seq (.pair (.inr R.input) (.inr R.input) (.inl 1))
    (.seq (R.code.rename Sum.inr)
    (.seq (.copy (.inl 1) (.inr R.output))
    (.seq (.nil (.inr R.input))
    (.seq (.nil (.inr R.output)) (.select false (.inl 2) (.inl 2)))))))

def foldCode (R : Routine f c) : Code (Fin 3 ⊕ R.Vars) :=
  .seq (.select true (.inl 2) (.inl 0))
    (.seq (.select false (.inl 1) (.inl 0)) (.loop (.inl 2) (foldBody R)))

theorem foldBody_correct (R : Routine f c) (x acc a xs : Data) :
    Bounded (foldBody R)
      (join (foldStore x acc (.pair a xs)) (zeroStore R.Vars))
      (join (foldStore x (f (.pair a acc)) xs) (zeroStore R.Vars))
      (c (.pair a acc)+20*((Data.pair a xs).size+acc.size+(f (.pair a acc)).size+1)-1) := by
  let l := foldStore x acc (.pair a xs)
  let l' := foldStore x (f (.pair a acc)) (.pair a xs)
  let z := zeroStore R.Vars
  let r := start R.input (.pair a acc)
  let r' := finish R.input R.output (.pair a acc) (f (.pair a acc))
  have h₁ : Bounded (.select true (.inr R.input) (.inl 2))
      (join l z) (join l (start R.input a)) (2+(Data.pair a xs).size) := by
    simpa [join_update_right,l,z,start,zeroStore,Data.head] using
      (Eval.select true (.inr R.input) (.inl 2) (join l z)).bounded
  have h₂ : Bounded (.pair (.inr R.input) (.inr R.input) (.inl 1))
      (join l (start R.input a)) (join l r) (1+a.size+a.size+acc.size) := by
    simpa [join_update_right,l,r,start,Function.update_idem] using
      (Eval.pair (.inr R.input) (.inr R.input) (.inl 1) (join l (start R.input a))).bounded
  have h₃ : Bounded (R.code.rename Sum.inr) (join l r) (join l r') (c (.pair a acc)) :=
    (R.correct (.pair a acc)).right l
  have h₄ : Bounded (.copy (.inl 1) (.inr R.output)) (join l r') (join l' r')
      (1+acc.size+(f (.pair a acc)).size) := by
    simpa [join_update_left,l,l',r',foldStore_update_one] using
      (Eval.copy (.inl 1) (.inr R.output) (join l r')).bounded
  have h₅ : Bounded (.nil (.inr R.input)) (join l' r')
      (join l' (start R.output (f (.pair a acc)))) (1+(Data.pair a acc).size) := by
    simpa only [join_update_right,r',reset_input R.distinct,join_inr,finish_input R.distinct] using
      (Eval.nil (.inr R.input) (join l' r')).bounded
  have h₆ : Bounded (.nil (.inr R.output))
      (join l' (start R.output (f (.pair a acc)))) (join l' z) (1+(f (.pair a acc)).size) := by
    simpa only [join_update_right,reset_start,join_inr,start_input,z] using
      (Eval.nil (.inr R.output) (join l' (start R.output (f (.pair a acc))))).bounded
  have h₇ : Bounded (.select false (.inl 2) (.inl 2)) (join l' z)
      (join (foldStore x (f (.pair a acc)) xs) z) (1+(Data.pair a xs).size+(Data.pair a xs).size) := by
    simpa [join_update_left,l',foldStore_update_two,Data.tail] using
      (Eval.select false (.inl 2) (.inl 2) (join l' z)).bounded
  have hh := h₁.seq (h₂.seq (h₃.seq (h₄.seq (h₅.seq (h₆.seq h₇)))))
  exact hh.mono (by simp only [Data.size_pair]; omega)

theorem foldLoop_correct (R : Routine f c) (x acc xs : Data) :
    Bounded (.loop (.inl 2) (foldBody R))
      (join (foldStore x acc xs) (zeroStore R.Vars))
      (join (foldStore x (Data.fold f acc xs) .nil) (zeroStore R.Vars))
      (Data.foldCost f c acc xs) := by
  induction xs generalizing acc with
  | nil => exact Bounded.loop_stop _ _ _ rfl
  | pair a xs _ ih =>
    have hh := Bounded.loop_step (by rfl :
      ((join (foldStore x acc (.pair a xs)) (zeroStore R.Vars)) (.inl 2)).nonempty = true)
      (foldBody_correct R x acc a xs) (ih (f (.pair a acc)))
    exact hh.mono (by simp only [Data.foldCost]; omega)

def fold (R : Routine f c) :
    Routine (fun x => Data.fold f x.tail x.head)
      (fun x => 2*x.size+6+Data.foldCost f c x.tail x.head) where
  Vars := Fin 3 ⊕ R.Vars
  finiteVars := inferInstance
  decVars := inferInstance
  input := .inl 0
  output := .inl 1
  distinct := by simp
  code := foldCode R
  correct x := by
    have es : start (0 : Fin 3) x = foldStore x .nil .nil := by
      funext i; fin_cases i <;> simp [start,zeroStore,foldStore]
    have ef : finish (Sum.inl (0 : Fin 3)) (Sum.inl (1 : Fin 3)) x (Data.fold f x.tail x.head) =
        join (foldStore x (Data.fold f x.tail x.head) .nil) (zeroStore R.Vars) := by
      rw [finish,start_left,es,join_update_left,foldStore_update_one]
    have h₁ : Bounded (.select true (.inl 2) (.inl 0))
        (join (foldStore x .nil .nil) (zeroStore R.Vars))
        (join (foldStore x .nil x.head) (zeroStore R.Vars)) (2+x.size) := by
      simpa [join_update_left,foldStore_update_two] using
        (Eval.select true (.inl 2) (.inl 0)
          (join (foldStore x .nil .nil) (zeroStore R.Vars))).bounded
    have h₂ : Bounded (.select false (.inl 1) (.inl 0))
        (join (foldStore x .nil x.head) (zeroStore R.Vars))
        (join (foldStore x x.tail x.head) (zeroStore R.Vars)) (2+x.size) := by
      simpa [join_update_left,foldStore_update_one] using
        (Eval.select false (.inl 1) (.inl 0)
          (join (foldStore x .nil x.head) (zeroStore R.Vars))).bounded
    have hh := h₁.seq (h₂.seq (foldLoop_correct R x x.tail x.head))
    rw [start_left,es,ef]
    exact hh.mono (by omega)

end Routine
end ThreeMachine.StackCompiler

namespace ThreeMachine.StackCompiler

class Coding (α : Type u1) where
  encode : α → Data

def enc {α : Type u2} [Coding α] : α → Data := Coding.encode

def volume {α : Type u3} [Coding α] (x : α) : ℕ := (enc x).size

instance : Coding Data := ⟨id⟩
instance : Coding Unit := ⟨fun _ => .nil⟩
instance : Coding Bool := ⟨fun b => if b then .pair .nil .nil else .nil⟩
instance {α : Type u4} {β : Type u5} [Coding α] [Coding β] : Coding (α × β) :=
  ⟨fun x => .pair (enc x.1) (enc x.2)⟩

def encodeList {α : Type u6} [Coding α] : List α → Data
  | [] => .nil
  | x :: xs => .pair (enc x) (encodeList xs)
instance {α : Type u7} [Coding α] : Coding (List α) := ⟨encodeList⟩

def encodeUnary : ℕ → Data | 0 => .nil | n+1 => .pair .nil (encodeUnary n)
instance : Coding ℕ := ⟨encodeUnary⟩
instance {α : Type u8} [Coding α] : Coding (Option α) :=
  ⟨fun x => match x with | none => .nil | some a => .pair (enc a) .nil⟩

@[simp] theorem enc_data (x : Data) : enc x = x := rfl
@[simp] theorem enc_unit (x : Unit) : enc x = .nil := rfl
@[simp] theorem enc_false : enc false = .nil := rfl
@[simp] theorem enc_true : enc true = .pair .nil .nil := rfl
@[simp] theorem enc_pair {α : Type u9} {β : Type u10} [Coding α] [Coding β] (x : α) (y : β) :
    enc (x,y) = .pair (enc x) (enc y) := rfl
@[simp] theorem enc_nil {α : Type u11} [Coding α] : enc ([] : List α) = .nil := rfl
@[simp] theorem enc_cons {α : Type u12} [Coding α] (x : α) (xs : List α) :
    enc (x :: xs) = .pair (enc x) (enc xs) := rfl
@[simp] theorem enc_zero : enc (0 : ℕ) = .nil := rfl
@[simp] theorem enc_succ (n : ℕ) : enc (n+1) = .pair .nil (enc n) := rfl
@[simp] theorem enc_none {α : Type u13} [Coding α] : enc (none : Option α) = .nil := rfl
@[simp] theorem enc_some {α : Type u14} [Coding α] (x : α) : enc (some x) = .pair (enc x) .nil := rfl

@[simp] theorem volume_pair {α : Type u15} {β : Type u16} [Coding α] [Coding β] (x : α) (y : β) :
    volume (x,y) = volume x+volume y+1 := Data.size_pair _ _
@[simp] theorem volume_nil {α : Type u17} [Coding α] : volume ([] : List α) = 1 := rfl
@[simp] theorem volume_cons {α : Type u18} [Coding α] (x : α) (xs : List α) :
    volume (x :: xs) = volume x+volume xs+1 := Data.size_pair _ _
@[simp] theorem volume_nat (n : ℕ) : volume n = 2*n+1 := by
  induction n with
  | zero => rfl
  | succ n ih =>
    change Data.size (.pair .nil (enc n)) = _
    change (enc n).size = 2*n+1 at ih
    simp only [Data.size_pair,Data.size_nil,ih]
    omega

structure Realizer {α : Type u19} {β : Type u20} [Coding α] [Coding β] (f : α → β) where
  transform : Data → Data
  charge : Data → ℕ
  routine : Routine transform charge
  correct : ∀ x, transform (enc x) = enc (f x)

namespace Realizer
variable {α : Type u21} {β : Type u22} {γ : Type u23} {δ : Type u24} [Coding α] [Coding β] [Coding γ] [Coding δ]
variable {f : α → β} {g : β → γ}

def time (R : Realizer f) (x : α) : ℕ := R.charge (enc x)

def id : Realizer (_root_.id : α → α) :=
  ⟨_root_.id,_,Routine.identity,fun _ => rfl⟩

@[simp] theorem time_id (x : α) : (id : Realizer (_root_.id : α → α)).time x = volume x+2 := rfl

def unit : Realizer (fun _ : α => ()) :=
  ⟨fun _ => .nil,_,Routine.nil,fun _ => rfl⟩

def nil : Realizer (fun _ : α => ([] : List β)) :=
  ⟨fun _ => .nil,_,Routine.nil,fun _ => rfl⟩

def zero : Realizer (fun _ : α => (0 : ℕ)) :=
  ⟨fun _ => .nil,_,Routine.nil,fun _ => rfl⟩

def false : Realizer (fun _ : α => Bool.false) :=
  ⟨fun _ => .nil,_,Routine.nil,fun _ => rfl⟩

def comp (R : Realizer f) (S : Realizer g) : Realizer (g ∘ f) where
  transform := S.transform ∘ R.transform
  charge := _
  routine := R.routine.comp S.routine
  correct x := by simp only [Function.comp_apply,R.correct,S.correct]

theorem time_comp (R : Realizer f) (S : Realizer g) (x : α) :
    (R.comp S).time x = R.time x+S.time (f x)+10*(volume (f x)+1) := by
  simp only [comp,time,Routine.comp,R.correct,volume]

def pair {g : α → γ} (R : Realizer f) (S : Realizer g) : Realizer (fun x => (f x,g x)) where
  transform := fun x => .pair (R.transform x) (S.transform x)
  charge := _
  routine := R.routine.pair S.routine
  correct x := by simp only [R.correct,S.correct,enc_pair]

theorem time_pair {g : α → γ} (R : Realizer f) (S : Realizer g) (x : α) :
    (R.pair S).time x = R.time x+S.time x+20*(volume x+volume (f x)+volume (g x)+1) := by
  simp only [pair,time,Routine.pair,R.correct,S.correct,volume]

def fst : Realizer (Prod.fst : α × β → α) :=
  ⟨Data.head,_,Routine.select true,fun _ => rfl⟩

def snd : Realizer (Prod.snd : α × β → β) :=
  ⟨Data.tail,_,Routine.select Bool.false,fun _ => rfl⟩

@[simp] theorem time_fst (x : α × β) : (fst : Realizer (Prod.fst : α × β → α)).time x = volume x+2 := rfl
@[simp] theorem time_snd (x : α × β) : (snd : Realizer (Prod.snd : α × β → β)).time x = volume x+2 := rfl

def congr {f' : α → β} (R : Realizer f) (h : ∀ x, f x = f' x) : Realizer f' :=
  { R with correct := fun x => (R.correct x).trans (congrArg enc (h x)) }

@[simp] theorem time_congr {f' : α → β} (R : Realizer f) (h : ∀ x, f x = f' x) (x : α) :
    (R.congr h).time x = R.time x := rfl

theorem fold_correct {F : α × β → β} (R : Realizer F) (xs : List α) (b : β) :
    Data.fold R.transform (enc b) (enc xs) = enc (xs.foldl (fun b a => F (a,b)) b) := by
  induction xs generalizing b with
  | nil => rfl
  | cons a xs ih =>
    change Data.fold R.transform (R.transform (enc (a,b))) (enc xs) = _
    rw [R.correct,ih]
    rfl

def fold {F : α × β → β} (R : Realizer F) :
    Realizer (fun x : List α × β => x.1.foldl (fun b a => F (a,b)) x.2) where
  transform := fun x => Data.fold R.transform x.tail x.head
  charge := _
  routine := R.routine.fold
  correct x := fold_correct R x.1 x.2

def foldTime {F : α × β → β} (R : Realizer F) (b : β) : List α → ℕ
  | [] => 1
  | a :: xs => R.time (a,b)+foldTime R (F (a,b)) xs+
      20*(volume (a :: xs)+volume b+volume (F (a,b))+1)

theorem foldTime_eq {F : α × β → β} (R : Realizer F) (xs : List α) (b : β) :
    Data.foldCost R.transform R.charge (enc b) (enc xs) = foldTime R b xs := by
  induction xs generalizing b with
  | nil => rfl
  | cons a xs ih =>
    change R.time (a,b)+Data.foldCost R.transform R.charge (R.transform (enc (a,b))) (enc xs)+
      20*(volume (a :: xs)+volume b+(R.transform (enc (a,b))).size+1) = _
    rw [R.correct,ih]
    rfl

theorem time_fold {F : α × β → β} (R : Realizer F) (x : List α × β) :
    R.fold.time x = 2*volume x+6+foldTime R x.2 x.1 := by
  change 2*volume x+6+Data.foldCost R.transform R.charge (enc x.2) (enc x.1) = _
  rw [foldTime_eq]

end Realizer
end ThreeMachine.StackCompiler

namespace ThreeMachine.StackCompiler.Tree
variable {V : Type} [DecidableEq V]
theorem Bounded.branch_true {src : V} {p q : Code V} {s t : V → Data} {n : ℕ}
    (h : (s src).nonempty = true) (hp : Bounded p s t n) : Bounded (.branch src p q) s t (n+1) := by
  obtain ⟨m,hm,he⟩ := hp
  exact ⟨m+1,by omega,Eval.branch_true h he⟩
theorem Bounded.branch_false {src : V} {p q : Code V} {s t : V → Data} {n : ℕ}
    (h : (s src).nonempty = false) (hq : Bounded q s t n) : Bounded (.branch src p q) s t (n+1) := by
  obtain ⟨m,hm,he⟩ := hq
  exact ⟨m+1,by omega,Eval.branch_false h he⟩
end ThreeMachine.StackCompiler.Tree

namespace ThreeMachine.StackCompiler
open ThreeMachine.StackCompiler.Tree
namespace Routine
variable {f g : Data → Data} {c d : Data → ℕ}
variable {V : Type} [DecidableEq V]

def invoke (R : Routine f c) (dst src : V) : Code (V ⊕ R.Vars) :=
  .seq (.copy (.inr R.input) (.inl src))
    (.seq (R.code.rename Sum.inr)
    (.seq (.copy (.inl dst) (.inr R.output))
    (.seq (.nil (.inr R.input)) (.nil (.inr R.output)))))

theorem invoke_correct (R : Routine f c) (dst src : V) (s : V → Data) :
    Bounded (R.invoke dst src) (join s (zeroStore R.Vars))
      (join (Function.update s dst (f (s src))) (zeroStore R.Vars))
      (c (s src)+10*((s src).size+(s dst).size+(f (s src)).size+1)) := by
  let a := start R.input (s src)
  let b := finish R.input R.output (s src) (f (s src))
  let t := Function.update s dst (f (s src))
  have h₁ : Bounded (.copy (.inr R.input) (.inl src))
      (join s (zeroStore R.Vars)) (join s a) (2+(s src).size) := by
    simpa [join_update_right,a,start,zeroStore] using
      (Eval.copy (.inr R.input) (.inl src) (join s (zeroStore R.Vars))).bounded
  have h₂ := (R.correct (s src)).right s
  have h₃ : Bounded (.copy (.inl dst) (.inr R.output)) (join s b) (join t b)
      (1+(s dst).size+(f (s src)).size) := by
    simpa [join_update_left,t,b] using (Eval.copy (.inl dst) (.inr R.output) (join s b)).bounded
  have h₄ : Bounded (.nil (.inr R.input)) (join t b)
      (join t (start R.output (f (s src)))) (1+(s src).size) := by
    simpa only [join_update_right,b,reset_input R.distinct,join_inr,finish_input R.distinct] using
      (Eval.nil (.inr R.input) (join t b)).bounded
  have h₅ : Bounded (.nil (.inr R.output)) (join t (start R.output (f (s src))))
      (join t (zeroStore R.Vars)) (1+(f (s src)).size) := by
    simpa only [join_update_right,reset_start,join_inr,start_input] using
      (Eval.nil (.inr R.output) (join t (start R.output (f (s src))))).bounded
  exact (h₁.seq (h₂.seq (h₃.seq (h₄.seq h₅)))).mono (by omega)

def chooseCode (R : Routine f c) (S : Routine g d) : Code ((Fin 3 ⊕ R.Vars) ⊕ S.Vars) :=
  .seq (.select true (.inl (.inl 2)) (.inl (.inl 0)))
    (.seq (.branch (.inl (.inl 2))
      ((R.invoke (1 : Fin 3) 0).rename Sum.inl)
      (S.invoke (Sum.inl (1 : Fin 3)) (Sum.inl 0)))
      (.nil (.inl (.inl 2))))

def choose (R : Routine f c) (S : Routine g d) :
    Routine (fun x => if x.head.nonempty then f x else g x)
      (fun x => c x+d x+30*(x.size+(f x).size+(g x).size+1)) where
  Vars := (Fin 3 ⊕ R.Vars) ⊕ S.Vars
  finiteVars := inferInstance
  decVars := inferInstance
  input := .inl (.inl 0)
  output := .inl (.inl 1)
  distinct := by simp
  code := chooseCode R S
  correct x := by
    let z := zeroStore R.Vars
    let w := zeroStore S.Vars
    let s := foldStore x .nil .nil
    let s' := foldStore x .nil x.head
    let y := if x.head.nonempty then f x else g x
    let t := foldStore x y x.head
    have es : start (0 : Fin 3) x = s := by
      funext i; fin_cases i <;> simp [s,start,zeroStore,foldStore]
    have ef : finish (Sum.inl (Sum.inl (0 : Fin 3))) (Sum.inl (Sum.inl (1 : Fin 3))) x y =
        join (join (foldStore x y .nil) z) w := by
      rw [finish,start_left,start_left,es,join_update_left,join_update_left]
      simp only [s,foldStore_update_one]
      rfl
    have h₁ : Bounded (.select true (.inl (.inl 2)) (.inl (.inl 0)))
        (join (join s z) w) (join (join s' z) w) (2+x.size) := by
      simpa [join_update_left,s,s',foldStore_update_two] using
        (Eval.select true (.inl (.inl 2)) (.inl (.inl 0)) (join (join s z) w)).bounded
    have h₂ : Bounded (.branch (.inl (.inl 2)) ((R.invoke (1 : Fin 3) 0).rename Sum.inl)
        (S.invoke (Sum.inl (1 : Fin 3)) (Sum.inl 0)))
        (join (join s' z) w) (join (join t z) w)
        (c x+d x+10*(x.size+(f x).size+(g x).size+2)+1) := by
      cases he : x.head.nonempty with
      | false =>
        have hh := (S.invoke_correct (Sum.inl (1 : Fin 3)) (Sum.inl 0) (join s' z)).branch_false
          (src := Sum.inl (Sum.inl (2 : Fin 3))) (p := ((R.invoke (1 : Fin 3) 0).rename Sum.inl)) (by simpa [s'] using he)
        simpa only [join_update_left,s',foldStore_update_one,t,y,he,Bool.false_eq_true,ite_false,join_inl,foldStore_zero] using
          (hh.mono (m := c x+d x+10*(x.size+(f x).size+(g x).size+2)+1)
            (by simp only [join_inl,foldStore_zero,foldStore_one,s',Data.size_nil]; omega))
      | true =>
        have hh := ((R.invoke_correct (1 : Fin 3) 0 s').left w).branch_true
          (src := Sum.inl (Sum.inl (2 : Fin 3))) (q := S.invoke (Sum.inl (1 : Fin 3)) (Sum.inl 0)) (by simpa [s'] using he)
        simpa only [s',foldStore_update_one,t,y,he,ite_true,foldStore_zero] using
          (hh.mono (m := c x+d x+10*(x.size+(f x).size+(g x).size+2)+1)
            (by simp only [foldStore_zero,foldStore_one,s',Data.size_nil]; omega))
    have h₃ : Bounded (.nil (.inl (.inl 2))) (join (join t z) w)
        (join (join (foldStore x y .nil) z) w) (1+x.head.size) := by
      simpa only [join_update_left,t,foldStore_update_two,join_inl,foldStore_two] using
        (Eval.nil (.inl (.inl 2)) (join (join t z) w)).bounded
    rw [start_left,start_left,es,ef]
    have hh := h₁.seq (h₂.seq h₃)
    exact hh.mono (by
      have hx : x.head.size ≤ x.size := by cases x <;> simp [Data.head]; omega
      omega)

end Routine
end ThreeMachine.StackCompiler

namespace ThreeMachine.StackCompiler
namespace Routine

def constant : (d : Data) → Routine (fun _ => d) (fun x => (2*d.size+1)*(20*x.size+50*d.size+50))
  | .nil => nil.mono (by intro x; simp only [Data.size_nil]; omega)
  | .pair a b => ((constant a).pair (constant b)).mono (by
      intro x
      simp only [Data.size_pair]
      nlinarith)

end Routine
namespace Realizer
variable {α : Type u25} {β : Type u26} {γ : Type u27} [Coding α] [Coding β] [Coding γ]

def constant (b : β) : Realizer (fun _ : α => b) :=
  ⟨fun _ => enc b,_,Routine.constant (enc b),fun _ => rfl⟩

def reinterpret (f : α → β) (h : ∀ x, enc (f x) = enc x) : Realizer f :=
  ⟨_root_.id,_,Routine.identity,fun x => (h x).symm⟩

@[simp] theorem time_reinterpret (f : α → β) (h : ∀ x, enc (f x) = enc x) (x : α) :
    (reinterpret f h).time x = volume x+2 := rfl

def cons : Realizer (fun x : α × List α => x.1 :: x.2) := reinterpret _ (fun _ => rfl)

def choose {f g : α → β} (R : Realizer f) (S : Realizer g) :
    Realizer (fun x : Bool × α => if x.1 then f x.2 else g x.2) where
  transform := fun x => if x.head.nonempty then (snd.comp R).transform x else (snd.comp S).transform x
  charge := _
  routine := (snd.comp R).routine.choose (snd.comp S).routine
  correct x := by
    rcases x with ⟨b,x⟩
    cases b <;> simp only [enc_pair,enc_false,enc_true,Data.head,Data.nonempty,
      Bool.false_eq_true,ite_false,ite_true]
    · exact (snd.comp S).correct (Bool.false,x)
    · exact (snd.comp R).correct (true,x)

theorem time_choose {f g : α → β} (R : Realizer f) (S : Realizer g) (x : Bool × α) :
    (R.choose S).time x = (snd.comp R).time x+(snd.comp S).time x+
      30*(volume x+volume (f x.2)+volume (g x.2)+1) := by
  change (snd.comp R).time x+(snd.comp S).time x+
    30*(volume x+((snd.comp R).transform (enc x)).size+((snd.comp S).transform (enc x)).size+1) = _
  rw [(snd.comp R).correct,(snd.comp S).correct]
  rfl

def ite {p : α → Bool} {f g : α → β} (P : Realizer p) (R : Realizer f) (S : Realizer g) :
    Realizer (fun x => if p x then f x else g x) :=
  ((P.pair id).comp (R.choose S)).congr (fun _ => rfl)

def succ : Realizer (fun n : ℕ => n+1) :=
  (unit.pair id).comp (reinterpret (fun x : Unit × ℕ => x.2+1) (by intro x; rfl)) |>.congr (fun _ => rfl)

end Realizer
end ThreeMachine.StackCompiler

end

end OAI