model_theory.order ⟷ Mathlib.ModelTheory.Order

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,7 +3,7 @@ Copyright (c) 2022 Aaron Anderson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Aaron Anderson
 -/
-import Mathbin.ModelTheory.Semantics
+import ModelTheory.Semantics
 
 #align_import model_theory.order from "leanprover-community/mathlib"@"6cf5900728239efa287df7761ec2a1ac9cf39b29"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Aaron Anderson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Aaron Anderson
-
-! This file was ported from Lean 3 source module model_theory.order
-! leanprover-community/mathlib commit 6cf5900728239efa287df7761ec2a1ac9cf39b29
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.ModelTheory.Semantics
 
+#align_import model_theory.order from "leanprover-community/mathlib"@"6cf5900728239efa287df7761ec2a1ac9cf39b29"
+
 /-!
 # Ordered First-Ordered Structures
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -42,7 +42,7 @@ namespace FirstOrder
 
 namespace Language
 
-open FirstOrder
+open scoped FirstOrder
 
 open Structure
 
@@ -217,6 +217,7 @@ instance orderedStructure_LE [LE M] : OrderedStructure Language.order M :=
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.model_preorder /-
 instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
   by
   simp only [preorder_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -224,8 +225,10 @@ instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
     relations.realize_transitive]
   exact ⟨le_refl, fun _ _ _ => le_trans⟩
 #align first_order.language.model_preorder FirstOrder.Language.model_preorder
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.model_partialOrder /-
 instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrderTheory :=
   by
   simp only [partial_order_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -233,8 +236,10 @@ instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrder
     forall_eq, relations.realize_transitive]
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans⟩
 #align first_order.language.model_partial_order FirstOrder.Language.model_partialOrder
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.model_linearOrder /-
 instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderTheory :=
   by
   simp only [linear_order_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -242,6 +247,7 @@ instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderThe
     relations.realize_transitive, forall_eq, relations.realize_total]
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans, le_total⟩
 #align first_order.language.model_linear_order FirstOrder.Language.model_linearOrder
+-/
 
 section OrderedStructure
 
@@ -266,12 +272,14 @@ theorem Term.realize_le [LE M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum 
 #align first_order.language.term.realize_le FirstOrder.Language.Term.realize_le
 -/
 
+#print FirstOrder.Language.Term.realize_lt /-
 @[simp]
 theorem Term.realize_lt [Preorder M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum α (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) := by
   simp [term.lt, lt_iff_le_not_le]
 #align first_order.language.term.realize_lt FirstOrder.Language.Term.realize_lt
+-/
 
 end OrderedStructure
 
@@ -322,6 +330,7 @@ theorem realize_noBotOrder [h : NoBotOrder M] : M ⊨ Language.order.noBotOrderS
 end LE
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.realize_denselyOrdered_iff /-
 theorem realize_denselyOrdered_iff [Preorder M] :
     M ⊨ Language.order.denselyOrderedSentence ↔ DenselyOrdered M :=
   by
@@ -332,15 +341,19 @@ theorem realize_denselyOrdered_iff [Preorder M] :
   intro h a b ab
   exact exists_between ab
 #align first_order.language.realize_densely_ordered_iff FirstOrder.Language.realize_denselyOrdered_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.realize_denselyOrdered /-
 @[simp]
 theorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] :
     M ⊨ Language.order.denselyOrderedSentence :=
   realize_denselyOrdered_iff.2 h
 #align first_order.language.realize_densely_ordered FirstOrder.Language.realize_denselyOrdered
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.model_dlo /-
 instance model_dlo [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder M] :
     M ⊨ Language.order.dlo :=
   by
@@ -350,6 +363,7 @@ instance model_dlo [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder
   rw [← Theory.model_iff]
   infer_instance
 #align first_order.language.model_DLO FirstOrder.Language.model_dlo
+-/
 
 end Language
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -216,12 +216,6 @@ instance orderedStructure_LE [LE M] : OrderedStructure Language.order M :=
 #align first_order.language.ordered_structure_has_le FirstOrder.Language.orderedStructure_LE
 -/
 
-/- warning: first_order.language.model_preorder -> FirstOrder.Language.model_preorder is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (FirstOrder.Language.preorderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M _inst_1)) (FirstOrder.Language.preorderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
-Case conversion may be inaccurate. Consider using '#align first_order.language.model_preorder FirstOrder.Language.model_preorderₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
   by
@@ -231,12 +225,6 @@ instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
   exact ⟨le_refl, fun _ _ _ => le_trans⟩
 #align first_order.language.model_preorder FirstOrder.Language.model_preorder
 
-/- warning: first_order.language.model_partial_order -> FirstOrder.Language.model_partialOrder is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : PartialOrder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M _inst_1))) (FirstOrder.Language.partialOrderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : PartialOrder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M _inst_1))) (FirstOrder.Language.partialOrderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
-Case conversion may be inaccurate. Consider using '#align first_order.language.model_partial_order FirstOrder.Language.model_partialOrderₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrderTheory :=
   by
@@ -246,12 +234,6 @@ instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrder
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans⟩
 #align first_order.language.model_partial_order FirstOrder.Language.model_partialOrder
 
-/- warning: first_order.language.model_linear_order -> FirstOrder.Language.model_linearOrder is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : LinearOrder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))) (FirstOrder.Language.linearOrderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : LinearOrder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))) (FirstOrder.Language.linearOrderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
-Case conversion may be inaccurate. Consider using '#align first_order.language.model_linear_order FirstOrder.Language.model_linearOrderₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderTheory :=
   by
@@ -284,12 +266,6 @@ theorem Term.realize_le [LE M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum 
 #align first_order.language.term.realize_le FirstOrder.Language.Term.realize_le
 -/
 
-/- warning: first_order.language.term.realize_lt -> FirstOrder.Language.Term.realize_lt is a dubious translation:
-lean 3 declaration is
-  forall {L : FirstOrder.Language.{u1, u2}} {α : Type.{u3}} {M : Type.{u4}} {n : Nat} [_inst_1 : FirstOrder.Language.IsOrdered.{u1, u2} L] [_inst_2 : FirstOrder.Language.Structure.{u1, u2, u4} L M] [_inst_3 : Preorder.{u4} M] [_inst_4 : FirstOrder.Language.OrderedStructure.{u1, u2, u4} L M _inst_1 (Preorder.toHasLe.{u4} M _inst_3) _inst_2] {t₁ : FirstOrder.Language.Term.{u1, u2, u3} L (Sum.{u3, 0} α (Fin n))} {t₂ : FirstOrder.Language.Term.{u1, u2, u3} L (Sum.{u3, 0} α (Fin n))} {v : α -> M} {xs : (Fin n) -> M}, Iff (FirstOrder.Language.BoundedFormula.Realize.{u1, u2, u4, u3} L M _inst_2 α n (FirstOrder.Language.Term.lt.{u1, u2, u3} L α n _inst_1 t₁ t₂) v xs) (LT.lt.{u4} M (Preorder.toHasLt.{u4} M _inst_3) (FirstOrder.Language.Term.realize.{u1, u2, u4, u3} L M _inst_2 (Sum.{u3, 0} α (Fin n)) (Sum.elim.{u3, 0, succ u4} α (Fin n) M v xs) t₁) (FirstOrder.Language.Term.realize.{u1, u2, u4, u3} L M _inst_2 (Sum.{u3, 0} α (Fin n)) (Sum.elim.{u3, 0, succ u4} α (Fin n) M v xs) t₂))
-but is expected to have type
-  forall {L : FirstOrder.Language.{u1, u2}} {α : Type.{u3}} {M : Type.{u4}} {n : Nat} [_inst_1 : FirstOrder.Language.IsOrdered.{u1, u2} L] [_inst_2 : FirstOrder.Language.Structure.{u1, u2, u4} L M] [_inst_3 : Preorder.{u4} M] [_inst_4 : FirstOrder.Language.OrderedStructure.{u1, u2, u4} L M _inst_1 (Preorder.toLE.{u4} M _inst_3) _inst_2] {t₁ : FirstOrder.Language.Term.{u1, u2, u3} L (Sum.{u3, 0} α (Fin n))} {t₂ : FirstOrder.Language.Term.{u1, u2, u3} L (Sum.{u3, 0} α (Fin n))} {v : α -> M} {xs : (Fin n) -> M}, Iff (FirstOrder.Language.BoundedFormula.Realize.{u1, u2, u4, u3} L M _inst_2 α n (FirstOrder.Language.Term.lt.{u1, u2, u3} L α n _inst_1 t₁ t₂) v xs) (LT.lt.{u4} M (Preorder.toLT.{u4} M _inst_3) (FirstOrder.Language.Term.realize.{u1, u2, u4, u3} L M _inst_2 (Sum.{u3, 0} α (Fin n)) (Sum.elim.{u3, 0, succ u4} α (Fin n) M v xs) t₁) (FirstOrder.Language.Term.realize.{u1, u2, u4, u3} L M _inst_2 (Sum.{u3, 0} α (Fin n)) (Sum.elim.{u3, 0, succ u4} α (Fin n) M v xs) t₂))
-Case conversion may be inaccurate. Consider using '#align first_order.language.term.realize_lt FirstOrder.Language.Term.realize_ltₓ'. -/
 @[simp]
 theorem Term.realize_lt [Preorder M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum α (Fin n))}
     {v : α → M} {xs : Fin n → M} :
@@ -345,12 +321,6 @@ theorem realize_noBotOrder [h : NoBotOrder M] : M ⊨ Language.order.noBotOrderS
 
 end LE
 
-/- warning: first_order.language.realize_densely_ordered_iff -> FirstOrder.Language.realize_denselyOrdered_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M], Iff (FirstOrder.Language.Sentence.Realize.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (FirstOrder.Language.denselyOrderedSentence.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)) (DenselyOrdered.{u1} M (Preorder.toHasLt.{u1} M _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M], Iff (FirstOrder.Language.Sentence.Realize.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M _inst_1)) (FirstOrder.Language.denselyOrderedSentence.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)) (DenselyOrdered.{u1} M (Preorder.toLT.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align first_order.language.realize_densely_ordered_iff FirstOrder.Language.realize_denselyOrdered_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem realize_denselyOrdered_iff [Preorder M] :
     M ⊨ Language.order.denselyOrderedSentence ↔ DenselyOrdered M :=
@@ -363,12 +333,6 @@ theorem realize_denselyOrdered_iff [Preorder M] :
   exact exists_between ab
 #align first_order.language.realize_densely_ordered_iff FirstOrder.Language.realize_denselyOrdered_iff
 
-/- warning: first_order.language.realize_densely_ordered -> FirstOrder.Language.realize_denselyOrdered is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M] [h : DenselyOrdered.{u1} M (Preorder.toHasLt.{u1} M _inst_1)], FirstOrder.Language.Sentence.Realize.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (FirstOrder.Language.denselyOrderedSentence.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M] [h : DenselyOrdered.{u1} M (Preorder.toLT.{u1} M _inst_1)], FirstOrder.Language.Sentence.Realize.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M _inst_1)) (FirstOrder.Language.denselyOrderedSentence.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
-Case conversion may be inaccurate. Consider using '#align first_order.language.realize_densely_ordered FirstOrder.Language.realize_denselyOrderedₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] :
@@ -376,12 +340,6 @@ theorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] :
   realize_denselyOrdered_iff.2 h
 #align first_order.language.realize_densely_ordered FirstOrder.Language.realize_denselyOrdered
 
