Language Maps

Maps between first-order languages in the style of the Flypitch project, as well as several important maps between structures.

Main Definitions

• A FirstOrder.Language.LHom, denoted L →ᴸ L', is a map between languages, sending the symbols of one to symbols of the same kind and arity in the other.
• A FirstOrder.Language.LEquiv, denoted L ≃ᴸ L', is an invertible language homomorphism.
• FirstOrder.Language.withConstants is defined so that if M is an L.Structure and A : Set M, L.withConstants A, denoted L[[A]], is a language which adds constant symbols for elements of A to L.

References

For the Flypitch project:

• [J. Han, F. van Doorn, A formal proof of the independence of the continuum hypothesis] [flypitch_cpp]
• [J. Han, F. van Doorn, A formalization of forcing and the unprovability of the continuum hypothesis][flypitch_itp]

structure FirstOrder.Language.LHom (L : Language) (L' : Language) : Type (max (max (max u u') v) v')

A language homomorphism maps the symbols of one language to symbols of another.

• onFunction ⦃n : ℕ⦄ : L.Functions n → L'.Functions n

  The mapping of functions

• onRelation ⦃n : ℕ⦄ : L.Relations n → L'.Relations n

  The mapping of relations

def FirstOrder.Language.«term_→ᴸ_» : Lean.TrailingParserDescr

A language homomorphism maps the symbols of one language to symbols of another.

