lean/OAI/Computability/RationalHitting/Procedures.lean

import OAI.Computability.RationalHitting.RationalBinary

namespace OAI


namespace RationalHitting

/-- A concrete syntax for nonnegative polynomial bounds. This is only used to
bound actual stack transitions, never as an additional machine instruction. -/
inductive TimeBound where
  | const : ℕ → TimeBound
  | variable : TimeBound
  | add : TimeBound → TimeBound → TimeBound
  | mul : TimeBound → TimeBound → TimeBound
  deriving DecidableEq

namespace TimeBound
instance {n : ℕ} : OfNat TimeBound n := ⟨const n⟩
instance : Add TimeBound := ⟨add⟩
instance : Mul TimeBound := ⟨mul⟩

def eval : TimeBound → ℕ → ℕ
  | .const c, _ => c
  | .variable, n => n
  | .add a b, n => a.eval n + b.eval n
  | .mul a b, n => a.eval n * b.eval n

@[simp] lemma eval_const (a n : ℕ) : (const a).eval n = a := rfl
@[simp] lemma eval_variable (n : ℕ) : variable.eval n = n := rfl
@[simp] lemma eval_add (a b : TimeBound) (n : ℕ) : (a+b).eval n=a.eval n+b.eval n := rfl
@[simp] lemma eval_mul (a b : TimeBound) (n : ℕ) : (a*b).eval n=a.eval n*b.eval n := rfl
@[simp] lemma eval_numeral (a n : ℕ) : (ofNat(a) : TimeBound).eval n = a := rfl

lemma monotone (p : TimeBound) : Monotone p.eval := by
  induction p with
  | const c => exact monotone_const
  | «variable» => exact monotone_id
  | add p q hp hq => exact hp.add hq
  | mul p q hp hq => exact fun a b h => Nat.mul_le_mul (hp h) (hq h)

/-- Substitution is again a polynomial with nonnegative coefficients. -/
def comp : TimeBound → TimeBound → TimeBound
  | .const c, _ => .const c
  | .variable, q => q
  | .add a b, q => a.comp q + b.comp q
  | .mul a b, q => a.comp q * b.comp q

@[simp] lemma eval_comp (p q : TimeBound) (n : ℕ) :
    (p.comp q).eval n = p.eval (q.eval n) := by
  induction p <;> simp_all [comp,eval]

/-- These certificates imply an ordinary fixed positive-coefficient, positive-
degree power bound. This prevents any hidden superpolynomial time allowance. -/
theorem growth (p : TimeBound) :
    ∃ C k : ℕ, 0<C ∧ 0<k ∧ ∀ n : ℕ, 1≤n → p.eval n≤C*n^k := by
  induction p with
  | const c =>
    refine ⟨c+1,1,by omega,by omega,?_⟩
    intro n hn
    simp only [eval,pow_one]
    nlinarith only [hn]
  | «variable» => exact ⟨1,1,by omega,by omega,by intro n _; simp [eval]⟩
  | add p q hp hq =>
    obtain ⟨C,k,hC,hk,hp⟩ := hp
    obtain ⟨D,l,hD,hl,hq⟩ := hq
    refine ⟨C+D,k+l,by omega,by omega,?_⟩
    intro n hn
    have hp' := (hp n hn).trans (Nat.mul_le_mul_left C
      (Nat.pow_le_pow_right hn (Nat.le_add_right k l)))
    have hq' := (hq n hn).trans (Nat.mul_le_mul_left D
      (Nat.pow_le_pow_right hn (Nat.le_add_left l k)))
    simpa only [eval,Nat.add_mul] using Nat.add_le_add hp' hq'
  | mul p q hp hq =>
    obtain ⟨C,k,hC,hk,hp⟩ := hp
    obtain ⟨D,l,hD,hl,hq⟩ := hq
    refine ⟨C*D,k+l,Nat.mul_pos hC hD,by omega,?_⟩
    intro n hn
    calc p.eval n*q.eval n ≤ (C*n^k)*(D*n^l) := Nat.mul_le_mul (hp n hn) (hq n hn)
         _ = (C*D)*n^(k+l) := by rw [pow_add]; ac_rfl

end TimeBound
end RationalHitting


