File: Mathlib/ModelTheory/Order.lean

full_name: FirstOrder.Language.order
code: /-- The language consisting of a single relation representing `≤`. -/
protected def order : Language 
goal: FirstOrder.Language

full_name: FirstOrder.Language.orderStructure
code: instance orderStructure [LE M] : Language.order.Structure M 
goal: FirstOrder.Language.order.Structure M

full_name: FirstOrder.Language.Order.Language.instIsRelational
code: instance Language.instIsRelational : IsRelational Language.order 
goal: FirstOrder.Language.order.IsRelational

full_name: FirstOrder.Language.Order.Language.instSubsingleton
code: instance Language.instSubsingleton : Subsingleton (Language.order.Relations n) 
goal: Subsingleton (FirstOrder.Language.order.Relations n)

full_name: FirstOrder.Language.IsOrdered.leSymb
code: /-- A language is ordered if it has a symbol representing `≤`. -/
class IsOrdered (L : Language.{u, v}) where
  leSymb : L.Relations 2
goal: L.Relations 2

full_name: FirstOrder.Language.IsOrdered
code: /-- A language is ordered if it has a symbol representing `≤`. -/
class IsOrdered (L : Language.{u, v}) where
  leSymb : L.Relations 2
goal: Type v

full_name: FirstOrder.Language.Term.le
code: /-- Joins two terms `t₁, t₂` in a formula representing `t₁ ≤ t₂`. -/
def Term.le (t₁ t₂ : L.Term (α ⊕ (Fin n))) : L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.Term.lt
code: /-- Joins two terms `t₁, t₂` in a formula representing `t₁ < t₂`. -/
def Term.lt (t₁ t₂ : L.Term (α ⊕ (Fin n))) : L.BoundedFormula α n 
goal: L.BoundedFormula α n

full_name: FirstOrder.Language.orderLHom
code: /-- The language homomorphism sending the unique symbol `≤` of `Language.order` to `≤` in an ordered
 language. -/
def orderLHom : Language.order →ᴸ L 
goal: FirstOrder.Language.order →ᴸ L

full_name: FirstOrder.Language.instIsOrderedOrder
code: instance : IsOrdered Language.order 
goal: FirstOrder.Language.order.IsOrdered

full_name: FirstOrder.Language.orderLHom_leSymb
code: @[simp]
theorem orderLHom_leSymb [L.IsOrdered] :
    (orderLHom L).onRelation leSymb = (leSymb : L.Relations 2) 
goal: L.orderLHom.onRelation FirstOrder.Language.leSymb = FirstOrder.Language.leSymb

full_name: FirstOrder.Language.orderLHom_order
code: @[simp]
theorem orderLHom_order : orderLHom Language.order = LHom.id Language.order 
goal: FirstOrder.Language.order.orderLHom = FirstOrder.Language.LHom.id FirstOrder.Language.order

full_name: FirstOrder.Language.sum.instIsOrdered
code: instance sum.instIsOrdered : IsOrdered (L.sum Language.order) 
goal: (L.sum FirstOrder.Language.order).IsOrdered

full_name: FirstOrder.Language.preorderTheory
code: /-- The theory of preorders. -/
def preorderTheory : L.Theory 
goal: L.Theory

full_name: FirstOrder.Language.partialOrderTheory
code: /-- The theory of partial orders. -/
def partialOrderTheory : L.Theory 
goal: L.Theory

full_name: FirstOrder.Language.linearOrderTheory
code: /-- The theory of linear orders. -/
def linearOrderTheory : L.Theory 
goal: L.Theory

full_name: FirstOrder.Language.noTopOrderSentence
code: /-- A sentence indicating that an order has no top element:
$\forall x, \exists y, \neg y \le x$.   -/
def noTopOrderSentence : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.noBotOrderSentence
code: /-- A sentence indicating that an order has no bottom element:
$\forall x, \exists y, \neg x \le y$. -/
def noBotOrderSentence : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.denselyOrderedSentence
code: /-- A sentence indicating that an order is dense:
$\forall x, \forall y, x < y \to \exists z, x < z \wedge z < y$. -/
def denselyOrderedSentence : L.Sentence 
goal: L.Sentence

full_name: FirstOrder.Language.dlo
code: /-- The theory of dense linear orders without endpoints. -/
def dlo : L.Theory 
goal: L.Theory

full_name: FirstOrder.Language.OrderedStructure
code: /-- A structure is ordered if its language has a `≤` symbol whose interpretation is -/
abbrev OrderedStructure [IsOrdered L] [LE M] [L.Structure M] : Prop 
goal: Prop

