ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- FirstOrder.Language.BoundedFormula.all_semanticallyEquivalent_not_ex_not
theorem all_semanticallyEquivalent_not_ex_not (φ : L.BoundedFormula α (n + 1)) :
    T.SemanticallyEquivalent φ.all φ.not.ex.not 
Arguments: {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {n : ℕ} (φ : L.BoundedFormula α (n + 1))
Goal: T.SemanticallyEquivalent (∀'φ) ∼(∃'∼φ)
-- FirstOrder.Language.BoundedFormula.ex_semanticallyEquivalent_not_all_not
theorem ex_semanticallyEquivalent_not_all_not (φ : L.BoundedFormula α (n + 1)) :
    T.SemanticallyEquivalent φ.ex φ.not.all.not 
Arguments: {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {n : ℕ} (φ : L.BoundedFormula α (n + 1))
Goal: T.SemanticallyEquivalent (∃'φ) ∼(∀'∼φ)
-- FirstOrder.Language.BoundedFormula.semanticallyEquivalent_all_liftAt
theorem semanticallyEquivalent_all_liftAt : T.SemanticallyEquivalent φ (φ.liftAt 1 n).all 
Arguments: {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {n : ℕ} (φ : L.BoundedFormula α n)
Goal: T.SemanticallyEquivalent φ (∀'FirstOrder.Language.BoundedFormula.liftAt 1 n φ)
-- FirstOrder.Language.Formula.semanticallyEquivalent_not_not
theorem semanticallyEquivalent_not_not : T.SemanticallyEquivalent φ φ.not.not 
Arguments: {L : FirstOrder.Language} {T : L.Theory} {α : Type w} (φ : L.Formula α)
Goal: T.SemanticallyEquivalent φ φ.not.not
-- FirstOrder.Language.Formula.imp_semanticallyEquivalent_not_sup
theorem imp_semanticallyEquivalent_not_sup : T.SemanticallyEquivalent (φ.imp ψ) (φ.not ⊔ ψ) 
Arguments: {L : FirstOrder.Language} {T : L.Theory} {α : Type w} (φ ψ : L.Formula α)
Goal: T.SemanticallyEquivalent (φ.imp ψ) (φ.not ⊔ ψ)
-- FirstOrder.Language.Formula.sup_semanticallyEquivalent_not_inf_not
theorem sup_semanticallyEquivalent_not_inf_not :
    T.SemanticallyEquivalent (φ ⊔ ψ) (φ.not ⊓ ψ.not).not 
Arguments: {L : FirstOrder.Language} {T : L.Theory} {α : Type w} (φ ψ : L.Formula α)
Goal: T.SemanticallyEquivalent (φ ⊔ ψ) (φ.not ⊓ ψ.not).not
-- FirstOrder.Language.Formula.inf_semanticallyEquivalent_not_sup_not
theorem inf_semanticallyEquivalent_not_sup_not :
    T.SemanticallyEquivalent (φ ⊓ ψ) (φ.not ⊔ ψ.not).not 
Arguments: {L : FirstOrder.Language} {T : L.Theory} {α : Type w} (φ ψ : L.Formula α)
Goal: T.SemanticallyEquivalent (φ ⊓ ψ) (φ.not ⊔ ψ.not).not
-- Cardinal.Categorical.isComplete
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 
Arguments: {L : FirstOrder.Language} (κ : Cardinal.{w}) (T : L.Theory) (h : κ.Categorical T) (h1 : ℵ₀ ≤ κ) (h2 : Cardinal.lift.{w, max u v} L.card ≤ Cardinal.lift.{max u v, w} κ) (hS : T.IsSatisfiable) (hT : ∀ (M : T.ModelType), Infinite ↑M)
Goal: T.IsComplete
-- Cardinal.empty_theory_categorical
theorem empty_theory_categorical (T : Language.empty.Theory) : κ.Categorical T 
Arguments: (κ : Cardinal.{w}) (T : FirstOrder.Language.empty.Theory)
Goal: κ.Categorical T
-- Cardinal.empty_infinite_Theory_isComplete
theorem empty_infinite_Theory_isComplete : Language.empty.infiniteTheory.IsComplete 
Goal: FirstOrder.Language.empty.infiniteTheory.IsComplete
-- Set.Definable.map_expansion
theorem Definable.map_expansion {L' : FirstOrder.Language} [L'.Structure M] (h : A.Definable L s)
    (φ : L →ᴸ L') [φ.IsExpansionOn M] : A.Definable L' s 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {s : Set (α → M)} {L' : FirstOrder.Language} [L'.Structure M] (h : A.Definable L s) (φ : L →ᴸ L') [φ.IsExpansionOn M]
Goal: A.Definable L' s
-- Set.definable_iff_exists_formula_sum
theorem definable_iff_exists_formula_sum :
    A.Definable L s ↔ ∃ φ : L.Formula (A ⊕ α), s = {v | φ.Realize (Sum.elim (↑) v)} 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {s : Set (α → M)}
Goal: A.Definable L s ↔ ∃ φ, s = {v | φ.Realize (Sum.elim Subtype.val v)}
-- Set.empty_definable_iff
theorem empty_definable_iff :
    (∅ : Set M).Definable L s ↔ ∃ φ : L.Formula α, s = setOf φ.Realize 
Arguments: {M : Type w} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {s : Set (α → M)}
Goal: ∅.Definable L s ↔ ∃ φ, s = setOf φ.Realize
-- Set.definable_iff_empty_definable_with_params
theorem definable_iff_empty_definable_with_params :
    A.Definable L s ↔ (∅ : Set M).Definable (L[[A]]) s 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {s : Set (α → M)}
Goal: A.Definable L s ↔ ∅.Definable (L.withConstants ↑A) s
-- Set.Definable.mono
theorem Definable.mono (hAs : A.Definable L s) (hAB : A ⊆ B) : B.Definable L s 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {B : Set M} {s : Set (α → M)} (hAs : A.Definable L s) (hAB : A ⊆ B)
Goal: B.Definable L s
-- Set.definable_empty
@[simp]
theorem definable_empty : A.Definable L (∅ : Set (α → M)) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁}
Goal: A.Definable L ∅
-- Set.definable_univ
@[simp]
theorem definable_univ : A.Definable L (univ : Set (α → M)) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁}
Goal: A.Definable L Set.univ
-- Set.Definable.inter
@[simp]
theorem Definable.inter {f g : Set (α → M)} (hf : A.Definable L f) (hg : A.Definable L g) :
    A.Definable L (f ∩ g) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {f g : Set (α → M)} (hf : A.Definable L f) (hg : A.Definable L g)
Goal: A.Definable L (f ∩ g)
-- Set.Definable.union
@[simp]
theorem Definable.union {f g : Set (α → M)} (hf : A.Definable L f) (hg : A.Definable L g) :
    A.Definable L (f ∪ g) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {f g : Set (α → M)} (hf : A.Definable L f) (hg : A.Definable L g)
Goal: A.Definable L (f ∪ g)
-- Set.definable_finset_inf
theorem definable_finset_inf {ι : Type*} {f : ι → Set (α → M)} (hf : ∀ i, A.Definable L (f i))
    (s : Finset ι) : A.Definable L (s.inf f) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {ι : Type u_2} {f : ι → Set (α → M)} (hf : ∀ (i : ι), A.Definable L (f i)) (s : Finset ι)
Goal: A.Definable L (s.inf f)
-- Set.definable_finset_sup
theorem definable_finset_sup {ι : Type*} {f : ι → Set (α → M)} (hf : ∀ i, A.Definable L (f i))
    (s : Finset ι) : A.Definable L (s.sup f) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {ι : Type u_2} {f : ι → Set (α → M)} (hf : ∀ (i : ι), A.Definable L (f i)) (s : Finset ι)
Goal: A.Definable L (s.sup f)
-- Set.definable_finset_biInter
theorem definable_finset_biInter {ι : Type*} {f : ι → Set (α → M)}
    (hf : ∀ i, A.Definable L (f i)) (s : Finset ι) : A.Definable L (⋂ i ∈ s, f i) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {ι : Type u_2} {f : ι → Set (α → M)} (hf : ∀ (i : ι), A.Definable L (f i)) (s : Finset ι)
Goal: A.Definable L (⋂ i ∈ s, f i)
-- Set.definable_finset_biUnion
theorem definable_finset_biUnion {ι : Type*} {f : ι → Set (α → M)}
    (hf : ∀ i, A.Definable L (f i)) (s : Finset ι) : A.Definable L (⋃ i ∈ s, f i) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {ι : Type u_2} {f : ι → Set (α → M)} (hf : ∀ (i : ι), A.Definable L (f i)) (s : Finset ι)
Goal: A.Definable L (⋃ i ∈ s, f i)
-- Set.Definable.compl
@[simp]
theorem Definable.compl {s : Set (α → M)} (hf : A.Definable L s) : A.Definable L sᶜ 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {s : Set (α → M)} (hf : A.Definable L s)
Goal: A.Definable L sᶜ
-- Set.Definable.sdiff
@[simp]
theorem Definable.sdiff {s t : Set (α → M)} (hs : A.Definable L s) (ht : A.Definable L t) :
    A.Definable L (s \ t) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {s t : Set (α → M)} (hs : A.Definable L s) (ht : A.Definable L t)
Goal: A.Definable L (s \ t)
-- Set.Definable.himp
@[simp] lemma Definable.himp {s t : Set (α → M)} (hs : A.Definable L s) (ht : A.Definable L t) :
    A.Definable L (s ⇨ t) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {s t : Set (α → M)} (hs : A.Definable L s) (ht : A.Definable L t)
Goal: A.Definable L (s ⇨ t)
-- Set.Definable.preimage_comp
theorem Definable.preimage_comp (f : α → β) {s : Set (α → M)} (h : A.Definable L s) :
    A.Definable L ((fun g : β → M => g ∘ f) ⁻¹' s) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {β : Type u_1} (f : α → β) {s : Set (α → M)} (h : A.Definable L s)
Goal: A.Definable L ((fun g => g ∘ f) ⁻¹' s)
-- Set.Definable.image_comp_equiv
theorem Definable.image_comp_equiv {s : Set (β → M)} (h : A.Definable L s) (f : α ≃ β) :
    A.Definable L ((fun g : β → M => g ∘ f) '' s) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {β : Type u_1} {s : Set (β → M)} (h : A.Definable L s) (f : α ≃ β)
Goal: A.Definable L ((fun g => g ∘ ⇑f) '' s)
-- Set.definable_iff_finitely_definable
theorem definable_iff_finitely_definable :
    A.Definable L s ↔ ∃ (A0 : Finset M), (A0 : Set M) ⊆ A ∧
      (A0 : Set M).Definable L s 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {s : Set (α → M)}
Goal: A.Definable L s ↔ ∃ A0, ↑A0 ⊆ A ∧ (↑A0).Definable L s
-- Set.Definable.image_comp_sum_inl_fin
theorem Definable.image_comp_sum_inl_fin (m : ℕ) {s : Set (Sum α (Fin m) → M)}
    (h : A.Definable L s) : A.Definable L ((fun g : Sum α (Fin m) → M => g ∘ Sum.inl) '' s) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} (m : ℕ) {s : Set (α ⊕ Fin m → M)} (h : A.Definable L s)
Goal: A.Definable L ((fun g => g ∘ Sum.inl) '' s)
-- Set.Definable.image_comp_embedding
theorem Definable.image_comp_embedding {s : Set (β → M)} (h : A.Definable L s) (f : α ↪ β)
    [Finite β] : A.Definable L ((fun g : β → M => g ∘ f) '' s) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {β : Type u_1} {s : Set (β → M)} (h : A.Definable L s) (f : α ↪ β) [Finite β]
Goal: A.Definable L ((fun g => g ∘ ⇑f) '' s)
-- Set.Definable.image_comp
theorem Definable.image_comp {s : Set (β → M)} (h : A.Definable L s) (f : α → β) [Finite α]
    [Finite β] : A.Definable L ((fun g : β → M => g ∘ f) '' s) 
Arguments: {M : Type w} {A : Set M} {L : FirstOrder.Language} [L.Structure M] {α : Type u₁} {β : Type u_1} {s : Set (β → M)} (h : A.Definable L s) (f : α → β) [Finite α] [Finite β]
Goal: A.Definable L ((fun g => g ∘ f) '' s)
-- FirstOrder.Language.DefinableSet.le_iff
theorem le_iff : s ≤ t ↔ (s : Set (α → M)) ≤ (t : Set (α → M)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} {s t : L.DefinableSet A α}
Goal: s ≤ t ↔ ↑s ≤ ↑t
-- FirstOrder.Language.DefinableSet.mem_top
@[simp]
theorem mem_top : x ∈ (⊤ : L.DefinableSet A α) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} {x : α → M}
Goal: x ∈ ⊤
-- FirstOrder.Language.DefinableSet.not_mem_bot
@[simp]
theorem not_mem_bot {x : α → M} : ¬x ∈ (⊥ : L.DefinableSet A α) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} {x : α → M}
Goal: x ∉ ⊥
-- FirstOrder.Language.DefinableSet.mem_sup
@[simp]
theorem mem_sup : x ∈ s ⊔ t ↔ x ∈ s ∨ x ∈ t 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} {s t : L.DefinableSet A α} {x : α → M}
Goal: x ∈ s ⊔ t ↔ x ∈ s ∨ x ∈ t
-- FirstOrder.Language.DefinableSet.mem_inf
@[simp]
theorem mem_inf : x ∈ s ⊓ t ↔ x ∈ s ∧ x ∈ t 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} {s t : L.DefinableSet A α} {x : α → M}
Goal: x ∈ s ⊓ t ↔ x ∈ s ∧ x ∈ t
-- FirstOrder.Language.DefinableSet.mem_compl
@[simp]
theorem mem_compl : x ∈ sᶜ ↔ ¬x ∈ s 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} {s : L.DefinableSet A α} {x : α → M}
Goal: x ∈ sᶜ ↔ x ∉ s
-- FirstOrder.Language.DefinableSet.mem_sdiff
@[simp]
theorem mem_sdiff : x ∈ s \ t ↔ x ∈ s ∧ ¬x ∈ t 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} {s t : L.DefinableSet A α} {x : α → M}
Goal: x ∈ s \ t ↔ x ∈ s ∧ x ∉ t
-- FirstOrder.Language.DefinableSet.coe_top
@[simp, norm_cast]
theorem coe_top : ((⊤ : L.DefinableSet A α) : Set (α → M)) = univ 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁}
Goal: ↑⊤ = Set.univ
-- FirstOrder.Language.DefinableSet.coe_bot
@[simp, norm_cast]
theorem coe_bot : ((⊥ : L.DefinableSet A α) : Set (α → M)) = ∅ 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁}
Goal: ↑⊥ = ∅
-- FirstOrder.Language.DefinableSet.coe_sup
@[simp, norm_cast]
theorem coe_sup (s t : L.DefinableSet A α) :
    ((s ⊔ t : L.DefinableSet A α) : Set (α → M)) = (s : Set (α → M)) ∪ (t : Set (α → M)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} (s t : L.DefinableSet A α)
