import Mathlib

namespace OAI

namespace PartitionPilot.Forcing

universe u

inductive SetFormula : Nat → Type
  | equal {n} : Fin n → Fin n → SetFormula n
  | mem {n} : Fin n → Fin n → SetFormula n
  | neg {n} : SetFormula n → SetFormula n
  | conj {n} : SetFormula n → SetFormula n → SetFormula n
  | all {n} : SetFormula (n + 1) → SetFormula n

namespace SetFormula

def extend {A : Type u} {n : Nat} (x : A) (env : Fin n → A) : Fin (n + 1) → A :=
  Fin.cases x env

def Realize (U : Set ZFSet.{u}) : {n : Nat} → SetFormula n → (Fin n → ZFSet.{u}) → Prop
  | _, .equal i j, env => env i = env j
  | _, .mem i j, env => env i ∈ env j
  | _, .neg φ, env => ¬ Realize U φ env
  | _, .conj φ ψ, env => Realize U φ env ∧ Realize U ψ env
  | _, .all φ, env => ∀ x ∈ U, Realize U φ (extend x env)

def ex {n : Nat} (φ : SetFormula (n + 1)) : SetFormula n := .neg (.all (.neg φ))

def disj {n : Nat} (φ ψ : SetFormula n) : SetFormula n := .neg (.conj (.neg φ) (.neg ψ))

def imp {n : Nat} (φ ψ : SetFormula n) : SetFormula n := .neg (.conj φ (.neg ψ))

end SetFormula

inductive BoundedFormula : Nat → Type
  | equal {n} : Fin n → Fin n → BoundedFormula n
  | mem {n} : Fin n → Fin n → BoundedFormula n
  | neg {n} : BoundedFormula n → BoundedFormula n
  | conj {n} : BoundedFormula n → BoundedFormula n → BoundedFormula n
  | allMem {n} : Fin n → BoundedFormula (n + 1) → BoundedFormula n

namespace BoundedFormula

open SetFormula

def imp {n} (φ ψ : BoundedFormula n) : BoundedFormula n := .neg (.conj φ (.neg ψ))

def disj {n} (φ ψ : BoundedFormula n) : BoundedFormula n := .neg (.conj (.neg φ) (.neg ψ))

def exMem {n} (b : Fin n) (φ : BoundedFormula (n + 1)) : BoundedFormula n :=
  .neg (.allMem b (.neg φ))

def toFormula : {n : Nat} → BoundedFormula n → SetFormula n
  | _, .equal i j => .equal i j
  | _, .mem i j => .mem i j
  | _, .neg φ => .neg φ.toFormula
  | _, .conj φ ψ => .conj φ.toFormula ψ.toFormula
  | _, .allMem b φ => .all (SetFormula.imp (.mem 0 b.succ) φ.toFormula)

def singletonFormula {n} (z x : Fin n) : BoundedFormula n :=
  .conj (.mem x z) (.allMem z (.equal 0 x.succ))

def unorderedPairFormula {n} (z x y : Fin n) : BoundedFormula n :=
  .conj (.mem x z) (.conj (.mem y z) (.allMem z (disj (.equal 0 x.succ) (.equal 0 y.succ))))

def orderedPairFormula {n} (z x y : Fin n) : BoundedFormula n :=
  exMem z (.conj (singletonFormula 0 x.succ)
    (exMem z.succ (.conj (unorderedPairFormula 0 x.succ.succ y.succ.succ)
      (unorderedPairFormula z.succ.succ 1 0))))

def pairMembershipFormula {n} (x y r : Fin n) : BoundedFormula n :=
  exMem r (orderedPairFormula 0 x.succ y.succ)

def relationBetweenFormula {n} (a b f : Fin n) : BoundedFormula n :=
  .allMem f (exMem a.succ (exMem b.succ.succ (orderedPairFormula 2 1 0)))

def functionFormula {n} (a b f : Fin n) : BoundedFormula n :=
  .conj (relationBetweenFormula a b f)
    (.allMem a (exMem b.succ (.conj (pairMembershipFormula 1 0 f.succ.succ)
      (.allMem b.succ.succ (imp (pairMembershipFormula 2 0 f.succ.succ.succ) (.equal 0 1))))))

def nonemptyFormula {n} (x : Fin n) : BoundedFormula n := exMem x (.equal 0 0)

