import Mathlib
import OAI.SetTheory.PartitionConsistency.Logic.Proofs
import OAI.SetTheory.PartitionConsistency.Logic.SetLanguage
import OAI.SetTheory.PartitionConsistency.Logic.CountableModels
import OAI.SetTheory.PartitionConsistency.Logic.Completeness

namespace OAI

/-! A concrete choice ground and collapse in Lean's universe metatheory.

This supplies an actual well-founded choice ground rather than hypothesizing
one. It does not supply the source's symmetric extension, does not prove the
constructible interpretation in ZF; the main proof below instead uses the concrete forcing interpretation.
-/


namespace PartitionConsistency

namespace Formula
variable {M : Type*} (E : M → M → Prop)

theorem realize_close {n} (φ : Formula n) :
    Realize E Fin.elim0 φ.close ↔ ∀ v : Fin n → M, Realize E v φ := by
  induction n with
  | zero =>
    exact ⟨fun h v => Subsingleton.elim (Fin.elim0 : Fin 0 → M) v ▸ h,
      fun h => h Fin.elim0⟩
  | succ n ih =>
    rw [close, ih]
    change (∀ v : Fin n → M, ∀ x : M, Realize E (Fin.snoc v x) φ) ↔ _
    constructor
    · intro h v
      have hv : Fin.snoc (fun i => v i.castSucc) (v (Fin.last n)) = v := by
        funext i
        refine Fin.lastCases ?_ (fun _ => ?_) i <;> simp
      exact hv ▸ h _ _
    · exact fun h v x => h (Fin.snoc v x)
end Formula


namespace SetLanguage
open Formula
variable {M : Type*} (E : M → M → Prop)

theorem realize_relation {n m} (p : Formula (n + 2))
    (r : Fin n → Fin m) (x y : Fin m) (v : Fin m → M) :
    Realize E v (relation p r x y) ↔
      Realize E (Fin.snoc (Fin.snoc (v ∘ r) (v x)) (v y)) p := by
  rw [relation, realize_rename]
  have hv : v ∘ Fin.lastCases y (Fin.lastCases x r) =
      Fin.snoc (Fin.snoc (v ∘ r) (v x)) (v y) := by
    funext i
    refine Fin.lastCases ?_ (fun j => ?_) i
    · simp
    · refine Fin.lastCases ?_ (fun k => ?_) j <;> simp [Function.comp_def]
  rw [hv]

theorem realize_separation {n} (p : Formula (n + 1)) :
    Realize E Fin.elim0 (separation p) ↔
      ∀ v : Fin n → M, ∀ A, ∃ B, ∀ x,
        E x B ↔ E x A ∧ Realize E (Fin.snoc v x) p := by
  unfold separation
  rw [realize_close]
  simp only [Realize, realize_rename, Fin.snoc_last, Fin.snoc_castSucc]
  apply forall_congr'
  intro v
  apply forall_congr'
  intro A
  apply exists_congr
  intro B
  apply forall_congr'
  intro x
  have h : Fin.snoc (Fin.snoc (Fin.snoc v A) B) x ∘
      Fin.lastCases (Fin.last (n + 2)) (fun i => i.castSucc.castSucc.castSucc) =
        Fin.snoc v x := by
    funext i
    refine Fin.lastCases ?_ (fun j => ?_) i <;> simp
  rw [h]
  simp only [iff_def]

theorem realize_replacement {n} (p : Formula (n + 2)) :
    Realize E Fin.elim0 (replacement p) ↔
      ∀ v : Fin n → M, ∀ A,
        (∀ x, E x A → ∃ y, Realize E (Fin.snoc (Fin.snoc v x) y) p ∧
          ∀ z, Realize E (Fin.snoc (Fin.snoc v x) z) p → z = y) →
        ∃ B, ∀ y, E y B ↔ ∃ x, E x A ∧
          Realize E (Fin.snoc (Fin.snoc v x) y) p := by
  unfold replacement
  rw [realize_close]
  simp only [Realize, realize_relation, Fin.snoc_last, Fin.snoc_castSucc]
  have h3 (v : Fin n → M) (a b c : M) :
      Fin.snoc (Fin.snoc (Fin.snoc v a) b) c ∘ (fun i => i.castSucc.castSucc.castSucc) = v := by
    ext i
    simp
  have h4 (v : Fin n → M) (a b c d : M) :
      Fin.snoc (Fin.snoc (Fin.snoc (Fin.snoc v a) b) c) d ∘
        (fun i => i.castSucc.castSucc.castSucc.castSucc) = v := by
    ext i
    simp
  simp only [h3, h4, ← iff_def]

