lean/OAI/Computability/RationalHitting/ProcedureControl.lean

import OAI.Computability.RationalHitting.ProcedurePairs

namespace OAI

namespace RationalHitting.StackLanguage
open Function
namespace Procedure
variable {A B : Type} {ca : A → List Bool} {cb : B → List Bool} {f : A → B}

/-- Give a procedure a single external input/output port. The two transfers
are real stack programs; scratch registers remain clean. -/
def toPort (p : Procedure ca cb f) : Procedure ca cb f where
  Registers := p.Registers ⊕ Fin 2
  finite := inferInstance
  decEq := inferInstance
  input := Sum.inr 0
  output := Sum.inr 0
  program := .seq (move (Sum.inr 0) (Sum.inl p.input) (Sum.inr 1))
    (.seq (p.program.rename Sum.inl) (move (Sum.inl p.output) (Sum.inr 0) (Sum.inr 1)))
  bound := 5*p.bound+4*TimeBound.variable+8
  correct a := by
    obtain ⟨t,ht,hp⟩ := p.correct a
    refine ⟨1+(4*(ca a).length+3)+(1+t+(4*(cb (f a)).length+3)),?_,?_⟩
    · have hs := p.size a
      simp only [TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,TimeBound.eval_variable]
      omega
    · exact Eval.seq (Eval.move_single (by simp) (by simp) (by simp) _)
        (Eval.seq (hp.rename_single Sum.inl Sum.inl_injective)
          (Eval.move_single (by simp) (by simp) (by simp) _))
  size a := by
    have hs := p.size a
    simp only [TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,TimeBound.eval_variable]
    omega

end Procedure

def splitPair {K : Type} [DecidableEq K] (a b tmp : K) : Program K :=
  .seq (unpackRecord.rename (threeRegs b tmp a)) (reverse tmp a)

lemma eval_splitPair {K : Type} [DecidableEq K] {a b tmp : K}
    (hab : a≠b) (hat : a≠tmp) (hbt : b≠tmp) (x y : List Bool) :
    Eval (splitPair a b tmp) (single b (codeWord x++y)) (both a b x y) (7*x.length+10) := by
  let f := threeRegs b tmp a
  have hf : Injective f := threeRegs_inj hbt hab.symm hat.symm
  have he := (eval_unpack_pair x y).rename f hf (fun _ => [])
  have hx : extend f (both (0 : Fin 3) 1 y x.reverse) (fun _ => [])=both b tmp y x.reverse := by
    simp only [both,extend_update_store f hf,extend_single f hf]
    rfl
  rw [extend_single f hf,hx] at he
  have hrev := eval_reverse hat.symm (both b tmp y x.reverse)
  have heq : update (update (both b tmp y x.reverse) tmp []) a
      ((both b tmp y x.reverse tmp).reverse++both b tmp y x.reverse a)=both a b x y := by
    funext k
    by_cases ha : k=a <;> by_cases hb : k=b <;> by_cases ht : k=tmp <;>
      simp_all [both,single]
  rw [heq] at hrev
  have hh := Eval.seq he hrev
  convert hh using 1 <;> simp [splitPair,f,threeRegs,both] ; omega

lemma extend_both {K L : Type} [DecidableEq K] [DecidableEq L] (f : K → L) (hf : Injective f)
    (i j : K) (x y : List Bool) :
    extend f (both i j x y) (fun _ => [])=both (f i) (f j) x y := by
  simp only [both,extend_update_store f hf,extend_single f hf]

namespace Procedure
variable {A B C K : Type} [Fintype K] [DecidableEq K]
  {ca : A → List Bool} {cb : B → List Bool} {cc : C → List Bool} {f : A×B → C}