def choiceFunctionFormula {n} (a f : Fin n) : BoundedFormula n :=
  .conj (.allMem f (exMem a.succ (exMem 0 (orderedPairFormula 2 1 0))))
    (.allMem a (exMem 0 (.conj (pairMembershipFormula 1 0 f.succ.succ)
      (.allMem 1 (imp (pairMembershipFormula 2 0 f.succ.succ.succ) (.equal 0 1))))))

end BoundedFormula

structure TransitiveGround where
  sets : Set ZFSet.{u}
  transitive : ∀ {x y}, x ∈ sets → y ∈ x → y ∈ sets

structure InjectionCode (D N f : ZFSet.{u}) : Prop where
  function : ZFSet.IsFunc D N f
  injective : ∀ x y z, ZFSet.pair x z ∈ f → ZFSet.pair y z ∈ f → x = y

namespace TransitiveGround

open SetFormula

variable (M : TransitiveGround.{u})

def groundEmbeddable (D N : ZFSet.{u}) : Prop := ∃ f ∈ M.sets, InjectionCode D N f

end TransitiveGround

def setTransitive (x : ZFSet.{u}) : Prop := ∀ y ∈ x, ∀ z ∈ y, z ∈ x

def ordinalSetProperty (x : ZFSet.{u}) : Prop :=
  setTransitive x ∧ ∀ y ∈ x, setTransitive y

namespace TransitiveGround

open SetFormula

variable (M : TransitiveGround.{u})

noncomputable def groundPower (B : ZFSet.{u}) : ZFSet.{u} :=
  ZFSet.sep (fun p => p ∈ M.sets) (ZFSet.powerset B)

end TransitiveGround

def GroundBelow (M : TransitiveGround.{u}) (A K : ZFSet.{u}) : Prop :=
  ∃ β ∈ K, M.groundEmbeddable A β

def GroundCardinal (M : TransitiveGround.{u}) (κ : ZFSet.{u}) : Prop :=
  ordinalSetProperty κ ∧ ∀ β ∈ κ, ¬ M.groundEmbeddable κ β

def CofinalFunctionCode (α K f : ZFSet.{u}) : Prop :=
  ZFSet.IsFunc α K f ∧ ∀ β ∈ K, ∃ x ∈ α, ∃ y ∈ K,
    ZFSet.pair x y ∈ f ∧ (β = y ∨ β ∈ y)

def GroundCofinalRegular (M : TransitiveGround.{u}) (K : ZFSet.{u}) : Prop :=
  ∀ α ∈ K, ∀ f ∈ M.sets, ¬ CofinalFunctionCode α K f

def GroundCardinalStrongLimit (M : TransitiveGround.{u}) (K : ZFSet.{u}) : Prop :=
  ∀ κ ∈ K, GroundCardinal M κ → GroundBelow M (M.groundPower κ) K

def GroundStandardInaccessible (M : TransitiveGround.{u}) (K : ZFSet.{u}) : Prop :=
  GroundCardinal M K ∧ ¬ M.groundEmbeddable K ZFSet.omega ∧
    GroundCofinalRegular M K ∧ GroundCardinalStrongLimit M K

namespace SetFormula

def extensionality : SetFormula 0 :=
  .all (.all (imp
    (.all (.conj (imp (.mem 0 2) (.mem 0 1)) (imp (.mem 0 1) (.mem 0 2))))
    (.equal 1 0)))

def foundation : SetFormula 0 :=
  .all (imp (ex (.mem 0 1))
    (ex (.conj (.mem 0 1) (.all (.neg (.conj (.mem 0 2) (.mem 0 1)))))))

def emptySet : SetFormula 0 := ex (.all (.neg (.mem 0 1)))

def pairing : SetFormula 0 :=
  .all (.all (ex (.all (.conj
    (imp (.mem 0 1) (disj (.equal 0 3) (.equal 0 2)))
    (imp (disj (.equal 0 3) (.equal 0 2)) (.mem 0 1))))))

def union : SetFormula 0 :=
  .all (ex (.all (.conj
    (imp (.mem 0 1) (ex (.conj (.mem 0 3) (.mem 1 0))))
    (imp (ex (.conj (.mem 0 3) (.mem 1 0))) (.mem 0 1)))))

def powerSet : SetFormula 0 :=
  .all (ex (.all (.conj
    (imp (.mem 0 1) (.all (imp (.mem 0 1) (.mem 0 3))))
    (imp (.all (imp (.mem 0 1) (.mem 0 3))) (.mem 0 1)))))

