import OAI.ModelTheory.Choiceless.LowerBound

namespace OAI

namespace CPTSeparation.FullCPT

noncomputable section

open Classical Hereditary Finset

open Operational (State Control Location Update)

attribute [local instance] CPTSeparation.FullCPT.instDecidableEqHF

variable {A R F : Type} {arity : F → ℕ}

def bindSlots {k : ℕ} (slots : ℕ → Option (Fin k)) (name : ℕ) : ℕ → Option (Fin (k+1)) :=
  fun x => if x = name then some 0 else (slots x).map Fin.succ

def Agrees {k : ℕ} (slots : ℕ → Option (Fin k)) (env : ℕ → HF A)
    (values : Fin k → HF A) : Prop :=
  ∀ x, env x = (slots x).elim Operational.empty values

lemma agrees_bind {k : ℕ} {slots : ℕ → Option (Fin k)} {env : ℕ → HF A}
    {values : Fin k → HF A} (h : Agrees slots env values) (name : ℕ) (x : HF A) :
    Agrees (bindSlots slots name) (Function.update env name x) (Fin.cons x values) := by
  intro y
  by_cases he : y = name
  · subst y
    simp [bindSlots]
  · rw [Function.update_of_ne he]
    rw [h y]
    simp only [bindSlots, ite_eq_right he]
    cases slots y <;> rfl

namespace Term

def compile : Term R F arity → {k : ℕ} → (ℕ → Option (Fin k)) → Operational.Term R F arity k
  | .var n, _, slots => match slots n with
      | none => .constant 0
      | some i => .var i
  | .ordinal n, _, _ => .constant n
  | .atoms, _, _ => .atoms
  | .app f args, _, slots => .app f (fun i => compile (args i) slots)
  | .pair a b, _, slots => .pair (compile a slots) (compile b slots)
  | .union a, _, slots => .union (compile a slots)
  | .unique a, _, slots => .unique (compile a slots)
  | .card a, _, slots => .card (compile a slots)
  | .equal a b, _, slots => .equal (compile a slots) (compile b slots)
  | .member a b, _, slots => .member (compile a slots) (compile b slots)
  | .isAtom a, _, slots => .isAtom (compile a slots)
  | .input r a b, _, slots => .input r (compile a slots) (compile b slots)
  | .not a, _, slots => .not (compile a slots)
  | .and a b, _, slots => .and (compile a slots) (compile b slots)
  | .or a b, _, slots => .not (.and (.not (compile a slots)) (.not (compile b slots)))
  | .conditional c a b, _, slots => .conditional (compile c slots) (compile a slots) (compile b slots)
  | .comprehend n bound guard body, _, slots =>
      .comprehension (compile bound slots) (compile guard (bindSlots slots n))
        (compile body (bindSlots slots n))