/-- Package an independently proved two-input clean register routine as a
serialized procedure. Its polynomial bound is not an operation oracle: the
actual Eval proof is required. -/
def fromBinary (p : Program K) (i j o : K) (hij : i≠j) (bnd : TimeBound)
    (hp : ∀ a b, ∃ t ≤ bnd.eval ((ca a).length+(cb b).length+1),
      Eval p (both i j (ca a) (cb b)) (single o (cc (f (a,b)))) t)
    (hs : ∀ a b, (cc (f (a,b))).length ≤ bnd.eval ((ca a).length+(cb b).length+1)) :
    Procedure (pairCode ca cb) cc f where
  Registers := K ⊕ Unit
  finite := inferInstance
  decEq := inferInstance
  input := Sum.inl j
  output := Sum.inl o
  program := .seq (splitPair (Sum.inl i) (Sum.inl j) (Sum.inr ())) (p.rename Sum.inl)
  bound := bnd + 7*TimeBound.variable+12
  correct a := by
    obtain ⟨t,ht,he⟩ := hp a.1 a.2
    refine ⟨1+(7*(ca a.1).length+10)+t,?_,?_⟩
    · have hh : (ca a.1).length+(cb a.2).length+1 ≤ (pairCode ca cb a).length+1 := by simp; omega
      have ht' := ht.trans (bnd.monotone hh)
      simp only [TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,TimeBound.eval_variable]
      simp only [pairCode_length] at *
      omega
    · exact Eval.seq (eval_splitPair (by simpa using hij) (by simp) (by simp) _ _)
        (by simpa only [extend_single Sum.inl Sum.inl_injective,extend_both Sum.inl Sum.inl_injective]
          using he.rename (Sum.inl : K → K ⊕ Unit) Sum.inl_injective (fun _ => []))
  size a := by
    have hh : (ca a.1).length+(cb a.2).length+1 ≤ (pairCode ca cb a).length+1 := by simp; omega
    have ht := (hs a.1 a.2).trans (bnd.monotone hh)
    simp only [Prod.mk.eta] at ht
    simp only [TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,TimeBound.eval_variable]
    omega

end Procedure
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage
open Function

def boolCode (b : Bool) : List Bool := [b]
@[simp] lemma boolCode_length (b : Bool) : (boolCode b).length=1 := rfl

namespace Procedure
variable {A B K : Type} [Fintype K] [DecidableEq K]
  {ca : A → List Bool} {cb : B → List Bool} {f g : A → B}

def rename (p : Procedure ca cb f) (e : p.Registers → K) (he : Injective e) : Procedure ca cb f where
  Registers := K
  finite := inferInstance
  decEq := inferInstance
  input := e p.input
  output := e p.output
  program := p.program.rename e
  bound := p.bound
  correct a := by
    obtain ⟨t,ht,he'⟩ := p.correct a
    exact ⟨t,ht,he'.rename_single e he⟩
  size := p.size

/-- Deterministic Boolean branching on a serialized pair. Only the selected
finite subprogram runs; the tag is physically consumed. -/
def branch (p : Procedure ca cb f) (q : Procedure ca cb g) :
    Procedure (pairCode boolCode ca) cb (fun a => if a.1 then f a.2 else g a.2) := by
  let R := (p.Registers ⊕ q.Registers) ⊕ Fin 3
  let e₁ : p.toPort.Registers → R := Sum.map Sum.inl Fin.castSucc
  let e₂ : q.toPort.Registers → R := Sum.map Sum.inr Fin.castSucc
  have he₁ : Injective e₁ := Sum.inl_injective.sumMap (Fin.castSucc_injective 2)
  have he₂ : Injective e₂ := Sum.inr_injective.sumMap (Fin.castSucc_injective 2)
  let p' := p.toPort.rename e₁ he₁
  let q' := q.toPort.rename e₂ he₂
  let port : R := Sum.inr 0
  let flag : R := Sum.inr 2
  let tmp : R := Sum.inr 1
  have hfp : flag≠port := by simp [flag,port,R]
  have hft : flag≠tmp := by simp [flag,tmp,R]
  have hpt : port≠tmp := by simp [port,tmp,R]
  have hp : p'.input=port ∧ p'.output=port := ⟨rfl,rfl⟩
  have hq : q'.input=port ∧ q'.output=port := ⟨rfl,rfl⟩
  let P := Program.seq (splitPair flag port tmp)
    (.branch flag .skip (.seq (.drop flag) q'.program) (.seq (.drop flag) p'.program))
  refine {
    Registers := R
    finite := inferInstance
    decEq := inferInstance
    input := port
    output := port
    program := P
    bound := p'.bound+q'.bound+25
    correct := ?_
    size := ?_ }
  · intro a
    have hs := eval_splitPair (a:=flag) (b:=port) (tmp:=tmp) hfp hft hpt
      (boolCode a.1) (ca a.2)
    simp only [boolCode_length] at hs
    have hd : Eval (.drop flag) (both flag port (boolCode a.1) (ca a.2)) (single port (ca a.2)) 1 := by
      have hh := Eval.drop flag (both flag port (boolCode a.1) (ca a.2))
      have hx : update (both flag port (boolCode a.1) (ca a.2)) flag [] = single port (ca a.2) := by
        rw [both_comm hfp]
        simp only [both,update_idem]
        exact update_eq_self_iff.mpr (by simp [hfp])
      rw [both_first hfp] at hh
      change Eval _ _ (update (both flag port (boolCode a.1) (ca a.2)) flag []) 1 at hh
      rw [hx] at hh
      exact hh
    have hlen : (ca a.2).length+1≤(pairCode boolCode ca a).length+1 := by simp
    cases hb : a.1 with
    | false =>
      obtain ⟨t,ht,he⟩ := q'.correct a.2
      rw [hq.1,hq.2] at he
      refine ⟨1+17+(1+(1+1+t)),?_,?_⟩
      · have ht' := ht.trans (q'.bound.monotone hlen)
        simp only [TimeBound.eval_add,TimeBound.eval_numeral]
        omega
      · simp only [Bool.false_eq_true,↓reduceIte]
        exact Eval.seq hs (Eval.branchFalse (ls:=[]) (by simp only [both_first hfp,boolCode,hb]) (Eval.seq hd he))
    | true =>
      obtain ⟨t,ht,he⟩ := p'.correct a.2
      rw [hp.1,hp.2] at he
      refine ⟨1+17+(1+(1+1+t)),?_,?_⟩
      · have ht' := ht.trans (p'.bound.monotone hlen)
        simp only [TimeBound.eval_add,TimeBound.eval_numeral]
        omega
      · simp only [↓reduceIte]
        exact Eval.seq hs (Eval.branchTrue (ls:=[]) (by simp only [both_first hfp,boolCode,hb]) (Eval.seq hd he))
  · intro a
    have hlen : (ca a.2).length+1≤(pairCode boolCode ca a).length+1 := by simp
    have h₁ := (p'.size a.2).trans (p'.bound.monotone hlen)
    have h₂ := (q'.size a.2).trans (q'.bound.monotone hlen)
    simp only [TimeBound.eval_add,TimeBound.eval_numeral]
    split <;> omega

