lean/OAI/Computability/DegreeRigidity/SetModels/ExtensionBasicAxioms.lean

import OAI.Computability.DegreeRigidity.SetModels.NameUnionCode

namespace OAI

namespace TuringRigidity.TransitiveNameModel
open Set RecursiveNames BoundedSetTheory CountableForcing
universe u

namespace BasicAxioms

def Extensionality (M : ZFSet.{u}) : Prop :=
  ∀ a ∈ M, ∀ b ∈ M, (∀ x ∈ M, x ∈ a ↔ x ∈ b) → a = b

def EmptySet (M : ZFSet.{u}) : Prop := ∃ a ∈ M, ∀ x ∈ M, x ∉ a

def Foundation (M : ZFSet.{u}) : Prop :=
  ∀ a ∈ M, (∃ x ∈ M, x ∈ a) →
    ∃ y ∈ M, y ∈ a ∧ ∀ z ∈ M, ¬ (z ∈ y ∧ z ∈ a)

theorem extensionality (M : ZFSet.{u}) (hM : Transitive M) : Extensionality M := by
  intro a ha b hb h
  apply ZFSet.ext
  intro x
  exact ⟨fun hx => (h x (hM a ha x hx)).mp hx,
    fun hx => (h x (hM b hb x hx)).mpr hx⟩

