import OAI.Computability.DegreeRigidity.Syntax.AtomicTruth
import OAI.Computability.DegreeRigidity.Syntax.BoundedRelations

namespace OAI

namespace TuringRigidity.BoundedForcing
open Set RecursiveNames CountableForcing AtomicForcing
open BoundedSetTheory (Formula)
universe u
variable {P : Type u} [Preorder P]

def push {α : Sort*} (x : α) (e : ℕ → α) : ℕ → α
  | 0 => x
  | n+1 => e n

@[simp] theorem push_zero {α : Sort*} (x : α) (e : ℕ → α) : push x e 0 = x := rfl
@[simp] theorem push_succ {α : Sort*} (x : α) (e : ℕ → α) (n : ℕ) : push x e (n+1) = e n := rfl

omit [Preorder P] in
theorem child_relation (a : Name P) (i : a.arity) : Name.Child (a.child i) a := by
  cases a
  exact ⟨i,rfl⟩

def Forces (e : ℕ → Name P) : Formula → P → Prop
  | .equal i j, p => EqForces (e i) (e j) p
  | .member i j, p => MemForces (e i) (e j) p
  | .conj φ ψ, p => Forces e φ p ∧ Forces e ψ p
  | .neg φ, p => ∀ q, q ≤ p → ¬ Forces e φ q
  | .existsMem i φ, p => ∃ j, p ≤ (e i).tag j ∧ Forces (push ((e i).child j) e) φ p

theorem forces_mono (φ : Formula) (e : ℕ → Name P) {p q : P} (hqp : q ≤ p)
    (h : Forces e φ p) : Forces e φ q := by
  induction φ generalizing e with
  | equal i j => exact eq_mono _ _ hqp h
  | member i j => exact mem_mono _ _ hqp h
  | conj φ ψ ihφ ihψ => exact ⟨ihφ e h.1,ihψ e h.2⟩
  | neg φ ih => exact fun r hr => h r (hr.trans hqp)
  | existsMem i φ ih =>
    obtain ⟨j,hj,hf⟩ := h
    exact ⟨j,hqp.trans hj,ih _ hf⟩

def Decision (e : ℕ → Name P) (φ : Formula) : Set P := {p | Forces e φ p ∨ Forces e (.neg φ) p}

theorem decision_dense (e : ℕ → Name P) (φ : Formula) : Dense (Decision e φ) := by
  classical
  intro p
  by_cases h : ∃ q, q ≤ p ∧ Forces e φ q
  · obtain ⟨q,hq,hf⟩ := h
    exact ⟨q,hq,Or.inl hf⟩
  · exact ⟨p,le_rfl,Or.inr (fun q hq hf => h ⟨q,hq,hf⟩)⟩

def Generic (N : Set (Name P)) (G : GenericFilter P) : Prop :=
  ∀ φ e, (∀ i, e i ∈ N) → ∃ p ∈ G.carrier, p ∈ Decision e φ

theorem truth {N : Set (Name P)} (hN : ChildClosed N) (G : GenericFilter P)
    (hA : AtomicForcing.Generic N G) (hG : Generic N G) (φ : Formula)
    (e : ℕ → Name P) (he : ∀ i, e i ∈ N) :
    φ.Eval (fun i => (e i).val G.carrier) ↔ ∃ p ∈ G.carrier, Forces e φ p := by
  induction φ generalizing e with
  | equal i j => exact eq_truth hN G hA _ _ (he i) (he j)
  | member i j => exact mem_truth hN G hA _ _ (he i) (he j)
  | conj φ ψ ihφ ihψ =>
    constructor
    · rintro ⟨hφ,hψ⟩
      obtain ⟨p,hp,hfp⟩ := (ihφ e he).mp hφ
      obtain ⟨q,hq,hfq⟩ := (ihψ e he).mp hψ
      obtain ⟨r,hr,hrp,hrq⟩ := G.directed hp hq
      exact ⟨r,hr,forces_mono φ e hrp hfp,forces_mono ψ e hrq hfq⟩
    · rintro ⟨p,hp,hφ,hψ⟩
      exact ⟨(ihφ e he).mpr ⟨p,hp,hφ⟩,(ihψ e he).mpr ⟨p,hp,hψ⟩⟩
  | neg φ ih =>
    constructor
    · intro hn
      obtain ⟨p,hp,hf | hf⟩ := hG φ e he
      · exact False.elim (hn ((ih e he).mpr ⟨p,hp,hf⟩))
      · exact ⟨p,hp,hf⟩
    · rintro ⟨p,hp,hn⟩ hv
      obtain ⟨q,hq,hf⟩ := (ih e he).mp hv
      obtain ⟨r,hr,hrp,hrq⟩ := G.directed hp hq
      exact hn r hrp (forces_mono φ e hrq hf)
  | existsMem i φ ih =>
    have hej (j) : ∀ n, push ((e i).child j) e n ∈ N := by
      intro n
      cases n with
      | zero =>
        exact hN (e i) (he i) _ (child_relation (e i) j)
      | succ n => exact he n
    have env (j) : (fun n => (push ((e i).child j) e n).val G.carrier) =
        BoundedSetTheory.cons ((e i).child j |>.val G.carrier) (fun n => (e n).val G.carrier) := by
      funext n
      cases n <;> rfl
    constructor
    · rintro ⟨x,hx,hφ⟩
      obtain ⟨j,hj,hxj⟩ := ((e i).mem_val_children G.carrier x).mp hx
      subst x
      rw [←env j] at hφ
      obtain ⟨p,hp,hf⟩ := (ih _ (hej j)).mp hφ
      obtain ⟨q,hq,hqp,hqj⟩ := G.directed hp hj
      exact ⟨q,hq,j,hqj,forces_mono φ _ hqp hf⟩
    · rintro ⟨p,hp,j,hj,hf⟩
      refine ⟨_,((e i).mem_val_children G.carrier _).mpr ⟨j,G.upper hj hp,rfl⟩,?_⟩
      rw [←env j]
      exact (ih _ (hej j)).mpr ⟨p,hp,hf⟩

end TuringRigidity.BoundedForcing

end OAI