end Procedure
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage
open Function

/-- Unary loop count. These symbols are explicitly popped by the loop body. -/
def unaryCode (n : ℕ) : List Bool := List.replicate n true
@[simp] lemma unaryCode_length (n : ℕ) : (unaryCode n).length=n := by simp [unaryCode]
@[simp] lemma unaryCode_zero : unaryCode 0=[] := rfl
@[simp] lemma unaryCode_succ (n : ℕ) : unaryCode (n+1)=true::unaryCode n := rfl

namespace Procedure
variable {A : Type} {ca : A → List Bool} {f : A → A}

def iterateProgram (p : Procedure ca ca f) : Program (p.Registers ⊕ Unit) :=
  .loop (Sum.inr ()) (.seq (p.program.rename Sum.inl) (.drop (Sum.inr ())))

lemma eval_iterateProgram (p : Procedure ca ca f) (hport : p.output=p.input)
    (n : ℕ) (a : A) (B : ℕ) (hb : ∀ i≤n, (ca (f^[i] a)).length≤B) :
    ∃ t≤n*(p.bound.eval (B+1)+3)+1,
    Eval (iterateProgram p) (both (Sum.inl p.input) (Sum.inr ()) (ca a) (unaryCode n))
      (single (Sum.inl p.input) (ca (f^[n] a))) t := by
  induction n generalizing a with
  | zero =>
    refine ⟨1,by simp,?_⟩
    simpa only [unaryCode_zero,both_nil_right (by simp : (Sum.inl p.input : p.Registers ⊕ Unit)≠Sum.inr ()),iterate_zero,id_eq,iterateProgram] using
      (Eval.whileNil (p:=.seq (p.program.rename Sum.inl) (.drop (Sum.inr ())))
        (show both (Sum.inl p.input) (Sum.inr ()) (ca a) [] (Sum.inr ())=[] by simp))
  | succ n ih =>
    obtain ⟨u,hu,he⟩ := p.correct a
    have hsize := hb 0 (by omega)
    simp only [iterate_zero,id_eq] at hsize
    have hu' := hu.trans (p.bound.monotone (Nat.add_le_add_right hsize 1))
    have hb' : ∀ i≤n, (ca (f^[i] (f a))).length≤B := by
      intro i hi
      simpa only [iterate_succ_apply] using hb (i+1) (by omega)
    obtain ⟨v,hv,hev⟩ := ih (f a) hb'
    rw [hport] at he
    have he' := he.rename_both (Sum.inl : p.Registers → p.Registers ⊕ Unit) Sum.inl_injective
      (Sum.inr ()) (unaryCode (n+1)) (by intro k; simp)
    have hd : Eval (.drop (Sum.inr ()))
        (both (Sum.inl p.input) (Sum.inr ()) (ca (f a)) (unaryCode (n+1)))
        (both (Sum.inl p.input) (Sum.inr ()) (ca (f a)) (unaryCode n)) 1 := by
      simpa only [both,both_second,unaryCode_succ,List.tail_cons,update_self,update_idem] using
        Eval.drop (Sum.inr ()) (both (Sum.inl p.input) (Sum.inr ()) (ca (f a)) (unaryCode (n+1)))
    refine ⟨1+(1+u+1)+v,?_,?_⟩
    · nlinarith only [hu',hv]
    · have hh := Eval.whileCons (by simp :
        both (Sum.inl p.input) (Sum.inr ()) (ca a) (unaryCode (n+1)) (Sum.inr ())≠[])
        (Eval.seq he' hd) hev
      simpa only [iterateProgram,iterate_succ_apply] using hh

/-- Bounded iteration is compiled to a real finite loop. The semantic size
invariant is a proof obligation, not a loop oracle or added main hypothesis. -/
def iterate (p : Procedure ca ca f) (Q : TimeBound)
    (hQ : ∀ (n : ℕ) (a : A) (i : ℕ), i≤n →
      (ca (f^[i] a)).length≤Q.eval ((pairCode unaryCode ca (n,a)).length+1)) :
    Procedure (pairCode unaryCode ca) ca (fun a => f^[a.1] a.2) := by
  let q := p.toPort
  let r : Procedure (pairCode unaryCode ca) ca (fun a => f^[a.1] a.2) := {
    Registers := (q.Registers ⊕ Unit) ⊕ Unit
    finite := inferInstance
    decEq := inferInstance
    input := Sum.inl (Sum.inl q.input)
    output := Sum.inl (Sum.inl q.input)
    program := .seq (splitPair (Sum.inl (Sum.inr ())) (Sum.inl (Sum.inl q.input)) (Sum.inr ()))
      ((iterateProgram q).rename Sum.inl)
    bound := TimeBound.variable*(q.bound.comp (Q+1)+3)+7*TimeBound.variable+Q+12
    correct a := by
      obtain ⟨t,ht,he⟩ := eval_iterateProgram q rfl a.1 a.2
        (Q.eval ((pairCode unaryCode ca a).length+1)) (by simpa only [Prod.mk.eta] using hQ a.1 a.2)
      refine ⟨1+(7*a.1+10)+t,?_,?_⟩
      · have hn : a.1 ≤ (pairCode unaryCode ca a).length+1 := by simp; omega
        have ht' := ht.trans (Nat.add_le_add_right (Nat.mul_le_mul_right _ hn) 1)
        simp only [TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,
          TimeBound.eval_variable,TimeBound.eval_comp]
        omega
      · have hs := eval_splitPair (tmp:=Sum.inr ()) (by simp : (Sum.inl (Sum.inr ()) : (q.Registers ⊕ Unit) ⊕ Unit)≠Sum.inl (Sum.inl q.input))
          (by simp) (by simp) (unaryCode a.1) (ca a.2)
        simp only [unaryCode_length] at hs
        rw [both_comm (by simp : (Sum.inl (Sum.inr ()) : (q.Registers ⊕ Unit) ⊕ Unit)≠Sum.inl (Sum.inl q.input))] at hs
        exact Eval.seq hs (by
          simpa only [extend_both Sum.inl Sum.inl_injective,
            extend_single Sum.inl Sum.inl_injective] using
            he.rename (Sum.inl : (q.Registers ⊕ Unit) → (q.Registers ⊕ Unit) ⊕ Unit) Sum.inl_injective (fun _ => []))
    size a := by
      have hs := hQ a.1 a.2 a.1 le_rfl
      simp only [Prod.mk.eta] at hs
      simp only [TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,
          TimeBound.eval_variable,TimeBound.eval_comp]
      omega }
  exact r

end Procedure
end RationalHitting.StackLanguage

end OAI