theorem foundation (M : ZFSet.{u}) (hM : Transitive M) : Foundation M := by
  rintro a ha ⟨x,_,hxa⟩
  have hne : a ≠ ∅ := by intro h; exact ZFSet.notMem_empty x (h ▸ hxa)
  obtain ⟨y,hya,hy⟩ := ZFSet.regularity a hne
  refine ⟨y,hM a ha y hya,hya,fun z _ hz => ?_⟩
  have hz' : z ∈ a ∩ y := ZFSet.mem_inter.mpr ⟨hz.2,hz.1⟩
  exact ZFSet.notMem_empty z (hy ▸ hz')

end BasicAxioms

theorem empty_mem_ground (M : ZFSet.{u}) (hM : Transitive M) (hne : M ≠ ∅) :
    (∅ : ZFSet.{u}) ∈ M := by
  obtain ⟨a,ha,hmin⟩ := ZFSet.regularity M hne
  have he : a = ∅ := by
    apply ZFSet.ext
    intro x
    constructor
    · intro hx
      have hi : x ∈ M ∩ a := ZFSet.mem_inter.mpr ⟨hM a ha x hx,hx⟩
      exact hmin ▸ hi
    · exact fun hx => False.elim (ZFSet.notMem_empty x hx)
  exact he ▸ ha

def emptyName (P : Type u) : Name P :=
  .mk (ULift Empty) (fun i => i.down.elim) (fun i => i.down.elim)

theorem encode_emptyName {P : Type u} (l : P → ZFSet.{u}) :
    (emptyName P).encode l = ∅ := by
  apply ZFSet.ext
  intro x
  simp [emptyName,Name.encode]

theorem val_emptyName {P : Type u} (G : Set P) : Name.val G (emptyName P) = ∅ := by
  apply ZFSet.ext
  intro x
  simp [emptyName,Name.mem_val]

theorem mem_extensionSet (M p : ZFSet.{u}) (G : Set (Conditions p)) (x : ZFSet.{u}) :
    x ∈ genericExtensionSet M p G ↔
      ∃ τ : Name (Conditions p), τ.encode (label p) ∈ M ∧ τ.val G = x := by
  change x ∈ (genericExtensionSet M p G : Set ZFSet.{u}) ↔ _
  rw [genericExtensionSet_coe]
  rfl

theorem extension_empty_mem (M p : ZFSet.{u}) (hM : Transitive M) (hne : M ≠ ∅)
    (G : Set (Conditions p)) : (∅ : ZFSet.{u}) ∈ genericExtensionSet M p G := by
  apply (mem_extensionSet M p G _).mpr
  refine ⟨emptyName _,?_,val_emptyName G⟩
  rw [encode_emptyName]
  exact empty_mem_ground M hM hne

theorem encode_pair {P : Type u} [Top P] (l : P → ZFSet.{u}) (σ τ : Name P) :
    (Name.pair σ τ).encode l =
      ({ZFSet.pair (σ.encode l) (l ⊤),ZFSet.pair (τ.encode l) (l ⊤)} : ZFSet.{u}) := by
  apply ZFSet.ext
  intro x
  change x ∈ ZFSet.range _ ↔ _
  rw [ZFSet.mem_range,ZFSet.mem_pair]
  constructor
  · rintro ⟨⟨b⟩,hb⟩
    cases b
    · exact Or.inr hb.symm
    · exact Or.inl hb.symm
  · rintro (hx|hx)
    · exact ⟨⟨true⟩,hx.symm⟩
    · exact ⟨⟨false⟩,hx.symm⟩

theorem names_pair_closed (M p : ZFSet.{u}) [Top (Conditions p)]
    (hM : Transitive M) (hP : Pairing M) (hp : p ∈ M)
    {σ τ : Name (Conditions p)} (hσ : σ ∈ names M p) (hτ : τ ∈ names M p) :
    Name.pair σ τ ∈ names M p := by
  have ht := hM p hp (label p ⊤) (label_mem p ⊤)
  change (Name.pair σ τ).encode (label p) ∈ M
  rw [encode_pair]
  exact pair_mem M hM hP (orderedPair_mem M hM hP hσ ht) (orderedPair_mem M hM hP hτ ht)

theorem extension_pairing (M p : ZFSet.{u}) [Top (Conditions p)]
    (hM : Transitive M) (hP : Pairing M) (hp : p ∈ M)
    (G : Set (Conditions p)) (hG : ⊤ ∈ G) : Pairing (genericExtensionSet M p G) := by
  intro a ha b hb
  obtain ⟨σ,hσ,rfl⟩ := (mem_extensionSet M p G a).mp ha
  obtain ⟨τ,hτ,rfl⟩ := (mem_extensionSet M p G b).mp hb
  refine ⟨({σ.val G,τ.val G} : ZFSet.{u}),?_,fun x _ => ZFSet.mem_pair⟩
  exact (mem_extensionSet M p G _).mpr
    ⟨Name.pair σ τ,names_pair_closed M p hM hP hp hσ hτ,Name.val_pair G hG σ τ⟩

theorem names_union_closed (M p r : ZFSet.{u}) [Preorder (Conditions p)]
    (hM : Transitive M) (hP : Pairing M) (hU : BoundedSetTheory.Union M)
    (hPow : PowerSet M) (hS : Separation M) (hp : p ∈ M) (hrM : r ∈ M)
    (hr : ∀ q s : Conditions p, ZFSet.pair (label p q) (label p s) ∈ r ↔ q ≤ s)
    {τ : Name (Conditions p)} (hτ : τ ∈ names M p) :
    Name.union τ ∈ names M p := by
  change (Name.union τ).encode (label p) ∈ M
  rw [encode_union p r hr]
  exact unionCode_mem M hM hP hU hPow hS hτ hp hrM

theorem extension_union (M p r : ZFSet.{u}) [Preorder (Conditions p)]
    (hM : Transitive M) (hP : Pairing M) (hU : BoundedSetTheory.Union M)
    (hPow : PowerSet M) (hS : Separation M) (hp : p ∈ M) (hrM : r ∈ M)
    (hr : ∀ q s : Conditions p, ZFSet.pair (label p q) (label p s) ∈ r ↔ q ≤ s)
    (G : GenericFilter (Conditions p)) : BoundedSetTheory.Union (genericExtensionSet M p G.carrier) := by
  intro a ha
  obtain ⟨τ,hτ,rfl⟩ := (mem_extensionSet M p G.carrier a).mp ha
  refine ⟨ZFSet.sUnion (τ.val G.carrier),?_,?_⟩
  · exact (mem_extensionSet M p G.carrier _).mpr
      ⟨Name.union τ,names_union_closed M p r hM hP hU hPow hS hp hrM hr hτ,Name.val_union G τ⟩
  · intro x _
    rw [ZFSet.mem_sUnion]
    constructor
    · rintro ⟨y,hy,hxy⟩
      exact ⟨y,genericExtensionSet_transitive M p hM G.carrier _ ha y hy,hy,hxy⟩
    · rintro ⟨y,_,hy,hxy⟩
      exact ⟨y,hy,hxy⟩

theorem extension_five_axioms (M p r : ZFSet.{u})
    [Preorder (Conditions p)] [Top (Conditions p)]
    (hM : Transitive M) (hne : M ≠ ∅) (hP : Pairing M)
    (hU : BoundedSetTheory.Union M) (hPow : PowerSet M) (hS : Separation M)
    (hp : p ∈ M) (hrM : r ∈ M)
    (hr : ∀ q s : Conditions p, ZFSet.pair (label p q) (label p s) ∈ r ↔ q ≤ s)
    (G : GenericFilter (Conditions p)) (hG : ⊤ ∈ G.carrier) :
    let E := genericExtensionSet M p G.carrier
    BasicAxioms.Extensionality E ∧ BasicAxioms.EmptySet E ∧
      Pairing E ∧ BoundedSetTheory.Union E ∧ BasicAxioms.Foundation E := by
  dsimp
  have hE := genericExtensionSet_transitive M p hM G.carrier
  exact ⟨BasicAxioms.extensionality _ hE,
    ⟨∅,extension_empty_mem M p hM hne G.carrier,fun x _ => ZFSet.notMem_empty x⟩,
    extension_pairing M p hM hP hp G.carrier hG,
    extension_union M p r hM hP hU hPow hS hp hrM hr G,
    BasicAxioms.foundation _ hE⟩

end TuringRigidity.TransitiveNameModel

end OAI