end SetLanguage

namespace ZFUniverse
universe u
abbrev E : ZFSet.{u} → ZFSet.{u} → Prop := (· ∈ ·)
open Formula SetLanguage

@[simp] theorem realize_subset {n} (v : Fin n → ZFSet.{u}) (a b : Fin n) :
    Realize E.{u} v (subset a b) ↔ v a ⊆ v b := by
  simp [subset, Realize, ZFSet.subset_def, Fin.snoc, Fin.castPred, Fin.castLT, E]

@[simp] theorem realize_empty {n} (v : Fin n → ZFSet.{u}) (a : Fin n) :
    Realize E.{u} v (empty a) ↔ v a = ∅ := by
  simp [empty, Realize, Fin.snoc, Fin.castLT, E, ZFSet.eq_empty]

@[simp] theorem realize_nonempty {n} (v : Fin n → ZFSet.{u}) (a : Fin n) :
    Realize E.{u} v (nonempty a) ↔ ∃ x, x ∈ v a := by
  simp [nonempty, Realize, Fin.snoc, Fin.castLT, E]

@[simp] theorem realize_pair {n} (v : Fin n → ZFSet.{u}) (p x y : Fin n) :
    Realize E.{u} v (unorderedPair p x y) ↔ v p = ({v x, v y} : ZFSet) := by
  rw [ZFSet.ext_iff]
  simp [unorderedPair, Realize, Fin.snoc, Fin.castPred, Fin.castLT, E, ← iff_def]

@[simp] theorem realize_successor {n} (v : Fin n → ZFSet.{u}) (b a : Fin n) :
    Realize E.{u} v (successor b a) ↔ v b = insert (v a) (v a) := by
  rw [ZFSet.ext_iff]
  simp [successor, Realize, Fin.snoc, Fin.castPred, Fin.castLT, E, or_comm, ← iff_def]

@[simp] theorem realize_orderedPair {n} (v : Fin n → ZFSet.{u}) (p x y : Fin n) :
    Realize E.{u} v (orderedPair p x y) ↔ v p = ZFSet.pair (v x) (v y) := by
  simp [orderedPair, Realize, Function.comp_def, Fin.snoc, Fin.castPred, Fin.castLT, ZFSet.pair]

@[simp] theorem realize_edge {n} (v : Fin n → ZFSet.{u}) (f x y : Fin n) :
    Realize E.{u} v (edge f x y) ↔ ZFSet.pair (v x) (v y) ∈ v f := by
  simp [edge, Realize, Function.comp_def, Fin.snoc, Fin.castPred, Fin.castLT, E]

@[simp] theorem realize_functionOn {n} (v : Fin n → ZFSet.{u}) (f d : Fin n) :
    Realize E.{u} v (functionOn f d) ↔
      (∀ p ∈ v f, ∃ x ∈ v d, ∃ y, p = ZFSet.pair x y) ∧
      ∀ x ∈ v d, ∃! y, ZFSet.pair x y ∈ v f := by
  simp [functionOn, Realize, Fin.snoc, Fin.castPred, Fin.castLT, E, ExistsUnique]

@[simp] theorem realize_mapsTo {n} (v : Fin n → ZFSet.{u}) (f d r : Fin n) :
    Realize E.{u} v (mapsTo f d r) ↔ ZFSet.IsFunc (v d) (v r) (v f) := by
  simp only [mapsTo, realize_rename, Realize, realize_functionOn, realize_edge]
  simp only [Function.comp_apply, Matrix.cons_val_zero, Matrix.cons_val_one,
    Fin.snoc, Fin.castLT, E]
  simp only [Fin.isValue, Fin.val_zero, Fin.zero_eta]
  constructor
  · rintro ⟨h, hmem⟩
    refine ⟨?_, h.2⟩
    intro p hp
    obtain ⟨x, hx, y, rfl⟩ := h.1 p hp
    exact ZFSet.pair_mem_prod.mpr ⟨hx, hmem x y hx hp⟩
  · rintro ⟨hsub, hfun⟩
    refine ⟨⟨?_, hfun⟩, ?_⟩
    · intro p hp
      obtain ⟨x, hx, y, _, heq⟩ := ZFSet.mem_prod.mp (hsub hp)
      exact ⟨x, hx, y, heq⟩
    · intro x y _ hp
      exact (ZFSet.pair_mem_prod.mp (hsub hp)).2

/-- The full parameterized Separation schema holds in the genuine set universe. -/
theorem separation_true {n} (p : Formula (n + 1)) :
    Realize E.{u} Fin.elim0 (separation p) := by
  rw [SetLanguage.realize_separation]
  intro v A
  exact ⟨ZFSet.sep (fun x => Realize E.{u} (Fin.snoc v x) p) A, fun _ => ZFSet.mem_sep⟩