-/- warning: first_order.language.model_DLO -> FirstOrder.Language.model_dlo is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : LinearOrder.{u1} M] [_inst_2 : DenselyOrdered.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))] [_inst_3 : NoTopOrder.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))] [_inst_4 : NoBotOrder.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))) (FirstOrder.Language.dlo.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : LinearOrder.{u1} M] [_inst_2 : DenselyOrdered.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))] [_inst_3 : NoTopOrder.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))] [_inst_4 : NoBotOrder.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))) (FirstOrder.Language.dlo.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
-Case conversion may be inaccurate. Consider using '#align first_order.language.model_DLO FirstOrder.Language.model_dloₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 instance model_dlo [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder M] :
     M ⊨ Language.order.dlo :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -208,16 +208,21 @@ theorem orderedStructure_iff [IsOrdered L] [LE M] [L.Structure M] :
 #align first_order.language.ordered_structure_iff FirstOrder.Language.orderedStructure_iff
 -/
 
-#print FirstOrder.Language.orderedStructure_lE /-
-instance orderedStructure_lE [LE M] : OrderedStructure Language.order M :=
+#print FirstOrder.Language.orderedStructure_LE /-
+instance orderedStructure_LE [LE M] : OrderedStructure Language.order M :=
   by
   rw [ordered_structure_iff, order_Lhom_order]
   exact Lhom.id_is_expansion_on M
-#align first_order.language.ordered_structure_has_le FirstOrder.Language.orderedStructure_lE
+#align first_order.language.ordered_structure_has_le FirstOrder.Language.orderedStructure_LE
 -/
 
+/- warning: first_order.language.model_preorder -> FirstOrder.Language.model_preorder is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (FirstOrder.Language.preorderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M _inst_1)) (FirstOrder.Language.preorderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
+Case conversion may be inaccurate. Consider using '#align first_order.language.model_preorder FirstOrder.Language.model_preorderₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print FirstOrder.Language.model_preorder /-
 instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
   by
   simp only [preorder_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -225,10 +230,14 @@ instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
     relations.realize_transitive]
   exact ⟨le_refl, fun _ _ _ => le_trans⟩
 #align first_order.language.model_preorder FirstOrder.Language.model_preorder
--/
 
+/- warning: first_order.language.model_partial_order -> FirstOrder.Language.model_partialOrder is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : PartialOrder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M _inst_1))) (FirstOrder.Language.partialOrderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : PartialOrder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M _inst_1))) (FirstOrder.Language.partialOrderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
+Case conversion may be inaccurate. Consider using '#align first_order.language.model_partial_order FirstOrder.Language.model_partialOrderₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print FirstOrder.Language.model_partialOrder /-
 instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrderTheory :=
   by
   simp only [partial_order_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -236,10 +245,14 @@ instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrder
     forall_eq, relations.realize_transitive]
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans⟩
 #align first_order.language.model_partial_order FirstOrder.Language.model_partialOrder
--/
 
+/- warning: first_order.language.model_linear_order -> FirstOrder.Language.model_linearOrder is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : LinearOrder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))) (FirstOrder.Language.linearOrderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : LinearOrder.{u1} M], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))) (FirstOrder.Language.linearOrderTheory.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
+Case conversion may be inaccurate. Consider using '#align first_order.language.model_linear_order FirstOrder.Language.model_linearOrderₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print FirstOrder.Language.model_linearOrder /-
 instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderTheory :=
   by
   simp only [linear_order_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -247,7 +260,6 @@ instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderThe
     relations.realize_transitive, forall_eq, relations.realize_total]
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans, le_total⟩
 #align first_order.language.model_linear_order FirstOrder.Language.model_linearOrder
--/
 
 section OrderedStructure
 
@@ -272,14 +284,18 @@ theorem Term.realize_le [LE M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum 
 #align first_order.language.term.realize_le FirstOrder.Language.Term.realize_le
 -/
 
-#print FirstOrder.Language.Term.realize_lt /-
+/- warning: first_order.language.term.realize_lt -> FirstOrder.Language.Term.realize_lt is a dubious translation:
+lean 3 declaration is
+  forall {L : FirstOrder.Language.{u1, u2}} {α : Type.{u3}} {M : Type.{u4}} {n : Nat} [_inst_1 : FirstOrder.Language.IsOrdered.{u1, u2} L] [_inst_2 : FirstOrder.Language.Structure.{u1, u2, u4} L M] [_inst_3 : Preorder.{u4} M] [_inst_4 : FirstOrder.Language.OrderedStructure.{u1, u2, u4} L M _inst_1 (Preorder.toHasLe.{u4} M _inst_3) _inst_2] {t₁ : FirstOrder.Language.Term.{u1, u2, u3} L (Sum.{u3, 0} α (Fin n))} {t₂ : FirstOrder.Language.Term.{u1, u2, u3} L (Sum.{u3, 0} α (Fin n))} {v : α -> M} {xs : (Fin n) -> M}, Iff (FirstOrder.Language.BoundedFormula.Realize.{u1, u2, u4, u3} L M _inst_2 α n (FirstOrder.Language.Term.lt.{u1, u2, u3} L α n _inst_1 t₁ t₂) v xs) (LT.lt.{u4} M (Preorder.toHasLt.{u4} M _inst_3) (FirstOrder.Language.Term.realize.{u1, u2, u4, u3} L M _inst_2 (Sum.{u3, 0} α (Fin n)) (Sum.elim.{u3, 0, succ u4} α (Fin n) M v xs) t₁) (FirstOrder.Language.Term.realize.{u1, u2, u4, u3} L M _inst_2 (Sum.{u3, 0} α (Fin n)) (Sum.elim.{u3, 0, succ u4} α (Fin n) M v xs) t₂))
+but is expected to have type
+  forall {L : FirstOrder.Language.{u1, u2}} {α : Type.{u3}} {M : Type.{u4}} {n : Nat} [_inst_1 : FirstOrder.Language.IsOrdered.{u1, u2} L] [_inst_2 : FirstOrder.Language.Structure.{u1, u2, u4} L M] [_inst_3 : Preorder.{u4} M] [_inst_4 : FirstOrder.Language.OrderedStructure.{u1, u2, u4} L M _inst_1 (Preorder.toLE.{u4} M _inst_3) _inst_2] {t₁ : FirstOrder.Language.Term.{u1, u2, u3} L (Sum.{u3, 0} α (Fin n))} {t₂ : FirstOrder.Language.Term.{u1, u2, u3} L (Sum.{u3, 0} α (Fin n))} {v : α -> M} {xs : (Fin n) -> M}, Iff (FirstOrder.Language.BoundedFormula.Realize.{u1, u2, u4, u3} L M _inst_2 α n (FirstOrder.Language.Term.lt.{u1, u2, u3} L α n _inst_1 t₁ t₂) v xs) (LT.lt.{u4} M (Preorder.toLT.{u4} M _inst_3) (FirstOrder.Language.Term.realize.{u1, u2, u4, u3} L M _inst_2 (Sum.{u3, 0} α (Fin n)) (Sum.elim.{u3, 0, succ u4} α (Fin n) M v xs) t₁) (FirstOrder.Language.Term.realize.{u1, u2, u4, u3} L M _inst_2 (Sum.{u3, 0} α (Fin n)) (Sum.elim.{u3, 0, succ u4} α (Fin n) M v xs) t₂))
+Case conversion may be inaccurate. Consider using '#align first_order.language.term.realize_lt FirstOrder.Language.Term.realize_ltₓ'. -/
 @[simp]
 theorem Term.realize_lt [Preorder M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum α (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) := by
   simp [term.lt, lt_iff_le_not_le]
 #align first_order.language.term.realize_lt FirstOrder.Language.Term.realize_lt
--/
 
 end OrderedStructure
 
@@ -329,8 +345,13 @@ theorem realize_noBotOrder [h : NoBotOrder M] : M ⊨ Language.order.noBotOrderS
 
 end LE
 
+/- warning: first_order.language.realize_densely_ordered_iff -> FirstOrder.Language.realize_denselyOrdered_iff is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M], Iff (FirstOrder.Language.Sentence.Realize.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (FirstOrder.Language.denselyOrderedSentence.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)) (DenselyOrdered.{u1} M (Preorder.toHasLt.{u1} M _inst_1))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M], Iff (FirstOrder.Language.Sentence.Realize.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M _inst_1)) (FirstOrder.Language.denselyOrderedSentence.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)) (DenselyOrdered.{u1} M (Preorder.toLT.{u1} M _inst_1))
+Case conversion may be inaccurate. Consider using '#align first_order.language.realize_densely_ordered_iff FirstOrder.Language.realize_denselyOrdered_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print FirstOrder.Language.realize_denselyOrdered_iff /-
 theorem realize_denselyOrdered_iff [Preorder M] :
     M ⊨ Language.order.denselyOrderedSentence ↔ DenselyOrdered M :=
   by