theorem eval_compile [Fintype A] (rel : R → A → A → Bool) (s : State F arity A)
    (t : Term R F arity) {k : ℕ} (slots : ℕ → Option (Fin k))
    (env : ℕ → HF A) (values : Fin k → HF A) (h : Agrees slots env values) :
    (t.compile slots).eval rel s values = t.eval rel s env := by
  induction t generalizing k env with
  | var n =>
      simp only [compile, eval]
      rw [h n]
      cases slots n <;> rfl
  | ordinal n => rfl
  | atoms => rfl
  | app f args ih =>
      simp only [compile, Operational.Term.eval, eval]
      congr 2
      funext i
      exact ih i slots env values h
  | pair a b iha ihb => simp only [compile, Operational.Term.eval, eval, iha slots env values h, ihb slots env values h]
  | union a ih => simp only [compile, Operational.Term.eval, eval, ih slots env values h]
  | unique a ih => simp only [compile, Operational.Term.eval, eval, ih slots env values h]
  | card a ih => simp only [compile, Operational.Term.eval, eval, ih slots env values h]
  | equal a b iha ihb => simp only [compile, Operational.Term.eval, eval, iha slots env values h, ihb slots env values h]
  | member a b iha ihb => simp only [compile, Operational.Term.eval, eval, iha slots env values h, ihb slots env values h]
  | isAtom a ih => simp only [compile, Operational.Term.eval, eval, ih slots env values h]
  | input r a b iha ihb => simp only [compile, Operational.Term.eval, eval, iha slots env values h, ihb slots env values h]
  | not a ih => simp only [compile, Operational.Term.eval, eval, ih slots env values h]
  | and a b iha ihb => simp only [compile, Operational.Term.eval, eval, iha slots env values h, ihb slots env values h]
  | or a b iha ihb =>
      simp only [compile, Operational.Term.eval, eval, iha slots env values h, ihb slots env values h]
      simp only [ne_eq, Operational.boolean_truth, not_and_or, not_not]
  | conditional c a b ihc iha ihb =>
      simp only [compile, Operational.Term.eval, eval, ihc slots env values h, iha slots env values h, ihb slots env values h]
  | comprehend n bound guard body ihbound ihguard ihbody =>
      simp only [compile, Operational.Term.eval, eval, ihbound slots env values h]
      have hg : (fun x => Operational.Term.eval rel s (guard.compile (bindSlots slots n)) (Fin.cons x values)) =
          (fun x => eval rel s guard (Function.update env n x)) := by
        funext x
        exact ihguard _ _ _ (agrees_bind h n x)
      have hb : (fun x => Operational.Term.eval rel s (body.compile (bindSlots slots n)) (Fin.cons x values)) =
          (fun x => eval rel s body (Function.update env n x)) := by
        funext x
        exact ihbody _ _ _ (agrees_bind h n x)
      have hg' (x : HF A) := congrFun hg x
      simp only [hg', hb]

end Term

namespace Rule

def compile : Rule R F arity → {k : ℕ} → (ℕ → Option (Fin k)) → Operational.Rule R F arity k
  | .skip, _, _ => .skip
  | .update f args value, _, slots => .update f (fun i => (args i).compile slots) (value.compile slots)
  | .parallel a b, _, slots => .parallel (compile a slots) (compile b slots)
  | .conditional c a b, _, slots => .conditional (c.compile slots) (compile a slots) (compile b slots)
  | .forall n bound body, _, slots => .forall (bound.compile slots) (compile body (bindSlots slots n))
  | .letValue n value body, _, slots => .letValue (value.compile slots) (compile body (bindSlots slots n))

theorem updates_compile [Fintype A] (rel : R → A → A → Bool) (s : State F arity A)
    (r : Rule R F arity) {k : ℕ} (slots : ℕ → Option (Fin k))
    (env : ℕ → HF A) (values : Fin k → HF A) (h : Agrees slots env values) :
    (r.compile slots).updates rel s values = r.updates rel s env := by
  induction r generalizing k env with
  | skip => rfl
  | update f args v =>
      simp only [compile, Operational.Rule.updates, updates, Term.eval_compile rel s _ _ _ _ h]
  | parallel a b iha ihb =>
      simp only [compile, Operational.Rule.updates, updates, iha slots env values h, ihb slots env values h]
  | conditional c a b iha ihb =>
      simp only [compile, Operational.Rule.updates, updates, Term.eval_compile rel s _ _ _ _ h,
        iha slots env values h, ihb slots env values h]
  | «forall» n bound body ih =>
      simp only [compile, Operational.Rule.updates, updates, Term.eval_compile rel s _ _ _ _ h]
      congr 1
      funext x
      exact ih _ _ _ (agrees_bind h n x)
  | letValue n value body ih =>
      simp only [compile, Operational.Rule.updates, updates, Term.eval_compile rel s _ _ _ _ h]
      exact ih _ _ _ (agrees_bind h n (value.eval rel s env))

end Rule

namespace Program

variable (P : Program R) [finiteA : Fintype A]

def accepts (time space : Polynomial ℕ) (rel : R → A → A → Bool) : Prop :=
  ∃ h st, h ≤ time.eval (Fintype.card A) ∧ P.run rel h = some st ∧ P.flag st .halt ∧ P.flag st .accept ∧
    (P.active rel h).card ≤ space.eval (Fintype.card A)

def compile : Operational.Machine R where
  Functions := P.Functions
  finiteFunctions := P.finiteFunctions
  arity := P.arity
  rule := P.body.compile (fun _ => none)

omit A R P in
lemma flag_compile
    {A : Type}
    {R : Type}
    (P : FullCPT.Program R)
    [Fintype A] (s : P.Store (A := A)) (c : Control) : P.compile.flag s c = P.flag s c := rfl

lemma step_compile (rel : R → A → A → Bool) (s : P.Store (A := A)) :
    P.compile.step rel s = P.step rel s := by
  change (if P.flag s .halt then some s else
    let u := (P.body.compile (fun _ => none)).updates rel s Fin.elim0
    if State.Consistent u then some (s.applyUpdates u) else none) = _
  have hu := Rule.updates_compile rel s P.body (fun _ => none)
    (fun _ => Operational.empty) Fin.elim0 (fun _ => rfl)
  dsimp only
  rw [hu]
  rfl

lemma run_compile (rel : R → A → A → Bool) (h : ℕ) :
    P.compile.run rel h = P.run rel h := by
  induction h with
  | zero => rfl
  | succ h ih =>
      simp only [Operational.Machine.run, run, ih]
      congr 1
      funext s
      exact P.step_compile rel s

lemma active_compile (rel : R → A → A → Bool) (h : ℕ) :
    P.compile.runActive rel h = P.active rel h := by
  unfold Operational.Machine.runActive active
  simp only [P.run_compile]
  congr 1
  funext j
  cases P.run rel j <;> simp ; rfl

lemma accepts_compile (time space : Polynomial ℕ) (rel : R → A → A → Bool) :
    P.compile.polynomialCumulativeAccepts time space rel ↔ P.accepts time space rel := by
  simp only [Operational.Machine.polynomialCumulativeAccepts, Operational.Machine.cumulativeAccepts,
    accepts, P.run_compile, Operational.Machine.flag, flag, P.active_compile]
  rfl

end Program

def Definable (Q : ∀ {A : Type}, [Fintype A] → Input A → Prop) : Prop :=
  ∃ P : Program Symbol, ∃ time space : Polynomial ℕ,
    ∀ (A : Type) [Fintype A] (I : Input A), P.accepts time space I.rel ↔ Q I

theorem query_not_definable : ¬ Definable (fun {_} [_] I => I.query) := by
  rintro ⟨P, time, space, h⟩
  apply query_not_polynomial_cumulative_HF
  refine ⟨P.compile, time, space, ?_⟩
  intro A inst I
  exact (P.accepts_compile time space I.rel).trans (h A I)

end

end CPTSeparation.FullCPT

end OAI