import OAI.Computability.DegreeRigidity.Syntax.BoundedSupport

namespace OAI


namespace TuringRigidity.BoundedForcing
open RecursiveNames TransitiveNameModel BoundedSetTheory AtomicForcing
universe u

namespace CertificateCode

def slots : ℕ → ℕ → (ℕ → ℕ) → Formula
  | 0, d, _v => .equal d d
  | n+1, d, v => .conj (slots n d v) (.member (v n) d)

theorem eval_slots (n d : ℕ) (v : ℕ → ℕ) (env : ℕ → ZFSet.{u}) :
    (slots n d v).Eval env ↔ ∀ i, i < n → env (v i) ∈ env d := by
  induction n with
  | zero => simp [slots,Formula.Eval]
  | succ n ih =>
    simp only [slots,Formula.Eval,ih]
    constructor
    · rintro ⟨h,hlast⟩ i hi
      rcases Nat.lt_succ_iff_lt_or_eq.mp hi with hi|rfl
      · exact h i hi
      · exact hlast
    · intro h; exact ⟨fun i hi => h i (by omega),h n (by omega)⟩

def matrix (φ : Formula) (ci oi pi : ℕ) (v : ℕ → ℕ) : Formula :=
  .conj (.transitive 2) (.conj (AtomicFormula.product 2 1)
    (.conj (AtomicFormula.graph 2 (ci+3) 1 (oi+3) 0)
      (.conj (slots (bound φ+1) 2 (fun i => v i+3))
        (code φ 2 (ci+3) 1 (oi+3) 0
          (fun i => truncate (bound φ+1) v i+3) (pi+3)))))

def certificate (φ : Formula) (ci oi pi : ℕ) (v : ℕ → ℕ) : SigmaFormula :=
  .existsSet (.existsSet (.existsSet (.bounded (matrix φ ci oi pi v))))
end CertificateCode

variable {c : ZFSet.{u}} [Preorder (Conditions c)]

theorem eval_certificate_matrix (φ : Formula) (d k f o : ZFSet.{u})
    (ho : ∀ r s : Conditions c, ZFSet.pair (label c r) (label c s) ∈ o ↔ r ≤ s)
    (e : ℕ → Name (Conditions c)) (p : Conditions c)
    (env : ℕ → ZFSet.{u}) (ci oi pi : ℕ) (v : ℕ → ℕ)
    (hc : env ci = c) (ho' : env oi = o) (hp : env pi = label c p)
    (hv : ∀ i, env (v i) = (e i).encode (label c)) :
    (CertificateCode.matrix φ ci oi pi v).Eval (cons f (cons k (cons d env))) ↔
      Transitive d ∧ k = ZFSet.prod d d ∧ Graph d c o f ∧
        (∀ i, i < bound φ+1 → (e i).encode (label c) ∈ d) ∧ Forces e φ p := by
  have query (hd : Transitive d) (hk : k = ZFSet.prod d d) (hf : Graph d c o f)
      (hs : ∀ i, i < bound φ+1 → (e i).encode (label c) ∈ d) :
      (code φ 2 (ci+3) 1 (oi+3) 0
        (fun i => truncate (bound φ+1) v i+3) (pi+3)).Eval
          (cons f (cons k (cons d env))) ↔ Forces e φ p := by
    let e' := truncate (bound φ+1) e
    have he' (i) : (e' i).encode (label c) ∈ d := by
      dsimp only [e',truncate]
      split
      · exact hs i (by assumption)
      · exact hs 0 (by omega)
    have ht (i) : env (truncate (bound φ+1) v i) = (e' i).encode (label c) := by
      dsimp only [e',truncate]
      split <;> exact hv _
    exact (eval_code φ hd ho hf e' he' p (cons f (cons k (cons d env)))
      2 (ci+3) 1 (oi+3) 0 (fun i => truncate (bound φ+1) v i+3) (pi+3)
      ⟨rfl,hc,hk,ho',rfl,hp⟩ ht).trans
      (forces_congr φ e' e (fun i hi => ite_eq_left (by omega)) p)
  simp only [CertificateCode.matrix,Formula.Eval,Formula.eval_transitive,
    AtomicFormula.eval_product,CertificateCode.eval_slots,cons_zero,cons_succ,hv]
  constructor
  · rintro ⟨hd,hk,hgraph,hs,hquery⟩
    have hf : Graph d c o f := by
      have h := (AtomicFormula.eval_graph 2 (ci+3) 1 (oi+3) 0 _ hk).mp hgraph
      simpa only [cons_zero,cons_succ,hc,ho'] using h
    exact ⟨hd,hk,hf,hs,(query hd hk hf hs).mp hquery⟩
  · rintro ⟨hd,hk,hf,hs,hq⟩
    refine ⟨hd,hk,?_,hs,(query hd hk hf hs).mpr hq⟩
    apply (AtomicFormula.eval_graph 2 (ci+3) 1 (oi+3) 0 _ hk).mpr
    simpa only [cons_zero,cons_succ,hc,ho'] using hf

theorem realize_boundedCertificate (M : ZFSet.{u}) (hM : Transitive M)
    (hP : Pairing M) (hU : BoundedSetTheory.Union M) (hPow : PowerSet M)
    (hS : Separation M) (hR : SigmaReplacement M) (hI : Infinity M)
    {o : ZFSet.{u}}
    (ho : ∀ r s : Conditions c, ZFSet.pair (label c r) (label c s) ∈ o ↔ r ≤ s)
    (φ : Formula) (e : ℕ → Name (Conditions c)) (p : Conditions c)
    (env : ℕ → ZFSet.{u}) (henv : ∀ i, env i ∈ M)
    (ci oi pi : ℕ) (v : ℕ → ℕ)
    (hc : env ci = c) (ho' : env oi = o) (hp : env pi = label c p)
    (hv : ∀ i, env (v i) = (e i).encode (label c)) :
    (CertificateCode.certificate φ ci oi pi v).Realize M env ↔ Forces e φ p := by
  have matrix (d k f : ZFSet.{u}) (hd : d ∈ M) (hk : k ∈ M) (hf : f ∈ M) :=
    (Formula.absolute (CertificateCode.matrix φ ci oi pi v) M hM
      (cons f (cons k (cons d env))) (by
        intro i; rcases i with _|i; exact hf
        rcases i with _|i; exact hk
        rcases i with _|i; exact hd
        exact henv i)).trans (eval_certificate_matrix φ d k f o ho e p env ci oi pi v hc ho' hp hv)
  change (∃ d ∈ M, ∃ k ∈ M, ∃ f ∈ M, _) ↔ _
  constructor
  · rintro ⟨d,hd,k,hk,f,hf,hm⟩
    exact ((matrix d k f hd hk hf).mp hm).2.2.2.2
  · intro hforce
    have he (i) : (e i).encode (label c) ∈ M := hv i ▸ henv (v i)
    obtain ⟨d,hd,hdT,_,hs⟩ := finite_container M hM hP hU hS hR hI
      (fun i => (e i).encode (label c)) he (bound φ+1)
    have hk := product_mem M hM hP hU hPow hS hd hd
    obtain ⟨f,hf,hfG⟩ := internal_atomic_graph M hM hP hU hPow hS hd
      (hc ▸ henv ci) (ho' ▸ henv oi)
    exact ⟨d,hd,_,hk,f,hf,(matrix d _ f hd hk hf).mpr ⟨hdT,rfl,hfG,hs,hforce⟩⟩

end TuringRigidity.BoundedForcing

end OAI