File: Mathlib/ModelTheory/Satisfiability.lean

full_name: FirstOrder.Language.Theory.IsSatisfiable
code: /-- A theory is satisfiable if a structure models it. -/
def IsSatisfiable : Prop 
goal: Prop

full_name: FirstOrder.Language.Theory.IsFinitelySatisfiable
code: /-- A theory is finitely satisfiable if all of its finite subtheories are satisfiable. -/
def IsFinitelySatisfiable : Prop 
goal: Prop

full_name: FirstOrder.Language.Theory.Model.isSatisfiable
code: theorem Model.isSatisfiable (M : Type w) [Nonempty M] [L.Structure M] [M ⊨ T] :
    T.IsSatisfiable 
goal: T.IsSatisfiable

full_name: FirstOrder.Language.Theory.IsSatisfiable.mono
code: theorem IsSatisfiable.mono (h : T'.IsSatisfiable) (hs : T ⊆ T') : T.IsSatisfiable 
goal: T.IsSatisfiable

full_name: FirstOrder.Language.Theory.isSatisfiable_empty
code: theorem isSatisfiable_empty (L : Language.{u, v}) : IsSatisfiable (∅ : L.Theory) 
goal: ∅.IsSatisfiable

full_name: FirstOrder.Language.Theory.isSatisfiable_of_isSatisfiable_onTheory
code: theorem isSatisfiable_of_isSatisfiable_onTheory {L' : Language.{w, w'}} (φ : L →ᴸ L')
    (h : (φ.onTheory T).IsSatisfiable) : T.IsSatisfiable 
goal: T.IsSatisfiable

full_name: FirstOrder.Language.Theory.isSatisfiable_onTheory_iff
code: theorem isSatisfiable_onTheory_iff {L' : Language.{w, w'}} {φ : L →ᴸ L'} (h : φ.Injective) :
    (φ.onTheory T).IsSatisfiable ↔ T.IsSatisfiable 
goal: (φ.onTheory T).IsSatisfiable ↔ T.IsSatisfiable

full_name: FirstOrder.Language.Theory.IsSatisfiable.isFinitelySatisfiable
code: theorem IsSatisfiable.isFinitelySatisfiable (h : T.IsSatisfiable) : T.IsFinitelySatisfiable 
goal: T.IsFinitelySatisfiable

full_name: FirstOrder.Language.Theory.isSatisfiable_iff_isFinitelySatisfiable
code: /-- The **Compactness Theorem of first-order logic**: A theory is satisfiable if and only if it is
finitely satisfiable. -/
theorem isSatisfiable_iff_isFinitelySatisfiable {T : L.Theory} :
    T.IsSatisfiable ↔ T.IsFinitelySatisfiable 
goal: T.IsSatisfiable ↔ T.IsFinitelySatisfiable

full_name: FirstOrder.Language.Theory.isSatisfiable_directed_union_iff
code: theorem isSatisfiable_directed_union_iff {ι : Type*} [Nonempty ι] {T : ι → L.Theory}
    (h : Directed (· ⊆ ·) T) : Theory.IsSatisfiable (⋃ i, T i) ↔ ∀ i, (T i).IsSatisfiable 
goal: FirstOrder.Language.Theory.IsSatisfiable (⋃ i, T i) ↔ ∀ (i : ι), (T i).IsSatisfiable

full_name: FirstOrder.Language.Theory.isSatisfiable_union_distinctConstantsTheory_of_card_le
code: theorem isSatisfiable_union_distinctConstantsTheory_of_card_le (T : L.Theory) (s : Set α)
    (M : Type w') [Nonempty M] [L.Structure M] [M ⊨ T]
    (h : Cardinal.lift.{w'} #s ≤ Cardinal.lift.{w} #M) :
    ((L.lhomWithConstants α).onTheory T ∪ L.distinctConstantsTheory s).IsSatisfiable 
goal: ((L.lhomWithConstants α).onTheory T ∪ L.distinctConstantsTheory s).IsSatisfiable

full_name: FirstOrder.Language.Theory.isSatisfiable_union_distinctConstantsTheory_of_infinite
code: theorem isSatisfiable_union_distinctConstantsTheory_of_infinite (T : L.Theory) (s : Set α)
    (M : Type w') [L.Structure M] [M ⊨ T] [Infinite M] :
    ((L.lhomWithConstants α).onTheory T ∪ L.distinctConstantsTheory s).IsSatisfiable 
goal: ((L.lhomWithConstants α).onTheory T ∪ L.distinctConstantsTheory s).IsSatisfiable

full_name: FirstOrder.Language.Theory.exists_large_model_of_infinite_model
code: /-- Any theory with an infinite model has arbitrarily large models. -/
theorem exists_large_model_of_infinite_model (T : L.Theory) (κ : Cardinal.{w}) (M : Type w')
    [L.Structure M] [M ⊨ T] [Infinite M] :
    ∃ N : ModelType.{_, _, max u v w} T, Cardinal.lift.{max u v w} κ ≤ #N 
goal: ∃ N, Cardinal.lift.{max u v w, w} κ ≤ #↑N

full_name: FirstOrder.Language.Theory.isSatisfiable_iUnion_iff_isSatisfiable_iUnion_finset
code: theorem isSatisfiable_iUnion_iff_isSatisfiable_iUnion_finset {ι : Type*} (T : ι → L.Theory) :
    IsSatisfiable (⋃ i, T i) ↔ ∀ s : Finset ι, IsSatisfiable (⋃ i ∈ s, T i) 
goal: FirstOrder.Language.Theory.IsSatisfiable (⋃ i, T i) ↔
  ∀ (s : Finset ι), FirstOrder.Language.Theory.IsSatisfiable (⋃ i ∈ s, T i)

full_name: FirstOrder.Language.exists_elementaryEmbedding_card_eq_of_le
code: /-- A version of The Downward Löwenheim–Skolem theorem where the structure `N` elementarily embeds
into `M`, but is not by type a substructure of `M`, and thus can be chosen to belong to the universe
of the cardinal `κ`.
 -/
theorem exists_elementaryEmbedding_card_eq_of_le (M : Type w') [L.Structure M] [Nonempty M]
    (κ : Cardinal.{w}) (h1 : ℵ₀ ≤ κ) (h2 : lift.{w} L.card ≤ Cardinal.lift.{max u v} κ)
    (h3 : lift.{w'} κ ≤ Cardinal.lift.{w} #M) :
    ∃ N : Bundled L.Structure, Nonempty (N ↪ₑ[L] M) ∧ #N = κ 
goal: ∃ N, Nonempty (↑N ↪ₑ[L] M) ∧ #↑N = κ

full_name: FirstOrder.Language.exists_elementaryEmbedding_card_eq_of_ge
code: /-- The **Upward Löwenheim–Skolem Theorem**: If `κ` is a cardinal greater than the cardinalities of
`L` and an infinite `L`-structure `M`, then `M` has an elementary extension of cardinality `κ`. -/
theorem exists_elementaryEmbedding_card_eq_of_ge (M : Type w') [L.Structure M] [iM : Infinite M]
    (κ : Cardinal.{w}) (h1 : Cardinal.lift.{w} L.card ≤ Cardinal.lift.{max u v} κ)
    (h2 : Cardinal.lift.{w} #M ≤ Cardinal.lift.{w'} κ) :
    ∃ N : Bundled L.Structure, Nonempty (M ↪ₑ[L] N) ∧ #N = κ 
goal: ∃ N, Nonempty (M ↪ₑ[L] ↑N) ∧ #↑N = κ

full_name: FirstOrder.Language.exists_elementaryEmbedding_card_eq
code: /-- The Löwenheim–Skolem Theorem: If `κ` is a cardinal greater than the cardinalities of `L`
and an infinite `L`-structure `M`, then there is an elementary embedding in the appropriate
direction between then `M` and a structure of cardinality `κ`. -/
theorem exists_elementaryEmbedding_card_eq (M : Type w') [L.Structure M] [iM : Infinite M]
    (κ : Cardinal.{w}) (h1 : ℵ₀ ≤ κ) (h2 : lift.{w} L.card ≤ Cardinal.lift.{max u v} κ) :
    ∃ N : Bundled L.Structure, (Nonempty (N ↪ₑ[L] M) ∨ Nonempty (M ↪ₑ[L] N)) ∧ #N = κ 
goal: ∃ N, (Nonempty (↑N ↪ₑ[L] M) ∨ Nonempty (M ↪ₑ[L] ↑N)) ∧ #↑N = κ

full_name: FirstOrder.Language.exists_elementarilyEquivalent_card_eq
code: /-- A consequence of the Löwenheim–Skolem Theorem: If `κ` is a cardinal greater than the
cardinalities of `L` and an infinite `L`-structure `M`, then there is a structure of cardinality `κ`
elementarily equivalent to `M`. -/
theorem exists_elementarilyEquivalent_card_eq (M : Type w') [L.Structure M] [Infinite M]
    (κ : Cardinal.{w}) (h1 : ℵ₀ ≤ κ) (h2 : lift.{w} L.card ≤ Cardinal.lift.{max u v} κ) :
    ∃ N : CategoryTheory.Bundled L.Structure, (M ≅[L] N) ∧ #N = κ 
goal: ∃ N, (M ≅[L] ↑N) ∧ #↑N = κ

full_name: FirstOrder.Language.Theory.exists_model_card_eq
code: theorem exists_model_card_eq (h : ∃ M : ModelType.{u, v, max u v} T, Infinite M) (κ : Cardinal.{w})
    (h1 : ℵ₀ ≤ κ) (h2 : Cardinal.lift.{w} L.card ≤ Cardinal.lift.{max u v} κ) :
    ∃ N : ModelType.{u, v, w} T, #N = κ 
goal: ∃ N, #↑N = κ

full_name: FirstOrder.Language.Theory.ModelsBoundedFormula
code: /-- A theory models a (bounded) formula when any of its nonempty models realizes that formula on all
  inputs. -/
def ModelsBoundedFormula (φ : L.BoundedFormula α n) : Prop 
goal: Prop

full_name: FirstOrder.Language.Theory._aux_Mathlib_ModelTheory_Satisfiability___unexpand_FirstOrder_Language_Theory_ModelsBoundedFormula_1
code: @[inherit_doc FirstOrder.Language.Theory.ModelsBoundedFormula]
infixl:51 " ⊨ᵇ " => ModelsBoundedFormula
goal: Lean.PrettyPrinter.Unexpander

full_name: FirstOrder.Language.Theory.«_aux_Mathlib_ModelTheory_Satisfiability___macroRules_FirstOrder_Language_Theory_term_⊨ᵇ__1»
code: @[inherit_doc FirstOrder.Language.Theory.ModelsBoundedFormula]
infixl:51 " ⊨ᵇ " => ModelsBoundedFormula
goal: Lean.Macro

full_name: FirstOrder.Language.Theory.models_formula_iff
code: theorem models_formula_iff {φ : L.Formula α} :
    T ⊨ᵇ φ ↔ ∀ (M : ModelType.{u, v, max u v} T) (v : α → M), φ.Realize v 
goal: T ⊨ᵇ φ ↔ ∀ (M : T.ModelType) (v : α → ↑M), φ.Realize v

full_name: FirstOrder.Language.Theory.models_sentence_iff
code: theorem models_sentence_iff {φ : L.Sentence} : T ⊨ᵇ φ ↔ ∀ M : ModelType.{u, v, max u v} T, M ⊨ φ 
goal: T ⊨ᵇ φ ↔ ∀ (M : T.ModelType), ↑M ⊨ φ

full_name: FirstOrder.Language.Theory.models_sentence_of_mem
code: theorem models_sentence_of_mem {φ : L.Sentence} (h : φ ∈ T) : T ⊨ᵇ φ 
goal: T ⊨ᵇ φ

full_name: FirstOrder.Language.Theory.models_iff_not_satisfiable
code: theorem models_iff_not_satisfiable (φ : L.Sentence) : T ⊨ᵇ φ ↔ ¬IsSatisfiable (T ∪ {φ.not}) 
goal: T ⊨ᵇ φ ↔ ¬(T ∪ {FirstOrder.Language.Formula.not φ}).IsSatisfiable

full_name: FirstOrder.Language.Theory.ModelsBoundedFormula.realize_sentence
code: theorem ModelsBoundedFormula.realize_sentence {φ : L.Sentence} (h : T ⊨ᵇ φ) (M : Type*)
    [L.Structure M] [M ⊨ T] [Nonempty M] : M ⊨ φ 
goal: M ⊨ φ

full_name: FirstOrder.Language.Theory.models_of_models_theory
code: theorem models_of_models_theory {T' : L.Theory}
    (h : ∀ φ : L.Sentence, φ ∈ T' → T ⊨ᵇ φ)
    {φ : L.Formula α} (hφ : T' ⊨ᵇ φ) : T ⊨ᵇ φ 
goal: T ⊨ᵇ φ

full_name: FirstOrder.Language.Theory.models_iff_finset_models
code: /-- An alternative statement of the Compactness Theorem. A formula `φ` is modeled by a
theory iff there is a finite subset `T0` of the theory such that `φ` is modeled by `T0` -/
theorem models_iff_finset_models {φ : L.Sentence} :
    T ⊨ᵇ φ ↔ ∃ T0 : Finset L.Sentence, (T0 : L.Theory) ⊆ T ∧ (T0 : L.Theory) ⊨ᵇ φ 
goal: T ⊨ᵇ φ ↔ ∃ T0, ↑T0 ⊆ T ∧ ↑T0 ⊨ᵇ φ

full_name: FirstOrder.Language.Theory.IsComplete
code: /-- A theory is complete when it is satisfiable and models each sentence or its negation. -/
def IsComplete (T : L.Theory) : Prop 
goal: Prop

full_name: FirstOrder.Language.Theory.IsComplete.models_not_iff
code: theorem models_not_iff (h : T.IsComplete) (φ : L.Sentence) : T ⊨ᵇ φ.not ↔ ¬T ⊨ᵇ φ 
goal: T ⊨ᵇ FirstOrder.Language.Formula.not φ ↔ ¬T ⊨ᵇ φ

full_name: FirstOrder.Language.Theory.IsComplete.realize_sentence_iff
code: theorem realize_sentence_iff (h : T.IsComplete) (φ : L.Sentence) (M : Type*) [L.Structure M]
    [M ⊨ T] [Nonempty M] : M ⊨ φ ↔ T ⊨ᵇ φ 
goal: M ⊨ φ ↔ T ⊨ᵇ φ

full_name: FirstOrder.Language.Theory.IsMaximal
code: /-- A theory is maximal when it is satisfiable and contains each sentence or its negation.
  Maximal theories are complete. -/
def IsMaximal (T : L.Theory) : Prop 
goal: Prop

full_name: FirstOrder.Language.Theory.IsMaximal.isComplete
code: theorem IsMaximal.isComplete (h : T.IsMaximal) : T.IsComplete 
goal: T.IsComplete

full_name: FirstOrder.Language.Theory.IsMaximal.mem_or_not_mem
code: theorem IsMaximal.mem_or_not_mem (h : T.IsMaximal) (φ : L.Sentence) : φ ∈ T ∨ φ.not ∈ T 
goal: φ ∈ T ∨ FirstOrder.Language.Formula.not φ ∈ T

full_name: FirstOrder.Language.Theory.IsMaximal.mem_of_models
code: theorem IsMaximal.mem_of_models (h : T.IsMaximal) {φ : L.Sentence} (hφ : T ⊨ᵇ φ) : φ ∈ T 
goal: φ ∈ T

full_name: FirstOrder.Language.Theory.IsMaximal.mem_iff_models
code: theorem IsMaximal.mem_iff_models (h : T.IsMaximal) (φ : L.Sentence) : φ ∈ T ↔ T ⊨ᵇ φ 
goal: φ ∈ T ↔ T ⊨ᵇ φ

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent
code: /-- Two (bounded) formulas are semantically equivalent over a theory `T` when they have the same
interpretation in every model of `T`. (This is also known as logical equivalence, which also has a
proof-theoretic definition.) -/
def SemanticallyEquivalent (T : L.Theory) (φ ψ : L.BoundedFormula α n) : Prop 
goal: Prop

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.refl
code: @[refl]
theorem SemanticallyEquivalent.refl (φ : L.BoundedFormula α n) : T.SemanticallyEquivalent φ φ 
goal: T.SemanticallyEquivalent φ φ

full_name: FirstOrder.Language.Theory.instIsReflBoundedFormulaSemanticallyEquivalent
code: instance : IsRefl (L.BoundedFormula α n) T.SemanticallyEquivalent 
goal: IsRefl (L.BoundedFormula α n) T.SemanticallyEquivalent

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.symm
code: @[symm]
theorem SemanticallyEquivalent.symm {φ ψ : L.BoundedFormula α n}
    (h : T.SemanticallyEquivalent φ ψ) : T.SemanticallyEquivalent ψ φ 
goal: T.SemanticallyEquivalent ψ φ

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.trans
code: @[trans]
theorem SemanticallyEquivalent.trans {φ ψ θ : L.BoundedFormula α n}
    (h1 : T.SemanticallyEquivalent φ ψ) (h2 : T.SemanticallyEquivalent ψ θ) :
    T.SemanticallyEquivalent φ θ 
goal: T.SemanticallyEquivalent φ θ

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.realize_bd_iff
code: theorem SemanticallyEquivalent.realize_bd_iff {φ ψ : L.BoundedFormula α n} {M : Type max u v}
    [Nonempty M] [L.Structure M] [T.Model M] (h : T.SemanticallyEquivalent φ ψ)
    {v : α → M} {xs : Fin n → M} : φ.Realize v xs ↔ ψ.Realize v xs 
goal: φ.Realize v xs ↔ ψ.Realize v xs

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.realize_iff
code: theorem SemanticallyEquivalent.realize_iff {φ ψ : L.Formula α} {M : Type max u v} [Nonempty M]
    [L.Structure M] (_hM : T.Model M) (h : T.SemanticallyEquivalent φ ψ) {v : α → M} :
    φ.Realize v ↔ ψ.Realize v 
goal: φ.Realize v ↔ ψ.Realize v

full_name: FirstOrder.Language.Theory.semanticallyEquivalentSetoid
code: /-- Semantic equivalence forms an equivalence relation on formulas. -/
def semanticallyEquivalentSetoid (T : L.Theory) : Setoid (L.BoundedFormula α n) 
goal: Setoid (L.BoundedFormula α n)

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.all
code: protected theorem SemanticallyEquivalent.all {φ ψ : L.BoundedFormula α (n + 1)}
    (h : T.SemanticallyEquivalent φ ψ) : T.SemanticallyEquivalent φ.all ψ.all 
goal: T.SemanticallyEquivalent (∀'φ) (∀'ψ)

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.ex
code: protected theorem SemanticallyEquivalent.ex {φ ψ : L.BoundedFormula α (n + 1)}
    (h : T.SemanticallyEquivalent φ ψ) : T.SemanticallyEquivalent φ.ex ψ.ex 
goal: T.SemanticallyEquivalent (∃'φ) (∃'ψ)

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.not
code: protected theorem SemanticallyEquivalent.not {φ ψ : L.BoundedFormula α n}
    (h : T.SemanticallyEquivalent φ ψ) : T.SemanticallyEquivalent φ.not ψ.not 
goal: T.SemanticallyEquivalent (∼φ) ∼ψ

full_name: FirstOrder.Language.Theory.SemanticallyEquivalent.imp
code: protected theorem SemanticallyEquivalent.imp {φ ψ φ' ψ' : L.BoundedFormula α n}
    (h : T.SemanticallyEquivalent φ ψ) (h' : T.SemanticallyEquivalent φ' ψ') :
    T.SemanticallyEquivalent (φ.imp φ') (ψ.imp ψ') 
goal: T.SemanticallyEquivalent (φ ⟹ φ') (ψ ⟹ ψ')

full_name: FirstOrder.Language.completeTheory.isSatisfiable
code: theorem isSatisfiable [Nonempty M] : (L.completeTheory M).IsSatisfiable 
goal: (L.completeTheory M).IsSatisfiable

full_name: FirstOrder.Language.completeTheory.mem_or_not_mem
code: theorem mem_or_not_mem (φ : L.Sentence) : φ ∈ L.completeTheory M ∨ φ.not ∈ L.completeTheory M 
goal: φ ∈ L.completeTheory M ∨ FirstOrder.Language.Formula.not φ ∈ L.completeTheory M

full_name: FirstOrder.Language.completeTheory.isMaximal
code: theorem isMaximal [Nonempty M] : (L.completeTheory M).IsMaximal 
goal: (L.completeTheory M).IsMaximal

full_name: FirstOrder.Language.completeTheory.isComplete
code: theorem isComplete [Nonempty M] : (L.completeTheory M).IsComplete 
goal: (L.completeTheory M).IsComplete

full_name: FirstOrder.Language.BoundedFormula.semanticallyEquivalent_not_not
code: theorem semanticallyEquivalent_not_not : T.SemanticallyEquivalent φ φ.not.not 
goal: T.SemanticallyEquivalent φ ∼∼φ

full_name: FirstOrder.Language.BoundedFormula.imp_semanticallyEquivalent_not_sup
code: theorem imp_semanticallyEquivalent_not_sup : T.SemanticallyEquivalent (φ.imp ψ) (φ.not ⊔ ψ) 
goal: T.SemanticallyEquivalent (φ ⟹ ψ) (∼φ ⊔ ψ)

full_name: FirstOrder.Language.BoundedFormula.sup_semanticallyEquivalent_not_inf_not
code: theorem sup_semanticallyEquivalent_not_inf_not :
    T.SemanticallyEquivalent (φ ⊔ ψ) (φ.not ⊓ ψ.not).not 
goal: T.SemanticallyEquivalent (φ ⊔ ψ) ∼(∼φ ⊓ ∼ψ)

full_name: FirstOrder.Language.BoundedFormula.inf_semanticallyEquivalent_not_sup_not
code: theorem inf_semanticallyEquivalent_not_sup_not :
    T.SemanticallyEquivalent (φ ⊓ ψ) (φ.not ⊔ ψ.not).not 
goal: T.SemanticallyEquivalent (φ ⊓ ψ) ∼(∼φ ⊔ ∼ψ)

full_name: FirstOrder.Language.BoundedFormula.all_semanticallyEquivalent_not_ex_not
code: theorem all_semanticallyEquivalent_not_ex_not (φ : L.BoundedFormula α (n + 1)) :
    T.SemanticallyEquivalent φ.all φ.not.ex.not 
goal: T.SemanticallyEquivalent (∀'φ) ∼(∃'∼φ)

full_name: FirstOrder.Language.BoundedFormula.ex_semanticallyEquivalent_not_all_not
code: theorem ex_semanticallyEquivalent_not_all_not (φ : L.BoundedFormula α (n + 1)) :
    T.SemanticallyEquivalent φ.ex φ.not.all.not 
goal: T.SemanticallyEquivalent (∃'φ) ∼(∀'∼φ)

full_name: FirstOrder.Language.BoundedFormula.semanticallyEquivalent_all_liftAt
code: theorem semanticallyEquivalent_all_liftAt : T.SemanticallyEquivalent φ (φ.liftAt 1 n).all 
goal: T.SemanticallyEquivalent φ (∀'FirstOrder.Language.BoundedFormula.liftAt 1 n φ)

full_name: FirstOrder.Language.Formula.semanticallyEquivalent_not_not
code: theorem semanticallyEquivalent_not_not : T.SemanticallyEquivalent φ φ.not.not 
goal: T.SemanticallyEquivalent φ φ.not.not

full_name: FirstOrder.Language.Formula.imp_semanticallyEquivalent_not_sup
code: theorem imp_semanticallyEquivalent_not_sup : T.SemanticallyEquivalent (φ.imp ψ) (φ.not ⊔ ψ) 
goal: T.SemanticallyEquivalent (φ.imp ψ) (φ.not ⊔ ψ)

full_name: FirstOrder.Language.Formula.sup_semanticallyEquivalent_not_inf_not
code: theorem sup_semanticallyEquivalent_not_inf_not :
    T.SemanticallyEquivalent (φ ⊔ ψ) (φ.not ⊓ ψ.not).not 
goal: T.SemanticallyEquivalent (φ ⊔ ψ) (φ.not ⊓ ψ.not).not

full_name: FirstOrder.Language.Formula.inf_semanticallyEquivalent_not_sup_not
code: theorem inf_semanticallyEquivalent_not_sup_not :
    T.SemanticallyEquivalent (φ ⊓ ψ) (φ.not ⊔ ψ.not).not 
goal: T.SemanticallyEquivalent (φ ⊓ ψ) (φ.not ⊔ ψ.not).not

full_name: Cardinal.Categorical
code: /-- A theory is `κ`-categorical if all models of size `κ` are isomorphic. -/
def Categorical : Prop 
goal: Prop

full_name: Cardinal.Categorical.isComplete
code: /-- The Łoś–Vaught Test : a criterion for categorical theories to be complete. -/
theorem Categorical.isComplete (h : κ.Categorical T) (h1 : ℵ₀ ≤ κ)
    (h2 : Cardinal.lift.{w} L.card ≤ Cardinal.lift.{max u v} κ) (hS : T.IsSatisfiable)
    (hT : ∀ M : Theory.ModelType.{u, v, max u v} T, Infinite M) : T.IsComplete 
goal: T.IsComplete

full_name: Cardinal.empty_theory_categorical
code: theorem empty_theory_categorical (T : Language.empty.Theory) : κ.Categorical T 
goal: κ.Categorical T

full_name: Cardinal.empty_infinite_Theory_isComplete
code: theorem empty_infinite_Theory_isComplete : Language.empty.infiniteTheory.IsComplete 
goal: FirstOrder.Language.empty.infiniteTheory.IsComplete