/-! Compositional finite-stack implementation. All the constants introduced
here describe actual finite programs, not arithmetic-operation oracles. -/
namespace RationalHitting.StackLanguage
open Function

variable {K L : Type} [DecidableEq K] [DecidableEq L]

def single (k : K) (w : List Bool) : Store K := update (fun _ => []) k w

@[simp] lemma single_self (k : K) (w : List Bool) : single k w k = w := by
  simp [single]
@[simp] lemma single_other {k j : K} (w : List Bool) (h : j≠k) : single k w j = [] := by
  simp [single,h]
@[simp] lemma single_nil (k : K) : single k [] = fun _ => [] := by
  funext j; by_cases h : j=k <;> simp [single,h]

lemma extend_single (f : K → L) (hf : Injective f) (k : K) (w : List Bool) :
    extend f (single k w) (fun _ => []) = single (f k) w := by
  rw [single, extend_update_store f hf]
  congr 1
  funext l
  by_cases h : ∃ a, f a=l
  · obtain ⟨a,rfl⟩ := h; simp [hf.extend_apply]
  · simp [extend_apply' _ _ _ h]

lemma Eval.rename_single {p : Program K} {i o : K} {x y : List Bool} {t : ℕ}
    (h : Eval p (single i x) (single o y) t) (f : K → L) (hf : Injective f) :
    Eval (p.rename f) (single (f i) x) (single (f o) y) t := by
  simpa only [extend_single f hf] using h.rename f hf (fun _ => [])

/-- A quantitative implementation, with completely clean stack input and
output. Both execution and result size are polynomially bounded. -/
structure Procedure {A B : Type} (ca : A → List Bool) (cb : B → List Bool) (f : A → B) where
  Registers : Type
  finite : Fintype Registers
  decEq : DecidableEq Registers
  input : Registers
  output : Registers
  program : @Program Registers
  bound : TimeBound
  correct : ∀ a, ∃ t ≤ bound.eval ((ca a).length+1),
    @Eval Registers decEq program (@single Registers decEq input (ca a))
      (@single Registers decEq output (cb (f a))) t
  size : ∀ a, (cb (f a)).length ≤ bound.eval ((ca a).length+1)

attribute [instance] Procedure.finite Procedure.decEq

/-- A compositional polynomial-time feasibility predicate. -/
def Feasible {A B : Type} (ca : A → List Bool) (cb : B → List Bool) (f : A → B) : Prop :=
  Nonempty (Procedure ca cb f)


/-- Order-preserving transfer, implemented using two stack reversals. -/
def move (a b tmp : K) : Program K := .seq (reverse a tmp) (reverse tmp b)

lemma eval_move {a b tmp : K} (hab : a≠b) (hat : a≠tmp) (hbt : b≠tmp)
    (s : Store K) (hb : s b=[]) (ht : s tmp=[]) :
    Eval (move a b tmp) s (update (update s a []) b (s a)) (4*(s a).length+3) := by
  have h₁ := eval_reverse hat s
  have h₂ := eval_reverse hbt.symm (update (update s a []) tmp ((s a).reverse++s tmp))
  have hh := Eval.seq h₁ h₂
  have he : update (update (update (update s a []) tmp ((s a).reverse++s tmp)) tmp []) b
      (((update (update s a []) tmp ((s a).reverse++s tmp)) tmp).reverse ++
        (update (update s a []) tmp ((s a).reverse++s tmp)) b) =
      update (update s a []) b (s a) := by
    funext j
    by_cases hja : j=a <;> by_cases hjb : j=b <;> by_cases hjt : j=tmp <;>
      simp_all
  rw [he] at hh
  convert hh using 1 <;> simp [move,ht]; omega

lemma Eval.move_single {a b tmp : K} (hab : a≠b) (hat : a≠tmp) (hbt : b≠tmp)
    (w : List Bool) :
    Eval (move a b tmp) (single a w) (single b w) (4*w.length+3) := by
  have h := eval_move hab hat hbt (single a w) (by simp [hab.symm]) (by simp [hat.symm])
  have he : update (update (single a w) a []) b w=single b w := by
    simp [single,update_idem]
  simpa only [single_self,he] using h

/-- Run in an embedded register bank, preserving every register outside it. -/
lemma Eval.runAt {p : Program K} {i o : K} {x y : List Bool} {t : ℕ}
    (h : Eval p (single i x) (single o y) t) (f : K → L) (hf : Injective f)
    (s : Store L) (hs : ∀ k, s (f k)=single i x k) :
    Eval (p.rename f) s (update (update s (f i) []) (f o) y) t := by
  have hi : (fun k => s (f k))=single i x := funext hs
  have he : extend f (fun _ => []) s=update s (f i) [] := by
    funext l
    by_cases hl : ∃ k, f k=l
    · obtain ⟨k,rfl⟩ := hl
      rw [hf.extend_apply]
      by_cases hk : k=i
      · subst k; simp
      · simp [update_of_ne (fun hh => hk (hf hh)),hs,single,hk]
    · have hn : l≠f i := fun hh => hl ⟨i,hh.symm⟩
      simp [extend_apply' _ _ _ hl,hn]
  have hh := eval_rename_from f hf s (hi.symm ▸ h)
  simpa only [single,extend_update_store f hf,he] using hh

namespace Procedure
variable {A B C : Type} {ca : A → List Bool} {cb : B → List Bool} {cc : C → List Bool}
  {f : A → B} {g : B → C}

/-- Identity has no operation of unbounded cost. -/
def identity (ca : A → List Bool) : Procedure ca ca id where
  Registers := Unit
  finite := inferInstance
  decEq := inferInstance
  input := ()
  output := ()
  program := .skip
  bound := TimeBound.variable+1
  correct a := ⟨1,by simp,Eval.skip _⟩
  size a := by simp; omega

/-- Composition uses disjoint scratch banks and an actual order-preserving
stack transfer. -/
def comp (q : Procedure cb cc g) (p : Procedure ca cb f) : Procedure ca cc (g ∘ f) where
  Registers := p.Registers ⊕ (q.Registers ⊕ Unit)
  finite := inferInstance
  decEq := inferInstance
  input := Sum.inl p.input
  output := Sum.inr (Sum.inl q.output)
  program := .seq (p.program.rename Sum.inl)
    (.seq (move (Sum.inl p.output) (Sum.inr (Sum.inl q.input)) (Sum.inr (Sum.inr ())))
      (q.program.rename (Sum.inr ∘ Sum.inl)))
  bound := 5*p.bound + q.bound.comp (p.bound+1) + 5
  correct a := by
    obtain ⟨t,ht,he⟩ := p.correct a
    obtain ⟨u,hu,hq⟩ := q.correct (f a)
    refine ⟨1+t+(1+(4*(cb (f a)).length+3)+u),?_,?_⟩
    · have hsize := p.size a
      have hu' := hu.trans (q.bound.monotone (Nat.add_le_add_right hsize 1))
      simp only [TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,TimeBound.eval_comp] at *
      omega
    · exact Eval.seq (he.rename_single Sum.inl Sum.inl_injective)
        (Eval.seq (Eval.move_single (by simp) (by simp) (by simp) _)
          (hq.rename_single (Sum.inr ∘ Sum.inl) (Sum.inr_injective.comp Sum.inl_injective)))
  size a := by
    have hs := (q.size (f a)).trans (q.bound.monotone (Nat.add_le_add_right (p.size a) 1))
    simp only [comp_apply,TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,TimeBound.eval_comp]
    omega

/-- Reinterpret equal input/output words, with no additional computation. -/
def recode {A' B' : Type} (p : Procedure ca cb f) (ca' : A' → List Bool)
    (cb' : B' → List Bool) (f' : A' → B') (e : A' → A)
    (hi : ∀ a, ca (e a)=ca' a) (ho : ∀ a, cb (f (e a))=cb' (f' a)) :
    Procedure ca' cb' f' where
  Registers := p.Registers
  finite := p.finite
  decEq := p.decEq
  input := p.input
  output := p.output
  program := p.program
  bound := p.bound
  correct a := by
    obtain ⟨t,ht,he⟩ := p.correct (e a)
    rw [hi,ho] at he
    rw [hi] at ht
    exact ⟨t,ht,he⟩
  size a := by simpa only [hi,ho] using p.size (e a)


end Procedure
end RationalHitting.StackLanguage

end OAI