@@ -341,19 +362,27 @@ theorem realize_denselyOrdered_iff [Preorder M] :
   intro h a b ab
   exact exists_between ab
 #align first_order.language.realize_densely_ordered_iff FirstOrder.Language.realize_denselyOrdered_iff
--/
 
+/- warning: first_order.language.realize_densely_ordered -> FirstOrder.Language.realize_denselyOrdered is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M] [h : DenselyOrdered.{u1} M (Preorder.toHasLt.{u1} M _inst_1)], FirstOrder.Language.Sentence.Realize.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M _inst_1)) (FirstOrder.Language.denselyOrderedSentence.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Preorder.{u1} M] [h : DenselyOrdered.{u1} M (Preorder.toLT.{u1} M _inst_1)], FirstOrder.Language.Sentence.Realize.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M _inst_1)) (FirstOrder.Language.denselyOrderedSentence.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
+Case conversion may be inaccurate. Consider using '#align first_order.language.realize_densely_ordered FirstOrder.Language.realize_denselyOrderedₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print FirstOrder.Language.realize_denselyOrdered /-
 @[simp]
 theorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] :
     M ⊨ Language.order.denselyOrderedSentence :=
   realize_denselyOrdered_iff.2 h
 #align first_order.language.realize_densely_ordered FirstOrder.Language.realize_denselyOrdered