Goal: ↑(s ⊔ t) = ↑s ∪ ↑t
-- FirstOrder.Language.DefinableSet.coe_inf
@[simp, norm_cast]
theorem coe_inf (s t : L.DefinableSet A α) :
    ((s ⊓ t : L.DefinableSet A α) : Set (α → M)) = (s : Set (α → M)) ∩ (t : Set (α → M)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} (s t : L.DefinableSet A α)
Goal: ↑(s ⊓ t) = ↑s ∩ ↑t
-- FirstOrder.Language.DefinableSet.coe_compl
@[simp, norm_cast]
theorem coe_compl (s : L.DefinableSet A α) :
    ((sᶜ : L.DefinableSet A α) : Set (α → M)) = (s : Set (α → M))ᶜ 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} (s : L.DefinableSet A α)
Goal: ↑sᶜ = (↑s)ᶜ
-- FirstOrder.Language.DefinableSet.coe_sdiff
@[simp, norm_cast]
theorem coe_sdiff (s t : L.DefinableSet A α) :
    ((s \ t : L.DefinableSet A α) : Set (α → M)) = (s : Set (α → M)) \ (t : Set (α → M)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} (s t : L.DefinableSet A α)
Goal: ↑(s \ t) = ↑s \ ↑t
-- FirstOrder.Language.DefinableSet.coe_himp
@[simp, norm_cast]
lemma coe_himp (s t : L.DefinableSet A α) : ↑(s ⇨ t) = (s ⇨ t : Set (α → M)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {A : Set M} {α : Type u₁} (s t : L.DefinableSet A α)
Goal: ↑(s ⇨ t) = ↑s ⇨ ↑t
-- FirstOrder.Language.closedUnder_univ
@[simp]
theorem closedUnder_univ : ClosedUnder f (univ : Set M) 
Arguments: (L : FirstOrder.Language) {M : Type w} [L.Structure M] {n : ℕ} (f : L.Functions n)
Goal: FirstOrder.Language.ClosedUnder f Set.univ
-- FirstOrder.Language.ClosedUnder.inter
theorem inter (hs : ClosedUnder f s) (ht : ClosedUnder f t) : ClosedUnder f (s ∩ t) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {n : ℕ} {f : L.Functions n} {s t : Set M} (hs : FirstOrder.Language.ClosedUnder f s) (ht : FirstOrder.Language.ClosedUnder f t)
Goal: FirstOrder.Language.ClosedUnder f (s ∩ t)
-- FirstOrder.Language.ClosedUnder.inf
theorem inf (hs : ClosedUnder f s) (ht : ClosedUnder f t) : ClosedUnder f (s ⊓ t) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {n : ℕ} {f : L.Functions n} {s t : Set M} (hs : FirstOrder.Language.ClosedUnder f s) (ht : FirstOrder.Language.ClosedUnder f t)
Goal: FirstOrder.Language.ClosedUnder f (s ⊓ t)
-- FirstOrder.Language.ClosedUnder.sInf
theorem sInf (hS : ∀ s, s ∈ S → ClosedUnder f s) : ClosedUnder f (sInf S) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {n : ℕ} {f : L.Functions n} {S : Set (Set M)} (hS : ∀ s ∈ S, FirstOrder.Language.ClosedUnder f s)
Goal: FirstOrder.Language.ClosedUnder f (sInf S)
-- FirstOrder.Language.Substructure.fun_mem
structure Substructure where
  carrier : Set M
  fun_mem : ∀ {n}, ∀ f : L.Functions n, ClosedUnder f carrier
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] (self : L.Substructure M) {n : ℕ} (f : L.Functions n)
Goal: FirstOrder.Language.ClosedUnder f ↑self
-- FirstOrder.Language.Substructure.mem_carrier
@[simp]
theorem mem_carrier {s : L.Substructure M} {x : M} : x ∈ s.carrier ↔ x ∈ s 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {s : L.Substructure M} {x : M}
Goal: x ∈ ↑s ↔ x ∈ s
-- FirstOrder.Language.Substructure.ext
@[ext]
theorem ext {S T : L.Substructure M} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {S T : L.Substructure M} (h : ∀ (x : M), x ∈ S ↔ x ∈ T)
Goal: S = T
-- FirstOrder.Language.Term.realize_mem
theorem Term.realize_mem {α : Type*} (t : L.Term α) (xs : α → M) (h : ∀ a, xs a ∈ S) :
    t.realize xs ∈ S 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {S : L.Substructure M} {α : Type u_3} (t : L.Term α) (xs : α → M) (h : ∀ (a : α), xs a ∈ S)