/-- The full parameterized Replacement schema holds in the genuine set universe. -/
theorem replacement_true {n} (p : Formula (n + 2)) :
    Realize E.{u} Fin.elim0 (replacement p) := by
  classical
  rw [SetLanguage.realize_replacement]
  intro v A h
  let f : A → ZFSet.{u} := fun x => Classical.choose (h x.val x.property)
  have hf (x : A) : Realize E.{u} (Fin.snoc (Fin.snoc v x.val) (f x)) p ∧
      ∀ y, Realize E.{u} (Fin.snoc (Fin.snoc v x.val) y) p → y = f x :=
    Classical.choose_spec (h x.val x.property)
  refine ⟨ZFSet.range f, fun y => ?_⟩
  rw [E, ZFSet.mem_range]
  constructor
  · rintro ⟨x, rfl⟩
    exact ⟨x.val, x.property, (hf x).1⟩
  · rintro ⟨x, hx, hp⟩
    exact ⟨⟨x, hx⟩, ((hf ⟨x, hx⟩).2 y hp).symm⟩

/-- A concrete model of every axiom and schema instance of pure ZF. -/
theorem models_ZF : Models E.{u} SetLanguage.ZF := by
  intro p hp
  cases hp with
  | extensionality =>
    simp only [extensionality, Realize]
    intro a b h
    apply ZFSet.ext
    intro x
    exact ⟨(h x).1, (h x).2⟩
  | emptySet =>
    simp only [emptySet, Realize, realize_empty]
    exact ⟨∅, rfl⟩
  | pairing =>
    simp only [pairing, Realize, realize_pair]
    intro a b
    exact ⟨{a, b}, rfl⟩
  | union =>
    simp only [union, Realize]
    intro a
    refine ⟨ZFSet.sUnion a, ?_⟩
    intro x
    exact ⟨ZFSet.mem_sUnion.mp, ZFSet.mem_sUnion.mpr⟩
  | powerSet =>
    simp only [powerSet, Realize, realize_subset]
    intro a
    refine ⟨ZFSet.powerset a, ?_⟩
    intro x
    exact ⟨ZFSet.mem_powerset.mp, ZFSet.mem_powerset.mpr⟩
  | infinity =>
    simp only [infinity, Realize, realize_empty, realize_successor]
    refine ⟨ZFSet.omega, ⟨∅, ZFSet.omega_zero, rfl⟩, ?_⟩
    intro x hx
    exact ⟨insert x x, ZFSet.omega_succ hx, rfl⟩
  | foundation =>
    simp only [foundation, Realize, realize_nonempty]
    intro a ha
    have hne : a ≠ ∅ := by
      rintro rfl
      obtain ⟨x, hx⟩ := ha
      exact ZFSet.notMem_empty x hx
    obtain ⟨b, hb, hi⟩ := ZFSet.regularity a hne
    refine ⟨b, hb, ?_⟩
    intro x hx hxa
    have : x ∈ a ∩ b := ZFSet.mem_inter.mpr ⟨hxa, hx⟩
    exact ZFSet.notMem_empty x (hi ▸ this)
  | separation p => exact separation_true p
  | replacement p => exact replacement_true p

@[simp] theorem realize_choiceOn {n} (v : Fin n → ZFSet.{u}) (c a : Fin n) :
    Realize E.{u} v (choiceOn c a) ↔
      Realize E v (functionOn c a) ∧ ∀ x ∈ v a, ∃ y, ZFSet.pair x y ∈ v c ∧ y ∈ x := by
  simp [choiceOn, Realize, Fin.snoc, Fin.castPred, Fin.castLT, E]