--/
 
+/- warning: first_order.language.model_DLO -> FirstOrder.Language.model_dlo is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : LinearOrder.{u1} M] [_inst_2 : DenselyOrdered.{u1} M (Preorder.toHasLt.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))] [_inst_3 : NoTopOrder.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))] [_inst_4 : NoBotOrder.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toHasLe.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (LinearOrder.toLattice.{u1} M _inst_1)))))) (FirstOrder.Language.dlo.{0, 0} FirstOrder.Language.order FirstOrder.Language.order.isOrdered)
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : LinearOrder.{u1} M] [_inst_2 : DenselyOrdered.{u1} M (Preorder.toLT.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))] [_inst_3 : NoTopOrder.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))] [_inst_4 : NoBotOrder.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))], FirstOrder.Language.Theory.Model.{0, 0, u1} FirstOrder.Language.order M (FirstOrder.Language.orderStructure.{u1} M (Preorder.toLE.{u1} M (PartialOrder.toPreorder.{u1} M (SemilatticeInf.toPartialOrder.{u1} M (Lattice.toSemilatticeInf.{u1} M (DistribLattice.toLattice.{u1} M (instDistribLattice.{u1} M _inst_1))))))) (FirstOrder.Language.dlo.{0, 0} FirstOrder.Language.order FirstOrder.Language.instIsOrderedOrder)
+Case conversion may be inaccurate. Consider using '#align first_order.language.model_DLO FirstOrder.Language.model_dloₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print FirstOrder.Language.model_dlo /-
 instance model_dlo [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder M] :
     M ⊨ Language.order.dlo :=
   by