Goal: FirstOrder.Language.Term.realize xs t ∈ S
-- FirstOrder.Language.Substructure.coe_copy
@[simp]
theorem coe_copy {s : Set M} (hs : s = S) : (S.copy s hs : Set M) = s 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {S : L.Substructure M} {s : Set M} (hs : s = ↑S)
Goal: ↑(S.copy s hs) = s
-- FirstOrder.Language.Substructure.copy_eq
theorem copy_eq {s : Set M} (hs : s = S) : S.copy s hs = S 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {S : L.Substructure M} {s : Set M} (hs : s = ↑S)
Goal: S.copy s hs = S
-- FirstOrder.Language.Substructure.constants_mem
theorem constants_mem (c : L.Constants) : (c : M) ∈ S 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {S : L.Substructure M} (c : L.Constants)
Goal: ↑c ∈ S
-- FirstOrder.Language.Substructure.mem_top
@[simp]
theorem mem_top (x : M) : x ∈ (⊤ : L.Substructure M) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] (x : M)
Goal: x ∈ ⊤
-- FirstOrder.Language.Substructure.coe_top
@[simp]
theorem coe_top : ((⊤ : L.Substructure M) : Set M) = Set.univ 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M]
Goal: ↑⊤ = Set.univ
-- FirstOrder.Language.Substructure.coe_inf
@[simp]
theorem coe_inf (p p' : L.Substructure M) :
    ((p ⊓ p' : L.Substructure M) : Set M) = (p : Set M) ∩ (p' : Set M) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] (p p' : L.Substructure M)
Goal: ↑(p ⊓ p') = ↑p ∩ ↑p'
-- FirstOrder.Language.Substructure.mem_inf
@[simp]
theorem mem_inf {p p' : L.Substructure M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {p p' : L.Substructure M} {x : M}
Goal: x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'
-- FirstOrder.Language.Substructure.coe_sInf
@[simp, norm_cast]
theorem coe_sInf (S : Set (L.Substructure M)) :
    ((sInf S : L.Substructure M) : Set M) = ⋂ s ∈ S, (s : Set M) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] (S : Set (L.Substructure M))
Goal: ↑(sInf S) = ⋂ s ∈ S, ↑s
-- FirstOrder.Language.Substructure.mem_sInf
theorem mem_sInf {S : Set (L.Substructure M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {S : Set (L.Substructure M)} {x : M}
Goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- FirstOrder.Language.Substructure.mem_iInf
theorem mem_iInf {ι : Sort*} {S : ι → L.Substructure M} {x : M} :
    (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {ι : Sort u_3} {S : ι → L.Substructure M} {x : M}
Goal: x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
-- FirstOrder.Language.Substructure.coe_iInf
@[simp, norm_cast]
theorem coe_iInf {ι : Sort*} {S : ι → L.Substructure M} :
    ((⨅ i, S i : L.Substructure M) : Set M) = ⋂ i, (S i : Set M) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {ι : Sort u_3} {S : ι → L.Substructure M}
Goal: ↑(⨅ i, S i) = ⋂ i, ↑(S i)
-- FirstOrder.Language.Substructure.mem_closure
theorem mem_closure {x : M} : x ∈ closure L s ↔ ∀ S : L.Substructure M, s ⊆ S → x ∈ S 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {s : Set M} {x : M}
Goal: x ∈ (FirstOrder.Language.Substructure.closure L).toFun s ↔ ∀ (S : L.Substructure M), s ⊆ ↑S → x ∈ S
-- FirstOrder.Language.Substructure.subset_closure
@[simp]
theorem subset_closure : s ⊆ closure L s 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {s : Set M}
Goal: s ⊆ ↑((FirstOrder.Language.Substructure.closure L).toFun s)
-- FirstOrder.Language.Substructure.not_mem_of_not_mem_closure
theorem not_mem_of_not_mem_closure {P : M} (hP : P ∉ closure L s) : P ∉ s 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {s : Set M} {P : M} (hP : P ∉ (FirstOrder.Language.Substructure.closure L).toFun s)
Goal: P ∉ s
-- FirstOrder.Language.Substructure.closed
@[simp]
theorem closed (S : L.Substructure M) : (closure L).closed (S : Set M) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] (S : L.Substructure M)
Goal: (FirstOrder.Language.Substructure.closure L).closed ↑S
-- FirstOrder.Language.Substructure.closure_le
@[simp]
theorem closure_le : closure L s ≤ S ↔ s ⊆ S 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {S : L.Substructure M} {s : Set M}
Goal: (FirstOrder.Language.Substructure.closure L).toFun s ≤ S ↔ s ⊆ ↑S
-- FirstOrder.Language.Substructure.closure_mono
theorem closure_mono ⦃s t : Set M⦄ (h : s ⊆ t) : closure L s ≤ closure L t 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] ⦃s t : Set M⦄ (h : s ⊆ t)
Goal: (FirstOrder.Language.Substructure.closure L).toFun s ≤ (FirstOrder.Language.Substructure.closure L).toFun t
-- FirstOrder.Language.Substructure.closure_eq_of_le
theorem closure_eq_of_le (h₁ : s ⊆ S) (h₂ : S ≤ closure L s) : closure L s = S 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {S : L.Substructure M} {s : Set M} (h₁ : s ⊆ ↑S) (h₂ : S ≤ (FirstOrder.Language.Substructure.closure L).toFun s)
Goal: (FirstOrder.Language.Substructure.closure L).toFun s = S
-- FirstOrder.Language.Substructure.coe_closure_eq_range_term_realize
theorem coe_closure_eq_range_term_realize :
    (closure L s : Set M) = range (@Term.realize L _ _ _ ((↑) : s → M)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {s : Set M}
Goal: ↑((FirstOrder.Language.Substructure.closure L).toFun s) = Set.range (FirstOrder.Language.Term.realize Subtype.val)
-- FirstOrder.Language.Substructure.mem_closure_iff_exists_term
theorem mem_closure_iff_exists_term {x : M} :
    x ∈ closure L s ↔ ∃ t : L.Term s, t.realize ((↑) : s → M) = x 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {s : Set M} {x : M}
Goal: x ∈ (FirstOrder.Language.Substructure.closure L).toFun s ↔ ∃ t, FirstOrder.Language.Term.realize Subtype.val t = x
-- FirstOrder.Language.Substructure.lift_card_closure_le_card_term
theorem lift_card_closure_le_card_term : Cardinal.lift.{max u w} #(closure L s) ≤ #(L.Term s) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {s : Set M}
Goal: Cardinal.lift.{max u w, w} (Cardinal.mk ↥((FirstOrder.Language.Substructure.closure L).toFun s)) ≤
  Cardinal.mk (L.Term ↑s)
-- FirstOrder.Language.Substructure.lift_card_closure_le
theorem lift_card_closure_le :
    Cardinal.lift.{u, w} #(closure L s) ≤
      max ℵ₀ (Cardinal.lift.{u, w} #s + Cardinal.lift.{w, u} #(Σi, L.Functions i)) 
Arguments: {L : FirstOrder.Language} {M : Type w} [L.Structure M] {s : Set M}
Goal: Cardinal.lift.{u, w} (Cardinal.mk ↥((FirstOrder.Language.Substructure.closure L).toFun s)) ≤
  max Cardinal.aleph0
    (Cardinal.lift.{u, w} (Cardinal.mk ↑s) + Cardinal.lift.{w, u} (Cardinal.mk ((i : ℕ) × L.Functions i)))
-- Set.Countable.substructure_closure
theorem _root_.Set.Countable.substructure_closure
    [Countable (Σl, L.Functions l)] (h : s.Countable) : Countable.{w + 1} (closure L s) 
Arguments: (L : FirstOrder.Language) {M : Type w} [L.Structure M] {s : Set M} [Countable ((l : ℕ) × L.Functions l)] (h : s.Countable)
Goal: Countable ↥((FirstOrder.Language.Substructure.closure L).toFun s)