/-- The set-graph version of Choice is true in the ambient universe. It is
obtained from Lean's permitted `Classical.choice`, not an additional axiom. -/
theorem AC_true : Realize E.{u} Fin.elim0 AC := by
  classical
  simp only [AC, Realize, realize_nonempty, realize_choiceOn, realize_functionOn]
  intro a h
  change (∀ x ∈ a, ∃ y, y ∈ x) at h
  let f : a → ZFSet.{u} := fun x => Classical.choose (h x.val x.property)
  have hf (x : a) : f x ∈ x.val := Classical.choose_spec (h x.val x.property)
  let c := ZFSet.range (fun x : a => ZFSet.pair x.val (f x))
  have hc (p) : p ∈ c ↔ ∃ x : a, ZFSet.pair x.val (f x) = p := ZFSet.mem_range
  refine ⟨c, ⟨?_, ?_⟩, ?_⟩
  · intro p hp
    obtain ⟨x, rfl⟩ := (hc p).mp hp
    exact ⟨x.val, x.property, f x, rfl⟩
  · intro x hx
    refine ⟨f ⟨x, hx⟩, (hc _).mpr ⟨⟨x, hx⟩, rfl⟩, ?_⟩
    intro y hy
    obtain ⟨z, hz⟩ := (hc _).mp hy
    obtain ⟨he, hfz⟩ := ZFSet.pair_inj.mp hz
    obtain rfl : z = (⟨x, hx⟩ : a) := Subtype.ext he
    exact hfz.symm
  · intro x hx
    exact ⟨f ⟨x, hx⟩, (hc _).mpr ⟨⟨x, hx⟩, rfl⟩, hf ⟨x, hx⟩⟩

/-- Full ZFC in exactly the syntax used for the selected consistency target. -/
theorem models_ZFC : Models E.{u} (SetLanguage.ZF ∪ {AC}) := by
  intro p hp
  rcases hp with hp | hp
  · exact models_ZF p hp
  · obtain rfl : p = AC := Set.mem_singleton_iff.mp hp
    exact AC_true

end ZFUniverse
namespace Formula

/-- Truth in the target syntax is invariant under genuine structure isomorphisms. -/
theorem realize_equiv {M N : Type*} (E : M → M → Prop) (F : N → N → Prop)
    (e : M ≃ N) (he : ∀ a b, E a b ↔ F (e a) (e b)) {n} (p : Formula n)
    (v : Fin n → M) : Realize E v p ↔ Realize F (e ∘ v) p := by
  induction p with
  | bot => rfl
  | mem x y => exact he (v x) (v y)
  | equal x y => exact e.injective.eq_iff.symm
  | imp p q hp hq => exact imp_congr (hp v) (hq v)
  | conj p q hp hq => exact and_congr (hp v) (hq v)
  | disj p q hp hq => exact or_congr (hp v) (hq v)
  | all p hp =>
    constructor
    · intro h x
      obtain ⟨y, rfl⟩ := e.surjective x
      simpa only [Fin.comp_snoc] using (hp (Fin.snoc v y)).1 (h y)
    · intro h y
      apply (hp (Fin.snoc v y)).2
      simpa only [Fin.comp_snoc] using h (e y)
  | ex p hp =>
    constructor
    · rintro ⟨y, hy⟩
      exact ⟨e y, by simpa only [Fin.comp_snoc] using (hp (Fin.snoc v y)).1 hy⟩
    · rintro ⟨x, hx⟩
      obtain ⟨y, rfl⟩ := e.surjective x
      exact ⟨y, (hp (Fin.snoc v y)).2 (by simpa only [Fin.comp_snoc] using hx)⟩
end Formula

/-- Transport of a whole theory, including schemas, across a relational isomorphism. -/
theorem models_equiv {M N : Type*} (E : M → M → Prop) (F : N → N → Prop)
    (e : M ≃ N) (he : ∀ a b, E a b ↔ F (e a) (e b)) (T : Theory) :
    Models E T ↔ Models F T := by
  have hv : e ∘ (Fin.elim0 : Fin 0 → M) = (Fin.elim0 : Fin 0 → N) :=
    Subsingleton.elim _ _
  unfold Models
  exact forall₂_congr fun p _ => by rw [Formula.realize_equiv E F e he p, hv]

namespace Mostowski
universe u v
variable {M : Type v} [Small.{u} M] {E : M → M → Prop} (hw : WellFounded E)

