import OAI.Computability.DegreeRigidity.OrdinalCodes.NumericDefSystem
import OAI.Computability.DegreeRigidity.Constructibility.DomainSyntaxClosure

namespace OAI

namespace TuringRigidity.NumericSyntax
open ElementaryModel BoundedSetTheory TransitiveNameModel BoundedDefinability
universe u

def Domain (P : ZFSet.{u} → (ℕ → ZFSet.{u}) → Prop) : Prop :=
  ∃ p : SentenceForm, ∀ B, Covers B → ∀ N : ZFSet.{u}, Transitive N →
    (∀ i, params B i ∈ N) → ∀ e, (∀ i, e i ∈ N) →
      (p.Sat (N : Set ZFSet) (mix e (params B)) ↔ P N e)

variable {P Q : ZFSet.{u} → (ℕ → ZFSet.{u}) → Prop}

theorem Numeric.toDomain {P : (ℕ → ZFSet.{u}) → Prop} (h : Numeric P) :
    Domain (fun _ e => P e) := by
  obtain ⟨p,hp⟩ := h
  refine ⟨fromBounded p,?_⟩
  intro B hB N hN hd e he
  rw [bounded_sat,Formula.absolute p N hN _ (by
    intro i; unfold mix; split <;> first | exact he _ | exact hd _)]
  exact hp B hB e

theorem Domain.congr (h : Domain P) (he : ∀ N e, P N e ↔ Q N e) : Domain Q := by
  obtain ⟨p,hp⟩ := h
  exact ⟨p,fun B hB N hN hd e he' => (hp B hB N hN hd e he').trans (he N e)⟩

theorem Domain.and (h : Domain P) (k : Domain Q) : Domain (fun N e => P N e ∧ Q N e) := by
  obtain ⟨p,hp⟩ := h; obtain ⟨q,hq⟩ := k
  exact ⟨.conj p q,fun B hB N hN hd e he =>
    and_congr (hp B hB N hN hd e he) (hq B hB N hN hd e he)⟩

theorem Domain.neg (h : Domain P) : Domain (fun N e => ¬ P N e) := by
  obtain ⟨p,hp⟩ := h
  exact ⟨.neg p,fun B hB N hN hd e he => not_congr (hp B hB N hN hd e he)⟩

theorem Domain.imp (h : Domain P) (k : Domain Q) : Domain (fun N e => P N e → Q N e) :=
  (h.and k.neg).neg.congr (fun _ _ => by tauto)

theorem Domain.subst (h : Domain P) (r : ℕ → ℕ) : Domain (fun N e => P N (e ∘ r)) := by
  obtain ⟨p,hp⟩ := h
  refine ⟨p.rename (slotMap r id),?_⟩
  intro B hB N hN hd e he
  rw [SentenceForm.sat_rename]
  change p.Sat _ (mix e (params B) ∘ slotMap r id) ↔ _
  rw [mix_slotMap,Function.comp_id]
  exact hp B hB N hN hd (e ∘ r) (fun i => he (r i))

theorem Domain.existsSet (h : Domain P) : Domain (fun N e => ∃ x ∈ N, P N (cons x e)) := by
  obtain ⟨p,hp⟩ := h
  refine ⟨.ex (p.rename bindSlots),?_⟩
  intro B hB N hN hd e he
  change (∃ x ∈ N, (p.rename bindSlots).Sat _ (cons x (mix e (params B)))) ↔ _
  apply exists_congr; intro x
  apply and_congr_right; intro hx
  rw [SentenceForm.sat_rename]
  change p.Sat _ (cons x (mix e (params B)) ∘ bindSlots) ↔ _
  rw [bind_mix]
  exact hp B hB N hN hd (cons x e) (by intro i; cases i; exact hx; exact he _)

theorem Domain.allMem (h : Domain P) (a : ℕ) : Domain (fun N e => ∀ x ∈ e a, P N (cons x e)) := by
  obtain ⟨p,hp⟩ := ((member_definable 0 (a+1)).toDomain.and h.neg).existsSet.neg
  refine ⟨p,?_⟩
  intro B hB N hN hd e he
  rw [hp B hB N hN hd e he]
  change (¬ ∃ x ∈ N, x ∈ e a ∧ ¬ P N (cons x e)) ↔ _
  classical
  constructor
  · intro h x hx
    by_contra hn
    exact h ⟨x,hN _ (he a) x hx,hx,hn⟩
  · intro h ⟨x,_,hx,hn⟩
    exact hn (h x hx)

theorem powerBound_domain (a q : ℕ) : Domain (fun N e => RelativeConstructible.PowerBound N (e a) (e q)) := by
  refine ⟨FullSetForcing.ownPower (2*a) (2*q),?_⟩
  intro B hB N hN hd e he
  rw [FullSetForcing.ownPower_spec N hN _ _ _ (by
    intro i; unfold mix; split <;> first | exact he _ | exact hd _)]
  simp only [mix_even,RelativeConstructible.PowerBound]

end TuringRigidity.NumericSyntax

end OAI