File: Mathlib/ModelTheory/Bundled.lean

full_name: CategoryTheory.Bundled.structure
code: protected instance CategoryTheory.Bundled.structure {L : FirstOrder.Language.{u, v}}
    (M : CategoryTheory.Bundled.{w} L.Structure) : L.Structure M 
goal: L.Structure ↑M

full_name: Equiv.bundledInduced
code: /-- A type bundled with the structure induced by an equivalence. -/
@[simps]
def bundledInduced : CategoryTheory.Bundled.{w'} L.Structure 
goal: CategoryTheory.Bundled L.Structure

full_name: Equiv.bundledInduced_str
code: /-- A type bundled with the structure induced by an equivalence. -/
@[simps]
def bundledInduced : CategoryTheory.Bundled.{w'} L.Structure 
goal: (Equiv.bundledInduced L g).str = g.inducedStructure

full_name: Equiv.bundledInduced_α
code: /-- A type bundled with the structure induced by an equivalence. -/
@[simps]
def bundledInduced : CategoryTheory.Bundled.{w'} L.Structure 
goal: ↑(Equiv.bundledInduced L g) = N

full_name: Equiv.bundledInducedEquiv
code: /-- An equivalence of types as a first-order equivalence to the bundled structure on the codomain.
-/
@[simp]
def bundledInducedEquiv : M ≃[L] g.bundledInduced L 
goal: M ≃[L] ↑(Equiv.bundledInduced L g)

full_name: FirstOrder.Language.equivSetoid
code: /-- The equivalence relation on bundled `L.Structure`s indicating that they are isomorphic. -/
instance equivSetoid : Setoid (CategoryTheory.Bundled L.Structure) 
goal: Setoid (CategoryTheory.Bundled L.Structure)

full_name: FirstOrder.Language.Theory.ModelType
code: /-- The type of nonempty models of a first-order theory. -/
structure ModelType where
  Carrier : Type w
  [struc : L.Structure Carrier]
  [is_model : T.Model Carrier]
  [nonempty' : Nonempty Carrier]
goal: Type (max (max u v) (w + 1))

full_name: FirstOrder.Language.Theory.ModelType.Carrier
code: /-- The type of nonempty models of a first-order theory. -/
structure ModelType where
  Carrier : Type w
  [struc : L.Structure Carrier]
  [is_model : T.Model Carrier]
  [nonempty' : Nonempty Carrier]
goal: Type w

full_name: FirstOrder.Language.Theory.ModelType.struc
code: /-- The type of nonempty models of a first-order theory. -/
structure ModelType where
  Carrier : Type w
  [struc : L.Structure Carrier]
  [is_model : T.Model Carrier]
  [nonempty' : Nonempty Carrier]
goal: L.Structure ↑self

full_name: FirstOrder.Language.Theory.ModelType.is_model
code: /-- The type of nonempty models of a first-order theory. -/
structure ModelType where
  Carrier : Type w
  [struc : L.Structure Carrier]
  [is_model : T.Model Carrier]
  [nonempty' : Nonempty Carrier]
goal: ↑self ⊨ T

full_name: FirstOrder.Language.Theory.ModelType.nonempty'
code: /-- The type of nonempty models of a first-order theory. -/
structure ModelType where
  Carrier : Type w
  [struc : L.Structure Carrier]
  [is_model : T.Model Carrier]
  [nonempty' : Nonempty Carrier]
goal: Nonempty ↑self

full_name: FirstOrder.Language.Theory.ModelType.instCoeSort
code: instance instCoeSort : CoeSort T.ModelType (Type w) 
goal: CoeSort T.ModelType (Type w)

full_name: FirstOrder.Language.Theory.ModelType.of
code: /-- The object in the category of R-algebras associated to a type equipped with the appropriate
typeclasses. -/
def of (M : Type w) [L.Structure M] [M ⊨ T] [Nonempty M] : T.ModelType 
goal: T.ModelType

full_name: FirstOrder.Language.Theory.ModelType.coe_of
code: @[simp]
theorem coe_of (M : Type w) [L.Structure M] [M ⊨ T] [Nonempty M] : (of T M : Type w) = M 
goal: ↑(FirstOrder.Language.Theory.ModelType.of T M) = M

full_name: FirstOrder.Language.Theory.ModelType.instNonempty
code: instance instNonempty (M : T.ModelType) : Nonempty M 
goal: Nonempty ↑M

full_name: FirstOrder.Language.Theory.ModelType.instInhabited
code: instance instInhabited : Inhabited (ModelType.{u, v, w} (∅ : L.Theory)) 
goal: Inhabited ∅.ModelType

full_name: FirstOrder.Language.Theory.ModelType.equivInduced
code: /-- Maps a bundled model along a bijection. -/
def equivInduced {M : ModelType.{u, v, w} T} {N : Type w'} (e : M ≃ N) :
    ModelType.{u, v, w'} T 
goal: T.ModelType

full_name: FirstOrder.Language.Theory.ModelType.of_small
code: instance of_small (M : Type w) [Nonempty M] [L.Structure M] [M ⊨ T] [h : Small.{w'} M] :
    Small.{w'} (ModelType.of T M) 
goal: Small.{w', w} ↑(FirstOrder.Language.Theory.ModelType.of T M)

full_name: FirstOrder.Language.Theory.ModelType.shrink
code: /-- Shrinks a small model to a particular universe. -/
noncomputable def shrink (M : ModelType.{u, v, w} T) [Small.{w'} M] : ModelType.{u, v, w'} T 
goal: T.ModelType

full_name: FirstOrder.Language.Theory.ModelType.ulift
code: /-- Lifts a model to a particular universe. -/
def ulift (M : ModelType.{u, v, w} T) : ModelType.{u, v, max w w'} T 
goal: T.ModelType

full_name: FirstOrder.Language.Theory.ModelType.reduct
code: /-- The reduct of any model of `φ.onTheory T` is a model of `T`. -/
@[simps]
def reduct {L' : Language} (φ : L →ᴸ L') (M : (φ.onTheory T).ModelType) : T.ModelType 
goal: T.ModelType

full_name: FirstOrder.Language.Theory.ModelType.reduct_struc
code: /-- The reduct of any model of `φ.onTheory T` is a model of `T`. -/
@[simps]
def reduct {L' : Language} (φ : L →ᴸ L') (M : (φ.onTheory T).ModelType) : T.ModelType 
goal: (FirstOrder.Language.Theory.ModelType.reduct φ M).struc = φ.reduct ↑M

full_name: FirstOrder.Language.Theory.ModelType.reduct_Carrier
code: /-- The reduct of any model of `φ.onTheory T` is a model of `T`. -/
@[simps]
def reduct {L' : Language} (φ : L →ᴸ L') (M : (φ.onTheory T).ModelType) : T.ModelType 
goal: ↑(FirstOrder.Language.Theory.ModelType.reduct φ M) = ↑M

full_name: FirstOrder.Language.Theory.ModelType.defaultExpansion_Carrier
code: /-- When `φ` is injective, `defaultExpansion` expands a model of `T` to a model of `φ.onTheory T`
  arbitrarily. -/
@[simps]
noncomputable def defaultExpansion {L' : Language} {φ : L →ᴸ L'} (h : φ.Injective)
    [∀ (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 : T.ModelType) [Inhabited M] : (φ.onTheory T).ModelType 
goal: ↑(FirstOrder.Language.Theory.ModelType.defaultExpansion h M) = ↑M

full_name: FirstOrder.Language.Theory.ModelType.defaultExpansion_struc
code: /-- When `φ` is injective, `defaultExpansion` expands a model of `T` to a model of `φ.onTheory T`
  arbitrarily. -/
@[simps]
noncomputable def defaultExpansion {L' : Language} {φ : L →ᴸ L'} (h : φ.Injective)
    [∀ (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 : T.ModelType) [Inhabited M] : (φ.onTheory T).ModelType 
goal: (FirstOrder.Language.Theory.ModelType.defaultExpansion h M).struc = φ.defaultExpansion ↑M

full_name: FirstOrder.Language.Theory.ModelType.defaultExpansion
code: /-- When `φ` is injective, `defaultExpansion` expands a model of `T` to a model of `φ.onTheory T`
  arbitrarily. -/
@[simps]
noncomputable def defaultExpansion {L' : Language} {φ : L →ᴸ L'} (h : φ.Injective)
    [∀ (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 : T.ModelType) [Inhabited M] : (φ.onTheory T).ModelType 
goal: (φ.onTheory T).ModelType

full_name: FirstOrder.Language.Theory.ModelType.leftStructure
code: instance leftStructure {L' : Language} {T : (L.sum L').Theory} (M : T.ModelType) : L.Structure M 
goal: L.Structure ↑M

full_name: FirstOrder.Language.Theory.ModelType.rightStructure
code: instance rightStructure {L' : Language} {T : (L.sum L').Theory} (M : T.ModelType) :
    L'.Structure M 
goal: L'.Structure ↑M

full_name: FirstOrder.Language.Theory.ModelType.subtheoryModel_struc
code: /-- A model of a theory is also a model of any subtheory. -/
@[simps]
def subtheoryModel (M : T.ModelType) {T' : L.Theory} (h : T' ⊆ T) : T'.ModelType 
goal: (M.subtheoryModel h).struc = M.struc

full_name: FirstOrder.Language.Theory.ModelType.subtheoryModel_Carrier
code: /-- A model of a theory is also a model of any subtheory. -/
@[simps]
def subtheoryModel (M : T.ModelType) {T' : L.Theory} (h : T' ⊆ T) : T'.ModelType 
goal: ↑(M.subtheoryModel h) = ↑M

full_name: FirstOrder.Language.Theory.ModelType.subtheoryModel
code: /-- A model of a theory is also a model of any subtheory. -/
@[simps]
def subtheoryModel (M : T.ModelType) {T' : L.Theory} (h : T' ⊆ T) : T'.ModelType 
goal: T'.ModelType

full_name: FirstOrder.Language.Theory.ModelType.subtheoryModel_models
code: instance subtheoryModel_models (M : T.ModelType) {T' : L.Theory} (h : T' ⊆ T) :
    M.subtheoryModel h ⊨ T 
goal: ↑(M.subtheoryModel h) ⊨ T

full_name: FirstOrder.Language.Theory.Model.bundled
code: /-- Bundles `M ⊨ T` as a `T.ModelType`. -/
def Model.bundled {M : Type w} [LM : L.Structure M] [ne : Nonempty M] (h : M ⊨ T) : T.ModelType 
goal: T.ModelType

full_name: FirstOrder.Language.Theory.coe_of
code: @[simp]
theorem coe_of {M : Type w} [L.Structure M] [Nonempty M] (h : M ⊨ T) : (h.bundled : Type w) = M 
goal: ↑h.bundled = M

full_name: FirstOrder.Language.ElementarilyEquivalent.toModel
code: /-- A structure that is elementarily equivalent to a model, bundled as a model. -/
def ElementarilyEquivalent.toModel {M : T.ModelType} {N : Type*} [LN : L.Structure N]
    (h : M ≅[L] N) : T.ModelType 
goal: T.ModelType

full_name: FirstOrder.Language.ElementarySubstructure.toModel
code: /-- An elementary substructure of a bundled model as a bundled model. -/
def ElementarySubstructure.toModel {M : T.ModelType} (S : L.ElementarySubstructure M) :
    T.ModelType 
goal: T.ModelType

full_name: FirstOrder.Language.ElementarySubstructure.toModel.instSmall
code: instance ElementarySubstructure.toModel.instSmall {M : T.ModelType}
    (S : L.ElementarySubstructure M) [h : Small.{w, x} S] : Small.{w, x} (S.toModel T) 
goal: Small.{w, x} ↑(FirstOrder.Language.ElementarySubstructure.toModel T S)