def SeparationSchema (U : Set ZFSet.{u}) : Prop :=
  ∀ {n} (φ : SetFormula (n + 1)) (params : Fin n → ZFSet.{u}),
    (∀ i, params i ∈ U) → ∀ x ∈ U, ∃ y ∈ U,
      ∀ z ∈ U, z ∈ y ↔ z ∈ x ∧ Realize U φ (extend z params)

def CollectionSchema (U : Set ZFSet.{u}) : Prop :=
  ∀ {n} (φ : SetFormula (n + 2)) (params : Fin n → ZFSet.{u}),
    (∀ i, params i ∈ U) → ∀ a ∈ U,
      (∀ x ∈ U, x ∈ a → ∃ y ∈ U, Realize U φ (extend x (extend y params))) →
      ∃ b ∈ U, ∀ x ∈ U, x ∈ a →
        ∃ y ∈ U, y ∈ b ∧ Realize U φ (extend x (extend y params))

def emptySetFormula {n : Nat} (x : Fin n) : SetFormula n := .all (.neg (.mem 0 x.succ))

def successorFormula {n : Nat} (y x : Fin n) : SetFormula n :=
  .all (.conj (imp (.mem 0 y.succ) (disj (.equal 0 x.succ) (.mem 0 x.succ)))
    (imp (disj (.equal 0 x.succ) (.mem 0 x.succ)) (.mem 0 y.succ)))

def infinity : SetFormula 0 :=
  ex (.conj (ex (.conj (.mem 0 1) (emptySetFormula 0)))
    (.all (imp (.mem 0 1) (ex (.conj (.mem 0 2) (successorFormula 0 1))))))

def choice : SetFormula 0 :=
  .all (imp (BoundedFormula.allMem 0 (BoundedFormula.nonemptyFormula 0)).toFormula
    (ex (BoundedFormula.choiceFunctionFormula 1 0).toFormula))

def ReplacementSchema (U : Set ZFSet.{u}) : Prop :=
  ∀ {n} (φ : SetFormula (n + 2)) (params : Fin n → ZFSet.{u}),
    (∀ i, params i ∈ U) → ∀ A ∈ U,
      (∀ x ∈ U, x ∈ A → ∃ y ∈ U, Realize U φ (extend x (extend y params)) ∧
        ∀ z ∈ U, Realize U φ (extend x (extend z params)) → z = y) →
      ∃ B ∈ U, ∀ y ∈ U, y ∈ B ↔ ∃ x ∈ U, x ∈ A ∧ Realize U φ (extend x (extend y params))

def finiteZFAxioms : SetFormula 0 :=
  .conj extensionality (.conj foundation (.conj emptySet
    (.conj pairing (.conj SetFormula.union (.conj powerSet infinity)))))

def ZFRealization (U : Set ZFSet.{u}) : Prop :=
  Realize U finiteZFAxioms Fin.elim0 ∧ SeparationSchema U ∧ ReplacementSchema U

end SetFormula

namespace BoundedFormula

open SetFormula

def injectionFormula {n} (d c f : Fin n) : BoundedFormula n :=
  .conj (functionFormula d c f) (.allMem d (.allMem d.succ (.allMem c.succ.succ
    (imp (.conj (pairMembershipFormula 2 0 f.succ.succ.succ)
      (pairMembershipFormula 1 0 f.succ.succ.succ)) (.equal 2 1)))))

end BoundedFormula

namespace SetFormula

def hasInjectionFormula {n} (d c : Fin n) : SetFormula n :=
  ex (BoundedFormula.injectionFormula d.succ c.succ 0).toFormula

end SetFormula

namespace BoundedFormula

open SetFormula

def surjectionFormula {n : Nat} (a b f : Fin n) : BoundedFormula n :=
  .conj (functionFormula a b f)
    (.allMem b (exMem a.succ (pairMembershipFormula 0 1 f.succ.succ)))

end BoundedFormula

namespace SetFormula

def partitionPrinciple : SetFormula 0 :=
  .all (.all (.all (imp (BoundedFormula.surjectionFormula (n := 3) 2 1 0).toFormula
    (hasInjectionFormula (n := 3) 1 2))))

end SetFormula

end PartitionPilot.Forcing

end OAI