import OAI.SetTheory.PartitionPrinciple.Geometry.GroundNaturalNumbers

namespace OAI


namespace PartitionPilot.Forcing

universe u

theorem setSuccessor_injective : Function.Injective (fun x : ZFSet.{u} => insert x x) := by
  intro x y eq
  change insert x x = insert y y at eq
  have xy : x = y ∨ x ∈ y := ZFSet.mem_insert_iff.1 (eq ▸ ZFSet.mem_insert x x)
  have yx : y = x ∨ y ∈ x := ZFSet.mem_insert_iff.1 (eq.symm ▸ ZFSet.mem_insert y y)
  rcases xy with eq | xy
  · exact eq
  · rcases yx with eq | yx
    · exact eq.symm
    · exact False.elim (ZFSet.mem_asymm xy yx)

theorem setSuccessor_ne_empty (x : ZFSet.{u}) : insert x x ≠ (∅ : ZFSet.{u}) := by
  intro eq
  exact ZFSet.notMem_empty x (eq ▸ ZFSet.mem_insert x x)

noncomputable def shiftedInjectionGraph (D f : ZFSet.{u}) : ZFSet.{u} :=
  ZFSet.sep (fun z => ∃ x ∈ D, ∃ n ∈ ZFSet.omega,
    z = ZFSet.pair x (insert n n) ∧ ZFSet.pair x n ∈ f) (ZFSet.prod D ZFSet.omega)

theorem mem_shiftedInjectionGraph (D f z : ZFSet.{u}) :
    z ∈ shiftedInjectionGraph D f ↔ ∃ x ∈ D, ∃ n ∈ ZFSet.omega,
      z = ZFSet.pair x (insert n n) ∧ ZFSet.pair x n ∈ f := by
  rw [shiftedInjectionGraph, ZFSet.mem_sep]
  constructor
  · exact And.right
  · intro h
    obtain ⟨x, hx, n, hn, eq, rel⟩ := h
    exact ⟨eq.symm ▸ ZFSet.pair_mem_prod.2 ⟨hx, ZFSet.omega_succ hn⟩,
      x, hx, n, hn, eq, rel⟩

theorem pair_mem_shiftedInjectionGraph (D f x y : ZFSet.{u}) :
    ZFSet.pair x y ∈ shiftedInjectionGraph D f ↔
      x ∈ D ∧ ∃ n ∈ ZFSet.omega, y = insert n n ∧ ZFSet.pair x n ∈ f := by
  rw [mem_shiftedInjectionGraph]
  constructor
  · rintro ⟨a, ha, n, hn, eq, rel⟩
    obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 eq
    exact ⟨ha, n, hn, rfl, rel⟩
  · rintro ⟨hx, n, hn, rfl, rel⟩
    exact ⟨x, hx, n, hn, rfl, rel⟩

theorem shiftedInjectionGraph_no_zero (D f x : ZFSet.{u}) :
    ZFSet.pair x ∅ ∉ shiftedInjectionGraph D f := by
  intro rel
  obtain ⟨_, n, _, eq, _⟩ := (pair_mem_shiftedInjectionGraph D f x ∅).1 rel
  exact setSuccessor_ne_empty n eq.symm

namespace InjectionCode

theorem shift {D f : ZFSet.{u}} (h : InjectionCode D ZFSet.omega f) :
    InjectionCode D ZFSet.omega (shiftedInjectionGraph D f) := by
  refine ⟨⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_⟩, ?_⟩
  · intro x hx
    obtain ⟨n, rel, unique⟩ := h.function.2 x hx
    have hn := (ZFSet.pair_mem_prod.1 (h.function.1 rel)).2
    refine ⟨insert n n, (pair_mem_shiftedInjectionGraph D f x _).2 ⟨hx, n, hn, rfl, rel⟩, ?_⟩
    intro y hy
    obtain ⟨_, m, _, eq, hm⟩ := (pair_mem_shiftedInjectionGraph D f x y).1 hy
    rw [eq, unique m hm]
  · intro x y z hx hy
    obtain ⟨_, n, _, zn, xn⟩ := (pair_mem_shiftedInjectionGraph D f x z).1 hx
    obtain ⟨_, m, _, zm, ym⟩ := (pair_mem_shiftedInjectionGraph D f y z).1 hy
    have eq := setSuccessor_injective (zn.symm.trans zm)
    exact h.injective x y m (eq ▸ xn) ym

