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 ⌀ |
|---|---|---|---|---|---|---|
gciMapComap (hf : Function.Injective f) : GaloisCoinsertion (map f) (comap f) :=
(gc_map_comap f).toGaloisCoinsertion fun S x => by simp [mem_comap, mem_map, hf.eq_iff]
variable (hf : Function.Injective f)
include hf | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | gciMapComap | `map f` and `comap f` form a `GaloisCoinsertion` when `f` is injective. |
comap_map_eq_of_injective (S : L.Substructure M) : (S.map f).comap f = S :=
(gciMapComap hf).u_l_eq _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_map_eq_of_injective | null |
comap_surjective_of_injective : Function.Surjective (comap f) :=
(gciMapComap hf).u_surjective | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_surjective_of_injective | null |
map_injective_of_injective : Function.Injective (map f) :=
(gciMapComap hf).l_injective | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_injective_of_injective | null |
comap_inf_map_of_injective (S T : L.Substructure M) : (S.map f ⊓ T.map f).comap f = S ⊓ T :=
(gciMapComap hf).u_inf_l _ _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_inf_map_of_injective | null |
comap_iInf_map_of_injective (S : ι → L.Substructure M) :
(⨅ i, (S i).map f).comap f = ⨅ i, S i :=
(gciMapComap hf).u_iInf_l _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_iInf_map_of_injective | null |
comap_sup_map_of_injective (S T : L.Substructure M) : (S.map f ⊔ T.map f).comap f = S ⊔ T :=
(gciMapComap hf).u_sup_l _ _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_sup_map_of_injective | null |
comap_iSup_map_of_injective (S : ι → L.Substructure M) :
(⨆ i, (S i).map f).comap f = ⨆ i, S i :=
(gciMapComap hf).u_iSup_l _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_iSup_map_of_injective | null |
map_le_map_iff_of_injective {S T : L.Substructure M} : S.map f ≤ T.map f ↔ S ≤ T :=
(gciMapComap hf).l_le_l_iff | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_le_map_iff_of_injective | null |
map_strictMono_of_injective : StrictMono (map f) :=
(gciMapComap hf).strictMono_l | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_strictMono_of_injective | null |
giMapComap : GaloisInsertion (map f) (comap f) :=
(gc_map_comap f).toGaloisInsertion fun S x h =>
let ⟨y, hy⟩ := hf x
mem_map.2 ⟨y, by simp [hy, h]⟩ | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | giMapComap | `map f` and `comap f` form a `GaloisInsertion` when `f` is surjective. |
map_comap_eq_of_surjective (S : L.Substructure N) : (S.comap f).map f = S :=
(giMapComap hf).l_u_eq _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_comap_eq_of_surjective | null |
map_surjective_of_surjective : Function.Surjective (map f) :=
(giMapComap hf).l_surjective | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_surjective_of_surjective | null |
comap_injective_of_surjective : Function.Injective (comap f) :=
(giMapComap hf).u_injective | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_injective_of_surjective | null |
map_inf_comap_of_surjective (S T : L.Substructure N) :
(S.comap f ⊓ T.comap f).map f = S ⊓ T :=
(giMapComap hf).l_inf_u _ _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_inf_comap_of_surjective | null |
map_iInf_comap_of_surjective (S : ι → L.Substructure N) :
(⨅ i, (S i).comap f).map f = ⨅ i, S i :=
(giMapComap hf).l_iInf_u _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_iInf_comap_of_surjective | null |
map_sup_comap_of_surjective (S T : L.Substructure N) :
(S.comap f ⊔ T.comap f).map f = S ⊔ T :=
(giMapComap hf).l_sup_u _ _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_sup_comap_of_surjective | null |
map_iSup_comap_of_surjective (S : ι → L.Substructure N) :
(⨆ i, (S i).comap f).map f = ⨆ i, S i :=
(giMapComap hf).l_iSup_u _ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_iSup_comap_of_surjective | null |
comap_le_comap_iff_of_surjective {S T : L.Substructure N} : S.comap f ≤ T.comap f ↔ S ≤ T :=
(giMapComap hf).u_le_u_iff | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_le_comap_iff_of_surjective | null |
comap_strictMono_of_surjective : StrictMono (comap f) :=
(giMapComap hf).strictMono_u | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comap_strictMono_of_surjective | null |
inducedStructure {S : L.Substructure M} : L.Structure S where
funMap {_} f x := ⟨funMap f fun i => x i, S.fun_mem f (fun i => x i) fun i => (x i).2⟩
RelMap {_} r x := RelMap r fun i => (x i : M) | instance | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | inducedStructure | null |
subtype (S : L.Substructure M) : S ↪[L] M where
toFun := (↑)
inj' := Subtype.coe_injective
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subtype | The natural embedding of an `L.Substructure` of `M` into `M`. |
subtype_apply {S : L.Substructure M} {x : S} : subtype S x = x :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subtype_apply | null |
subtype_injective (S : L.Substructure M) : Function.Injective (subtype S) :=
Subtype.coe_injective
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subtype_injective | null |
coe_subtype : ⇑S.subtype = ((↑) : S → M) :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_subtype | null |
topEquiv : (⊤ : L.Substructure M) ≃[L] M where
toFun := subtype ⊤
invFun m := ⟨m, mem_top m⟩
left_inv m := by simp
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | topEquiv | The equivalence between the maximal substructure of a structure and the structure itself. |
coe_topEquiv :
⇑(topEquiv : (⊤ : L.Substructure M) ≃[L] M) = ((↑) : (⊤ : L.Substructure M) → M) :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_topEquiv | null |
realize_boundedFormula_top {α : Type*} {n : ℕ} {φ : L.BoundedFormula α n}
{v : α → (⊤ : L.Substructure M)} {xs : Fin n → (⊤ : L.Substructure M)} :
φ.Realize v xs ↔ φ.Realize (((↑) : _ → M) ∘ v) ((↑) ∘ xs) := by
rw [← StrongHomClass.realize_boundedFormula Substructure.topEquiv φ]
simp
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | realize_boundedFormula_top | null |
realize_formula_top {α : Type*} {φ : L.Formula α} {v : α → (⊤ : L.Substructure M)} :
φ.Realize v ↔ φ.Realize (((↑) : (⊤ : L.Substructure M) → M) ∘ v) := by
rw [← StrongHomClass.realize_formula Substructure.topEquiv φ]
simp | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | realize_formula_top | null |
@[elab_as_elim]
closure_induction' (s : Set M) {p : ∀ x, x ∈ closure L s → Prop}
(Hs : ∀ (x) (h : x ∈ s), p x (subset_closure h))
(Hfun : ∀ {n : ℕ} (f : L.Functions n), ClosedUnder f { x | ∃ hx, p x hx }) {x}
(hx : x ∈ closure L s) : p x hx := by
refine Exists.elim ?_ fun (hx : x ∈ closure L s) (hc : p x ... | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_induction' | A dependent version of `Substructure.closure_induction`. |
substructureReduct (φ : L →ᴸ L') [φ.IsExpansionOn M] :
L'.Substructure M ↪o L.Substructure M where
toFun S :=
{ carrier := S
fun_mem := fun {n} f x hx => by
have h := S.fun_mem (φ.onFunction f) x hx
simp only [LHom.map_onFunction, Substructure.mem_carrier] at h
exact h }
inj' S... | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | substructureReduct | Reduces the language of a substructure along a language hom. |
mem_substructureReduct {x : M} {S : L'.Substructure M} :
x ∈ φ.substructureReduct S ↔ x ∈ S :=
Iff.rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_substructureReduct | null |
coe_substructureReduct {S : L'.Substructure M} : (φ.substructureReduct S : Set M) = ↑S :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_substructureReduct | null |
withConstants (S : L.Substructure M) {A : Set M} (h : A ⊆ S) : L[[A]].Substructure M where
carrier := S
fun_mem {n} f := by
obtain f | f := f
· exact S.fun_mem f
· cases n
· exact fun _ _ => h f.2
· exact isEmptyElim f
variable {A : Set M} {s : Set M} (h : A ⊆ S)
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | withConstants | Turns any substructure containing a constant set `A` into a `L[[A]]`-substructure. |
mem_withConstants {x : M} : x ∈ S.withConstants h ↔ x ∈ S :=
Iff.rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_withConstants | null |
coe_withConstants : (S.withConstants h : Set M) = ↑S :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_withConstants | null |
reduct_withConstants :
(L.lhomWithConstants A).substructureReduct (S.withConstants h) = S := by
ext
simp | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | reduct_withConstants | null |
subset_closure_withConstants : A ⊆ closure (L[[A]]) s := by
intro a ha
simp only [SetLike.mem_coe]
let a' : L[[A]].Constants := Sum.inr ⟨a, ha⟩
exact constants_mem a' | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subset_closure_withConstants | null |
closure_withConstants_eq :
closure (L[[A]]) s =
(closure L (A ∪ s)).withConstants ((A.subset_union_left).trans subset_closure) := by
refine closure_eq_of_le ((A.subset_union_right).trans subset_closure) ?_
rw [← (L.lhomWithConstants A).substructureReduct.le_iff_le]
simp only [subset_closure, reduct_with... | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | closure_withConstants_eq | null |
@[simps!]
domRestrict (f : M →[L] N) (p : L.Substructure M) : p →[L] N :=
f.comp p.subtype.toHom | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | domRestrict | The restriction of a first-order hom to a substructure `s ⊆ M` gives a hom `s → N`. |
@[simps]
codRestrict (p : L.Substructure N) (f : M →[L] N) (h : ∀ c, f c ∈ p) : M →[L] p where
toFun c := ⟨f c, h c⟩
map_fun' {n} f x := by aesop
map_rel' {_} R x h := f.map_rel R x h
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | codRestrict | A first-order hom `f : M → N` whose values lie in a substructure `p ⊆ N` can be restricted to a
hom `M → p`. |
comp_codRestrict (f : M →[L] N) (g : N →[L] P) (p : L.Substructure P) (h : ∀ b, g b ∈ p) :
((codRestrict p g h).comp f : M →[L] p) = codRestrict p (g.comp f) fun _ => h _ :=
ext fun _ => rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comp_codRestrict | null |
subtype_comp_codRestrict (f : M →[L] N) (p : L.Substructure N) (h : ∀ b, f b ∈ p) :
p.subtype.toHom.comp (codRestrict p f h) = f :=
ext fun _ => rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subtype_comp_codRestrict | null |
range (f : M →[L] N) : L.Substructure N :=
(map f ⊤).copy (Set.range f) Set.image_univ.symm | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range | The range of a first-order hom `f : M → N` is a submodule of `N`.
See Note [range copy pattern]. |
range_coe (f : M →[L] N) : (range f : Set N) = Set.range f :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range_coe | null |
mem_range {f : M →[L] N} {x} : x ∈ range f ↔ ∃ y, f y = x :=
Iff.rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_range | null |
range_eq_map (f : M →[L] N) : f.range = map f ⊤ := by
ext
simp | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range_eq_map | null |
mem_range_self (f : M →[L] N) (x : M) : f x ∈ f.range :=
⟨x, rfl⟩
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_range_self | null |
range_id : range (id L M) = ⊤ :=
SetLike.coe_injective Set.range_id | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range_id | null |
range_comp (f : M →[L] N) (g : N →[L] P) : range (g.comp f : M →[L] P) = map g (range f) :=
SetLike.coe_injective (Set.range_comp g f) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range_comp | null |
range_comp_le_range (f : M →[L] N) (g : N →[L] P) : range (g.comp f : M →[L] P) ≤ range g :=
SetLike.coe_mono (Set.range_comp_subset_range f g) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range_comp_le_range | null |
range_eq_top {f : M →[L] N} : range f = ⊤ ↔ Function.Surjective f := by
rw [SetLike.ext'_iff, range_coe, coe_top, Set.range_eq_univ] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range_eq_top | null |
range_le_iff_comap {f : M →[L] N} {p : L.Substructure N} : range f ≤ p ↔ comap f p = ⊤ := by
rw [range_eq_map, map_le_iff_le_comap, eq_top_iff] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range_le_iff_comap | null |
map_le_range {f : M →[L] N} {p : L.Substructure M} : map f p ≤ range f :=
SetLike.coe_mono (Set.image_subset_range f p) | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | map_le_range | null |
eqLocus (f g : M →[L] N) : Substructure L M where
carrier := { x : M | f x = g x }
fun_mem {n} fn x hx := by
have h : f ∘ x = g ∘ x := by
ext
repeat' rw [Function.comp_apply]
apply hx
simp [h]
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | eqLocus | The substructure of elements `x : M` such that `f x = g x` |
mem_eqLocus {f g : M →[L] N} {x : M} : x ∈ f.eqLocus g ↔ f x = g x := Iff.rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | mem_eqLocus | null |
eqOn_closure {f g : M →[L] N} {s : Set M} (h : Set.EqOn f g s) :
Set.EqOn f g (closure L s) :=
show closure L s ≤ f.eqLocus g from closure_le.2 h | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | eqOn_closure | If two `L.Hom`s are equal on a set, then they are equal on its substructure closure. |
eq_of_eqOn_top {f g : M →[L] N} (h : Set.EqOn f g (⊤ : Substructure L M)) : f = g :=
ext fun _ => h trivial
variable {s : Set M} | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | eq_of_eqOn_top | null |
eq_of_eqOn_dense (hs : closure L s = ⊤) {f g : M →[L] N} (h : s.EqOn f g) : f = g :=
eq_of_eqOn_top <| hs ▸ eqOn_closure h | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | eq_of_eqOn_dense | null |
domRestrict (f : M ↪[L] N) (p : L.Substructure M) : p ↪[L] N :=
f.comp p.subtype
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | domRestrict | The restriction of a first-order embedding to a substructure `s ⊆ M` gives an embedding `s → N`. |
domRestrict_apply (f : M ↪[L] N) (p : L.Substructure M) (x : p) : f.domRestrict p x = f x :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | domRestrict_apply | null |
codRestrict (p : L.Substructure N) (f : M ↪[L] N) (h : ∀ c, f c ∈ p) : M ↪[L] p where
toFun := f.toHom.codRestrict p h
inj' _ _ ab := f.injective (Subtype.mk_eq_mk.1 ab)
map_fun' {_} F x := (f.toHom.codRestrict p h).map_fun' F x
map_rel' {n} r x := by
rw [← p.subtype.map_rel]
change RelMap r (Hom.comp p... | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | codRestrict | A first-order embedding `f : M → N` whose values lie in a substructure `p ⊆ N` can be restricted
to an embedding `M → p`. |
codRestrict_apply (p : L.Substructure N) (f : M ↪[L] N) {h} (x : M) :
(codRestrict p f h x : N) = f x :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | codRestrict_apply | null |
codRestrict_apply' (p : L.Substructure N) (f : M ↪[L] N) {h} (x : M) :
codRestrict p f h x = ⟨f x, h x⟩ :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | codRestrict_apply' | null |
comp_codRestrict (f : M ↪[L] N) (g : N ↪[L] P) (p : L.Substructure P) (h : ∀ b, g b ∈ p) :
((codRestrict p g h).comp f : M ↪[L] p) = codRestrict p (g.comp f) fun _ => h _ :=
ext fun _ => rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | comp_codRestrict | null |
subtype_comp_codRestrict (f : M ↪[L] N) (p : L.Substructure N) (h : ∀ b, f b ∈ p) :
p.subtype.comp (codRestrict p f h) = f :=
ext fun _ => rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subtype_comp_codRestrict | null |
noncomputable substructureEquivMap (f : M ↪[L] N) (s : L.Substructure M) :
s ≃[L] s.map f.toHom where
toFun := codRestrict (s.map f.toHom) (f.domRestrict s) fun ⟨m, hm⟩ => ⟨m, hm, rfl⟩
invFun n := ⟨Classical.choose n.2, (Classical.choose_spec n.2).1⟩
left_inv := fun ⟨m, hm⟩ =>
Subtype.mk_eq_mk.2
(f.... | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | substructureEquivMap | The equivalence between a substructure `s` and its image `s.map f.toHom`, where `f` is an
embedding. |
substructureEquivMap_apply (f : M ↪[L] N) (p : L.Substructure M) (x : p) :
(f.substructureEquivMap p x : N) = f x :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | substructureEquivMap_apply | null |
subtype_substructureEquivMap (f : M ↪[L] N) (s : L.Substructure M) :
(subtype _).comp (f.substructureEquivMap s).toEmbedding = f.comp (subtype _) := by
ext; rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subtype_substructureEquivMap | null |
@[simps toEquiv_apply] noncomputable equivRange (f : M ↪[L] N) : M ≃[L] f.toHom.range where
toFun := codRestrict f.toHom.range f f.toHom.mem_range_self
invFun n := Classical.choose n.2
left_inv m :=
f.injective (Classical.choose_spec (codRestrict f.toHom.range f f.toHom.mem_range_self m).2)
right_inv := fun... | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | equivRange | The equivalence between the domain and the range of an embedding `f`. |
equivRange_apply (f : M ↪[L] N) (x : M) : (f.equivRange x : N) = f x :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | equivRange_apply | null |
subtype_equivRange (f : M ↪[L] N) : (subtype _).comp f.equivRange.toEmbedding = f := by
ext; rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subtype_equivRange | null |
toHom_range (f : M ≃[L] N) : f.toHom.range = ⊤ := by
ext n
simp only [Hom.mem_range, coe_toHom, Substructure.mem_top, iff_true]
exact ⟨f.symm n, apply_symm_apply _ _⟩ | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | toHom_range | null |
inclusion {S T : L.Substructure M} (h : S ≤ T) : S ↪[L] T :=
S.subtype.codRestrict _ fun x => h x.2
@[simp] | def | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | inclusion | The embedding associated to an inclusion of substructures. |
inclusion_self (S : L.Substructure M) : inclusion (le_refl S) = Embedding.refl L S := rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | inclusion_self | null |
coe_inclusion {S T : L.Substructure M} (h : S ≤ T) :
(inclusion h : S → T) = Set.inclusion h :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | coe_inclusion | null |
range_subtype (S : L.Substructure M) : S.subtype.toHom.range = S := by
ext x
simp only [Hom.mem_range, Embedding.coe_toHom, coe_subtype]
refine ⟨?_, fun h => ⟨⟨x, h⟩, rfl⟩⟩
rintro ⟨⟨y, hy⟩, rfl⟩
exact hy
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | range_subtype | null |
subtype_comp_inclusion {S T : L.Substructure M} (h : S ≤ T) :
T.subtype.comp (inclusion h) = S.subtype := rfl | lemma | ModelTheory | [
"Mathlib.Data.Fintype.Order",
"Mathlib.Order.Closure",
"Mathlib.ModelTheory.Semantics",
"Mathlib.ModelTheory.Encoding"
] | Mathlib/ModelTheory/Substructures.lean | subtype_comp_inclusion | null |
Term (α : Type u') : Type max u u'
| var : α → Term α
| func : ∀ {l : ℕ} (_f : L.Functions l) (_ts : Fin l → Term α), Term α
export Term (var func)
variable {L} | inductive | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | Term | A term on `α` is either a variable indexed by an element of `α` or a function symbol applied to
simpler terms. |
instDecidableEq [DecidableEq α] [∀ n, DecidableEq (L.Functions n)] : DecidableEq (L.Term α)
| .var a, .var b => decidable_of_iff (a = b) <| by simp
| @Term.func _ _ m f xs, @Term.func _ _ n g ys =>
if h : m = n then
letI : DecidableEq (L.Term α) := instDecidableEq
decidable_of_iff (f = h ▸ g ∧... | instance | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | instDecidableEq | null |
@[simp]
varFinset [DecidableEq α] : L.Term α → Finset α
| var i => {i}
| func _f ts => univ.biUnion fun i => (ts i).varFinset | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | varFinset | The `Finset` of variables used in a given term. |
@[simp]
varFinsetLeft [DecidableEq α] : L.Term (α ⊕ β) → Finset α
| var (Sum.inl i) => {i}
| var (Sum.inr _i) => ∅
| func _f ts => univ.biUnion fun i => (ts i).varFinsetLeft | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | varFinsetLeft | The `Finset` of variables from the left side of a sum used in a given term. |
@[simp]
relabel (g : α → β) : L.Term α → L.Term β
| var i => var (g i)
| func f ts => func f fun {i} => (ts i).relabel g | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | relabel | Relabels a term's variables along a particular function. |
relabel_id (t : L.Term α) : t.relabel id = t := by
induction t with
| var => rfl
| func _ _ ih => simp [ih]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | relabel_id | null |
relabel_id_eq_id : (Term.relabel id : L.Term α → L.Term α) = id :=
funext relabel_id
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | relabel_id_eq_id | null |
relabel_relabel (f : α → β) (g : β → γ) (t : L.Term α) :
(t.relabel f).relabel g = t.relabel (g ∘ f) := by
induction t with
| var => rfl
| func _ _ ih => simp [ih]
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | relabel_relabel | null |
relabel_comp_relabel (f : α → β) (g : β → γ) :
(Term.relabel g ∘ Term.relabel f : L.Term α → L.Term γ) = Term.relabel (g ∘ f) :=
funext (relabel_relabel f g) | theorem | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | relabel_comp_relabel | null |
@[simps]
relabelEquiv (g : α ≃ β) : L.Term α ≃ L.Term β :=
⟨relabel g, relabel g.symm, fun t => by simp, fun t => by simp⟩ | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | relabelEquiv | Relabels a term's variables along a bijection. |
restrictVar [DecidableEq α] : ∀ (t : L.Term α) (_f : t.varFinset → β), L.Term β
| var a, f => var (f ⟨a, mem_singleton_self a⟩)
| func F ts, f =>
func F fun i => (ts i).restrictVar (f ∘ Set.inclusion
(subset_biUnion_of_mem (fun i => varFinset (ts i)) (mem_univ i))) | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | restrictVar | Restricts a term to use only a set of the given variables. |
restrictVarLeft [DecidableEq α] {γ : Type*} :
∀ (t : L.Term (α ⊕ γ)) (_f : t.varFinsetLeft → β), L.Term (β ⊕ γ)
| var (Sum.inl a), f => var (Sum.inl (f ⟨a, mem_singleton_self a⟩))
| var (Sum.inr a), _f => var (Sum.inr a)
| func F ts, f =>
func F fun i =>
(ts i).restrictVarLeft (f ∘ Set.inclusion (su... | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | restrictVarLeft | Restricts a term to use only a set of the given variables on the left side of a sum. |
Constants.term (c : L.Constants) : L.Term α :=
func c default | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | Constants.term | The representation of a constant symbol as a term. |
Functions.apply₁ (f : L.Functions 1) (t : L.Term α) : L.Term α :=
func f ![t] | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | Functions.apply₁ | Applies a unary function to a term. |
Functions.apply₂ (f : L.Functions 2) (t₁ t₂ : L.Term α) : L.Term α :=
func f ![t₁, t₂] | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | Functions.apply₂ | Applies a binary function to two terms. |
Functions.term {n : ℕ} (f : L.Functions n) : L.Term (Fin n) :=
func f Term.var | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | Functions.term | The representation of a function symbol as a term, on fresh variables indexed by Fin. |
@[simp]
constantsToVars : L[[γ]].Term α → L.Term (γ ⊕ α)
| var a => var (Sum.inr a)
| @func _ _ 0 f ts =>
Sum.casesOn f (fun f => func f fun i => (ts i).constantsToVars) fun c => var (Sum.inl c)
| @func _ _ (_n + 1) f ts =>
Sum.casesOn f (fun f => func f fun i => (ts i).constantsToVars) fun c => isEmptyEl... | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | constantsToVars | Sends a term with constants to a term with extra variables. |
@[simp]
varsToConstants : L.Term (γ ⊕ α) → L[[γ]].Term α
| var (Sum.inr a) => var a
| var (Sum.inl c) => Constants.term (Sum.inr c)
| func f ts => func (Sum.inl f) fun i => (ts i).varsToConstants | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | varsToConstants | Sends a term with extra variables to a term with constants. |
@[simps]
constantsVarsEquiv : L[[γ]].Term α ≃ L.Term (γ ⊕ α) :=
⟨constantsToVars, varsToConstants, by
intro t
induction t with
| var => rfl
| @func n f _ ih =>
cases n
· cases f
· simp [constantsToVars, varsToConstants, ih]
· simp [constantsToVars, varsToConstants, Constant... | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | constantsVarsEquiv | A bijection between terms with constants and terms with extra variables. |
constantsVarsEquivLeft : L[[γ]].Term (α ⊕ β) ≃ L.Term ((γ ⊕ α) ⊕ β) :=
constantsVarsEquiv.trans (relabelEquiv (Equiv.sumAssoc _ _ _)).symm
@[simp] | def | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | constantsVarsEquivLeft | A bijection between terms with constants and terms with extra variables. |
constantsVarsEquivLeft_apply (t : L[[γ]].Term (α ⊕ β)) :
constantsVarsEquivLeft t = (constantsToVars t).relabel (Equiv.sumAssoc _ _ _).symm :=
rfl
@[simp] | theorem | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | constantsVarsEquivLeft_apply | null |
constantsVarsEquivLeft_symm_apply (t : L.Term ((γ ⊕ α) ⊕ β)) :
constantsVarsEquivLeft.symm t = varsToConstants (t.relabel (Equiv.sumAssoc _ _ _)) :=
rfl | theorem | ModelTheory | [
"Mathlib.Data.Set.Prod",
"Mathlib.Logic.Equiv.Fin.Basic",
"Mathlib.ModelTheory.LanguageMap",
"Mathlib.Algebra.Order.Group.Nat"
] | Mathlib/ModelTheory/Syntax.lean | constantsVarsEquivLeft_symm_apply | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.