lean/OAI/ModelTheory/AbstractElementary/ModelExistence.lean

import Mathlib

namespace OAI

/-! Models of prescribed cardinality in abstract elementary classes. -/

universe u

namespace EventualCategoricity

open FirstOrder
open scoped Cardinal

structure SetModel (L : FirstOrder.Language.{u, u}) where
  carrier : ZFSet.{u}
  str : L.Structure carrier

instance {L : FirstOrder.Language.{u, u}} (M : SetModel L) : L.Structure M.carrier := M.str

namespace SetModel

variable {L : FirstOrder.Language.{u, u}}

def Submodel (M N : SetModel L) : Prop :=
  ∃ e : M.carrier ↪[L] N.carrier, ∀ x, (e x).val = x.val

def ImageOf (M : SetModel L) {N N' : SetModel L}
    (f : N.carrier ≃[L] N'.carrier) (M' : SetModel L) : Prop :=
  M'.Submodel N' ∧ ∀ y : ZFSet.{u},
    y ∈ M'.carrier ↔ ∃ x : N.carrier, x.val ∈ M.carrier ∧ (f x).val = y

def card (M : SetModel L) : Cardinal.{u} := M.carrier.card

end SetModel

structure AEC (L : FirstOrder.Language.{u, u}) where
  mem : SetModel L → Prop
  strong : SetModel L → SetModel L → Prop
  strong_mem : ∀ {M N}, strong M N → mem M ∧ mem N
  refl : ∀ M, mem M → strong M M
  trans : ∀ {M N P}, strong M N → strong N P → strong M P
  antisymm : ∀ {M N}, strong M N → strong N M → M = N
  submodel : ∀ {M N}, strong M N → M.Submodel N
  isoClosed : ∀ {M N}, mem M → (M.carrier ≃[L] N.carrier) → mem N
  isoStrong : ∀ {M N N'}, strong M N →
    ∀ f : N.carrier ≃[L] N'.carrier,
      ∃ M', M.ImageOf f M' ∧ strong M' N'
  coherence : ∀ {M₀ M₁ M₂}, M₀.Submodel M₁ →
    strong M₀ M₂ → strong M₁ M₂ → strong M₀ M₁
  chainUnion : ∀ δ : Ordinal.{u}, δ ≠ 0 →
    ∀ c : δ.ToType → SetModel L,
      (∀ i, mem (c i)) → (∀ i j, i ≤ j → strong (c i) (c j)) →
      ∃ U, mem U ∧
        (∀ x : ZFSet.{u}, x ∈ U.carrier ↔ ∃ i, x ∈ (c i).carrier) ∧
        (∀ i, strong (c i) U) ∧
        ∀ N, mem N → (∀ i, strong (c i) N) → strong U N
  LS : Cardinal.{u}
  LS_infinite : ℵ₀ ≤ LS
  LS_language : L.card + ℵ₀ ≤ LS
  LS_bound : ∀ M, mem M → ∀ A : ZFSet.{u}, A ⊆ M.carrier →
    ∃ N, strong N M ∧ A ⊆ N.carrier ∧ N.card ≤ A.card + LS
  LS_least : ∀ ℓ : Cardinal.{u}, ℵ₀ ≤ ℓ → L.card + ℵ₀ ≤ ℓ →
    (∀ M, mem M → ∀ A : ZFSet.{u}, A ⊆ M.carrier →
      ∃ N, strong N M ∧ A ⊆ N.carrier ∧ N.card ≤ A.card + ℓ) → LS ≤ ℓ

namespace AEC

variable {L : FirstOrder.Language.{u, u}}

def Categorical (K : AEC L) (κ : Cardinal.{u}) : Prop :=
  (∃ M, K.mem M ∧ M.card = κ) ∧
  ∀ M N, K.mem M → K.mem N → M.card = κ → N.card = κ →
    Nonempty (M.carrier ≃[L] N.carrier)

def UnboundedCategoricity (K : AEC L) : Prop :=
  ∀ κ : Cardinal.{u}, ∃ ρ, κ ≤ ρ ∧ K.Categorical ρ

def CategoricityTail (K : AEC L) : Prop :=
  ∃ θ : Cardinal.{u}, ∀ κ, θ ≤ κ → K.Categorical κ

end AEC

def UniformEventualCategoricity : Prop :=
  ∀ lam : Cardinal.{u}, ℵ₀ ≤ lam → ∃ μ : Cardinal.{u}, lam ≤ μ ∧
    ∀ (L : FirstOrder.Language.{u, u}) (K : AEC L), K.LS ≤ lam →
      (∃ κ, μ ≤ κ ∧ K.Categorical κ) → ∀ κ', μ ≤ κ' → K.Categorical κ'

def QualitativeEventualCategoricity : Prop :=
  ∀ (L : FirstOrder.Language.{u, u}) (K : AEC L),
    K.UnboundedCategoricity → K.CategoricityTail

theorem exists_subset_card (x : ZFSet.{u}) {κ : Cardinal.{u}}
    (hκ : κ ≤ x.card) :
    ∃ A : ZFSet.{u}, A ⊆ x ∧ A.card = κ := by
  have h : Cardinal.lift.{u + 1} κ ≤ Cardinal.mk x := by
    rw [ZFSet.cardinalMk_coe_sort]
    exact Cardinal.lift_le.mpr hκ
  obtain ⟨s, hs, hc⟩ := Cardinal.le_mk_iff_exists_subset.mp h
  let A := x.sep (fun y => y ∈ s)
  have hA : (A : Set ZFSet.{u}) = s := by
    ext y
    change y ∈ x.sep (fun z => z ∈ s) ↔ y ∈ s
    rw [ZFSet.mem_sep]
    exact ⟨And.right, fun hy => ⟨hs hy, hy⟩⟩
  refine ⟨A, ZFSet.sep_subset, ?_⟩
  apply Cardinal.lift_inj.{u, u + 1}.mp
  rw [← ZFSet.cardinalMk_coe_sort]
  change Cardinal.mk (A : Set ZFSet.{u}) = Cardinal.lift κ
  rw [hA, hc]

namespace SetModel

variable {L : FirstOrder.Language.{u, u}} {M N : SetModel L}

theorem Submodel.carrier_subset (h : M.Submodel N) : M.carrier ⊆ N.carrier := by
  obtain ⟨e, he⟩ := h
  intro x hx
  have hmem := (e ⟨x, hx⟩).property
  simpa only [he ⟨x, hx⟩] using hmem

theorem Submodel.card_le (h : M.Submodel N) : M.card ≤ N.card :=
  ZFSet.card_mono h.carrier_subset

theorem Submodel.of_carrier_subset {P : SetModel L}
    (hMP : M.Submodel P) (hNP : N.Submodel P) (hMN : M.carrier ⊆ N.carrier) :
    M.Submodel N := by
  obtain ⟨e, he⟩ := hMP
  obtain ⟨f, hf⟩ := hNP
  let i : M.carrier → N.carrier := fun x => ⟨x.val, hMN x.property⟩
  have hfi : (f : N.carrier → P.carrier) ∘ i = e := by
    funext x
    apply Subtype.ext
    exact (hf (i x)).trans (he x).symm
  refine ⟨{ toFun := i, inj' := ?_, map_fun' := ?_, map_rel' := ?_ }, fun _ => rfl⟩
  · intro x y h
    apply Subtype.ext
    exact congrArg (fun z : N.carrier => z.val) h
  · intro n g x
    apply f.injective
    change (f ∘ i) (Language.Structure.funMap g x) =
      f (Language.Structure.funMap g (i ∘ x))
    rw [hfi, f.map_fun, e.map_fun, ← Function.comp_assoc, hfi]
  · intro n r x
    rw [← f.map_rel r (i ∘ x), ← Function.comp_assoc, hfi, e.map_rel]

end SetModel

namespace AEC

variable {L : FirstOrder.Language.{u, u}} (K : AEC L)

theorem strong_of_carrier_subset {A B M : SetModel L}
    (hAM : K.strong A M) (hBM : K.strong B M) (hAB : A.carrier ⊆ B.carrier) :
    K.strong A B :=
  K.coherence ((K.submodel hAM).of_carrier_subset (K.submodel hBM) hAB) hAM hBM

theorem exists_small_strong_submodel (M : SetModel L) (hM : K.mem M)
    (A : ZFSet.{u}) (hA : A ⊆ M.carrier) {κ : Cardinal.{u}}
    (hLS : K.LS ≤ κ) (hAκ : A.card ≤ κ) :
    ∃ N, K.strong N M ∧ A ⊆ N.carrier ∧ N.card ≤ κ := by
  obtain ⟨N, hNM, hAN, hN⟩ := K.LS_bound M hM A hA
  exact ⟨N, hNM, hAN,
    hN.trans (Cardinal.add_le_of_le (K.LS_infinite.trans hLS) hAκ hLS)⟩

theorem small_strong_submodels_directed {A B M : SetModel L}
    (hAM : K.strong A M) (hBM : K.strong B M) {κ : Cardinal.{u}}
    (hLS : K.LS ≤ κ) (hAκ : A.card ≤ κ) (hBκ : B.card ≤ κ) :
    ∃ N, K.strong N M ∧ K.strong A N ∧ K.strong B N ∧ N.card ≤ κ := by
  have hAB : A.carrier ∪ B.carrier ⊆ M.carrier := by
    intro x hx
    rcases ZFSet.mem_union.mp hx with hx | hx
    · exact (K.submodel hAM).carrier_subset hx
    · exact (K.submodel hBM).carrier_subset hx
  have hABκ : (A.carrier ∪ B.carrier).card ≤ κ :=
    ZFSet.card_union_le.trans
      (Cardinal.add_le_of_le (K.LS_infinite.trans hLS) hAκ hBκ)
  obtain ⟨N, hNM, hABN, hN⟩ := K.exists_small_strong_submodel M
    (K.strong_mem hAM).2 (A.carrier ∪ B.carrier) hAB hLS hABκ
  exact ⟨N, hNM,
    K.strong_of_carrier_subset hAM hNM (fun _ hx => hABN (ZFSet.mem_union.mpr (.inl hx))),
    K.strong_of_carrier_subset hBM hNM (fun _ hx => hABN (ZFSet.mem_union.mpr (.inr hx))),
    hN⟩

theorem small_strong_submodels_cover (M : SetModel L) (hM : K.mem M)
    {x : ZFSet.{u}} (hx : x ∈ M.carrier) :
    ∃ N, K.strong N M ∧ x ∈ N.carrier ∧ N.card ≤ K.LS := by
  obtain ⟨N, hNM, hxN, hN⟩ := K.exists_small_strong_submodel M hM {x}
    (by
      intro y hy
      have hyx : y = x := ZFSet.mem_singleton.mp hy
      simpa only [hyx] using hx) le_rfl
    (by simpa using Cardinal.one_le_aleph0.trans K.LS_infinite)
  exact ⟨N, hNM, hxN (by simp), hN⟩

theorem exists_strong_submodel_card_containing (M : SetModel L) (hM : K.mem M)
    (A : ZFSet.{u}) (hA : A ⊆ M.carrier) {κ : Cardinal.{u}}
    (hLS : K.LS ≤ κ) (hAκ : A.card ≤ κ) (hκM : κ ≤ M.card) :
    ∃ N, K.strong N M ∧ A ⊆ N.carrier ∧ N.card = κ := by
  obtain ⟨B, hB, hBc⟩ := exists_subset_card M.carrier hκM
  have hAB : A ∪ B ⊆ M.carrier := by
    intro x hx
    rcases ZFSet.mem_union.mp hx with hx | hx
    · exact hA hx
    · exact hB hx
  obtain ⟨N, hNM, hABN, hNc⟩ := K.LS_bound M hM (A ∪ B) hAB
  have hinf : ℵ₀ ≤ κ := K.LS_infinite.trans hLS
  have hABc : (A ∪ B).card ≤ κ :=
    (ZFSet.card_union_le).trans (Cardinal.add_le_of_le hinf hAκ hBc.le)
  have hNle : N.card ≤ κ :=
    hNc.trans (Cardinal.add_le_of_le hinf hABc hLS)
  have hBN : B ⊆ N.carrier := by
    intro x hx
    exact hABN (ZFSet.mem_union.mpr (Or.inr hx))
  have hNge : κ ≤ N.card := by
    rw [← hBc]
    exact ZFSet.card_mono hBN
  refine ⟨N, hNM, ?_, hNle.antisymm hNge⟩
  intro x hx
  exact hABN (ZFSet.mem_union.mpr (Or.inl hx))

theorem exists_strong_submodel_card (M : SetModel L) (hM : K.mem M)
    {κ : Cardinal.{u}} (hLS : K.LS ≤ κ) (hκM : κ ≤ M.card) :
    ∃ N, K.strong N M ∧ N.card = κ := by
  obtain ⟨N, hNM, _, hN⟩ := K.exists_strong_submodel_card_containing M hM
    ∅ (ZFSet.empty_subset _) hLS (by simp) hκM
  exact ⟨N, hNM, hN⟩

theorem arbitrarily_large_models (hK : K.UnboundedCategoricity) (κ : Cardinal.{u}) :
    ∃ M, K.mem M ∧ κ ≤ M.card := by
  obtain ⟨ρ, hκρ, ⟨M, hM, hc⟩, _⟩ := hK κ
  exact ⟨M, hM, hc ▸ hκρ⟩

theorem models_at_every_cardinal_above_LS (hK : K.UnboundedCategoricity)
    {κ : Cardinal.{u}} (hLS : K.LS ≤ κ) :
    ∃ M, K.mem M ∧ M.card = κ := by
  obtain ⟨M, hM, hκM⟩ := K.arbitrarily_large_models hK κ
  obtain ⟨N, hNM, hN⟩ := K.exists_strong_submodel_card M hM hLS hκM
  exact ⟨N, (K.strong_mem hNM).1, hN⟩

theorem contains_copy_at_categorical_cardinal {ρ : Cardinal.{u}}
    (hρ : K.Categorical ρ) (hLS : K.LS ≤ ρ)
    (C M : SetModel L) (hC : K.mem C) (hCc : C.card = ρ) (hM : K.mem M)
    (hρM : ρ ≤ M.card) :
    ∃ N, K.strong N M ∧ N.card = ρ ∧ Nonempty (C.carrier ≃[L] N.carrier) := by
  obtain ⟨N, hNM, hN⟩ := K.exists_strong_submodel_card M hM hLS hρM
  exact ⟨N, hNM, hN, hρ.2 C N hC (K.strong_mem hNM).1 hCc hN⟩

end AEC
end EventualCategoricity

end OAI