end InjectionCode

noncomputable def adjoinInjectionGraph (D f a : ZFSet.{u}) : ZFSet.{u} :=
  insert (ZFSet.pair a ∅) (shiftedInjectionGraph D f)

theorem pair_mem_adjoinInjectionGraph (D f a x y : ZFSet.{u}) :
    ZFSet.pair x y ∈ adjoinInjectionGraph D f a ↔
      (x = a ∧ y = ∅) ∨ ZFSet.pair x y ∈ shiftedInjectionGraph D f := by
  rw [adjoinInjectionGraph, ZFSet.mem_insert_iff, ZFSet.pair_inj]

namespace InjectionCode

theorem adjoin_fresh {D f a : ZFSet.{u}} (h : InjectionCode D ZFSet.omega f) (fresh : a ∉ D) :
    InjectionCode (insert a D) ZFSet.omega (adjoinInjectionGraph D f a) := by
  have shifted := h.shift
  refine ⟨⟨?_, ?_⟩, ?_⟩
  · intro z hz
    rcases ZFSet.mem_insert_iff.1 hz with rfl | hz
    · exact ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_insert a D, ZFSet.omega_zero⟩
    · obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 (shifted.function.1 hz)
      exact ZFSet.pair_mem_prod.2 ⟨ZFSet.mem_insert_of_mem a hx, hy⟩
  · intro x hx
    rcases ZFSet.mem_insert_iff.1 hx with eq | hx
    · subst x
      refine ⟨∅, (pair_mem_adjoinInjectionGraph D f a a ∅).2 (Or.inl ⟨rfl, rfl⟩), ?_⟩
      intro y hy
      rcases (pair_mem_adjoinInjectionGraph D f a a y).1 hy with eq | rel
      · exact eq.2
      · exact False.elim (fresh ((pair_mem_shiftedInjectionGraph D f a y).1 rel).1)
    · obtain ⟨y, rel, unique⟩ := shifted.function.2 x hx
      refine ⟨y, (pair_mem_adjoinInjectionGraph D f a x y).2 (Or.inr rel), ?_⟩
      intro z hz
      rcases (pair_mem_adjoinInjectionGraph D f a x z).1 hz with eq | rel
      · exact False.elim (fresh (eq.1 ▸ hx))
      · exact unique z rel
  · intro x y z hx hy
    rcases (pair_mem_adjoinInjectionGraph D f a x z).1 hx with eqx | shiftx
    · rcases (pair_mem_adjoinInjectionGraph D f a y z).1 hy with eqy | shifty
      · exact eqx.1.trans eqy.1.symm
      · rw [eqx.2] at shifty
        exact False.elim (shiftedInjectionGraph_no_zero D f y shifty)
    · rcases (pair_mem_adjoinInjectionGraph D f a y z).1 hy with eqy | shifty
      · rw [eqy.2] at shiftx
        exact False.elim (shiftedInjectionGraph_no_zero D f x shiftx)
      · exact shifted.injective x y z shiftx shifty

end InjectionCode

end PartitionPilot.Forcing



namespace PartitionPilot.Forcing.BoundedFormula

open SetFormula
universe u

def shiftedInjectionEntryFormula {n} (z d o f : Fin n) : BoundedFormula n :=
  exMem d (exMem o.succ (exMem o.succ.succ
    (.conj (successorFormula 0 1)
      (.conj (orderedPairFormula z.succ.succ.succ 2 0)
        (pairMembershipFormula 2 1 f.succ.succ.succ)))))

theorem truth_shiftedInjectionEntryFormula {n} (z d o f : Fin n)
    (env : Fin n → ZFSet.{u}) (omega : env o = ZFSet.omega) :
    Truth (shiftedInjectionEntryFormula z d o f) env ↔
      ∃ x ∈ env d, ∃ m ∈ ZFSet.omega,
        env z = ZFSet.pair x (insert m m) ∧ ZFSet.pair x m ∈ env f := by
  simp only [shiftedInjectionEntryFormula, truth_exMem, Truth,
    truth_successorFormula, truth_orderedPairFormula, truth_pairMembershipFormula]
  change (∃ x ∈ env d, ∃ m ∈ env o, ∃ k ∈ env o,
    k = insert m m ∧ env z = ZFSet.pair x k ∧ ZFSet.pair x m ∈ env f) ↔ _
  rw [omega]
  constructor
  · rintro ⟨x, hx, m, hm, k, _, rfl, eq, rel⟩
    exact ⟨x, hx, m, hm, eq, rel⟩
  · rintro ⟨x, hx, m, hm, eq, rel⟩
    exact ⟨x, hx, m, hm, insert m m, ZFSet.omega_succ hm, rfl, eq, rel⟩