/-- Collapse by genuine external well-founded recursion, not recursion over an
arbitrary first-order model's internal membership relation. -/
noncomputable def collapse : M → ZFSet.{u} :=
  hw.fix (fun a f => ZFSet.range (fun x : {x // E x a} => f x.val x.property))

theorem collapse_eq (a : M) : collapse hw a =
    ZFSet.range (fun x : {x // E x a} => collapse hw x.val) := by
  exact hw.fix_eq _ a

theorem mem_collapse_iff (a : M) (x : ZFSet.{u}) :
    x ∈ collapse hw a ↔ ∃ b, E b a ∧ collapse hw b = x := by
  rw [collapse_eq, ZFSet.mem_range]
  exact ⟨fun ⟨b, hb⟩ => ⟨b.val, b.property, hb⟩,
    fun ⟨b, hb, he⟩ => ⟨⟨b, hb⟩, he⟩⟩

variable (he : ∀ a b, (∀ x, E x a ↔ E x b) → a = b)

include he in
/-- Extensionality makes the collapse injective. -/
theorem collapse_injective : Function.Injective (collapse.{u} hw) := by
  intro a
  induction a using hw.induction with
  | h a ih =>
    intro b hab
    apply he a b
    intro x
    constructor
    · intro hxa
      have hx : collapse hw x ∈ collapse hw b :=
        hab ▸ (mem_collapse_iff hw a _).2 ⟨x, hxa, rfl⟩
      obtain ⟨y, hy, hxy⟩ := (mem_collapse_iff hw b _).1 hx
      have : x = y := ih x hxa hxy.symm
      exact this.symm ▸ hy
    · intro hxb
      have hx : collapse hw x ∈ collapse hw a :=
        hab.symm ▸ (mem_collapse_iff hw b _).2 ⟨x, hxb, rfl⟩
      obtain ⟨y, hy, hxy⟩ := (mem_collapse_iff hw a _).1 hx
      have : y = x := ih y hy hxy
      exact this ▸ hy

include he in
theorem collapse_mem_collapse (a b : M) :
    collapse.{u} hw a ∈ collapse hw b ↔ E a b := by
  rw [mem_collapse_iff]
  constructor
  · rintro ⟨x, hx, hx'⟩
    exact collapse_injective hw he hx' ▸ hx
  · exact fun hab => ⟨a, hab, rfl⟩

/-- The range of the collapse is transitive as a collection of actual sets. -/
theorem range_transitive : ∀ a ∈ Set.range (collapse.{u} hw), ∀ b ∈ a,
    b ∈ Set.range (collapse hw) := by
  rintro a ⟨x, rfl⟩ b hb
  obtain ⟨y, _, hy⟩ := (mem_collapse_iff hw x b).1 hb
  exact ⟨y, hy⟩

/-- Collapse is a membership isomorphism onto its transitive range. -/
noncomputable def rangeEquiv : M ≃ Set.range (collapse.{u} hw) :=
  Equiv.ofInjective (collapse hw) (collapse_injective hw he)

theorem rangeEquiv_mem (a b : M) :
    (rangeEquiv.{u} hw he a).val ∈ (rangeEquiv hw he b).val ↔ E a b :=
  collapse_mem_collapse hw he a b

include he in
/-- A well-founded extensional small model has an isomorphic transitive model. -/
theorem range_models {T : Theory} (hT : Models E T) :
    Models (fun a b : Set.range (collapse.{u} hw) => a.val ∈ b.val) T :=
  (models_equiv E _ (rangeEquiv hw he) (fun a b => (rangeEquiv_mem hw he a b).symm) T).mp hT

end Mostowski

namespace ZFUniverse
open Formula SetLanguage

/-- In Lean's universe metatheory there is a countable, transitive pure-set
model of full ZFC. This is proved using `ZFSet`, downward Löwenheim–Skolem,
and the collapse; it is NOT an assumption inferred from bare Con(ZF). -/
theorem exists_countable_transitive_ZFC :
    ∃ M : Set ZFSet.{0}, M.Nonempty ∧ M.Countable ∧
      (∀ a ∈ M, ∀ b ∈ a, b ∈ M) ∧
      Models (fun a b : M => a.val ∈ b.val) (SetLanguage.ZF ∪ {AC}) := by
  obtain ⟨N, hN, hct, hmodel⟩ :=
    CountableModel.exists_countable_model E.{0} models_ZFC
  have : Countable N := hct.to_subtype
  let r : N → N → Prop := fun a b => a.val ∈ b.val
  have hw : WellFounded r := InvImage.wf Subtype.val ZFSet.mem_wf
  have he : ∀ a b : N, (∀ x, r x a ↔ r x b) → a = b := by
    have hex : Realize r Fin.elim0 extensionality :=
      hmodel _ (Or.inl IsZFAxiom.extensionality)
    intro a b hab
    apply hex a b
    intro x
    exact ⟨(hab x).mp, (hab x).mpr⟩
  let c : N → ZFSet.{0} := Mostowski.collapse hw
  refine ⟨Set.range c, ?_, Set.countable_range c,
    Mostowski.range_transitive.{0} hw, Mostowski.range_models.{0} hw he hmodel⟩
  obtain ⟨x, hx⟩ := hN
  exact ⟨c ⟨x, hx⟩, ⟨⟨x, hx⟩, rfl⟩⟩

/-- Existence of an actual choice ground, not yet an extension violating Choice. -/
theorem consistent_ZFC : Consistent (SetLanguage.ZF ∪ {AC}) :=
  consistent_of_model E.{0} models_ZFC

end ZFUniverse
end PartitionConsistency

end OAI