fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
nonempty [Mn : Nonempty M] (h : M ≅[L] N) : Nonempty N :=
h.nonempty_iff.1 Mn | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | nonempty | null |
infinite_iff (h : M ≅[L] N) : Infinite M ↔ Infinite N :=
(model_infiniteTheory_iff L).symm.trans (h.theory_model_iff.trans (model_infiniteTheory_iff L)) | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | infinite_iff | null |
infinite [Mi : Infinite M] (h : M ≅[L] N) : Infinite N :=
h.infinite_iff.1 Mi | theorem | ModelTheory | [
"Mathlib.Data.Finset.Basic",
"Mathlib.ModelTheory.Syntax",
"Mathlib.Data.List.ProdSigma"
] | Mathlib/ModelTheory/Semantics.lean | infinite | null |
@[simps]
skolem₁ : Language :=
⟨fun n => L.BoundedFormula Empty (n + 1), fun _ => Empty⟩
variable {L} | def | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | skolem₁ | A language consisting of Skolem functions for another language.
Called `skolem₁` because it is the first step in building a Skolemization of a language. |
card_functions_sum_skolem₁ :
#(Σ n, (L.sum L.skolem₁).Functions n) = #(Σ n, L.BoundedFormula Empty (n + 1)) := by
simp only [card_functions_sum, skolem₁_Functions, mk_sigma, sum_add_distrib']
conv_lhs => enter [2, 1, i]; rw [lift_id'.{u, v}]
rw [add_comm, add_eq_max, max_eq_left]
· refine sum_le_sum _ _ fun... | theorem | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | card_functions_sum_skolem₁ | null |
card_functions_sum_skolem₁_le : #(Σ n, (L.sum L.skolem₁).Functions n) ≤ max ℵ₀ L.card := by
rw [card_functions_sum_skolem₁]
trans #(Σ n, L.BoundedFormula Empty n)
· exact
⟨⟨Sigma.map Nat.succ fun _ => id,
Nat.succ_injective.sigma_map fun _ => Function.injective_id⟩⟩
· refine _root_.trans Bounded... | theorem | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | card_functions_sum_skolem₁_le | null |
noncomputable skolem₁Structure : L.skolem₁.Structure M :=
⟨fun {_} φ x => Classical.epsilon fun a => φ.Realize default (Fin.snoc x a : _ → M), fun {_} r =>
Empty.elim r⟩ | instance | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | skolem₁Structure | The structure assigning each function symbol of `L.skolem₁` to a skolem function generated with
choice. |
skolem₁_reduct_isElementary (S : (L.sum L.skolem₁).Substructure M) :
(LHom.sumInl.substructureReduct S).IsElementary := by
apply (LHom.sumInl.substructureReduct S).isElementary_of_exists
intro n φ x a h
let φ' : (L.sum L.skolem₁).Functions n := LHom.sumInr.onFunction φ
use ⟨funMap φ' ((↑) ∘ x), ?_⟩
· exac... | theorem | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | skolem₁_reduct_isElementary | null |
noncomputable elementarySkolem₁Reduct (S : (L.sum L.skolem₁).Substructure M) :
L.ElementarySubstructure M :=
⟨LHom.sumInl.substructureReduct S, S.skolem₁_reduct_isElementary⟩ | def | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | elementarySkolem₁Reduct | Any `L.sum L.skolem₁`-substructure is an elementary `L`-substructure. |
coeSort_elementarySkolem₁Reduct (S : (L.sum L.skolem₁).Substructure M) :
(S.elementarySkolem₁Reduct : Type w) = S :=
rfl | theorem | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | coeSort_elementarySkolem₁Reduct | null |
Substructure.elementarySkolem₁Reduct.instSmall :
Small.{max u v} (⊥ : (L.sum L.skolem₁).Substructure M).elementarySkolem₁Reduct := by
rw [coeSort_elementarySkolem₁Reduct]
infer_instance | instance | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | Substructure.elementarySkolem₁Reduct.instSmall | null |
exists_small_elementarySubstructure : ∃ S : L.ElementarySubstructure M, Small.{max u v} S :=
⟨Substructure.elementarySkolem₁Reduct ⊥, inferInstance⟩
variable {M} | theorem | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | exists_small_elementarySubstructure | null |
exists_elementarySubstructure_card_eq (s : Set M) (κ : Cardinal.{w'}) (h1 : ℵ₀ ≤ κ)
(h2 : Cardinal.lift.{w'} #s ≤ Cardinal.lift.{w} κ)
(h3 : Cardinal.lift.{w'} L.card ≤ Cardinal.lift.{max u v} κ)
(h4 : Cardinal.lift.{w} κ ≤ Cardinal.lift.{w'} #M) :
∃ S : L.ElementarySubstructure M, s ⊆ S ∧ Cardinal.lift... | theorem | ModelTheory | [
"Mathlib.ModelTheory.ElementarySubstructures"
] | Mathlib/ModelTheory/Skolem.lean | exists_elementarySubstructure_card_eq | The **Downward Löwenheim–Skolem theorem** :
If `s` is a set in an `L`-structure `M` and `κ` an infinite cardinal such that
`max (#s, L.card) ≤ κ` and `κ ≤ # M`, then `M` has an elementary substructure containing `s` of
cardinality `κ`. |
ClosedUnder : Prop :=
∀ x : Fin n → M, (∀ i : Fin n, x i ∈ s) → funMap f x ∈ s
variable (L)
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | ClosedUnder | Indicates that a set in a given structure is a closed under a function symbol. |
closedUnder_univ : ClosedUnder f (univ : Set M) := fun _ _ => mem_univ _
variable {L f s} {t : Set M} | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closedUnder_univ | null |
inter (hs : ClosedUnder f s) (ht : ClosedUnder f t) : ClosedUnder f (s ∩ t) := fun x h =>
mem_inter (hs x fun i => mem_of_mem_inter_left (h i)) (ht x fun i => mem_of_mem_inter_right (h i)) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | inter | null |
inf (hs : ClosedUnder f s) (ht : ClosedUnder f t) : ClosedUnder f (s ⊓ t) :=
hs.inter ht
variable {S : Set (Set M)} | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | inf | null |
sInf (hS : ∀ s, s ∈ S → ClosedUnder f s) : ClosedUnder f (sInf S) := fun x h s hs =>
hS s hs x fun i => h i s hs | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | sInf | null |
Substructure where
/-- The underlying set of this substructure -/
carrier : Set M
fun_mem : ∀ {n}, ∀ f : L.Functions n, ClosedUnder f carrier
variable {L} {M} | structure | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | Substructure | A substructure of a structure `M` is a set closed under application of function symbols. |
instSetLike : SetLike (L.Substructure M) M :=
⟨Substructure.carrier, fun p q h => by cases p; cases q; congr⟩ | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | instSetLike | null |
Simps.coe (S : L.Substructure M) : Set M :=
S
initialize_simps_projections Substructure (carrier → coe, as_prefix coe)
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | Simps.coe | See Note [custom simps projection] |
mem_carrier {s : L.Substructure M} {x : M} : x ∈ s.carrier ↔ x ∈ s :=
Iff.rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_carrier | null |
@[ext]
ext {S T : L.Substructure M} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T :=
SetLike.ext h | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | ext | Two substructures are equal if they have the same elements. |
protected copy (S : L.Substructure M) (s : Set M) (hs : s = S) : L.Substructure M where
carrier := s
fun_mem _ f := hs.symm ▸ S.fun_mem _ f | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | copy | Copy a substructure replacing `carrier` with a set that is equal to it. |
Term.realize_mem {α : Type*} (t : L.Term α) (xs : α → M) (h : ∀ a, xs a ∈ S) :
t.realize xs ∈ S := by
induction t with
| var a => exact h a
| func f ts ih => exact Substructure.fun_mem _ _ _ ih | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | Term.realize_mem | null |
@[simp]
coe_copy {s : Set M} (hs : s = S) : (S.copy s hs : Set M) = s :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_copy | null |
copy_eq {s : Set M} (hs : s = S) : S.copy s hs = S :=
SetLike.coe_injective hs | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | copy_eq | null |
constants_mem (c : L.Constants) : (c : M) ∈ S :=
mem_carrier.2 (S.fun_mem c _ finZeroElim) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | constants_mem | null |
instTop : Top (L.Substructure M) :=
⟨{ carrier := Set.univ
fun_mem := fun {_} _ _ _ => Set.mem_univ _ }⟩ | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | instTop | The substructure `M` of the structure `M`. |
instInhabited : Inhabited (L.Substructure M) :=
⟨⊤⟩
@[simp] | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | instInhabited | null |
mem_top (x : M) : x ∈ (⊤ : L.Substructure M) :=
Set.mem_univ x
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_top | null |
coe_top : ((⊤ : L.Substructure M) : Set M) = Set.univ :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_top | null |
instInf : Min (L.Substructure M) :=
⟨fun S₁ S₂ =>
{ carrier := (S₁ : Set M) ∩ (S₂ : Set M)
fun_mem := fun {_} f => (S₁.fun_mem f).inf (S₂.fun_mem f) }⟩
@[simp] | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | instInf | The inf of two substructures is their intersection. |
coe_inf (p p' : L.Substructure M) :
((p ⊓ p' : L.Substructure M) : Set M) = (p : Set M) ∩ (p' : Set M) :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_inf | null |
mem_inf {p p' : L.Substructure M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p' :=
Iff.rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_inf | null |
instInfSet : InfSet (L.Substructure M) :=
⟨fun s =>
{ carrier := ⋂ t ∈ s, (t : Set M)
fun_mem := fun {n} f =>
ClosedUnder.sInf
(by
rintro _ ⟨t, rfl⟩
by_cases h : t ∈ s
· simpa [h] using t.fun_mem f
· simp [h]) }⟩
@[simp, norm_cast] | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | instInfSet | null |
coe_sInf (S : Set (L.Substructure M)) :
((sInf S : L.Substructure M) : Set M) = ⋂ s ∈ S, (s : Set M) :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_sInf | null |
mem_sInf {S : Set (L.Substructure M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p :=
Set.mem_iInter₂ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_sInf | null |
mem_iInf {ι : Sort*} {S : ι → L.Substructure M} {x : M} :
(x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i := by simp only [iInf, mem_sInf, Set.forall_mem_range]
@[simp, norm_cast] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_iInf | null |
coe_iInf {ι : Sort*} {S : ι → L.Substructure M} :
((⨅ i, S i : L.Substructure M) : Set M) = ⋂ i, (S i : Set M) := by
simp only [iInf, coe_sInf, Set.biInter_range] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_iInf | null |
instCompleteLattice : CompleteLattice (L.Substructure M) :=
{ completeLatticeOfInf (L.Substructure M) fun _ =>
IsGLB.of_image
(fun {S T : L.Substructure M} => show (S : Set M) ≤ T ↔ S ≤ T from SetLike.coe_subset_coe)
isGLB_biInf with
le := (· ≤ ·)
lt := (· < ·)
top := ⊤
le_top :=... | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | instCompleteLattice | Substructures of a structure form a complete lattice. |
closure : LowerAdjoint ((↑) : L.Substructure M → Set M) :=
⟨fun s => sInf { S | s ⊆ S }, fun _ _ =>
⟨Set.Subset.trans fun _x hx => mem_sInf.2 fun _S hS => hS hx, fun h => sInf_le h⟩⟩
variable {L} {s : Set M} | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure | The `L.Substructure` generated by a set. |
mem_closure {x : M} : x ∈ closure L s ↔ ∀ S : L.Substructure M, s ⊆ S → x ∈ S :=
mem_sInf | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_closure | null |
@[simp]
subset_closure : s ⊆ closure L s :=
(closure L).le_closure s | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subset_closure | The substructure generated by a set includes the set. |
notMem_of_notMem_closure {P : M} (hP : P ∉ closure L s) : P ∉ s := fun h =>
hP (subset_closure h)
@[deprecated (since := "2025-05-23")] alias not_mem_of_not_mem_closure := notMem_of_notMem_closure
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | notMem_of_notMem_closure | null |
closed (S : L.Substructure M) : (closure L).closed (S : Set M) :=
congr rfl ((closure L).eq_of_le Set.Subset.rfl fun _x xS => mem_closure.2 fun _T hT => hT xS)
open Set | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closed | null |
@[simp]
closure_le : closure L s ≤ S ↔ s ⊆ S :=
(closure L).closure_le_closed_iff_le s S.closed | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_le | A substructure `S` includes `closure L s` if and only if it includes `s`. |
@[gcongr]
closure_mono ⦃s t : Set M⦄ (h : s ⊆ t) : closure L s ≤ closure L t :=
(closure L).monotone h | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_mono | Substructure closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure L s ≤ closure L t`. |
closure_eq_of_le (h₁ : s ⊆ S) (h₂ : S ≤ closure L s) : closure L s = S :=
(closure L).eq_of_le h₁ h₂ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_eq_of_le | null |
coe_closure_eq_range_term_realize :
(closure L s : Set M) = range (@Term.realize L _ _ _ ((↑) : s → M)) := by
let S : L.Substructure M := ⟨range (Term.realize (L := L) ((↑) : s → M)), fun {n} f x hx => by
simp only [mem_range] at *
refine ⟨func f fun i => Classical.choose (hx i), ?_⟩
simp only [Term.r... | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_closure_eq_range_term_realize | null |
small_closure [Small.{u} s] : Small.{u} (closure L s) := by
rw [← SetLike.coe_sort_coe, Substructure.coe_closure_eq_range_term_realize]
exact small_range _ | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | small_closure | null |
mem_closure_iff_exists_term {x : M} :
x ∈ closure L s ↔ ∃ t : L.Term s, t.realize ((↑) : s → M) = x := by
rw [← SetLike.mem_coe, coe_closure_eq_range_term_realize, mem_range] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_closure_iff_exists_term | null |
lift_card_closure_le_card_term : Cardinal.lift.{max u w} #(closure L s) ≤ #(L.Term s) := by
rw [← SetLike.coe_sort_coe, coe_closure_eq_range_term_realize]
rw [← Cardinal.lift_id'.{w, max u w} #(L.Term s)]
exact Cardinal.mk_range_le_lift | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | lift_card_closure_le_card_term | null |
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)) := by
rw [← lift_umax]
refine lift_card_closure_le_card_term.trans (Term.card_le.trans ?_)
rw [mk_sum, lift_umax.{w, u}] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | lift_card_closure_le | null |
mem_closed_iff (s : Set M) :
s ∈ (closure L).closed ↔ ∀ {n}, ∀ f : L.Functions n, ClosedUnder f s := by
refine ⟨fun h n f => ?_, fun h => ?_⟩
· rw [← h]
exact Substructure.fun_mem _ _
· have h' : closure L s = ⟨s, h⟩ := closure_eq_of_le (refl _) subset_closure
exact congr_arg _ h'
variable (L) | lemma | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_closed_iff | null |
mem_closed_of_isRelational [L.IsRelational] (s : Set M) : s ∈ (closure L).closed :=
(mem_closed_iff s).2 isEmptyElim
@[simp] | lemma | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_closed_of_isRelational | null |
closure_eq_of_isRelational [L.IsRelational] (s : Set M) : closure L s = s :=
LowerAdjoint.closure_eq_self_of_mem_closed _ (mem_closed_of_isRelational L s)
@[simp] | lemma | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_eq_of_isRelational | null |
mem_closure_iff_of_isRelational [L.IsRelational] (s : Set M) (m : M) :
m ∈ closure L s ↔ m ∈ s := by
rw [← SetLike.mem_coe, closure_eq_of_isRelational] | lemma | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_closure_iff_of_isRelational | null |
_root_.Set.Countable.substructure_closure
[Countable (Σ l, L.Functions l)] (h : s.Countable) : Countable.{w + 1} (closure L s) := by
haveI : Countable s := h.to_subtype
rw [← mk_le_aleph0_iff, ← lift_le_aleph0]
exact lift_card_closure_le_card_term.trans mk_le_aleph0
variable {L} (S) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | _root_.Set.Countable.substructure_closure | null |
@[elab_as_elim]
closure_induction {p : M → Prop} {x} (h : x ∈ closure L s) (Hs : ∀ x ∈ s, p x)
(Hfun : ∀ {n : ℕ} (f : L.Functions n), ClosedUnder f (setOf p)) : p x :=
(@closure_le L M _ ⟨setOf p, fun {_} => Hfun⟩ _).2 Hs h | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_induction | An induction principle for closure membership. If `p` holds for all elements of `s`, and
is preserved under function symbols, then `p` holds for all elements of the closure of `s`. |
@[elab_as_elim]
dense_induction {p : M → Prop} (x : M) {s : Set M} (hs : closure L s = ⊤)
(Hs : ∀ x ∈ s, p x) (Hfun : ∀ {n : ℕ} (f : L.Functions n), ClosedUnder f (setOf p)) : p x := by
have : ∀ x ∈ closure L s, p x := fun x hx => closure_induction hx Hs fun {n} => Hfun
simpa [hs] using this x
variable (L) (M) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | dense_induction | If `s` is a dense set in a structure `M`, `Substructure.closure L s = ⊤`, then in order to prove
that some predicate `p` holds for all `x : M` it suffices to verify `p x` for `x ∈ s`, and verify
that `p` is preserved under function symbols. |
protected gi : GaloisInsertion (@closure L M _) (↑) where
choice s _ := closure L s
gc := (closure L).gc
le_l_u _ := subset_closure
choice_eq _ _ := rfl
variable {L} {M} | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | gi | `closure` forms a Galois insertion with the coercion to set. |
@[simp]
closure_eq : closure L (S : Set M) = S :=
(Substructure.gi L M).l_u_eq S
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_eq | Closure of a substructure `S` equals `S`. |
closure_empty : closure L (∅ : Set M) = ⊥ :=
(Substructure.gi L M).gc.l_bot
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_empty | null |
closure_univ : closure L (univ : Set M) = ⊤ :=
@coe_top L M _ ▸ closure_eq ⊤ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_univ | null |
closure_union (s t : Set M) : closure L (s ∪ t) = closure L s ⊔ closure L t :=
(Substructure.gi L M).gc.l_sup | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_union | null |
closure_iUnion {ι} (s : ι → Set M) : closure L (⋃ i, s i) = ⨆ i, closure L (s i) :=
(Substructure.gi L M).gc.l_iSup | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_iUnion | null |
closure_insert (s : Set M) (m : M) : closure L (insert m s) = closure L {m} ⊔ closure L s :=
closure_union {m} s | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_insert | null |
small_bot : Small.{u} (⊥ : L.Substructure M) := by
rw [← closure_empty]
haveI : Small.{u} (∅ : Set M) := small_subsingleton _
exact Substructure.small_closure | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | small_bot | null |
iSup_eq_closure {ι : Sort*} (S : ι → L.Substructure M) :
⨆ i, S i = closure L (⋃ i, (S i : Set M)) := by simp_rw [closure_iUnion, closure_eq] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | iSup_eq_closure | null |
mem_iSup_of_directed {ι : Type*} [hι : Nonempty ι] {S : ι → L.Substructure M}
(hS : Directed (· ≤ ·) S) {x : M} :
x ∈ ⨆ i, S i ↔ ∃ i, x ∈ S i := by
refine ⟨?_, fun ⟨i, hi⟩ ↦ le_iSup S i hi⟩
suffices x ∈ closure L (⋃ i, (S i : Set M)) → ∃ i, x ∈ S i by
simpa only [closure_iUnion, closure_eq (S _)] using ... | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_iSup_of_directed | null |
mem_sSup_of_directedOn {S : Set (L.Substructure M)} (Sne : S.Nonempty)
(hS : DirectedOn (· ≤ ·) S) {x : M} :
x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s := by
haveI : Nonempty S := Sne.to_subtype
simp only [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, Subtype.exists, exists_prop]
variable (L) (M) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_sSup_of_directedOn | null |
@[simps]
comap (φ : M →[L] N) (S : L.Substructure N) : L.Substructure M where
carrier := φ ⁻¹' S
fun_mem {n} f x hx := by
rw [mem_preimage, φ.map_fun]
exact S.fun_mem f (φ ∘ x) hx
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap | The preimage of a substructure along a homomorphism is a substructure. |
mem_comap {S : L.Substructure N} {f : M →[L] N} {x : M} : x ∈ S.comap f ↔ f x ∈ S :=
Iff.rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_comap | null |
comap_comap (S : L.Substructure P) (g : N →[L] P) (f : M →[L] N) :
(S.comap g).comap f = S.comap (g.comp f) :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_comap | null |
comap_id (S : L.Substructure P) : S.comap (Hom.id _ _) = S :=
ext (by simp) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_id | null |
@[simps]
map (φ : M →[L] N) (S : L.Substructure M) : L.Substructure N where
carrier := φ '' S
fun_mem {n} f x hx :=
(mem_image _ _ _).1
⟨funMap f fun i => Classical.choose (hx i),
S.fun_mem f _ fun i => (Classical.choose_spec (hx i)).1, by
simp only [Hom.map_fun, SetLike.mem_coe]
e... | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map | The image of a substructure along a homomorphism is a substructure. |
mem_map {f : M →[L] N} {S : L.Substructure M} {y : N} :
y ∈ S.map f ↔ ∃ x ∈ S, f x = y :=
Iff.rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_map | null |
mem_map_of_mem (f : M →[L] N) {S : L.Substructure M} {x : M} (hx : x ∈ S) : f x ∈ S.map f :=
mem_image_of_mem f hx | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_map_of_mem | null |
apply_coe_mem_map (f : M →[L] N) (S : L.Substructure M) (x : S) : f x ∈ S.map f :=
mem_map_of_mem f x.prop | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | apply_coe_mem_map | null |
map_map (g : N →[L] P) (f : M →[L] N) : (S.map f).map g = S.map (g.comp f) :=
SetLike.coe_injective <| image_image _ _ _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_map | null |
map_le_iff_le_comap {f : M →[L] N} {S : L.Substructure M} {T : L.Substructure N} :
S.map f ≤ T ↔ S ≤ T.comap f :=
image_subset_iff | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_le_iff_le_comap | null |
gc_map_comap (f : M →[L] N) : GaloisConnection (map f) (comap f) := fun _ _ =>
map_le_iff_le_comap | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | gc_map_comap | null |
map_le_of_le_comap {T : L.Substructure N} {f : M →[L] N} : S ≤ T.comap f → S.map f ≤ T :=
(gc_map_comap f).l_le | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_le_of_le_comap | null |
le_comap_of_map_le {T : L.Substructure N} {f : M →[L] N} : S.map f ≤ T → S ≤ T.comap f :=
(gc_map_comap f).le_u | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | le_comap_of_map_le | null |
le_comap_map {f : M →[L] N} : S ≤ (S.map f).comap f :=
(gc_map_comap f).le_u_l _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | le_comap_map | null |
map_comap_le {S : L.Substructure N} {f : M →[L] N} : (S.comap f).map f ≤ S :=
(gc_map_comap f).l_u_le _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_comap_le | null |
monotone_map {f : M →[L] N} : Monotone (map f) :=
(gc_map_comap f).monotone_l | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | monotone_map | null |
monotone_comap {f : M →[L] N} : Monotone (comap f) :=
(gc_map_comap f).monotone_u
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | monotone_comap | null |
map_comap_map {f : M →[L] N} : ((S.map f).comap f).map f = S.map f :=
(gc_map_comap f).l_u_l_eq_l _
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_comap_map | null |
comap_map_comap {S : L.Substructure N} {f : M →[L] N} :
((S.comap f).map f).comap f = S.comap f :=
(gc_map_comap f).u_l_u_eq_u _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_map_comap | null |
map_sup (S T : L.Substructure M) (f : M →[L] N) : (S ⊔ T).map f = S.map f ⊔ T.map f :=
(gc_map_comap f).l_sup | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_sup | null |
map_iSup {ι : Sort*} (f : M →[L] N) (s : ι → L.Substructure M) :
(⨆ i, s i).map f = ⨆ i, (s i).map f :=
(gc_map_comap f).l_iSup | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_iSup | null |
comap_inf (S T : L.Substructure N) (f : M →[L] N) :
(S ⊓ T).comap f = S.comap f ⊓ T.comap f :=
(gc_map_comap f).u_inf | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_inf | null |
comap_iInf {ι : Sort*} (f : M →[L] N) (s : ι → L.Substructure N) :
(⨅ i, s i).comap f = ⨅ i, (s i).comap f :=
(gc_map_comap f).u_iInf
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_iInf | null |
map_bot (f : M →[L] N) : (⊥ : L.Substructure M).map f = ⊥ :=
(gc_map_comap f).l_bot
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_bot | null |
comap_top (f : M →[L] N) : (⊤ : L.Substructure N).comap f = ⊤ :=
(gc_map_comap f).u_top
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_top | null |
map_id (S : L.Substructure M) : S.map (Hom.id L M) = S :=
SetLike.coe_injective <| Set.image_id _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_id | null |
map_closure (f : M →[L] N) (s : Set M) : (closure L s).map f = closure L (f '' s) :=
Eq.symm <|
closure_eq_of_le (Set.image_mono subset_closure) <|
map_le_iff_le_comap.2 <| closure_le.2 fun x hx => subset_closure ⟨x, hx, rfl⟩
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_closure | null |
closure_image (f : M →[L] N) : closure L (f '' s) = map f (closure L s) :=
(map_closure f s).symm | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_image | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.