end PartitionPilot.Forcing.BoundedFormula

namespace PartitionPilot.Forcing.TransitiveGround

open SetFormula
universe u
variable (M : TransitiveGround.{u})

theorem insert_mem (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    {a D : ZFSet.{u}} (ha : a ∈ M.sets) (hD : D ∈ M.sets) : insert a D ∈ M.sets := by
  have single : ({a} : ZFSet.{u}) ∈ M.sets := by
    simpa only [ZFSet.pair_eq_singleton] using M.unorderedPair_mem pairing ha ha
  have joined := M.binary_union_mem pairing unions single hD
  have eq : ({a} : ZFSet.{u}) ∪ D = insert a D := by
    apply ZFSet.ext
    intro z
    rw [ZFSet.mem_union, ZFSet.mem_singleton, ZFSet.mem_insert_iff]
  exact eq ▸ joined

theorem shiftedInjectionGraph_mem
    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
    (infinite : Realize M.sets infinity Fin.elim0)
    {D f : ZFSet.{u}} (hD : D ∈ M.sets) (hf : f ∈ M.sets) :
    shiftedInjectionGraph D f ∈ M.sets := by
  have hO := M.omega_mem separation infinite
  have bound := M.prod_mem pairing unions powers separation hD hO
  let params := extend D (extend ZFSet.omega (extend f Fin.elim0))
  have members : ∀ i, params i ∈ M.sets :=
    Fin.cases hD (Fin.cases hO (Fin.cases hf (fun i => Fin.elim0 i)))
  have selected := M.separation_mem separation
    (BoundedFormula.shiftedInjectionEntryFormula 0 1 2 3).toFormula params members bound
  have eq : ZFSet.sep (fun z => Realize M.sets
      (BoundedFormula.shiftedInjectionEntryFormula 0 1 2 3).toFormula (extend z params))
      (ZFSet.prod D ZFSet.omega) = shiftedInjectionGraph D f := by
    apply ZFSet.ext
    intro z
    rw [ZFSet.mem_sep, shiftedInjectionGraph, ZFSet.mem_sep]
    apply and_congr_right
    intro hz
    exact (BoundedFormula.realize_toFormula M _ _
      (Fin.cases (M.transitive bound hz) members)).trans
        (BoundedFormula.truth_shiftedInjectionEntryFormula 0 1 2 3 (extend z params) rfl)
  exact eq ▸ selected

theorem adjoinInjectionGraph_mem
    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
    (infinite : Realize M.sets infinity Fin.elim0)
    {D f a : ZFSet.{u}} (hD : D ∈ M.sets) (hf : f ∈ M.sets) (ha : a ∈ M.sets) :
    adjoinInjectionGraph D f a ∈ M.sets :=
  M.insert_mem pairing unions
    (M.orderedPair_mem pairing ha (M.empty_mem ⟨a, ha⟩))
    (M.shiftedInjectionGraph_mem pairing unions powers separation infinite hD hf)

theorem groundEmbeddable_insert
    (pairing : Realize M.sets SetFormula.pairing Fin.elim0)
    (unions : Realize M.sets SetFormula.union Fin.elim0)
    (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets)
    (infinite : Realize M.sets infinity Fin.elim0)
    {D a : ZFSet.{u}} (hD : D ∈ M.sets) (ha : a ∈ M.sets)
    (small : M.groundEmbeddable D ZFSet.omega) :
    M.groundEmbeddable (insert a D) ZFSet.omega := by
  classical
  by_cases member : a ∈ D
  · have eq : insert a D = D := by
      apply ZFSet.ext
      intro z
      rw [ZFSet.mem_insert_iff]
      exact ⟨fun h => h.elim (fun eq => eq.symm ▸ member) id, Or.inr⟩
    exact eq.symm ▸ small
  · obtain ⟨f, hf, code⟩ := small
    exact ⟨adjoinInjectionGraph D f a,
      M.adjoinInjectionGraph_mem pairing unions powers separation infinite hD hf ha,
      code.adjoin_fresh member⟩

end PartitionPilot.Forcing.TransitiveGround

end OAI