@@ -363,7 +392,6 @@ instance model_dlo [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder
   rw [← Theory.model_iff]
   infer_instance
 #align first_order.language.model_DLO FirstOrder.Language.model_dlo
--/
 
 end Language
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Aaron Anderson
 
 ! This file was ported from Lean 3 source module model_theory.order
-! leanprover-community/mathlib commit 1ed3a113dbc6f5b33eae3b96211d4e26ca3a5e9d
+! leanprover-community/mathlib commit 6cf5900728239efa287df7761ec2a1ac9cf39b29
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -12,6 +12,9 @@ import Mathbin.ModelTheory.Semantics
 
 /-!
 # Ordered First-Ordered Structures
+
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
 This file defines ordered first-order languages and structures, as well as their theories.
 
 ## Main Definitions

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

@@ -45,14 +45,18 @@ open Structure
 
 variable {L : Language.{u, v}} {α : Type w} {M : Type w'} {n : ℕ}
 
+#print FirstOrder.Language.order /-
 /-- The language consisting of a single relation representing `≤`. -/
 protected def order : Language :=
   Language.mk₂ Empty Empty Empty Empty Unit
 #align first_order.language.order FirstOrder.Language.order
+-/
 
+#print FirstOrder.Language.orderStructure /-
 instance orderStructure [LE M] : Language.order.Structure M :=
   Structure.mk₂ Empty.elim Empty.elim Empty.elim Empty.elim fun _ => (· ≤ ·)
 #align first_order.language.order_Structure FirstOrder.Language.orderStructure
+-/
 
 namespace Order
 
@@ -64,10 +68,12 @@ instance : Subsingleton (Language.order.Relations n) :=
 
 end Order
 
+#print FirstOrder.Language.IsOrdered /-
 /-- A language is ordered if it has a symbol representing `≤`. -/
 class IsOrdered (L : Language.{u, v}) where
   leSymb : L.Relations 2
 #align first_order.language.is_ordered FirstOrder.Language.IsOrdered
+-/
 
 export IsOrdered (leSymb)
 
@@ -75,39 +81,49 @@ section IsOrdered
 
 variable [IsOrdered L]
 
+#print FirstOrder.Language.Term.le /-
 /-- Joins two terms `t₁, t₂` in a formula representing `t₁ ≤ t₂`. -/
 def Term.le (t₁ t₂ : L.term (Sum α (Fin n))) : L.BoundedFormula α n :=
   leSymb.boundedFormula₂ t₁ t₂
 #align first_order.language.term.le FirstOrder.Language.Term.le
+-/
 
+#print FirstOrder.Language.Term.lt /-
 /-- Joins two terms `t₁, t₂` in a formula representing `t₁ < t₂`. -/
 def Term.lt (t₁ t₂ : L.term (Sum α (Fin n))) : L.BoundedFormula α n :=
   t₁.le t₂ ⊓ ∼(t₂.le t₁)
 #align first_order.language.term.lt FirstOrder.Language.Term.lt
+-/
 
 variable (L)
 
+#print FirstOrder.Language.orderLHom /-
 /-- The language homomorphism sending the unique symbol `≤` of `language.order` to `≤` in an ordered
  language. -/
-def orderLhom : Language.order →ᴸ L :=
+def orderLHom : Language.order →ᴸ L :=
   LHom.mk₂ Empty.elim Empty.elim Empty.elim Empty.elim fun _ => leSymb
-#align first_order.language.order_Lhom FirstOrder.Language.orderLhom
+#align first_order.language.order_Lhom FirstOrder.Language.orderLHom
+-/
 
 end IsOrdered
 
 instance : IsOrdered Language.order :=
   ⟨Unit.unit⟩
 
+#print FirstOrder.Language.orderLHom_leSymb /-
 @[simp]
-theorem orderLhom_leSymb [L.IsOrdered] :
-    (orderLhom L).onRelation leSymb = (leSymb : L.Relations 2) :=
+theorem orderLHom_leSymb [L.IsOrdered] :
+    (orderLHom L).onRelation leSymb = (leSymb : L.Relations 2) :=
   rfl
-#align first_order.language.order_Lhom_le_symb FirstOrder.Language.orderLhom_leSymb
+#align first_order.language.order_Lhom_le_symb FirstOrder.Language.orderLHom_leSymb
+-/
 
+#print FirstOrder.Language.orderLHom_order /-
 @[simp]
-theorem orderLhom_order : orderLhom Language.order = LHom.id Language.order :=
+theorem orderLHom_order : orderLHom Language.order = LHom.id Language.order :=
   LHom.funext (Subsingleton.elim _ _) (Subsingleton.elim _ _)
-#align first_order.language.order_Lhom_order FirstOrder.Language.orderLhom_order
+#align first_order.language.order_Lhom_order FirstOrder.Language.orderLHom_order
+-/
 
 instance : IsOrdered (L.Sum Language.order) :=
   ⟨Sum.inr IsOrdered.leSymb⟩
@@ -116,68 +132,89 @@ section
 
 variable (L) [IsOrdered L]
 
+#print FirstOrder.Language.preorderTheory /-
 /-- The theory of preorders. -/
 def preorderTheory : L.Theory :=
   {leSymb.Reflexive, leSymb.Transitive}
 #align first_order.language.preorder_theory FirstOrder.Language.preorderTheory
+-/
 
+#print FirstOrder.Language.partialOrderTheory /-
 /-- The theory of partial orders. -/
 def partialOrderTheory : L.Theory :=
   {leSymb.Reflexive, leSymb.antisymmetric, leSymb.Transitive}
 #align first_order.language.partial_order_theory FirstOrder.Language.partialOrderTheory
+-/
 
+#print FirstOrder.Language.linearOrderTheory /-
 /-- The theory of linear orders. -/
 def linearOrderTheory : L.Theory :=
   {leSymb.Reflexive, leSymb.antisymmetric, leSymb.Transitive, leSymb.Total}
 #align first_order.language.linear_order_theory FirstOrder.Language.linearOrderTheory
+-/
 
+#print FirstOrder.Language.noTopOrderSentence /-
 /-- A sentence indicating that an order has no top element:
 $\forall x, \exists y, \neg y \le x$.   -/
 def noTopOrderSentence : L.Sentence :=
   ∀'∃'∼((&1).le &0)
 #align first_order.language.no_top_order_sentence FirstOrder.Language.noTopOrderSentence
+-/
 
+#print FirstOrder.Language.noBotOrderSentence /-
 /-- A sentence indicating that an order has no bottom element:
 $\forall x, \exists y, \neg x \le y$. -/
 def noBotOrderSentence : L.Sentence :=
   ∀'∃'∼((&0).le &1)
 #align first_order.language.no_bot_order_sentence FirstOrder.Language.noBotOrderSentence
+-/
 
+#print FirstOrder.Language.denselyOrderedSentence /-
 /-- 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 :=
   ∀'∀'((&0).lt &1 ⟹ ∃'((&0).lt &2 ⊓ (&2).lt &1))
 #align first_order.language.densely_ordered_sentence FirstOrder.Language.denselyOrderedSentence
+-/
 
+#print FirstOrder.Language.dlo /-
 /-- The theory of dense linear orders without endpoints. -/
-def dLO : L.Theory :=
+def dlo : L.Theory :=
   L.linearOrderTheory ∪ {L.noTopOrderSentence, L.noBotOrderSentence, L.denselyOrderedSentence}
-#align first_order.language.DLO FirstOrder.Language.dLO
+#align first_order.language.DLO FirstOrder.Language.dlo
+-/
 
 end
 
 variable (L M)
 
+#print FirstOrder.Language.OrderedStructure /-
 /-- A structure is ordered if its language has a `≤` symbol whose interpretation is -/
 abbrev OrderedStructure [IsOrdered L] [LE M] [L.Structure M] : Prop :=
-  LHom.IsExpansionOn (orderLhom L) M
+  LHom.IsExpansionOn (orderLHom L) M
 #align first_order.language.ordered_structure FirstOrder.Language.OrderedStructure
+-/
 
 variable {L M}
 
+#print FirstOrder.Language.orderedStructure_iff /-
 @[simp]
 theorem orderedStructure_iff [IsOrdered L] [LE M] [L.Structure M] :
-    L.OrderedStructure M ↔ LHom.IsExpansionOn (orderLhom L) M :=
+    L.OrderedStructure M ↔ LHom.IsExpansionOn (orderLHom L) M :=
   Iff.rfl
 #align first_order.language.ordered_structure_iff FirstOrder.Language.orderedStructure_iff
+-/
 
+#print FirstOrder.Language.orderedStructure_lE /-
 instance orderedStructure_lE [LE M] : OrderedStructure Language.order M :=
   by
   rw [ordered_structure_iff, order_Lhom_order]
   exact Lhom.id_is_expansion_on M
 #align first_order.language.ordered_structure_has_le FirstOrder.Language.orderedStructure_lE
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.model_preorder /-
 instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
   by
   simp only [preorder_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -185,8 +222,10 @@ instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
     relations.realize_transitive]
   exact ⟨le_refl, fun _ _ _ => le_trans⟩
 #align first_order.language.model_preorder FirstOrder.Language.model_preorder
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.model_partialOrder /-
 instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrderTheory :=
   by
   simp only [partial_order_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -194,8 +233,10 @@ instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrder
     forall_eq, relations.realize_transitive]
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans⟩
 #align first_order.language.model_partial_order FirstOrder.Language.model_partialOrder
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.model_linearOrder /-
 instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderTheory :=
   by
   simp only [linear_order_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
@@ -203,11 +244,13 @@ instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderThe
     relations.realize_transitive, forall_eq, relations.realize_total]
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans, le_total⟩
 #align first_order.language.model_linear_order FirstOrder.Language.model_linearOrder
+-/
 
 section OrderedStructure
 
 variable [IsOrdered L] [L.Structure M]
 
+#print FirstOrder.Language.relMap_leSymb /-
 @[simp]
 theorem relMap_leSymb [LE M] [L.OrderedStructure M] {a b : M} :
     RelMap (leSymb : L.Relations 2) ![a, b] ↔ a ≤ b :=
@@ -215,20 +258,25 @@ theorem relMap_leSymb [LE M] [L.OrderedStructure M] {a b : M} :
   rw [← order_Lhom_le_symb, Lhom.map_on_relation]
   rfl
 #align first_order.language.rel_map_le_symb FirstOrder.Language.relMap_leSymb
+-/
 
+#print FirstOrder.Language.Term.realize_le /-
 @[simp]
 theorem Term.realize_le [LE M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum α (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) := by
   simp [term.le]
 #align first_order.language.term.realize_le FirstOrder.Language.Term.realize_le
+-/
 
+#print FirstOrder.Language.Term.realize_lt /-
 @[simp]
 theorem Term.realize_lt [Preorder M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum α (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) := by
   simp [term.lt, lt_iff_le_not_le]
 #align first_order.language.term.realize_lt FirstOrder.Language.Term.realize_lt
+-/
 
 end OrderedStructure
 
@@ -237,6 +285,7 @@ section LE
 variable [LE M]
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.realize_noTopOrder_iff /-
 theorem realize_noTopOrder_iff : M ⊨ Language.order.noTopOrderSentence ↔ NoTopOrder M :=
   by
   simp only [no_top_order_sentence, sentence.realize, formula.realize, bounded_formula.realize_all,
@@ -245,14 +294,18 @@ theorem realize_noTopOrder_iff : M ⊨ Language.order.noTopOrderSentence ↔ NoT
   intro h a
   exact exists_not_le a
 #align first_order.language.realize_no_top_order_iff FirstOrder.Language.realize_noTopOrder_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.realize_noTopOrder /-
 @[simp]
 theorem realize_noTopOrder [h : NoTopOrder M] : M ⊨ Language.order.noTopOrderSentence :=
   realize_noTopOrder_iff.2 h
 #align first_order.language.realize_no_top_order FirstOrder.Language.realize_noTopOrder
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.realize_noBotOrder_iff /-
 theorem realize_noBotOrder_iff : M ⊨ Language.order.noBotOrderSentence ↔ NoBotOrder M :=
   by
   simp only [no_bot_order_sentence, sentence.realize, formula.realize, bounded_formula.realize_all,
@@ -261,16 +314,20 @@ theorem realize_noBotOrder_iff : M ⊨ Language.order.noBotOrderSentence ↔ NoB
   intro h a
   exact exists_not_ge a
 #align first_order.language.realize_no_bot_order_iff FirstOrder.Language.realize_noBotOrder_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.realize_noBotOrder /-
 @[simp]
 theorem realize_noBotOrder [h : NoBotOrder M] : M ⊨ Language.order.noBotOrderSentence :=
   realize_noBotOrder_iff.2 h
 #align first_order.language.realize_no_bot_order FirstOrder.Language.realize_noBotOrder
+-/
 
 end LE
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.realize_denselyOrdered_iff /-
 theorem realize_denselyOrdered_iff [Preorder M] :
     M ⊨ Language.order.denselyOrderedSentence ↔ DenselyOrdered M :=
   by
@@ -281,24 +338,29 @@ theorem realize_denselyOrdered_iff [Preorder M] :
   intro h a b ab
   exact exists_between ab
 #align first_order.language.realize_densely_ordered_iff FirstOrder.Language.realize_denselyOrdered_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print FirstOrder.Language.realize_denselyOrdered /-
 @[simp]
 theorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] :
     M ⊨ Language.order.denselyOrderedSentence :=
   realize_denselyOrdered_iff.2 h
 #align first_order.language.realize_densely_ordered FirstOrder.Language.realize_denselyOrdered
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-instance model_dLO [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder M] :
-    M ⊨ Language.order.dLO :=
+#print FirstOrder.Language.model_dlo /-
+instance model_dlo [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder M] :
+    M ⊨ Language.order.dlo :=
   by
   simp only [DLO, Set.union_insert, Set.union_singleton, Theory.model_iff, Set.mem_insert_iff,
     forall_eq_or_imp, realize_no_top_order, realize_no_bot_order, realize_densely_ordered,
     true_and_iff]
   rw [← Theory.model_iff]
   infer_instance
-#align first_order.language.model_DLO FirstOrder.Language.model_dLO
+#align first_order.language.model_DLO FirstOrder.Language.model_dlo
+-/
 
 end Language
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/039ef89bef6e58b32b62898dd48e9d1a4312bb65

@@ -90,7 +90,7 @@ variable (L)
 /-- The language homomorphism sending the unique symbol `≤` of `language.order` to `≤` in an ordered
  language. -/
 def orderLhom : Language.order →ᴸ L :=
-  Lhom.mk₂ Empty.elim Empty.elim Empty.elim Empty.elim fun _ => leSymb
+  LHom.mk₂ Empty.elim Empty.elim Empty.elim Empty.elim fun _ => leSymb
 #align first_order.language.order_Lhom FirstOrder.Language.orderLhom
 
 end IsOrdered
@@ -105,8 +105,8 @@ theorem orderLhom_leSymb [L.IsOrdered] :
 #align first_order.language.order_Lhom_le_symb FirstOrder.Language.orderLhom_leSymb
 
 @[simp]
-theorem orderLhom_order : orderLhom Language.order = Lhom.id Language.order :=
-  Lhom.funext (Subsingleton.elim _ _) (Subsingleton.elim _ _)
+theorem orderLhom_order : orderLhom Language.order = LHom.id Language.order :=
+  LHom.funext (Subsingleton.elim _ _) (Subsingleton.elim _ _)
 #align first_order.language.order_Lhom_order FirstOrder.Language.orderLhom_order
 
 instance : IsOrdered (L.Sum Language.order) :=
@@ -160,14 +160,14 @@ variable (L M)
 
 /-- A structure is ordered if its language has a `≤` symbol whose interpretation is -/
 abbrev OrderedStructure [IsOrdered L] [LE M] [L.Structure M] : Prop :=
-  Lhom.IsExpansionOn (orderLhom L) M
+  LHom.IsExpansionOn (orderLhom L) M
 #align first_order.language.ordered_structure FirstOrder.Language.OrderedStructure
 
 variable {L M}
 
 @[simp]
 theorem orderedStructure_iff [IsOrdered L] [LE M] [L.Structure M] :
-    L.OrderedStructure M ↔ Lhom.IsExpansionOn (orderLhom L) M :=
+    L.OrderedStructure M ↔ LHom.IsExpansionOn (orderLhom L) M :=
   Iff.rfl
 #align first_order.language.ordered_structure_iff FirstOrder.Language.orderedStructure_iff
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/22131150f88a2d125713ffa0f4693e3355b1eb49

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Aaron Anderson
 
 ! This file was ported from Lean 3 source module model_theory.order
-! leanprover-community/mathlib commit 3baad3bf89c68ebd87445d27b38136888392b1b1
+! leanprover-community/mathlib commit 1ed3a113dbc6f5b33eae3b96211d4e26ca3a5e9d
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -19,13 +19,13 @@ This file defines ordered first-order languages and structures, as well as their
 * `first_order.language.order_Structure` is the structure on an ordered type, assigning the symbol
 representing `≤` to the actual relation `≤`.
 * `first_order.language.is_ordered` points out a specific symbol in a language as representing `≤`.
-* `first_order.language.is_ordered_structure` indicates that a structure over a
-* `first_order.language.Theory.linear_order` and similar define the theories of preorders,
+* `first_order.language.ordered_structure` indicates that the `≤` symbol in an ordered language
+is interpreted as the actual relation `≤` in a particular structure.
+* `first_order.language.linear_order_theory` and similar define the theories of preorders,
 partial orders, and linear orders.
-* `first_order.language.Theory.DLO` defines the theory of dense linear orders without endpoints, a
+* `first_order.language.DLO` defines the theory of dense linear orders without endpoints, a
 particularly useful example in model theory.
 
-
 ## Main Results
 * `partial_order`s model the theory of partial orders, `linear_order`s model the theory of
 linear orders, and dense linear orders without endpoints model `Theory.DLO`.
@@ -50,11 +50,11 @@ protected def order : Language :=
   Language.mk₂ Empty Empty Empty Empty Unit
 #align first_order.language.order FirstOrder.Language.order
 
-namespace Order
-
-instance structure [LE M] : Language.order.Structure M :=
+instance orderStructure [LE M] : Language.order.Structure M :=
   Structure.mk₂ Empty.elim Empty.elim Empty.elim Empty.elim fun _ => (· ≤ ·)
-#align first_order.language.order.Structure FirstOrder.Language.order.structure
+#align first_order.language.order_Structure FirstOrder.Language.orderStructure
+
+namespace Order
 
 instance : IsRelational Language.order :=
   Language.isRelational_mk₂
@@ -112,98 +112,104 @@ theorem orderLhom_order : orderLhom Language.order = Lhom.id Language.order :=
 instance : IsOrdered (L.Sum Language.order) :=
   ⟨Sum.inr IsOrdered.leSymb⟩
 
+section
+
+variable (L) [IsOrdered L]
+
 /-- The theory of preorders. -/
-protected def Theory.preorder : Language.order.Theory :=
+def preorderTheory : L.Theory :=
   {leSymb.Reflexive, leSymb.Transitive}
-#align first_order.language.Theory.preorder FirstOrder.Language.Theory.preorder
+#align first_order.language.preorder_theory FirstOrder.Language.preorderTheory
 
 /-- The theory of partial orders. -/
-protected def Theory.partialOrder : Language.order.Theory :=
+def partialOrderTheory : L.Theory :=
   {leSymb.Reflexive, leSymb.antisymmetric, leSymb.Transitive}
-#align first_order.language.Theory.partial_order FirstOrder.Language.Theory.partialOrder
+#align first_order.language.partial_order_theory FirstOrder.Language.partialOrderTheory
 
 /-- The theory of linear orders. -/
-protected def Theory.linearOrder : Language.order.Theory :=
+def linearOrderTheory : L.Theory :=
   {leSymb.Reflexive, leSymb.antisymmetric, leSymb.Transitive, leSymb.Total}
-#align first_order.language.Theory.linear_order FirstOrder.Language.Theory.linearOrder
+#align first_order.language.linear_order_theory FirstOrder.Language.linearOrderTheory
 
 /-- A sentence indicating that an order has no top element:
 $\forall x, \exists y, \neg y \le x$.   -/
-protected def Sentence.noTopOrder : Language.order.Sentence :=
+def noTopOrderSentence : L.Sentence :=
   ∀'∃'∼((&1).le &0)
-#align first_order.language.sentence.no_top_order FirstOrder.Language.Sentence.noTopOrder
+#align first_order.language.no_top_order_sentence FirstOrder.Language.noTopOrderSentence
 
 /-- A sentence indicating that an order has no bottom element:
 $\forall x, \exists y, \neg x \le y$. -/
-protected def Sentence.noBotOrder : Language.order.Sentence :=
+def noBotOrderSentence : L.Sentence :=
   ∀'∃'∼((&0).le &1)
-#align first_order.language.sentence.no_bot_order FirstOrder.Language.Sentence.noBotOrder
+#align first_order.language.no_bot_order_sentence FirstOrder.Language.noBotOrderSentence
 
 /-- A sentence indicating that an order is dense:
 $\forall x, \forall y, x < y \to \exists z, x < z \wedge z < y$. -/
-protected def Sentence.denselyOrdered : Language.order.Sentence :=
+def denselyOrderedSentence : L.Sentence :=
   ∀'∀'((&0).lt &1 ⟹ ∃'((&0).lt &2 ⊓ (&2).lt &1))
-#align first_order.language.sentence.densely_ordered FirstOrder.Language.Sentence.denselyOrdered
+#align first_order.language.densely_ordered_sentence FirstOrder.Language.denselyOrderedSentence
 
 /-- The theory of dense linear orders without endpoints. -/
-protected def Theory.dLO : Language.order.Theory :=
-  Theory.linearOrder ∪ {Sentence.noTopOrder, Sentence.noBotOrder, Sentence.denselyOrdered}
-#align first_order.language.Theory.DLO FirstOrder.Language.Theory.dLO
+def dLO : L.Theory :=
+  L.linearOrderTheory ∪ {L.noTopOrderSentence, L.noBotOrderSentence, L.denselyOrderedSentence}
+#align first_order.language.DLO FirstOrder.Language.dLO
+
+end
 
 variable (L M)
 
 /-- A structure is ordered if its language has a `≤` symbol whose interpretation is -/
-abbrev IsOrderedStructure [IsOrdered L] [LE M] [L.Structure M] : Prop :=
+abbrev OrderedStructure [IsOrdered L] [LE M] [L.Structure M] : Prop :=
   Lhom.IsExpansionOn (orderLhom L) M
-#align first_order.language.is_ordered_structure FirstOrder.Language.IsOrderedStructure
+#align first_order.language.ordered_structure FirstOrder.Language.OrderedStructure
 
 variable {L M}
 
 @[simp]
-theorem isOrderedStructure_iff [IsOrdered L] [LE M] [L.Structure M] :
-    L.IsOrderedStructure M ↔ Lhom.IsExpansionOn (orderLhom L) M :=
+theorem orderedStructure_iff [IsOrdered L] [LE M] [L.Structure M] :
+    L.OrderedStructure M ↔ Lhom.IsExpansionOn (orderLhom L) M :=
   Iff.rfl
-#align first_order.language.is_ordered_structure_iff FirstOrder.Language.isOrderedStructure_iff
+#align first_order.language.ordered_structure_iff FirstOrder.Language.orderedStructure_iff
 
-instance isOrderedStructure_lE [LE M] : IsOrderedStructure Language.order M :=
+instance orderedStructure_lE [LE M] : OrderedStructure Language.order M :=
   by
-  rw [is_ordered_structure_iff, order_Lhom_order]
+  rw [ordered_structure_iff, order_Lhom_order]
   exact Lhom.id_is_expansion_on M
-#align first_order.language.is_ordered_structure_has_le FirstOrder.Language.isOrderedStructure_lE
+#align first_order.language.ordered_structure_has_le FirstOrder.Language.orderedStructure_lE
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-instance model_preorder [Preorder M] : M ⊨ Theory.preorder :=
+instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory :=
   by
-  simp only [Theory.preorder, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
+  simp only [preorder_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
     forall_eq_or_imp, relations.realize_reflexive, rel_map_apply₂, forall_eq,
     relations.realize_transitive]
   exact ⟨le_refl, fun _ _ _ => le_trans⟩
 #align first_order.language.model_preorder FirstOrder.Language.model_preorder
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-instance model_partialOrder [PartialOrder M] : M ⊨ Theory.partialOrder :=
+instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrderTheory :=
   by
-  simp only [Theory.partial_order, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
+  simp only [partial_order_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
     forall_eq_or_imp, relations.realize_reflexive, rel_map_apply₂, relations.realize_antisymmetric,
     forall_eq, relations.realize_transitive]
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans⟩
 #align first_order.language.model_partial_order FirstOrder.Language.model_partialOrder
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-instance model_linearOrder [LinearOrder M] : M ⊨ Theory.linearOrder :=
+instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderTheory :=
   by
-  simp only [Theory.linear_order, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
+  simp only [linear_order_theory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,
     forall_eq_or_imp, relations.realize_reflexive, rel_map_apply₂, relations.realize_antisymmetric,
     relations.realize_transitive, forall_eq, relations.realize_total]
   exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans, le_total⟩
 #align first_order.language.model_linear_order FirstOrder.Language.model_linearOrder
 
-section IsOrderedStructure
+section OrderedStructure
 
 variable [IsOrdered L] [L.Structure M]
 
 @[simp]
-theorem relMap_leSymb [LE M] [L.IsOrderedStructure M] {a b : M} :
+theorem relMap_leSymb [LE M] [L.OrderedStructure M] {a b : M} :
     RelMap (leSymb : L.Relations 2) ![a, b] ↔ a ≤ b :=
   by
   rw [← order_Lhom_le_symb, Lhom.map_on_relation]
@@ -211,29 +217,29 @@ theorem relMap_leSymb [LE M] [L.IsOrderedStructure M] {a b : M} :
 #align first_order.language.rel_map_le_symb FirstOrder.Language.relMap_leSymb
 
 @[simp]
-theorem Term.realize_le [LE M] [L.IsOrderedStructure M] {t₁ t₂ : L.term (Sum α (Fin n))} {v : α → M}
+theorem Term.realize_le [LE M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum α (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) := by
   simp [term.le]
 #align first_order.language.term.realize_le FirstOrder.Language.Term.realize_le
 
 @[simp]
-theorem Term.realize_lt [Preorder M] [L.IsOrderedStructure M] {t₁ t₂ : L.term (Sum α (Fin n))}
+theorem Term.realize_lt [Preorder M] [L.OrderedStructure M] {t₁ t₂ : L.term (Sum α (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) := by
   simp [term.lt, lt_iff_le_not_le]
 #align first_order.language.term.realize_lt FirstOrder.Language.Term.realize_lt
 
-end IsOrderedStructure
+end OrderedStructure
 
 section LE
 
 variable [LE M]
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem realize_noTopOrder_iff : M ⊨ Sentence.noTopOrder ↔ NoTopOrder M :=
+theorem realize_noTopOrder_iff : M ⊨ Language.order.noTopOrderSentence ↔ NoTopOrder M :=
   by
-  simp only [sentence.no_top_order, sentence.realize, formula.realize, bounded_formula.realize_all,
+  simp only [no_top_order_sentence, sentence.realize, formula.realize, bounded_formula.realize_all,
     bounded_formula.realize_ex, bounded_formula.realize_not, realize, term.realize_le, Sum.elim_inr]
   refine' ⟨fun h => ⟨fun a => h a⟩, _⟩
   intro h a
@@ -242,14 +248,14 @@ theorem realize_noTopOrder_iff : M ⊨ Sentence.noTopOrder ↔ NoTopOrder M :=
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem realize_noTopOrder [h : NoTopOrder M] : M ⊨ Sentence.noTopOrder :=
+theorem realize_noTopOrder [h : NoTopOrder M] : M ⊨ Language.order.noTopOrderSentence :=
   realize_noTopOrder_iff.2 h
 #align first_order.language.realize_no_top_order FirstOrder.Language.realize_noTopOrder
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem realize_noBotOrder_iff : M ⊨ Sentence.noBotOrder ↔ NoBotOrder M :=
+theorem realize_noBotOrder_iff : M ⊨ Language.order.noBotOrderSentence ↔ NoBotOrder M :=
   by
-  simp only [sentence.no_bot_order, sentence.realize, formula.realize, bounded_formula.realize_all,
+  simp only [no_bot_order_sentence, sentence.realize, formula.realize, bounded_formula.realize_all,
     bounded_formula.realize_ex, bounded_formula.realize_not, realize, term.realize_le, Sum.elim_inr]
   refine' ⟨fun h => ⟨fun a => h a⟩, _⟩
   intro h a
@@ -258,16 +264,17 @@ theorem realize_noBotOrder_iff : M ⊨ Sentence.noBotOrder ↔ NoBotOrder M :=
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem realize_noBotOrder [h : NoBotOrder M] : M ⊨ Sentence.noBotOrder :=
+theorem realize_noBotOrder [h : NoBotOrder M] : M ⊨ Language.order.noBotOrderSentence :=
   realize_noBotOrder_iff.2 h
 #align first_order.language.realize_no_bot_order FirstOrder.Language.realize_noBotOrder
 
 end LE
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem realize_denselyOrdered_iff [Preorder M] : M ⊨ Sentence.denselyOrdered ↔ DenselyOrdered M :=
+theorem realize_denselyOrdered_iff [Preorder M] :
+    M ⊨ Language.order.denselyOrderedSentence ↔ DenselyOrdered M :=
   by
-  simp only [sentence.densely_ordered, sentence.realize, formula.realize,
+  simp only [densely_ordered_sentence, sentence.realize, formula.realize,
     bounded_formula.realize_imp, bounded_formula.realize_all, realize, term.realize_lt,
     Sum.elim_inr, bounded_formula.realize_ex, bounded_formula.realize_inf]
   refine' ⟨fun h => ⟨fun a b ab => h a b ab⟩, _⟩
@@ -277,17 +284,18 @@ theorem realize_denselyOrdered_iff [Preorder M] : M ⊨ Sentence.denselyOrdered
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] : M ⊨ Sentence.denselyOrdered :=
+theorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] :
+    M ⊨ Language.order.denselyOrderedSentence :=
   realize_denselyOrdered_iff.2 h
 #align first_order.language.realize_densely_ordered FirstOrder.Language.realize_denselyOrdered
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 instance model_dLO [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder M] :
-    M ⊨ Theory.dLO :=
+    M ⊨ Language.order.dLO :=
   by
-  simp only [Theory.DLO, Set.union_insert, Set.union_singleton, Theory.model_iff,
-    Set.mem_insert_iff, forall_eq_or_imp, realize_no_top_order, realize_no_bot_order,
-    realize_densely_ordered, true_and_iff]
+  simp only [DLO, Set.union_insert, Set.union_singleton, Theory.model_iff, Set.mem_insert_iff,
+    forall_eq_or_imp, realize_no_top_order, realize_no_bot_order, realize_densely_ordered,
+    true_and_iff]
   rw [← Theory.model_iff]
   infer_instance
 #align first_order.language.model_DLO FirstOrder.Language.model_dLO

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Aaron Anderson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Aaron Anderson
-
-! This file was ported from Lean 3 source module model_theory.order
-! leanprover-community/mathlib commit 1ed3a113dbc6f5b33eae3b96211d4e26ca3a5e9d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.ModelTheory.Semantics
 
+#align_import model_theory.order from "leanprover-community/mathlib"@"1ed3a113dbc6f5b33eae3b96211d4e26ca3a5e9d"
+
 /-!
 # Ordered First-Ordered Structures
 This file defines ordered first-order languages and structures, as well as their theories.

@@ -41,9 +41,7 @@ namespace Language
 
 set_option linter.uppercaseLean3 false
 
-open FirstOrder
-
-open Structure
+open FirstOrder Structure
 
 variable {L : Language.{u, v}} {α : Type w} {M : Type w'} {n : ℕ}
 
@@ -176,10 +174,10 @@ theorem orderedStructure_iff [IsOrdered L] [LE M] [L.Structure M] :
   Iff.rfl
 #align first_order.language.ordered_structure_iff FirstOrder.Language.orderedStructure_iff
 
-instance orderedStructure_lE [LE M] : OrderedStructure Language.order M := by
+instance orderedStructure_LE [LE M] : OrderedStructure Language.order M := by
   rw [orderedStructure_iff, orderLHom_order]
   exact LHom.id_isExpansionOn M
-#align first_order.language.ordered_structure_has_le FirstOrder.Language.orderedStructure_lE
+#align first_order.language.ordered_structure_has_le FirstOrder.Language.orderedStructure_LE
 
 instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory := by
   simp only [preorderTheory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,

@@ -28,7 +28,7 @@ particularly useful example in model theory.
 
 ## Main Results
 * `PartialOrder`s model the theory of partial orders, `LinearOrder`s model the theory of
-linear orders, and dense linear orders without endpoints model `Theory.DLO`.
+linear orders, and dense linear orders without endpoints model `Language.dlo`.
 
 -/
 

Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com>