def FirstOrder.Language.LHom.reduct {L : Language} {L' : Language} (ϕ : L →ᴸ L') (M : Type u_1) [L'.Structure M] : L.Structure M

Pulls a structure back along a language map.

def FirstOrder.Language.LHom.id (L : Language) : L →ᴸ L

The identity language homomorphism.

@[simp]

theorem FirstOrder.Language.LHom.id_onFunction (L : Language) (_n : ℕ) (a : L.Functions _n) : (LHom.id L).onFunction a = id a

@[simp]

theorem FirstOrder.Language.LHom.id_onRelation (L : Language) (_n : ℕ) (a : L.Relations _n) : (LHom.id L).onRelation a = id a

instance FirstOrder.Language.LHom.instInhabited {L : Language} : Inhabited (L →ᴸ L)

def FirstOrder.Language.LHom.sumInl {L : Language} {L' : Language} : L →ᴸ L.sum L'

The inclusion of the left factor into the sum of two languages.

@[simp]

theorem FirstOrder.Language.LHom.sumInl_onRelation {L : Language} {L' : Language} (_n : ℕ) (val : L.Relations _n) : LHom.sumInl.onRelation val = Sum.inl val

@[simp]

theorem FirstOrder.Language.LHom.sumInl_onFunction {L : Language} {L' : Language} (_n : ℕ) (val : L.Functions _n) : LHom.sumInl.onFunction val = Sum.inl val

def FirstOrder.Language.LHom.sumInr {L : Language} {L' : Language} : L' →ᴸ L.sum L'

The inclusion of the right factor into the sum of two languages.

@[simp]

theorem FirstOrder.Language.LHom.sumInr_onRelation {L : Language} {L' : Language} (_n : ℕ) (val : L'.Relations _n) : LHom.sumInr.onRelation val = Sum.inr val

@[simp]

theorem FirstOrder.Language.LHom.sumInr_onFunction {L : Language} {L' : Language} (_n : ℕ) (val : L'.Functions _n) : LHom.sumInr.onFunction val = Sum.inr val

def FirstOrder.Language.LHom.ofIsEmpty (L : Language) (L' : Language) [L.IsAlgebraic] [L.IsRelational] : L →ᴸ L'

The inclusion of an empty language into any other language.

@[simp]

theorem FirstOrder.Language.LHom.ofIsEmpty_onRelation (L : Language) (L' : Language) [L.IsAlgebraic] [L.IsRelational] {n : ℕ} (a : L.Relations n) : (LHom.ofIsEmpty L L').onRelation a = isEmptyElim a

@[simp]

theorem FirstOrder.Language.LHom.ofIsEmpty_onFunction (L : Language) (L' : Language) [L.IsAlgebraic] [L.IsRelational] {n : ℕ} (a : L.Functions n) : (LHom.ofIsEmpty L L').onFunction a = isEmptyElim a

theorem FirstOrder.Language.LHom.funext {L : Language} {L' : Language} {F G : L →ᴸ L'} (h_fun : F.onFunction = G.onFunction) (h_rel : F.onRelation = G.onRelation) : F = G

theorem FirstOrder.Language.LHom.funext_iff {L : Language} {L' : Language} {F G : L →ᴸ L'} : F = G ↔ F.onFunction = G.onFunction ∧ F.onRelation = G.onRelation

instance FirstOrder.Language.LHom.instUniqueOfIsAlgebraicOfIsRelational {L : Language} {L' : Language} [L.IsAlgebraic] [L.IsRelational] : Unique (L →ᴸ L')

def FirstOrder.Language.LHom.comp {L : Language} {L' : Language} {L'' : Language} (g : L' →ᴸ L'') (f : L →ᴸ L') : L →ᴸ L''

The composition of two language homomorphisms.

@[simp]

theorem FirstOrder.Language.LHom.comp_onFunction {L : Language} {L' : Language} {L'' : Language} (g : L' →ᴸ L'') (f : L →ᴸ L') (_n : ℕ) (F : L.Functions _n) : (g.comp f).onFunction F = g.onFunction (f.onFunction F)

@[simp]

theorem FirstOrder.Language.LHom.comp_onRelation {L : Language} {L' : Language} {L'' : Language} (g : L' →ᴸ L'') (f : L →ᴸ L') (x✝ : ℕ) (R : L.Relations x✝) : (g.comp f).onRelation R = g.onRelation (f.onRelation R)

@[simp]

theorem FirstOrder.Language.LHom.id_comp {L : Language} {L' : Language} (F : L →ᴸ L') : (LHom.id L').comp F = F

@[simp]

theorem FirstOrder.Language.LHom.comp_id {L : Language} {L' : Language} (F : L →ᴸ L') : F.comp (LHom.id L) = F

theorem FirstOrder.Language.LHom.comp_assoc {L : Language} {L' : Language} {L'' : Language} {L3 : Language} (F : L'' →ᴸ L3) (G : L' →ᴸ L'') (H : L →ᴸ L') : (F.comp G).comp H = F.comp (G.comp H)

def FirstOrder.Language.LHom.sumElim {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L'' : Language} (ψ : L'' →ᴸ L') : L.sum L'' →ᴸ L'

A language map defined on two factors of a sum.

@[simp]

theorem FirstOrder.Language.LHom.sumElim_onRelation {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L'' : Language} (ψ : L'' →ᴸ L') (_n : ℕ) (a✝ : L.Relations _n ⊕ L''.Relations _n) : (ϕ.sumElim ψ).onRelation a✝ = Sum.elim (fun (f : L.Relations _n) => ϕ.onRelation f) (fun (f : L''.Relations _n) => ψ.onRelation f) a✝

@[simp]

theorem FirstOrder.Language.LHom.sumElim_onFunction {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L'' : Language} (ψ : L'' →ᴸ L') (_n : ℕ) (a✝ : L.Functions _n ⊕ L''.Functions _n) : (ϕ.sumElim ψ).onFunction a✝ = Sum.elim (fun (f : L.Functions _n) => ϕ.onFunction f) (fun (f : L''.Functions _n) => ψ.onFunction f) a✝

theorem FirstOrder.Language.LHom.sumElim_comp_inl {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L'' : Language} (ψ : L'' →ᴸ L') : (ϕ.sumElim ψ).comp LHom.sumInl = ϕ

theorem FirstOrder.Language.LHom.sumElim_comp_inr {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L'' : Language} (ψ : L'' →ᴸ L') : (ϕ.sumElim ψ).comp LHom.sumInr = ψ

theorem FirstOrder.Language.LHom.sumElim_inl_inr {L : Language} {L' : Language} : LHom.sumInl.sumElim LHom.sumInr = LHom.id (L.sum L')

theorem FirstOrder.Language.LHom.comp_sumElim {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L'' : Language} (ψ : L'' →ᴸ L') {L3 : Language} (θ : L' →ᴸ L3) : θ.comp (ϕ.sumElim ψ) = (θ.comp ϕ).sumElim (θ.comp ψ)

def FirstOrder.Language.LHom.sumMap {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L₁ : Language} {L₂ : Language} (ψ : L₁ →ᴸ L₂) : L.sum L₁ →ᴸ L'.sum L₂

The map between two sum-languages induced by maps on the two factors.

@[simp]

theorem FirstOrder.Language.LHom.sumMap_onFunction {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L₁ : Language} {L₂ : Language} (ψ : L₁ →ᴸ L₂) (_n : ℕ) (a✝ : L.Functions _n ⊕ L₁.Functions _n) : (ϕ.sumMap ψ).onFunction a✝ = Sum.map (fun (f : L.Functions _n) => ϕ.onFunction f) (fun (f : L₁.Functions _n) => ψ.onFunction f) a✝

@[simp]

theorem FirstOrder.Language.LHom.sumMap_onRelation {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L₁ : Language} {L₂ : Language} (ψ : L₁ →ᴸ L₂) (_n : ℕ) (a✝ : L.Relations _n ⊕ L₁.Relations _n) : (ϕ.sumMap ψ).onRelation a✝ = Sum.map (fun (f : L.Relations _n) => ϕ.onRelation f) (fun (f : L₁.Relations _n) => ψ.onRelation f) a✝

@[simp]

theorem FirstOrder.Language.LHom.sumMap_comp_inl {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L₁ : Language} {L₂ : Language} (ψ : L₁ →ᴸ L₂) : (ϕ.sumMap ψ).comp LHom.sumInl = LHom.sumInl.comp ϕ

@[simp]

theorem FirstOrder.Language.LHom.sumMap_comp_inr {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L₁ : Language} {L₂ : Language} (ψ : L₁ →ᴸ L₂) : (ϕ.sumMap ψ).comp LHom.sumInr = LHom.sumInr.comp ψ

structure FirstOrder.Language.LHom.Injective {L : Language} {L' : Language} (ϕ : L →ᴸ L') : Prop

A language homomorphism is injective when all the maps between symbol types are.

• onFunction {n : ℕ} : Function.Injective fun (f : L.Functions n) => ϕ.onFunction f
• onRelation {n : ℕ} : Function.Injective fun (R : L.Relations n) => ϕ.onRelation R

noncomputable def FirstOrder.Language.LHom.defaultExpansion {L : Language} {L' : Language} (ϕ : L →ᴸ L') [(n : ℕ) → (f : L'.Functions n) → Decidable (f ∈ Set.range fun (f : L.Functions n) => ϕ.onFunction f)] [(n : ℕ) → (r : L'.Relations n) → Decidable (r ∈ Set.range fun (r : L.Relations n) => ϕ.onRelation r)] (M : Type u_1) [Inhabited M] [L.Structure M] : L'.Structure M

Pulls an L-structure along a language map ϕ : L →ᴸ L', and then expands it to an L'-structure arbitrarily.

class FirstOrder.Language.LHom.IsExpansionOn {L : Language} {L' : Language} (ϕ : L →ᴸ L') (M : Type u_1) [L.Structure M] [L'.Structure M] : Prop

A language homomorphism is an expansion on a structure if it commutes with the interpretation of all symbols on that structure.

• map_onFunction {n : ℕ} (f : L.Functions n) (x : Fin n → M) : Structure.funMap (ϕ.onFunction f) x = Structure.funMap f x
• map_onRelation {n : ℕ} (R : L.Relations n) (x : Fin n → M) : Structure.RelMap (ϕ.onRelation R) x = Structure.RelMap R x

@[simp]

theorem FirstOrder.Language.LHom.map_onFunction {L : Language} {L' : Language} (ϕ : L →ᴸ L') {M : Type u_1} [L.Structure M] [L'.Structure M] [ϕ.IsExpansionOn M] {n : ℕ} (f : L.Functions n) (x : Fin n → M) : Structure.funMap (ϕ.onFunction f) x = Structure.funMap f x

@[simp]

theorem FirstOrder.Language.LHom.map_onRelation {L : Language} {L' : Language} (ϕ : L →ᴸ L') {M : Type u_1} [L.Structure M] [L'.Structure M] [ϕ.IsExpansionOn M] {n : ℕ} (R : L.Relations n) (x : Fin n → M) : Structure.RelMap (ϕ.onRelation R) x = Structure.RelMap R x

instance FirstOrder.Language.LHom.id_isExpansionOn {L : Language} (M : Type u_1) [L.Structure M] : (LHom.id L).IsExpansionOn M

instance FirstOrder.Language.LHom.ofIsEmpty_isExpansionOn {L : Language} {L' : Language} (M : Type u_1) [L.Structure M] [L'.Structure M] [L.IsAlgebraic] [L.IsRelational] : (LHom.ofIsEmpty L L').IsExpansionOn M

instance FirstOrder.Language.LHom.sumElim_isExpansionOn {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L'' : Language} (ψ : L'' →ᴸ L') (M : Type u_1) [L.Structure M] [L'.Structure M] [L''.Structure M] [ϕ.IsExpansionOn M] [ψ.IsExpansionOn M] : (ϕ.sumElim ψ).IsExpansionOn M

instance FirstOrder.Language.LHom.sumMap_isExpansionOn {L : Language} {L' : Language} (ϕ : L →ᴸ L') {L₁ : Language} {L₂ : Language} (ψ : L₁ →ᴸ L₂) (M : Type u_1) [L.Structure M] [L'.Structure M] [L₁.Structure M] [L₂.Structure M] [ϕ.IsExpansionOn M] [ψ.IsExpansionOn M] : (ϕ.sumMap ψ).IsExpansionOn M

instance FirstOrder.Language.LHom.sumInl_isExpansionOn {L : Language} {L' : Language} (M : Type u_1) [L.Structure M] [L'.Structure M] : LHom.sumInl.IsExpansionOn M

instance FirstOrder.Language.LHom.sumInr_isExpansionOn {L : Language} {L' : Language} (M : Type u_1) [L.Structure M] [L'.Structure M] : LHom.sumInr.IsExpansionOn M

@[simp]

theorem FirstOrder.Language.LHom.funMap_sumInl {L : Language} {L' : Language} {M : Type w} [L.Structure M] [(L.sum L').Structure M] [LHom.sumInl.IsExpansionOn M] {n : ℕ} {f : L.Functions n} {x : Fin n → M} : Structure.funMap (Sum.inl f) x = Structure.funMap f x

@[simp]

theorem FirstOrder.Language.LHom.funMap_sumInr {L : Language} {L' : Language} {M : Type w} [L.Structure M] [(L'.sum L).Structure M] [LHom.sumInr.IsExpansionOn M] {n : ℕ} {f : L.Functions n} {x : Fin n → M} : Structure.funMap (Sum.inr f) x = Structure.funMap f x

theorem FirstOrder.Language.LHom.sumInl_injective {L : Language} {L' : Language} : LHom.sumInl.Injective

theorem FirstOrder.Language.LHom.sumInr_injective {L : Language} {L' : Language} : LHom.sumInr.Injective

@[instance 100]

instance FirstOrder.Language.LHom.isExpansionOn_reduct {L : Language} {L' : Language} (ϕ : L →ᴸ L') (M : Type u_1) [L'.Structure M] : ϕ.IsExpansionOn M

theorem FirstOrder.Language.LHom.Injective.isExpansionOn_default {L : Language} {L' : Language} {ϕ : L →ᴸ L'} [(n : ℕ) → (f : L'.Functions n) → Decidable (f ∈ Set.range fun (f : L.Functions n) => ϕ.onFunction f)] [(n : ℕ) → (r : L'.Relations n) → Decidable (r ∈ Set.range fun (r : L.Relations n) => ϕ.onRelation r)] (h : ϕ.Injective) (M : Type u_1) [Inhabited M] [L.Structure M] : ϕ.IsExpansionOn M

structure FirstOrder.Language.LEquiv (L : Language) (L' : Language) : Type (max (max (max u_1 u_2) u_3) u_4)

A language equivalence maps the symbols of one language to symbols of another bijectively.

• toLHom : L →ᴸ L'

  The forward language homomorphism

• invLHom : L' →ᴸ L

  The inverse language homomorphism

• left_inv : self.invLHom.comp self.toLHom = LHom.id L
• right_inv : self.toLHom.comp self.invLHom = LHom.id L'

def FirstOrder.Language.«term_≃ᴸ_» : Lean.TrailingParserDescr

A language equivalence maps the symbols of one language to symbols of another bijectively.

def FirstOrder.Language.LEquiv.refl (L : Language) : L ≃ᴸ L

The identity equivalence from a first-order language to itself.

@[simp]

theorem FirstOrder.Language.LEquiv.refl_toLHom (L : Language) : (LEquiv.refl L).toLHom = LHom.id L

@[simp]

theorem FirstOrder.Language.LEquiv.refl_invLHom (L : Language) : (LEquiv.refl L).invLHom = LHom.id L

instance FirstOrder.Language.LEquiv.instInhabited {L : Language} : Inhabited (L ≃ᴸ L)

def FirstOrder.Language.LEquiv.symm {L : Language} {L' : Language} (e : L ≃ᴸ L') : L' ≃ᴸ L

The inverse of an equivalence of first-order languages.

@[simp]

theorem FirstOrder.Language.LEquiv.symm_toLHom {L : Language} {L' : Language} (e : L ≃ᴸ L') : e.symm.toLHom = e.invLHom

@[simp]

theorem FirstOrder.Language.LEquiv.symm_invLHom {L : Language} {L' : Language} (e : L ≃ᴸ L') : e.symm.invLHom = e.toLHom

def FirstOrder.Language.LEquiv.trans {L : Language} {L' : Language} {L'' : Language} (e : L ≃ᴸ L') (e' : L' ≃ᴸ L'') : L ≃ᴸ L''

The composition of equivalences of first-order languages.

@[simp]

theorem FirstOrder.Language.LEquiv.trans_toLHom {L : Language} {L' : Language} {L'' : Language} (e : L ≃ᴸ L') (e' : L' ≃ᴸ L'') : (e.trans e').toLHom = e'.toLHom.comp e.toLHom

@[simp]

theorem FirstOrder.Language.LEquiv.trans_invLHom {L : Language} {L' : Language} {L'' : Language} (e : L ≃ᴸ L') (e' : L' ≃ᴸ L'') : (e.trans e').invLHom = e.invLHom.comp e'.invLHom

def FirstOrder.Language.constantsOnFunc (α : Type u') : ℕ → Type u'

The type of functions for a language consisting only of constant symbols.

def FirstOrder.Language.constantsOn (α : Type u') : Language

A language with constants indexed by a type.

@[simp]

theorem FirstOrder.Language.constantsOn_Functions (α : Type u') (a✝ : ℕ) : (constantsOn α).Functions a✝ = constantsOnFunc α a✝

@[simp]

theorem FirstOrder.Language.constantsOn_Relations (α : Type u') (x✝ : ℕ) : (constantsOn α).Relations x✝ = Empty

theorem FirstOrder.Language.constantsOn_constants {α : Type u'} : (constantsOn α).Constants = α

instance FirstOrder.Language.isAlgebraic_constantsOn {α : Type u'} : (constantsOn α).IsAlgebraic

instance FirstOrder.Language.isEmpty_functions_constantsOn_succ {α : Type u'} {n : ℕ} : IsEmpty ((constantsOn α).Functions (n + 1))

instance FirstOrder.Language.isRelational_constantsOn {α : Type u'} [_ie : IsEmpty α] : (constantsOn α).IsRelational

theorem FirstOrder.Language.card_constantsOn {α : Type u'} : (constantsOn α).card = Cardinal.mk α

def FirstOrder.Language.constantsOn.structure {M : Type w} {α : Type u'} (f : α → M) : (constantsOn α).Structure M

Gives a constantsOn α structure to a type by assigning each constant a value.

def FirstOrder.Language.LHom.constantsOnMap {α : Type u'} {β : Type v'} (f : α → β) : constantsOn α →ᴸ constantsOn β

A map between index types induces a map between constant languages.

theorem FirstOrder.Language.constantsOnMap_isExpansionOn {M : Type w} {α : Type u'} {β : Type v'} {f : α → β} {fα : α → M} {fβ : β → M} (h : fβ ∘ f = fα) : (LHom.constantsOnMap f).IsExpansionOn M

def FirstOrder.Language.withConstants (L : Language) (α : Type w') : Language

Extends a language with a constant for each element of a parameter set in M.

def FirstOrder.«term_[[_]]» : Lean.TrailingParserDescr

Extends a language with a constant for each element of a parameter set in M.

@[simp]

theorem FirstOrder.Language.card_withConstants (L : Language) (α : Type w') : (L.withConstants α).card = Cardinal.lift.{w', max u v} L.card + Cardinal.lift.{max u v, w'} (Cardinal.mk α)

def FirstOrder.Language.lhomWithConstants (L : Language) (α : Type w') : L →ᴸ L.withConstants α

The language map adding constants.

@[simp]

theorem FirstOrder.Language.lhomWithConstants_onFunction (L : Language) (α : Type w') (_n : ℕ) (val : L.Functions _n) : (L.lhomWithConstants α).onFunction val = Sum.inl val

@[simp]

theorem FirstOrder.Language.lhomWithConstants_onRelation (L : Language) (α : Type w') (_n : ℕ) (val : L.Relations _n) : (L.lhomWithConstants α).onRelation val = Sum.inl val

theorem FirstOrder.Language.lhomWithConstants_injective (L : Language) (α : Type w') : (L.lhomWithConstants α).Injective

def FirstOrder.Language.con (L : Language) {α : Type w'} (a : α) : (L.withConstants α).Constants

The constant symbol indexed by a particular element.

def FirstOrder.Language.LHom.addConstants {L : Language} (α : Type w') {L' : Language} (φ : L →ᴸ L') : L.withConstants α →ᴸ L'.withConstants α

Adds constants to a language map.

instance FirstOrder.Language.paramsStructure (α : Type w') (A : Set α) : (constantsOn ↑A).Structure α

def FirstOrder.Language.LEquiv.addEmptyConstants (L : Language) (α : Type w') [ie : IsEmpty α] : L ≃ᴸ L.withConstants α

The language map removing an empty constant set.

@[simp]

theorem FirstOrder.Language.LEquiv.addEmptyConstants_toLHom (L : Language) (α : Type w') [ie : IsEmpty α] : (addEmptyConstants L α).toLHom = L.lhomWithConstants α

@[simp]

theorem FirstOrder.Language.LEquiv.addEmptyConstants_invLHom (L : Language) (α : Type w') [ie : IsEmpty α] : (addEmptyConstants L α).invLHom = (LHom.id L).sumElim (LHom.ofIsEmpty (constantsOn α) L)

@[simp]

theorem FirstOrder.Language.withConstants_funMap_sumInl (L : Language) {M : Type w} [L.Structure M] {α : Type w'} [(L.withConstants α).Structure M] [(L.lhomWithConstants α).IsExpansionOn M] {n : ℕ} {f : L.Functions n} {x : Fin n → M} : Structure.funMap (Sum.inl f) x = Structure.funMap f x

@[simp]

theorem FirstOrder.Language.withConstants_relMap_sumInl (L : Language) {M : Type w} [L.Structure M] {α : Type w'} [(L.withConstants α).Structure M] [(L.lhomWithConstants α).IsExpansionOn M] {n : ℕ} {R : L.Relations n} {x : Fin n → M} : Structure.RelMap (Sum.inl R) x = Structure.RelMap R x

@[deprecated FirstOrder.Language.withConstants_funMap_sumInl (since := "2025-02-21")]

theorem FirstOrder.Language.withConstants_funMap_sum_inl (L : Language) {M : Type w} [L.Structure M] {α : Type w'} [(L.withConstants α).Structure M] [(L.lhomWithConstants α).IsExpansionOn M] {n : ℕ} {f : L.Functions n} {x : Fin n → M} : Structure.funMap (Sum.inl f) x = Structure.funMap f x

Alias of FirstOrder.Language.withConstants_funMap_sumInl.

@[deprecated FirstOrder.Language.withConstants_relMap_sumInl (since := "2025-02-21")]

theorem FirstOrder.Language.withConstants_relMap_sum_inl (L : Language) {M : Type w} [L.Structure M] {α : Type w'} [(L.withConstants α).Structure M] [(L.lhomWithConstants α).IsExpansionOn M] {n : ℕ} {R : L.Relations n} {x : Fin n → M} : Structure.RelMap (Sum.inl R) x = Structure.RelMap R x

Alias of FirstOrder.Language.withConstants_relMap_sumInl.

def FirstOrder.Language.lhomWithConstantsMap (L : Language) {α : Type w'} {β : Type u_1} (f : α → β) : L.withConstants α →ᴸ L.withConstants β

The language map extending the constant set.

@[simp]

theorem FirstOrder.Language.LHom.map_constants_comp_sumInl (L : Language) {α : Type w'} {β : Type u_1} {f : α → β} : (L.lhomWithConstantsMap f).comp LHom.sumInl = L.lhomWithConstants β

instance FirstOrder.Language.constantsOnSelfStructure {M : Type w} : (constantsOn M).Structure M

instance FirstOrder.Language.withConstantsSelfStructure (L : Language) {M : Type w} [L.Structure M] : (L.withConstants M).Structure M

instance FirstOrder.Language.withConstants_self_expansion (L : Language) {M : Type w} [L.Structure M] : (L.lhomWithConstants M).IsExpansionOn M

instance FirstOrder.Language.withConstantsStructure (L : Language) {M : Type w} [L.Structure M] (α : Type u_1) [(constantsOn α).Structure M] : (L.withConstants α).Structure M

instance FirstOrder.Language.withConstants_expansion (L : Language) {M : Type w} [L.Structure M] (α : Type u_1) [(constantsOn α).Structure M] : (L.lhomWithConstants α).IsExpansionOn M

instance FirstOrder.Language.addEmptyConstants_is_expansion_on' (L : Language) {M : Type w} [L.Structure M] : (LEquiv.addEmptyConstants L ↑∅).toLHom.IsExpansionOn M

instance FirstOrder.Language.addEmptyConstants_symm_isExpansionOn (L : Language) {M : Type w} [L.Structure M] : (LEquiv.addEmptyConstants L ↑∅).symm.toLHom.IsExpansionOn M

instance FirstOrder.Language.addConstants_expansion (L : Language) {M : Type w} [L.Structure M] (α : Type u_1) [(constantsOn α).Structure M] {L' : Language} [L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] : (LHom.addConstants α φ).IsExpansionOn M

@[simp]

theorem FirstOrder.Language.withConstants_funMap_sumInr (L : Language) {M : Type w} [L.Structure M] (α : Type u_1) [(constantsOn α).Structure M] {a : α} {x : Fin 0 → M} : Structure.funMap (Sum.inr a) x = ↑(L.con a)

@[deprecated FirstOrder.Language.withConstants_funMap_sumInr (since := "2025-02-21")]

theorem FirstOrder.Language.withConstants_funMap_sum_inr (L : Language) {M : Type w} [L.Structure M] (α : Type u_1) [(constantsOn α).Structure M] {a : α} {x : Fin 0 → M} : Structure.funMap (Sum.inr a) x = ↑(L.con a)

Alias of FirstOrder.Language.withConstants_funMap_sumInr.

@[simp]

theorem FirstOrder.Language.coe_con (L : Language) {M : Type w} [L.Structure M] (A : Set M) {a : ↑A} : ↑(L.con a) = ↑a

instance FirstOrder.Language.constantsOnMap_inclusion_isExpansionOn {M : Type w} {A B : Set M} (h : A ⊆ B) : (LHom.constantsOnMap (Set.inclusion h)).IsExpansionOn M

instance FirstOrder.Language.map_constants_inclusion_isExpansionOn (L : Language) {M : Type w} [L.Structure M] {A B : Set M} (h : A ⊆ B) : (L.lhomWithConstantsMap (Set.inclusion h)).IsExpansionOn M