full_name: FirstOrder.Language.orderedStructure_iff
code: @[simp]
theorem orderedStructure_iff [IsOrdered L] [LE M] [L.Structure M] :
    L.OrderedStructure M ↔ LHom.IsExpansionOn (orderLHom L) M 
goal: L.OrderedStructure M ↔ L.orderLHom.IsExpansionOn M

full_name: FirstOrder.Language.orderedStructure_LE
code: instance orderedStructure_LE [LE M] : OrderedStructure Language.order M 
goal: FirstOrder.Language.order.OrderedStructure M

full_name: FirstOrder.Language.model_preorder
code: instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory 
goal: M ⊨ FirstOrder.Language.order.preorderTheory

full_name: FirstOrder.Language.model_partialOrder
code: instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrderTheory 
goal: M ⊨ FirstOrder.Language.order.partialOrderTheory

full_name: FirstOrder.Language.model_linearOrder
code: instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderTheory 
goal: M ⊨ FirstOrder.Language.order.linearOrderTheory

full_name: FirstOrder.Language.relMap_leSymb
code: @[simp]
theorem relMap_leSymb [LE M] [L.OrderedStructure M] {a b : M} :
    RelMap (leSymb : L.Relations 2) ![a, b] ↔ a ≤ b 
goal: FirstOrder.Language.Structure.RelMap FirstOrder.Language.leSymb ![a, b] ↔ a ≤ b

full_name: FirstOrder.Language.Term.realize_le
code: @[simp]
theorem Term.realize_le [LE M] [L.OrderedStructure M] {t₁ t₂ : L.Term (α ⊕ (Fin n))} {v : α → M}
    {xs : Fin n → M} :
    (t₁.le t₂).Realize v xs ↔ t₁.realize (Sum.elim v xs) ≤ t₂.realize (Sum.elim v xs) 
goal: (t₁.le t₂).Realize v xs ↔
  FirstOrder.Language.Term.realize (Sum.elim v xs) t₁ ≤ FirstOrder.Language.Term.realize (Sum.elim v xs) t₂

full_name: FirstOrder.Language.Term.realize_lt
code: @[simp]
theorem Term.realize_lt [Preorder M] [L.OrderedStructure M] {t₁ t₂ : L.Term (α ⊕ (Fin n))}
    {v : α → M} {xs : Fin n → M} :
    (t₁.lt t₂).Realize v xs ↔ t₁.realize (Sum.elim v xs) < t₂.realize (Sum.elim v xs) 
goal: (t₁.lt t₂).Realize v xs ↔
  FirstOrder.Language.Term.realize (Sum.elim v xs) t₁ < FirstOrder.Language.Term.realize (Sum.elim v xs) t₂

full_name: FirstOrder.Language.realize_noTopOrder_iff
code: theorem realize_noTopOrder_iff : M ⊨ Language.order.noTopOrderSentence ↔ NoTopOrder M 
goal: M ⊨ FirstOrder.Language.order.noTopOrderSentence ↔ NoTopOrder M

full_name: FirstOrder.Language.realize_noTopOrder
code: @[simp]
theorem realize_noTopOrder [h : NoTopOrder M] : M ⊨ Language.order.noTopOrderSentence 
goal: M ⊨ FirstOrder.Language.order.noTopOrderSentence

full_name: FirstOrder.Language.realize_noBotOrder_iff
code: theorem realize_noBotOrder_iff : M ⊨ Language.order.noBotOrderSentence ↔ NoBotOrder M 
goal: M ⊨ FirstOrder.Language.order.noBotOrderSentence ↔ NoBotOrder M

full_name: FirstOrder.Language.realize_noBotOrder
code: @[simp]
theorem realize_noBotOrder [h : NoBotOrder M] : M ⊨ Language.order.noBotOrderSentence 
goal: M ⊨ FirstOrder.Language.order.noBotOrderSentence

full_name: FirstOrder.Language.realize_denselyOrdered_iff
code: theorem realize_denselyOrdered_iff [Preorder M] :
    M ⊨ Language.order.denselyOrderedSentence ↔ DenselyOrdered M 
goal: M ⊨ FirstOrder.Language.order.denselyOrderedSentence ↔ DenselyOrdered M

full_name: FirstOrder.Language.realize_denselyOrdered
code: @[simp]
theorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] :
    M ⊨ Language.order.denselyOrderedSentence 
goal: M ⊨ FirstOrder.Language.order.denselyOrderedSentence

full_name: FirstOrder.Language.model_dlo
code: instance model_dlo [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder M] :
    M ⊨ Language.order.dlo 
goal: M ⊨ FirstOrder.Language.order.dlo