model_theory.direct_limit | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

f53b2399

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

1a51edf1

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -228,8 +228,8 @@ theorem exists_unify_eq {α : Type _} [Fintype α] {x y : α → Σ i, G i} (xy
       i ∈ upperBounds (range (Sigma.fst ∘ y))), unify f x i hx = unify f y i hy :=
   by
   obtain ⟨i, hi⟩ := Finite.bddAbove_range (Sum.elim (fun a => (x a).1) fun a => (y a).1)
-  rw [sum.elim_range, upperBounds_union] at hi 
-  simp_rw [← Function.comp_apply Sigma.fst _] at hi 
+  rw [sum.elim_range, upperBounds_union] at hi
+  simp_rw [← Function.comp_apply Sigma.fst _] at hi
   exact ⟨i, hi.1, hi.2, funext fun a => (equiv_iff G f _ _).1 (xy a)⟩
 #align first_order.language.direct_limit.exists_unify_eq FirstOrder.Language.DirectLimit.exists_unify_eq
 -/
@@ -324,7 +324,7 @@ def of (i : ι) : G i ↪[L] DirectLimit G f
     where
   toFun := Quotient.mk' ∘ Sigma.mk i
   inj' x y h := by
-    simp only [Quotient.eq'] at h 
+    simp only [Quotient.eq'] at h
     obtain ⟨j, h1, h2, h3⟩ := h
     exact (f i j h1).Injective h3
 #align first_order.language.direct_limit.of FirstOrder.Language.DirectLimit.of
@@ -387,9 +387,9 @@ def lift : DirectLimit G f ↪[L] P
       exact congr_arg _ ((equiv_iff _ _ _ _).1 xy)
   inj' x y xy :=
     by
-    rw [← Quotient.out_eq x, ← Quotient.out_eq y, Quotient.lift_mk, Quotient.lift_mk] at xy 
+    rw [← Quotient.out_eq x, ← Quotient.out_eq y, Quotient.lift_mk, Quotient.lift_mk] at xy
     obtain ⟨i, hx, hy⟩ := directed_of (· ≤ ·) x.out.1 y.out.1
-    rw [← Hg x.out.1 i hx, ← Hg y.out.1 i hy] at xy 
+    rw [← Hg x.out.1 i hx, ← Hg y.out.1 i hy] at xy
     rw [← Quotient.out_eq x, ← Quotient.out_eq y, Quotient.eq', equiv_iff G f hx hy]
     exact (g i).Injective xy
   map_fun' n F x := by

1a51edf1

bump to nightly-2024-02-07-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

8a1bf67e

Diff

@@ -216,7 +216,7 @@ theorem relMap_unify_equiv {n : ℕ} (R : L.Relations n) (x : Fin n → Σ i, G
     RelMap R (unify f x i hi) = RelMap R (unify f x j hj) :=
   by
   obtain ⟨k, ik, jk⟩ := directed_of (· ≤ ·) i j
-  rw [← (f i k ik).map_rel, comp_unify, ← (f j k jk).map_rel, comp_unify]
+  rw [← (f i k ik).mapRel, comp_unify, ← (f j k jk).mapRel, comp_unify]
 #align first_order.language.direct_limit.rel_map_unify_equiv FirstOrder.Language.DirectLimit.relMap_unify_equiv
 -/
 
@@ -398,7 +398,7 @@ def lift : DirectLimit G f ↪[L] P
     simp only [Quotient.lift_mk, embedding.map_fun]
   map_rel' n R x := by
     obtain ⟨i, y, rfl⟩ := exists_quotient_mk_sigma_mk_eq G f x
-    rw [rel_map_quotient_mk_sigma_mk G f, ← (g i).map_rel R y, ← Function.comp.assoc,
+    rw [rel_map_quotient_mk_sigma_mk G f, ← (g i).mapRel R y, ← Function.comp.assoc,
       Quotient.lift_comp_mk]
 #align first_order.language.direct_limit.lift FirstOrder.Language.DirectLimit.lift
 -/

1a51edf1

bump to nightly-2024-01-17-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

8ba88f37

Diff

@@ -155,12 +155,12 @@ noncomputable def sigmaStructure [IsDirected ι (· ≤ ·)] [Nonempty ι] : L.S
   funMap n F x :=
     ⟨_,
       funMap F
-        (unify f x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1))
-          (Classical.choose_spec (Fintype.bddAbove_range fun a => (x a).1)))⟩
+        (unify f x (Classical.choose (Finite.bddAbove_range fun a => (x a).1))
+          (Classical.choose_spec (Finite.bddAbove_range fun a => (x a).1)))⟩
   rel_map n R x :=
     RelMap R
-      (unify f x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1))
-        (Classical.choose_spec (Fintype.bddAbove_range fun a => (x a).1)))
+      (unify f x (Classical.choose (Finite.bddAbove_range fun a => (x a).1))
+        (Classical.choose_spec (Finite.bddAbove_range fun a => (x a).1)))
 #align first_order.language.direct_limit.sigma_structure FirstOrder.Language.DirectLimit.sigmaStructure
 -/
 
@@ -227,7 +227,7 @@ theorem exists_unify_eq {α : Type _} [Fintype α] {x y : α → Σ i, G i} (xy
     ∃ (i : ι) (hx : i ∈ upperBounds (range (Sigma.fst ∘ x))) (hy :
       i ∈ upperBounds (range (Sigma.fst ∘ y))), unify f x i hx = unify f y i hy :=
   by
-  obtain ⟨i, hi⟩ := Fintype.bddAbove_range (Sum.elim (fun a => (x a).1) fun a => (y a).1)
+  obtain ⟨i, hi⟩ := Finite.bddAbove_range (Sum.elim (fun a => (x a).1) fun a => (y a).1)
   rw [sum.elim_range, upperBounds_union] at hi 
   simp_rw [← Function.comp_apply Sigma.fst _] at hi 
   exact ⟨i, hi.1, hi.2, funext fun a => (equiv_iff G f _ _).1 (xy a)⟩
@@ -238,7 +238,7 @@ theorem exists_unify_eq {α : Type _} [Fintype α] {x y : α → Σ i, G i} (xy
 theorem funMap_equiv_unify {n : ℕ} (F : L.Functions n) (x : Fin n → Σ i, G i) (i : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     @funMap _ _ (sigmaStructure G f) _ F x ≈ ⟨_, funMap F (unify f x i hi)⟩ :=
-  funMap_unify_equiv G f F x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
+  funMap_unify_equiv G f F x (Classical.choose (Finite.bddAbove_range fun a => (x a).1)) i _ hi
 #align first_order.language.direct_limit.fun_map_equiv_unify FirstOrder.Language.DirectLimit.funMap_equiv_unify
 -/
 
@@ -246,7 +246,7 @@ theorem funMap_equiv_unify {n : ℕ} (F : L.Functions n) (x : Fin n → Σ i, G
 theorem relMap_equiv_unify {n : ℕ} (R : L.Relations n) (x : Fin n → Σ i, G i) (i : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     @RelMap _ _ (sigmaStructure G f) _ R x = RelMap R (unify f x i hi) :=
-  relMap_unify_equiv G f R x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
+  relMap_unify_equiv G f R x (Classical.choose (Finite.bddAbove_range fun a => (x a).1)) i _ hi
 #align first_order.language.direct_limit.rel_map_equiv_unify FirstOrder.Language.DirectLimit.relMap_equiv_unify
 -/
 
@@ -284,7 +284,7 @@ theorem funMap_quotient_mk'_sigma_mk' {n : ℕ} {F : L.Functions n} {i : ι} {x
   by
   simp only [Function.comp_apply, fun_map_quotient_mk, Quotient.eq']
   obtain ⟨k, ik, jk⟩ :=
-    directed_of (· ≤ ·) i (Classical.choose (Fintype.bddAbove_range fun a : Fin n => i))
+    directed_of (· ≤ ·) i (Classical.choose (Finite.bddAbove_range fun a : Fin n => i))
   refine' ⟨k, jk, ik, _⟩
   simp only [embedding.map_fun, comp_unify]
   rfl
@@ -298,7 +298,7 @@ theorem relMap_quotient_mk'_sigma_mk' {n : ℕ} {R : L.Relations n} {i : ι} {x
   by
   rw [rel_map_quotient_mk]
   obtain ⟨k, ik, jk⟩ :=
-    directed_of (· ≤ ·) i (Classical.choose (Fintype.bddAbove_range fun a : Fin n => i))
+    directed_of (· ≤ ·) i (Classical.choose (Finite.bddAbove_range fun a : Fin n => i))
   rw [rel_map_equiv_unify G f R (fun a => ⟨i, x a⟩) i, unify_sigma_mk_self]
 #align first_order.language.direct_limit.rel_map_quotient_mk_sigma_mk FirstOrder.Language.DirectLimit.relMap_quotient_mk'_sigma_mk'
 -/
@@ -307,7 +307,7 @@ theorem relMap_quotient_mk'_sigma_mk' {n : ℕ} {R : L.Relations n} {i : ι} {x
 theorem exists_quotient_mk'_sigma_mk'_eq {α : Type _} [Fintype α] (x : α → DirectLimit G f) :
     ∃ (i : ι) (y : α → G i), x = Quotient.mk' ∘ Sigma.mk i ∘ y :=
   by
-  obtain ⟨i, hi⟩ := Fintype.bddAbove_range fun a => (x a).out.1
+  obtain ⟨i, hi⟩ := Finite.bddAbove_range fun a => (x a).out.1
   refine' ⟨i, unify f (Quotient.out ∘ x) i hi, _⟩
   ext a
   rw [Quotient.eq_mk_iff_out, Function.comp_apply, unify, equiv_iff G f _]

1a51edf1

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ 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.Data.Fintype.Order
-import Mathbin.Algebra.DirectLimit
-import Mathbin.ModelTheory.Quotients
-import Mathbin.ModelTheory.FinitelyGenerated
+import Data.Fintype.Order
+import Algebra.DirectLimit
+import ModelTheory.Quotients
+import ModelTheory.FinitelyGenerated
 
 #align_import model_theory.direct_limit from "leanprover-community/mathlib"@"1a51edf13debfcbe223fa06b1cb353b9ed9751cc"

1a51edf1

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 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.direct_limit
-! leanprover-community/mathlib commit 1a51edf13debfcbe223fa06b1cb353b9ed9751cc
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fintype.Order
 import Mathbin.Algebra.DirectLimit
 import Mathbin.ModelTheory.Quotients
 import Mathbin.ModelTheory.FinitelyGenerated
 
+#align_import model_theory.direct_limit from "leanprover-community/mathlib"@"1a51edf13debfcbe223fa06b1cb353b9ed9751cc"
+
 /-!
 # Direct Limits of First-Order Structures

1a51edf1

bump to nightly-2023-07-16-17

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

6db63fa6

Diff

@@ -63,18 +63,18 @@ theorem map_map [DirectedSystem G fun i j h => f i j h] {i j k} (hij hjk x) :
 
 variable {G' : ℕ → Type w} [∀ i, L.Structure (G' i)] (f' : ∀ n : ℕ, G' n ↪[L] G' (n + 1))
 
-#print FirstOrder.Language.DirectedSystem.natLeRec /-
+#print FirstOrder.Language.DirectedSystem.natLERec /-
 /-- Given a chain of embeddings of structures indexed by `ℕ`, defines a `directed_system` by
 composing them. -/
-def natLeRec (m n : ℕ) (h : m ≤ n) : G' m ↪[L] G' n :=
+def natLERec (m n : ℕ) (h : m ≤ n) : G' m ↪[L] G' n :=
   Nat.leRecOn h (fun k g => (f' k).comp g) (Embedding.refl L _)
-#align first_order.language.directed_system.nat_le_rec FirstOrder.Language.DirectedSystem.natLeRec
+#align first_order.language.directed_system.nat_le_rec FirstOrder.Language.DirectedSystem.natLERec
 -/
 
-#print FirstOrder.Language.DirectedSystem.coe_natLeRec /-
+#print FirstOrder.Language.DirectedSystem.coe_natLERec /-
 @[simp]
-theorem coe_natLeRec (m n : ℕ) (h : m ≤ n) :
-    (natLeRec f' m n h : G' m → G' n) = Nat.leRecOn h fun n => f' n :=
+theorem coe_natLERec (m n : ℕ) (h : m ≤ n) :
+    (natLERec f' m n h : G' m → G' n) = Nat.leRecOn h fun n => f' n :=
   by
   obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le h
   ext x
@@ -83,14 +83,14 @@ theorem coe_natLeRec (m n : ℕ) (h : m ≤ n) :
   ·
     rw [Nat.leRecOn_succ le_self_add, nat_le_rec, Nat.leRecOn_succ le_self_add, ← nat_le_rec,
       embedding.comp_apply, ih]
-#align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLeRec
+#align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLERec
 -/
 
-#print FirstOrder.Language.DirectedSystem.natLeRec.directedSystem /-
-instance natLeRec.directedSystem : DirectedSystem G' fun i j h => natLeRec f' i j h :=
+#print FirstOrder.Language.DirectedSystem.natLERec.directedSystem /-
+instance natLERec.directedSystem : DirectedSystem G' fun i j h => natLERec f' i j h :=
   ⟨fun i x h => congr (congr rfl (Nat.leRecOn_self _)) rfl, fun i j k ij jk => by
     simp [Nat.leRecOn_trans ij jk]⟩
-#align first_order.language.directed_system.nat_le_rec.directed_system FirstOrder.Language.DirectedSystem.natLeRec.directedSystem
+#align first_order.language.directed_system.nat_le_rec.directed_system FirstOrder.Language.DirectedSystem.natLERec.directedSystem
 -/
 
 end DirectedSystem

1a51edf1

bump to nightly-2023-07-09-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/1a51edf13debfcbe223fa06b1cb353b9ed9751cc

e0217a15

Diff

@@ -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.direct_limit
-! leanprover-community/mathlib commit f53b23994ac4c13afa38d31195c588a1121d1860
+! leanprover-community/mathlib commit 1a51edf13debfcbe223fa06b1cb353b9ed9751cc
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.ModelTheory.FinitelyGenerated
 
 /-!
 # Direct Limits of First-Order Structures
+
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
 This file constructs the direct limit of a directed system of first-order embeddings.
 
 ## Main Definitions

f53b2399

bump to nightly-2023-07-07-19

mathlib commit https://github.com/leanprover-community/mathlib/commit/8905e5ed90859939681a725b00f6063e65096d95

4b102645

Diff

@@ -428,9 +428,9 @@ theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
 -/
 
-#print FirstOrder.Language.DirectLimit.cG /-
+#print FirstOrder.Language.DirectLimit.cg /-
 /-- The direct limit of countably many countably generated structures is countably generated. -/
-theorem cG {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
+theorem cg {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     (h : ∀ i, Structure.CG L (G i)) [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) :=
@@ -446,7 +446,7 @@ theorem cG {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)
     · rw [(Classical.choose_spec (h (out x).1).out).2]
       simp only [substructure.coe_top]
     · simp only [embedding.coe_to_hom, direct_limit.of_apply, Sigma.eta, Quotient.out_eq]
-#align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cG
+#align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cg
 -/
 
 #print FirstOrder.Language.DirectLimit.cg' /-
@@ -454,7 +454,7 @@ instance cg' {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ 
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     [h : ∀ i, Structure.CG L (G i)] [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) :=
-  cG f h
+  cg f h
 #align first_order.language.direct_limit.cg' FirstOrder.Language.DirectLimit.cg'
 -/

f53b2399

bump to nightly-2023-07-04-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/728ef9dbb281241906f25cbeb30f90d83e0bb451

14fda1fe

Diff

@@ -41,27 +41,34 @@ variable (f : ∀ i j, i ≤ j → G i ↪[L] G j)
 
 namespace DirectedSystem
 
+#print FirstOrder.Language.DirectedSystem.map_self /-
 /-- A copy of `directed_system.map_self` specialized to `L`-embeddings, as otherwise the
 `λ i j h, f i j h` can confuse the simplifier. -/
 theorem map_self [DirectedSystem G fun i j h => f i j h] (i x h) : f i i h x = x :=
   DirectedSystem.map_self (fun i j h => f i j h) i x h
 #align first_order.language.directed_system.map_self FirstOrder.Language.DirectedSystem.map_self
+-/
 
+#print FirstOrder.Language.DirectedSystem.map_map /-
 /-- A copy of `directed_system.map_map` specialized to `L`-embeddings, as otherwise the
 `λ i j h, f i j h` can confuse the simplifier. -/
 theorem map_map [DirectedSystem G fun i j h => f i j h] {i j k} (hij hjk x) :
     f j k hjk (f i j hij x) = f i k (le_trans hij hjk) x :=
   DirectedSystem.map_map (fun i j h => f i j h) hij hjk x
 #align first_order.language.directed_system.map_map FirstOrder.Language.DirectedSystem.map_map
+-/
 
 variable {G' : ℕ → Type w} [∀ i, L.Structure (G' i)] (f' : ∀ n : ℕ, G' n ↪[L] G' (n + 1))
 
+#print FirstOrder.Language.DirectedSystem.natLeRec /-
 /-- Given a chain of embeddings of structures indexed by `ℕ`, defines a `directed_system` by
 composing them. -/
 def natLeRec (m n : ℕ) (h : m ≤ n) : G' m ↪[L] G' n :=
   Nat.leRecOn h (fun k g => (f' k).comp g) (Embedding.refl L _)
 #align first_order.language.directed_system.nat_le_rec FirstOrder.Language.DirectedSystem.natLeRec
+-/
 
+#print FirstOrder.Language.DirectedSystem.coe_natLeRec /-
 @[simp]
 theorem coe_natLeRec (m n : ℕ) (h : m ≤ n) :
     (natLeRec f' m n h : G' m → G' n) = Nat.leRecOn h fun n => f' n :=
@@ -74,24 +81,30 @@ theorem coe_natLeRec (m n : ℕ) (h : m ≤ n) :
     rw [Nat.leRecOn_succ le_self_add, nat_le_rec, Nat.leRecOn_succ le_self_add, ← nat_le_rec,
       embedding.comp_apply, ih]
 #align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLeRec
+-/
 
+#print FirstOrder.Language.DirectedSystem.natLeRec.directedSystem /-
 instance natLeRec.directedSystem : DirectedSystem G' fun i j h => natLeRec f' i j h :=
   ⟨fun i x h => congr (congr rfl (Nat.leRecOn_self _)) rfl, fun i j k ij jk => by
     simp [Nat.leRecOn_trans ij jk]⟩
 #align first_order.language.directed_system.nat_le_rec.directed_system FirstOrder.Language.DirectedSystem.natLeRec.directedSystem
+-/
 
 end DirectedSystem
 
 namespace DirectLimit
 
+#print FirstOrder.Language.DirectLimit.unify /-
 /-- Raises a family of elements in the `Σ`-type to the same level along the embeddings. -/
 def unify {α : Type _} (x : α → Σ i, G i) (i : ι) (h : i ∈ upperBounds (range (Sigma.fst ∘ x)))
     (a : α) : G i :=
   f (x a).1 i (h (mem_range_self a)) (x a).2
 #align first_order.language.direct_limit.unify FirstOrder.Language.DirectLimit.unify
+-/
 
 variable [DirectedSystem G fun i j h => f i j h]
 
+#print FirstOrder.Language.DirectLimit.unify_sigma_mk_self /-
 @[simp]
 theorem unify_sigma_mk_self {α : Type _} {i : ι} {x : α → G i} :
     (unify f (Sigma.mk i ∘ x) i fun j ⟨a, hj⟩ => trans (le_of_eq hj.symm) (refl _)) = x :=
@@ -99,7 +112,9 @@ theorem unify_sigma_mk_self {α : Type _} {i : ι} {x : α → G i} :
   ext a
   simp only [unify, DirectedSystem.map_self]
 #align first_order.language.direct_limit.unify_sigma_mk_self FirstOrder.Language.DirectLimit.unify_sigma_mk_self
+-/
 
+#print FirstOrder.Language.DirectLimit.comp_unify /-
 theorem comp_unify {α : Type _} {x : α → Σ i, G i} {i j : ι} (ij : i ≤ j)
     (h : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     f i j ij ∘ unify f x i h = unify f x j fun k hk => trans (mem_upperBounds.1 h k hk) ij :=
@@ -107,6 +122,7 @@ theorem comp_unify {α : Type _} {x : α → Σ i, G i} {i j : ι} (ij : i ≤ j
   ext a
   simp [unify, DirectedSystem.map_map]
 #align first_order.language.direct_limit.comp_unify FirstOrder.Language.DirectLimit.comp_unify
+-/
 
 end DirectLimit
 
@@ -114,6 +130,7 @@ variable (G)
 
 namespace DirectLimit
 
+#print FirstOrder.Language.DirectLimit.setoid /-
 /-- The directed limit glues together the structures along the embeddings. -/
 def setoid [DirectedSystem G fun i j h => f i j h] [IsDirected ι (· ≤ ·)] : Setoid (Σ i, G i)
     where
@@ -128,7 +145,9 @@ def setoid [DirectedSystem G fun i j h => f i j h] [IsDirected ι (· ≤ ·)] :
       symm
       rw [← DirectedSystem.map_map, ← hjk, DirectedSystem.map_map]⟩
 #align first_order.language.direct_limit.setoid FirstOrder.Language.DirectLimit.setoid
+-/
 
+#print FirstOrder.Language.DirectLimit.sigmaStructure /-
 /-- The structure on the `Σ`-type which becomes the structure on the direct limit after quotienting.
  -/
 noncomputable def sigmaStructure [IsDirected ι (· ≤ ·)] [Nonempty ι] : L.Structure (Σ i, G i)
@@ -143,13 +162,16 @@ noncomputable def sigmaStructure [IsDirected ι (· ≤ ·)] [Nonempty ι] : L.S
       (unify f x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1))
         (Classical.choose_spec (Fintype.bddAbove_range fun a => (x a).1)))
 #align first_order.language.direct_limit.sigma_structure FirstOrder.Language.DirectLimit.sigmaStructure
+-/
 
 end DirectLimit
 
+#print FirstOrder.Language.DirectLimit /-
 /-- The direct limit of a directed system is the structures glued together along the embeddings. -/
 def DirectLimit [DirectedSystem G fun i j h => f i j h] [IsDirected ι (· ≤ ·)] :=
   Quotient (DirectLimit.setoid G f)
 #align first_order.language.direct_limit FirstOrder.Language.DirectLimit
+-/
 
 attribute [local instance] direct_limit.setoid
 
@@ -161,6 +183,7 @@ namespace DirectLimit
 
 variable [IsDirected ι (· ≤ ·)] [DirectedSystem G fun i j h => f i j h]
 
+#print FirstOrder.Language.DirectLimit.equiv_iff /-
 theorem equiv_iff {x y : Σ i, G i} {i : ι} (hx : x.1 ≤ i) (hy : y.1 ≤ i) :
     x ≈ y ↔ (f x.1 i hx) x.2 = (f y.1 i hy) y.2 :=
   by
@@ -174,7 +197,9 @@ theorem equiv_iff {x y : Σ i, G i} {i : ι} (hx : x.1 ≤ i) (hy : y.1 ≤ i) :
   rw [DirectedSystem.map_map, DirectedSystem.map_map] at *
   exact h
 #align first_order.language.direct_limit.equiv_iff FirstOrder.Language.DirectLimit.equiv_iff
+-/
 
+#print FirstOrder.Language.DirectLimit.funMap_unify_equiv /-
 theorem funMap_unify_equiv {n : ℕ} (F : L.Functions n) (x : Fin n → Σ i, G i) (i j : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) (hj : j ∈ upperBounds (range (Sigma.fst ∘ x))) :
     (⟨i, funMap F (unify f x i hi)⟩ : Σ i, G i) ≈ ⟨j, funMap F (unify f x j hj)⟩ :=
@@ -183,7 +208,9 @@ theorem funMap_unify_equiv {n : ℕ} (F : L.Functions n) (x : Fin n → Σ i, G
   refine' ⟨k, ik, jk, _⟩
   rw [(f i k ik).map_fun, (f j k jk).map_fun, comp_unify, comp_unify]
 #align first_order.language.direct_limit.fun_map_unify_equiv FirstOrder.Language.DirectLimit.funMap_unify_equiv
+-/
 
+#print FirstOrder.Language.DirectLimit.relMap_unify_equiv /-
 theorem relMap_unify_equiv {n : ℕ} (R : L.Relations n) (x : Fin n → Σ i, G i) (i j : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) (hj : j ∈ upperBounds (range (Sigma.fst ∘ x))) :
     RelMap R (unify f x i hi) = RelMap R (unify f x j hj) :=
@@ -191,9 +218,11 @@ theorem relMap_unify_equiv {n : ℕ} (R : L.Relations n) (x : Fin n → Σ i, G
   obtain ⟨k, ik, jk⟩ := directed_of (· ≤ ·) i j
   rw [← (f i k ik).map_rel, comp_unify, ← (f j k jk).map_rel, comp_unify]
 #align first_order.language.direct_limit.rel_map_unify_equiv FirstOrder.Language.DirectLimit.relMap_unify_equiv
+-/
 
 variable [Nonempty ι]
 
+#print FirstOrder.Language.DirectLimit.exists_unify_eq /-
 theorem exists_unify_eq {α : Type _} [Fintype α] {x y : α → Σ i, G i} (xy : x ≈ y) :
     ∃ (i : ι) (hx : i ∈ upperBounds (range (Sigma.fst ∘ x))) (hy :
       i ∈ upperBounds (range (Sigma.fst ∘ y))), unify f x i hx = unify f y i hy :=
@@ -203,19 +232,25 @@ theorem exists_unify_eq {α : Type _} [Fintype α] {x y : α → Σ i, G i} (xy
   simp_rw [← Function.comp_apply Sigma.fst _] at hi 
   exact ⟨i, hi.1, hi.2, funext fun a => (equiv_iff G f _ _).1 (xy a)⟩
 #align first_order.language.direct_limit.exists_unify_eq FirstOrder.Language.DirectLimit.exists_unify_eq
+-/
 
+#print FirstOrder.Language.DirectLimit.funMap_equiv_unify /-
 theorem funMap_equiv_unify {n : ℕ} (F : L.Functions n) (x : Fin n → Σ i, G i) (i : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     @funMap _ _ (sigmaStructure G f) _ F x ≈ ⟨_, funMap F (unify f x i hi)⟩ :=
   funMap_unify_equiv G f F x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
 #align first_order.language.direct_limit.fun_map_equiv_unify FirstOrder.Language.DirectLimit.funMap_equiv_unify
+-/
 
+#print FirstOrder.Language.DirectLimit.relMap_equiv_unify /-
 theorem relMap_equiv_unify {n : ℕ} (R : L.Relations n) (x : Fin n → Σ i, G i) (i : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     @RelMap _ _ (sigmaStructure G f) _ R x = RelMap R (unify f x i hi) :=
   relMap_unify_equiv G f R x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
 #align first_order.language.direct_limit.rel_map_equiv_unify FirstOrder.Language.DirectLimit.relMap_equiv_unify
+-/
 
+#print FirstOrder.Language.DirectLimit.prestructure /-
 /-- The direct limit `setoid` respects the structure `sigma_structure`, so quotienting by it
   gives rise to a valid structure. -/
 noncomputable instance prestructure : L.Prestructure (DirectLimit.setoid G f)
@@ -233,12 +268,16 @@ noncomputable instance prestructure : L.Prestructure (DirectLimit.setoid G f)
       trans (rel_map_equiv_unify G f R x i hx) (trans _ (symm (rel_map_equiv_unify G f R y i hy)))
     rw [h]
 #align first_order.language.direct_limit.prestructure FirstOrder.Language.DirectLimit.prestructure
+-/
 
+#print FirstOrder.Language.DirectLimit.instStructureDirectLimit /-
 /-- The `L.Structure` on a direct limit of `L.Structure`s. -/
-noncomputable instance structure : L.Structure (DirectLimit G f) :=
+noncomputable instance instStructureDirectLimit : L.Structure (DirectLimit G f) :=
   Language.quotientStructure
-#align first_order.language.direct_limit.Structure FirstOrder.Language.DirectLimit.structure
+#align first_order.language.direct_limit.Structure FirstOrder.Language.DirectLimit.instStructureDirectLimit
+-/
 
+#print FirstOrder.Language.DirectLimit.funMap_quotient_mk'_sigma_mk' /-
 @[simp]
 theorem funMap_quotient_mk'_sigma_mk' {n : ℕ} {F : L.Functions n} {i : ι} {x : Fin n → G i} :
     (funMap F fun a => (⟦⟨i, x a⟩⟧ : DirectLimit G f)) = ⟦⟨i, funMap F x⟩⟧ :=
@@ -250,7 +289,9 @@ theorem funMap_quotient_mk'_sigma_mk' {n : ℕ} {F : L.Functions n} {i : ι} {x
   simp only [embedding.map_fun, comp_unify]
   rfl
 #align first_order.language.direct_limit.fun_map_quotient_mk_sigma_mk FirstOrder.Language.DirectLimit.funMap_quotient_mk'_sigma_mk'
+-/
 
+#print FirstOrder.Language.DirectLimit.relMap_quotient_mk'_sigma_mk' /-
 @[simp]
 theorem relMap_quotient_mk'_sigma_mk' {n : ℕ} {R : L.Relations n} {i : ι} {x : Fin n → G i} :
     (RelMap R fun a => (⟦⟨i, x a⟩⟧ : DirectLimit G f)) = RelMap R x :=
@@ -260,7 +301,9 @@ theorem relMap_quotient_mk'_sigma_mk' {n : ℕ} {R : L.Relations n} {i : ι} {x
     directed_of (· ≤ ·) i (Classical.choose (Fintype.bddAbove_range fun a : Fin n => i))
   rw [rel_map_equiv_unify G f R (fun a => ⟨i, x a⟩) i, unify_sigma_mk_self]
 #align first_order.language.direct_limit.rel_map_quotient_mk_sigma_mk FirstOrder.Language.DirectLimit.relMap_quotient_mk'_sigma_mk'
+-/
 
+#print FirstOrder.Language.DirectLimit.exists_quotient_mk'_sigma_mk'_eq /-
 theorem exists_quotient_mk'_sigma_mk'_eq {α : Type _} [Fintype α] (x : α → DirectLimit G f) :
     ∃ (i : ι) (y : α → G i), x = Quotient.mk' ∘ Sigma.mk i ∘ y :=
   by
@@ -271,9 +314,11 @@ theorem exists_quotient_mk'_sigma_mk'_eq {α : Type _} [Fintype α] (x : α →
   · simp only [DirectedSystem.map_self]
   · rfl
 #align first_order.language.direct_limit.exists_quotient_mk_sigma_mk_eq FirstOrder.Language.DirectLimit.exists_quotient_mk'_sigma_mk'_eq
+-/
 
 variable (L ι)
 
+#print FirstOrder.Language.DirectLimit.of /-
 /-- The canonical map from a component to the direct limit. -/
 def of (i : ι) : G i ↪[L] DirectLimit G f
     where
@@ -283,14 +328,18 @@ def of (i : ι) : G i ↪[L] DirectLimit G f
     obtain ⟨j, h1, h2, h3⟩ := h
     exact (f i j h1).Injective h3
 #align first_order.language.direct_limit.of FirstOrder.Language.DirectLimit.of
+-/
 
 variable {L ι G f}
 
+#print FirstOrder.Language.DirectLimit.of_apply /-
 @[simp]
 theorem of_apply {i : ι} {x : G i} : of L ι G f i x = ⟦⟨i, x⟩⟧ :=
   rfl
 #align first_order.language.direct_limit.of_apply FirstOrder.Language.DirectLimit.of_apply
+-/
 
+#print FirstOrder.Language.DirectLimit.of_f /-
 @[simp]
 theorem of_f {i j : ι} {hij : i ≤ j} {x : G i} : of L ι G f j (f i j hij x) = of L ι G f i x :=
   by
@@ -298,19 +347,24 @@ theorem of_f {i j : ι} {hij : i ≤ j} {x : G i} : of L ι G f j (f i j hij x)
   refine' Setoid.symm ⟨j, hij, refl j, _⟩
   simp only [DirectedSystem.map_self]
 #align first_order.language.direct_limit.of_f FirstOrder.Language.DirectLimit.of_f
+-/
 
+#print FirstOrder.Language.DirectLimit.exists_of /-
 /-- Every element of the direct limit corresponds to some element in
 some component of the directed system. -/
 theorem exists_of (z : DirectLimit G f) : ∃ i x, of L ι G f i x = z :=
   ⟨z.out.1, z.out.2, by simp⟩
 #align first_order.language.direct_limit.exists_of FirstOrder.Language.DirectLimit.exists_of
+-/
 
+#print FirstOrder.Language.DirectLimit.inductionOn /-
 @[elab_as_elim]
-protected theorem induction_on {C : DirectLimit G f → Prop} (z : DirectLimit G f)
+protected theorem inductionOn {C : DirectLimit G f → Prop} (z : DirectLimit G f)
     (ih : ∀ i x, C (of L ι G f i x)) : C z :=
   let ⟨i, x, h⟩ := exists_of z
   h ▸ ih i x
-#align first_order.language.direct_limit.induction_on FirstOrder.Language.DirectLimit.induction_on
+#align first_order.language.direct_limit.induction_on FirstOrder.Language.DirectLimit.inductionOn
+-/
 
 variable {P : Type u₁} [L.Structure P] (g : ∀ i, G i ↪[L] P)
 
@@ -318,6 +372,7 @@ variable (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
 
 variable (L ι G f)
 
+#print FirstOrder.Language.DirectLimit.lift /-
 /-- The universal property of the direct limit: maps from the components to another module
 that respect the directed system structure (i.e. make some diagram commute) give rise
 to a unique map out of the direct limit. -/
@@ -346,26 +401,34 @@ def lift : DirectLimit G f ↪[L] P
     rw [rel_map_quotient_mk_sigma_mk G f, ← (g i).map_rel R y, ← Function.comp.assoc,
       Quotient.lift_comp_mk]
 #align first_order.language.direct_limit.lift FirstOrder.Language.DirectLimit.lift
+-/
 
 variable {L ι G f}
 
+#print FirstOrder.Language.DirectLimit.lift_quotient_mk'_sigma_mk' /-
 @[simp]
 theorem lift_quotient_mk'_sigma_mk' {i} (x : G i) : lift L ι G f g Hg ⟦⟨i, x⟩⟧ = (g i) x :=
   by
   change (lift L ι G f g Hg).toFun ⟦⟨i, x⟩⟧ = _
   simp only [lift, Quotient.lift_mk]
 #align first_order.language.direct_limit.lift_quotient_mk_sigma_mk FirstOrder.Language.DirectLimit.lift_quotient_mk'_sigma_mk'
+-/
 
+#print FirstOrder.Language.DirectLimit.lift_of /-
 theorem lift_of {i} (x : G i) : lift L ι G f g Hg (of L ι G f i x) = g i x := by simp
 #align first_order.language.direct_limit.lift_of FirstOrder.Language.DirectLimit.lift_of
+-/
 
+#print FirstOrder.Language.DirectLimit.lift_unique /-
 theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
     F x =
       lift L ι G f (fun i => F.comp <| of L ι G f i)
         (fun i j hij x => by rw [F.comp_apply, F.comp_apply, of_f]) x :=
-  DirectLimit.induction_on x fun i x => by rw [lift_of] <;> rfl
+  DirectLimit.inductionOn x fun i x => by rw [lift_of] <;> rfl
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
+-/
 
+#print FirstOrder.Language.DirectLimit.cG /-
 /-- The direct limit of countably many countably generated structures is countably generated. -/
 theorem cG {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
@@ -384,13 +447,16 @@ theorem cG {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)
       simp only [substructure.coe_top]
     · simp only [embedding.coe_to_hom, direct_limit.of_apply, Sigma.eta, Quotient.out_eq]
 #align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cG
+-/
 
+#print FirstOrder.Language.DirectLimit.cg' /-
 instance cg' {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     [h : ∀ i, Structure.CG L (G i)] [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) :=
   cG f h
 #align first_order.language.direct_limit.cg' FirstOrder.Language.DirectLimit.cg'
+-/
 
 end DirectLimit

f53b2399

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -316,8 +316,6 @@ variable {P : Type u₁} [L.Structure P] (g : ∀ i, G i ↪[L] P)
 
 variable (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
 
-include Hg
-
 variable (L ι G f)
 
 /-- The universal property of the direct limit: maps from the components to another module
@@ -351,8 +349,6 @@ def lift : DirectLimit G f ↪[L] P
 
 variable {L ι G f}
 
-omit Hg
-
 @[simp]
 theorem lift_quotient_mk'_sigma_mk' {i} (x : G i) : lift L ι G f g Hg ⟦⟨i, x⟩⟧ = (g i) x :=
   by

f53b2399

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -85,7 +85,7 @@ end DirectedSystem
 namespace DirectLimit
 
 /-- Raises a family of elements in the `Σ`-type to the same level along the embeddings. -/
-def unify {α : Type _} (x : α → Σi, G i) (i : ι) (h : i ∈ upperBounds (range (Sigma.fst ∘ x)))
+def unify {α : Type _} (x : α → Σ i, G i) (i : ι) (h : i ∈ upperBounds (range (Sigma.fst ∘ x)))
     (a : α) : G i :=
   f (x a).1 i (h (mem_range_self a)) (x a).2
 #align first_order.language.direct_limit.unify FirstOrder.Language.DirectLimit.unify
@@ -100,7 +100,7 @@ theorem unify_sigma_mk_self {α : Type _} {i : ι} {x : α → G i} :
   simp only [unify, DirectedSystem.map_self]
 #align first_order.language.direct_limit.unify_sigma_mk_self FirstOrder.Language.DirectLimit.unify_sigma_mk_self
 
-theorem comp_unify {α : Type _} {x : α → Σi, G i} {i j : ι} (ij : i ≤ j)
+theorem comp_unify {α : Type _} {x : α → Σ i, G i} {i j : ι} (ij : i ≤ j)
     (h : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     f i j ij ∘ unify f x i h = unify f x j fun k hk => trans (mem_upperBounds.1 h k hk) ij :=
   by
@@ -115,9 +115,9 @@ variable (G)
 namespace DirectLimit
 
 /-- The directed limit glues together the structures along the embeddings. -/
-def setoid [DirectedSystem G fun i j h => f i j h] [IsDirected ι (· ≤ ·)] : Setoid (Σi, G i)
+def setoid [DirectedSystem G fun i j h => f i j h] [IsDirected ι (· ≤ ·)] : Setoid (Σ i, G i)
     where
-  R := fun ⟨i, x⟩ ⟨j, y⟩ => ∃ (k : ι)(ik : i ≤ k)(jk : j ≤ k), f i k ik x = f j k jk y
+  R := fun ⟨i, x⟩ ⟨j, y⟩ => ∃ (k : ι) (ik : i ≤ k) (jk : j ≤ k), f i k ik x = f j k jk y
   iseqv :=
     ⟨fun ⟨i, x⟩ => ⟨i, refl i, refl i, rfl⟩, fun ⟨i, x⟩ ⟨j, y⟩ ⟨k, ik, jk, h⟩ =>
       ⟨k, jk, ik, h.symm⟩, fun ⟨i, x⟩ ⟨j, y⟩ ⟨k, z⟩ ⟨ij, hiij, hjij, hij⟩ ⟨jk, hjjk, hkjk, hjk⟩ =>
@@ -131,7 +131,7 @@ def setoid [DirectedSystem G fun i j h => f i j h] [IsDirected ι (· ≤ ·)] :
 
 /-- The structure on the `Σ`-type which becomes the structure on the direct limit after quotienting.
  -/
-noncomputable def sigmaStructure [IsDirected ι (· ≤ ·)] [Nonempty ι] : L.Structure (Σi, G i)
+noncomputable def sigmaStructure [IsDirected ι (· ≤ ·)] [Nonempty ι] : L.Structure (Σ i, G i)
     where
   funMap n F x :=
     ⟨_,
@@ -161,7 +161,7 @@ namespace DirectLimit
 
 variable [IsDirected ι (· ≤ ·)] [DirectedSystem G fun i j h => f i j h]
 
-theorem equiv_iff {x y : Σi, G i} {i : ι} (hx : x.1 ≤ i) (hy : y.1 ≤ i) :
+theorem equiv_iff {x y : Σ i, G i} {i : ι} (hx : x.1 ≤ i) (hy : y.1 ≤ i) :
     x ≈ y ↔ (f x.1 i hx) x.2 = (f y.1 i hy) y.2 :=
   by
   cases x
@@ -175,16 +175,16 @@ theorem equiv_iff {x y : Σi, G i} {i : ι} (hx : x.1 ≤ i) (hy : y.1 ≤ i) :
   exact h
 #align first_order.language.direct_limit.equiv_iff FirstOrder.Language.DirectLimit.equiv_iff
 
-theorem funMap_unify_equiv {n : ℕ} (F : L.Functions n) (x : Fin n → Σi, G i) (i j : ι)
+theorem funMap_unify_equiv {n : ℕ} (F : L.Functions n) (x : Fin n → Σ i, G i) (i j : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) (hj : j ∈ upperBounds (range (Sigma.fst ∘ x))) :
-    (⟨i, funMap F (unify f x i hi)⟩ : Σi, G i) ≈ ⟨j, funMap F (unify f x j hj)⟩ :=
+    (⟨i, funMap F (unify f x i hi)⟩ : Σ i, G i) ≈ ⟨j, funMap F (unify f x j hj)⟩ :=
   by
   obtain ⟨k, ik, jk⟩ := directed_of (· ≤ ·) i j
   refine' ⟨k, ik, jk, _⟩
   rw [(f i k ik).map_fun, (f j k jk).map_fun, comp_unify, comp_unify]
 #align first_order.language.direct_limit.fun_map_unify_equiv FirstOrder.Language.DirectLimit.funMap_unify_equiv
 
-theorem relMap_unify_equiv {n : ℕ} (R : L.Relations n) (x : Fin n → Σi, G i) (i j : ι)
+theorem relMap_unify_equiv {n : ℕ} (R : L.Relations n) (x : Fin n → Σ i, G i) (i j : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) (hj : j ∈ upperBounds (range (Sigma.fst ∘ x))) :
     RelMap R (unify f x i hi) = RelMap R (unify f x j hj) :=
   by
@@ -194,23 +194,23 @@ theorem relMap_unify_equiv {n : ℕ} (R : L.Relations n) (x : Fin n → Σi, G i
 
 variable [Nonempty ι]
 
-theorem exists_unify_eq {α : Type _} [Fintype α] {x y : α → Σi, G i} (xy : x ≈ y) :
-    ∃ (i : ι)(hx : i ∈ upperBounds (range (Sigma.fst ∘ x)))(hy :
+theorem exists_unify_eq {α : Type _} [Fintype α] {x y : α → Σ i, G i} (xy : x ≈ y) :
+    ∃ (i : ι) (hx : i ∈ upperBounds (range (Sigma.fst ∘ x))) (hy :
       i ∈ upperBounds (range (Sigma.fst ∘ y))), unify f x i hx = unify f y i hy :=
   by
   obtain ⟨i, hi⟩ := Fintype.bddAbove_range (Sum.elim (fun a => (x a).1) fun a => (y a).1)
-  rw [sum.elim_range, upperBounds_union] at hi
-  simp_rw [← Function.comp_apply Sigma.fst _] at hi
+  rw [sum.elim_range, upperBounds_union] at hi 
+  simp_rw [← Function.comp_apply Sigma.fst _] at hi 
   exact ⟨i, hi.1, hi.2, funext fun a => (equiv_iff G f _ _).1 (xy a)⟩
 #align first_order.language.direct_limit.exists_unify_eq FirstOrder.Language.DirectLimit.exists_unify_eq
 
-theorem funMap_equiv_unify {n : ℕ} (F : L.Functions n) (x : Fin n → Σi, G i) (i : ι)
+theorem funMap_equiv_unify {n : ℕ} (F : L.Functions n) (x : Fin n → Σ i, G i) (i : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     @funMap _ _ (sigmaStructure G f) _ F x ≈ ⟨_, funMap F (unify f x i hi)⟩ :=
   funMap_unify_equiv G f F x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
 #align first_order.language.direct_limit.fun_map_equiv_unify FirstOrder.Language.DirectLimit.funMap_equiv_unify
 
-theorem relMap_equiv_unify {n : ℕ} (R : L.Relations n) (x : Fin n → Σi, G i) (i : ι)
+theorem relMap_equiv_unify {n : ℕ} (R : L.Relations n) (x : Fin n → Σ i, G i) (i : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     @RelMap _ _ (sigmaStructure G f) _ R x = RelMap R (unify f x i hi) :=
   relMap_unify_equiv G f R x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
@@ -262,7 +262,7 @@ theorem relMap_quotient_mk'_sigma_mk' {n : ℕ} {R : L.Relations n} {i : ι} {x
 #align first_order.language.direct_limit.rel_map_quotient_mk_sigma_mk FirstOrder.Language.DirectLimit.relMap_quotient_mk'_sigma_mk'
 
 theorem exists_quotient_mk'_sigma_mk'_eq {α : Type _} [Fintype α] (x : α → DirectLimit G f) :
-    ∃ (i : ι)(y : α → G i), x = Quotient.mk' ∘ Sigma.mk i ∘ y :=
+    ∃ (i : ι) (y : α → G i), x = Quotient.mk' ∘ Sigma.mk i ∘ y :=
   by
   obtain ⟨i, hi⟩ := Fintype.bddAbove_range fun a => (x a).out.1
   refine' ⟨i, unify f (Quotient.out ∘ x) i hi, _⟩
@@ -279,7 +279,7 @@ def of (i : ι) : G i ↪[L] DirectLimit G f
     where
   toFun := Quotient.mk' ∘ Sigma.mk i
   inj' x y h := by
-    simp only [Quotient.eq'] at h
+    simp only [Quotient.eq'] at h 
     obtain ⟨j, h1, h2, h3⟩ := h
     exact (f i j h1).Injective h3
 #align first_order.language.direct_limit.of FirstOrder.Language.DirectLimit.of
@@ -326,7 +326,7 @@ to a unique map out of the direct limit. -/
 def lift : DirectLimit G f ↪[L] P
     where
   toFun :=
-    Quotient.lift (fun x : Σi, G i => (g x.1) x.2) fun x y xy =>
+    Quotient.lift (fun x : Σ i, G i => (g x.1) x.2) fun x y xy =>
       by
       simp only
       obtain ⟨i, hx, hy⟩ := directed_of (· ≤ ·) x.1 y.1
@@ -334,9 +334,9 @@ def lift : DirectLimit G f ↪[L] P
       exact congr_arg _ ((equiv_iff _ _ _ _).1 xy)
   inj' x y xy :=
     by
-    rw [← Quotient.out_eq x, ← Quotient.out_eq y, Quotient.lift_mk, Quotient.lift_mk] at xy
+    rw [← Quotient.out_eq x, ← Quotient.out_eq y, Quotient.lift_mk, Quotient.lift_mk] at xy 
     obtain ⟨i, hx, hy⟩ := directed_of (· ≤ ·) x.out.1 y.out.1
-    rw [← Hg x.out.1 i hx, ← Hg y.out.1 i hy] at xy
+    rw [← Hg x.out.1 i hx, ← Hg y.out.1 i hy] at xy 
     rw [← Quotient.out_eq x, ← Quotient.out_eq y, Quotient.eq', equiv_iff G f hx hy]
     exact (g i).Injective xy
   map_fun' n F x := by

f53b2399

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -25,7 +25,7 @@ This file constructs the direct limit of a directed system of first-order embedd
 
 universe v w u₁ u₂
 
-open FirstOrder
+open scoped FirstOrder
 
 namespace FirstOrder
 
@@ -306,11 +306,11 @@ theorem exists_of (z : DirectLimit G f) : ∃ i x, of L ι G f i x = z :=
 #align first_order.language.direct_limit.exists_of FirstOrder.Language.DirectLimit.exists_of
 
 @[elab_as_elim]
-protected theorem inductionOn {C : DirectLimit G f → Prop} (z : DirectLimit G f)
+protected theorem induction_on {C : DirectLimit G f → Prop} (z : DirectLimit G f)
     (ih : ∀ i x, C (of L ι G f i x)) : C z :=
   let ⟨i, x, h⟩ := exists_of z
   h ▸ ih i x
-#align first_order.language.direct_limit.induction_on FirstOrder.Language.DirectLimit.inductionOn
+#align first_order.language.direct_limit.induction_on FirstOrder.Language.DirectLimit.induction_on
 
 variable {P : Type u₁} [L.Structure P] (g : ∀ i, G i ↪[L] P)
 
@@ -367,7 +367,7 @@ theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
     F x =
       lift L ι G f (fun i => F.comp <| of L ι G f i)
         (fun i j hij x => by rw [F.comp_apply, F.comp_apply, of_f]) x :=
-  DirectLimit.inductionOn x fun i x => by rw [lift_of] <;> rfl
+  DirectLimit.induction_on x fun i x => by rw [lift_of] <;> rfl
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
 
 /-- The direct limit of countably many countably generated structures is countably generated. -/

f53b2399

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -306,11 +306,11 @@ theorem exists_of (z : DirectLimit G f) : ∃ i x, of L ι G f i x = z :=
 #align first_order.language.direct_limit.exists_of FirstOrder.Language.DirectLimit.exists_of
 
 @[elab_as_elim]
-protected theorem induction_on {C : DirectLimit G f → Prop} (z : DirectLimit G f)
+protected theorem inductionOn {C : DirectLimit G f → Prop} (z : DirectLimit G f)
     (ih : ∀ i x, C (of L ι G f i x)) : C z :=
   let ⟨i, x, h⟩ := exists_of z
   h ▸ ih i x
-#align first_order.language.direct_limit.induction_on FirstOrder.Language.DirectLimit.induction_on
+#align first_order.language.direct_limit.induction_on FirstOrder.Language.DirectLimit.inductionOn
 
 variable {P : Type u₁} [L.Structure P] (g : ∀ i, G i ↪[L] P)
 
@@ -367,7 +367,7 @@ theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
     F x =
       lift L ι G f (fun i => F.comp <| of L ι G f i)
         (fun i j hij x => by rw [F.comp_apply, F.comp_apply, of_f]) x :=
-  DirectLimit.induction_on x fun i x => by rw [lift_of] <;> rfl
+  DirectLimit.inductionOn x fun i x => by rw [lift_of] <;> rfl
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
 
 /-- The direct limit of countably many countably generated structures is countably generated. -/

f53b2399

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -377,10 +377,10 @@ theorem cG {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)
     Structure.CG L (DirectLimit G f) :=
   by
   refine' ⟨⟨⋃ i, direct_limit.of L ι G f i '' Classical.choose (h i).out, _, _⟩⟩
-  · exact Set.countable_unionᵢ fun i => Set.Countable.image (Classical.choose_spec (h i).out).1 _
+  · exact Set.countable_iUnion fun i => Set.Countable.image (Classical.choose_spec (h i).out).1 _
   · rw [eq_top_iff, substructure.closure_Union]
     simp_rw [← embedding.coe_to_hom, substructure.closure_image]
-    rw [le_supᵢ_iff]
+    rw [le_iSup_iff]
     intro S hS x hx
     let out := @Quotient.out _ (direct_limit.setoid G f)
     refine' hS (out x).1 ⟨(out x).2, _, _⟩

f53b2399

bump to nightly-2023-05-13-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/403190b5419b3f03f1a2893ad9352ca7f7d8bff6

a0be3cad

Diff

@@ -371,10 +371,10 @@ theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
 
 /-- The direct limit of countably many countably generated structures is countably generated. -/
-theorem cg {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
+theorem cG {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
-    (h : ∀ i, Structure.Cg L (G i)) [DirectedSystem G fun i j h => f i j h] :
-    Structure.Cg L (DirectLimit G f) :=
+    (h : ∀ i, Structure.CG L (G i)) [DirectedSystem G fun i j h => f i j h] :
+    Structure.CG L (DirectLimit G f) :=
   by
   refine' ⟨⟨⋃ i, direct_limit.of L ι G f i '' Classical.choose (h i).out, _, _⟩⟩
   · exact Set.countable_unionᵢ fun i => Set.Countable.image (Classical.choose_spec (h i).out).1 _
@@ -387,13 +387,13 @@ theorem cg {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)
     · rw [(Classical.choose_spec (h (out x).1).out).2]
       simp only [substructure.coe_top]
     · simp only [embedding.coe_to_hom, direct_limit.of_apply, Sigma.eta, Quotient.out_eq]
-#align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cg
+#align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cG
 
 instance cg' {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
-    [h : ∀ i, Structure.Cg L (G i)] [DirectedSystem G fun i j h => f i j h] :
-    Structure.Cg L (DirectLimit G f) :=
-  cg f h
+    [h : ∀ i, Structure.CG L (G i)] [DirectedSystem G fun i j h => f i j h] :
+    Structure.CG L (DirectLimit G f) :=
+  cG f h
 #align first_order.language.direct_limit.cg' FirstOrder.Language.DirectLimit.cg'
 
 end DirectLimit

f53b2399

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

f53b2399

chore: adapt to multiple goal linter 3 (#12372)

A PR analogous to #12338 and #12361: reformatting proofs following the multiple goals linter of #12339.

d29b3780

Diff

@@ -142,8 +142,8 @@ def setoid [DirectedSystem G fun i j h => f i j h] [IsDirected ι (· ≤ ·)] :
         obtain ⟨ijk, hijijk, hjkijk⟩ := directed_of (· ≤ ·) ij jk
         refine' ⟨ijk, le_trans hiij hijijk, le_trans hkjk hjkijk, _⟩
         rw [← DirectedSystem.map_map, hij, DirectedSystem.map_map]
-        symm
-        rw [← DirectedSystem.map_map, ← hjk, DirectedSystem.map_map] <;> assumption⟩
+        · symm
+          rw [← DirectedSystem.map_map, ← hjk, DirectedSystem.map_map] <;> assumption⟩
 #align first_order.language.direct_limit.setoid FirstOrder.Language.DirectLimit.setoid
 
 /-- The structure on the `Σ`-type which becomes the structure on the direct limit after quotienting.

f53b2399

chore: superfluous parentheses part 2 (#12131)

Co-authored-by: Moritz Firsching <firsching@google.com>

d48d30ac

Diff

@@ -351,7 +351,7 @@ theorem exists_fg_substructure_in_Sigma (S : L.Substructure (DirectLimit G f)) (
   let ⟨A, A_closure⟩ := S_fg
   let ⟨i, y, eq_y⟩ := exists_quotient_mk'_sigma_mk'_eq G _ (fun a : A ↦ a.1)
   use i
-  use (Substructure.closure L (range y))
+  use Substructure.closure L (range y)
   rw [Substructure.map_closure]
   simp only [Embedding.coe_toHom, of_apply]
   rw [← image_univ, image_image, image_univ, ← eq_y,

f53b2399

feat(ModelTheory): lift of equivalences between direct limits, and direct limit of system of substructures (#11174)

Define the equivalence between direct limits of isomorphic systems, and the equivalence between the direct limit of a system of substructures and the union of these substructures. Co-authored-by: Aaron Anderson <awainverse@gmail.com>

Co-authored-by: Gabin <68381468+QuinnLesquimau@users.noreply.github.com> Co-authored-by: Johan Commelin <johan@commelin.net>

0d98b682

Diff

@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2022 Aaron Anderson. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Aaron Anderson
+Authors: Aaron Anderson, Gabin Kolly
 -/
 import Mathlib.Init.Align
 import Mathlib.Data.Fintype.Order
@@ -18,10 +18,15 @@ This file constructs the direct limit of a directed system of first-order embedd
 ## Main Definitions
 * `FirstOrder.Language.DirectLimit G f` is the direct limit of the directed system `f` of
   first-order embeddings between the structures indexed by `G`.
+* `FirstOrder.Language.DirectLimit.lift` is the universal property of the direct limit: maps
+  from the components to another module that respect the directed system structure give rise to
+  a unique map out of the direct limit.
+* `FirstOrder.Language.DirectLimit.equiv_lift` is the equivalence between limits of
+  isomorphic direct systems.
 -/
 
 
-universe v w u₁ u₂
+universe v w w' u₁ u₂
 
 open FirstOrder
 
@@ -335,6 +340,23 @@ protected theorem inductionOn {C : DirectLimit G f → Prop} (z : DirectLimit G
   h ▸ ih i x
 #align first_order.language.direct_limit.induction_on FirstOrder.Language.DirectLimit.inductionOn
 
+theorem iSup_range_of_eq_top : ⨆ i, (of L ι G f i).toHom.range = ⊤ :=
+  eq_top_iff.2 (fun x _ ↦ DirectLimit.inductionOn x
+    (fun i _ ↦ le_iSup (fun i ↦ Hom.range (Embedding.toHom (of L ι G f i))) i (mem_range_self _)))
+
+/-- Every finitely generated substructure of the direct limit corresponds to some
+substructure in some component of the directed system. -/
+theorem exists_fg_substructure_in_Sigma (S : L.Substructure (DirectLimit G f)) (S_fg : S.FG) :
+    ∃ i, ∃ T : L.Substructure (G i), T.map (of L ι G f i).toHom = S := by
+  let ⟨A, A_closure⟩ := S_fg
+  let ⟨i, y, eq_y⟩ := exists_quotient_mk'_sigma_mk'_eq G _ (fun a : A ↦ a.1)
+  use i
+  use (Substructure.closure L (range y))
+  rw [Substructure.map_closure]
+  simp only [Embedding.coe_toHom, of_apply]
+  rw [← image_univ, image_image, image_univ, ← eq_y,
+    Subtype.range_coe_subtype, Finset.setOf_mem, A_closure]
+
 variable {P : Type u₁} [L.Structure P] (g : ∀ i, G i ↪[L] P)
 variable (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
 variable (L ι G f)
@@ -387,6 +409,38 @@ theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
   DirectLimit.inductionOn x fun i x => by rw [lift_of]; rfl
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
 
+lemma range_lift : (lift L ι G f g Hg).toHom.range = ⨆ i, (g i).toHom.range := by
+  simp_rw [Hom.range_eq_map]
+  rw [← iSup_range_of_eq_top, Substructure.map_iSup]
+  simp_rw [Hom.range_eq_map, Substructure.map_map]
+  rfl
+
+variable (L ι G f)
+variable (G' : ι → Type w') [∀ i, L.Structure (G' i)]
+variable (f' : ∀ i j, i ≤ j → G' i ↪[L] G' j)
+variable (g : ∀ i, G i ≃[L] G' i)
+variable (H_commuting : ∀ i j hij x, g j (f i j hij x) = f' i j hij (g i x))
+variable [DirectedSystem G' fun i j h => f' i j h]
+
+/-- The isomorphism between limits of isomorphic systems. -/
+noncomputable def equiv_lift : DirectLimit G f ≃[L] DirectLimit G' f' := by
+  let U i : G i ↪[L] DirectLimit G' f' := (of L _ G' f' i).comp (g i).toEmbedding
+  let F : DirectLimit G f ↪[L] DirectLimit G' f' := lift L _ G f U <| by
+    intro _ _ _ _
+    simp only [U, Embedding.comp_apply, Equiv.coe_toEmbedding, H_commuting, of_f]
+  have surj_f : Function.Surjective F := by
+    intro x
+    rcases x with ⟨i, pre_x⟩
+    use of L _ G f i ((g i).symm pre_x)
+    simp only [F, U, lift_of, Embedding.comp_apply, Equiv.coe_toEmbedding, Equiv.apply_symm_apply]
+    rfl
+  exact ⟨Equiv.ofBijective F ⟨F.injective, surj_f⟩, F.map_fun', F.map_rel'⟩
+
+theorem equiv_lift_of {i : ι} (x : G i) :
+    equiv_lift L ι G f G' f' g H_commuting (of L ι G f i x) = of L ι G' f' i (g i x) := rfl
+
+variable {L ι G f}
+
 /-- The direct limit of countably many countably generated structures is countably generated. -/
 theorem cg {ι : Type*} [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
@@ -414,6 +468,66 @@ instance cg' {ι : Type*} [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·
 
 end DirectLimit
 
+section Substructure
+
+variable [Nonempty ι] [IsDirected ι (· ≤ ·)]
+variable {M N : Type*} [L.Structure M] [L.Structure N] (S : ι →o L.Substructure M)
+
+instance : DirectedSystem (fun i ↦ S i) (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) where
+  map_self' := fun _ _ _ ↦ rfl
+  map_map' := fun _ _ _ ↦ rfl
+
+namespace DirectLimit
+
+/-- The map from a direct limit of a system of substructures of `M` into `M`. -/
+def liftInclusion :
+    DirectLimit (fun i ↦ S i) (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) ↪[L] M :=
+  DirectLimit.lift L ι (fun i ↦ S i) (fun _ _ h ↦ Substructure.inclusion (S.monotone h))
+    (fun _ ↦ Substructure.subtype _) (fun _ _ _ _ ↦ rfl)
+
+theorem liftInclusion_of {i : ι} (x : S i) :
+    (liftInclusion S) (of L ι _ (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) i x)
+    = Substructure.subtype (S i) x := rfl
+
+lemma rangeLiftInclusion : (liftInclusion S).toHom.range = ⨆ i, S i := by
+  simp_rw [liftInclusion, range_lift, Substructure.range_subtype]
+
+/-- The isomorphism between a direct limit of a system of substructures and their union. -/
+noncomputable def Equiv_iSup :
+    DirectLimit (fun i ↦ S i) (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) ≃[L]
+    (iSup S : L.Substructure M) := by
+  have liftInclusion_in_sup : ∀ x, liftInclusion S x ∈ (⨆ i, S i) := by
+    simp only [← rangeLiftInclusion, Hom.mem_range, Embedding.coe_toHom]
+    intro x; use x
+  let F := Embedding.codRestrict (⨆ i, S i) _ liftInclusion_in_sup
+  have F_surj : Function.Surjective F := by
+    rintro ⟨m, hm⟩
+    rw [← rangeLiftInclusion, Hom.mem_range] at hm
+    rcases hm with ⟨a, _⟩; use a
+    simpa only [F, Embedding.codRestrict_apply', Subtype.mk.injEq]
+  exact ⟨Equiv.ofBijective F ⟨F.injective, F_surj⟩, F.map_fun', F.map_rel'⟩
+
+theorem Equiv_isup_of_apply {i : ι} (x : S i) :
+    Equiv_iSup S (of L ι _ (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) i x)
+    = Substructure.inclusion (le_iSup _ _) x := rfl
+
+theorem Equiv_isup_symm_inclusion_apply {i : ι} (x : S i) :
+    (Equiv_iSup S).symm (Substructure.inclusion (le_iSup _ _) x)
+    = of L ι _ (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) i x := by
+  apply (Equiv_iSup S).injective
+  simp only [Equiv.apply_symm_apply]
+  rfl
+
+@[simp]
+theorem Equiv_isup_symm_inclusion (i : ι) :
+    (Equiv_iSup S).symm.toEmbedding.comp (Substructure.inclusion (le_iSup _ _))
+    = of L ι _ (fun _ _ h ↦ Substructure.inclusion (S.monotone h)) i := by
+  ext x; exact Equiv_isup_symm_inclusion_apply _ x
+
+end DirectLimit
+
+end Substructure
+
 end Language
 
 end FirstOrder

f53b2399

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -32,9 +32,7 @@ namespace Language
 open Structure Set
 
 variable {L : Language} {ι : Type v} [Preorder ι]
-
 variable {G : ι → Type w} [∀ i, L.Structure (G i)]
-
 variable (f : ∀ i j, i ≤ j → G i ↪[L] G j)
 
 namespace DirectedSystem
@@ -338,9 +336,7 @@ protected theorem inductionOn {C : DirectLimit G f → Prop} (z : DirectLimit G
 #align first_order.language.direct_limit.induction_on FirstOrder.Language.DirectLimit.inductionOn
 
 variable {P : Type u₁} [L.Structure P] (g : ∀ i, G i ↪[L] P)
-
 variable (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
-
 variable (L ι G f)
 
 /-- The universal property of the direct limit: maps from the components to another module

f53b2399

chore(ModelTheory/DirectLimit): Fintype -> Finite, Encodable -> Countable (#10913)

e612a999

Diff

@@ -208,9 +208,9 @@ theorem relMap_unify_equiv {n : ℕ} (R : L.Relations n) (x : Fin n → Σˣ f)
 
 variable [Nonempty ι]
 
-theorem exists_unify_eq {α : Type*} [Fintype α] {x y : α → Σˣ f} (xy : x ≈ y) :
-    ∃ (i : ι)(hx : i ∈ upperBounds (range (Sigma.fst ∘ x)))(hy :
-      i ∈ upperBounds (range (Sigma.fst ∘ y))), unify f x i hx = unify f y i hy := by
+theorem exists_unify_eq {α : Type*} [Finite α] {x y : α → Σˣ f} (xy : x ≈ y) :
+    ∃ (i : ι) (hx : i ∈ upperBounds (range (Sigma.fst ∘ x)))
+      (hy : i ∈ upperBounds (range (Sigma.fst ∘ y))), unify f x i hx = unify f y i hy := by
   obtain ⟨i, hi⟩ := Finite.bddAbove_range (Sum.elim (fun a => (x a).1) fun a => (y a).1)
   rw [Sum.elim_range, upperBounds_union] at hi
   simp_rw [← Function.comp_apply (f := Sigma.fst)] at hi
@@ -273,7 +273,7 @@ theorem relMap_quotient_mk'_sigma_mk' {n : ℕ} {R : L.Relations n} {i : ι} {x
   rw [unify_sigma_mk_self]
 #align first_order.language.direct_limit.rel_map_quotient_mk_sigma_mk FirstOrder.Language.DirectLimit.relMap_quotient_mk'_sigma_mk'
 
-theorem exists_quotient_mk'_sigma_mk'_eq {α : Type*} [Fintype α] (x : α → DirectLimit G f) :
+theorem exists_quotient_mk'_sigma_mk'_eq {α : Type*} [Finite α] (x : α → DirectLimit G f) :
     ∃ (i : ι) (y : α → G i), x = fun a => ⟦.mk f i (y a)⟧ := by
   obtain ⟨i, hi⟩ := Finite.bddAbove_range fun a => (x a).out.1
   refine' ⟨i, unify f (Quotient.out ∘ x) i hi, _⟩
@@ -392,7 +392,7 @@ theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
 
 /-- The direct limit of countably many countably generated structures is countably generated. -/
-theorem cg {ι : Type*} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
+theorem cg {ι : Type*} [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     (h : ∀ i, Structure.CG L (G i)) [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) := by
@@ -409,7 +409,7 @@ theorem cg {ι : Type*} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)]
     · simp only [out, Embedding.coe_toHom, DirectLimit.of_apply, Sigma.eta, Quotient.out_eq]
 #align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cg
 
-instance cg' {ι : Type*} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
+instance cg' {ι : Type*} [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     [h : ∀ i, Structure.CG L (G i)] [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) :=

f53b2399

chore: more backporting of simp changes from #10995 (#11001)

Co-authored-by: Patrick Massot <patrickmassot@free.fr> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

d9589c14

Diff

@@ -406,7 +406,7 @@ theorem cg {ι : Type*} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)]
     refine' hS (out x).1 ⟨(out x).2, _, _⟩
     · rw [(Classical.choose_spec (h (out x).1).out).2]
       trivial
-    · simp only [Embedding.coe_toHom, DirectLimit.of_apply, Sigma.eta, Quotient.out_eq]
+    · simp only [out, Embedding.coe_toHom, DirectLimit.of_apply, Sigma.eta, Quotient.out_eq]
 #align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cg
 
 instance cg' {ι : Type*} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]

f53b2399

chore: classify added instance porting notes (#10925)

Classifies by adding issue number (#10754) to porting notes claiming added instance.

1d96f991

Diff

@@ -166,7 +166,7 @@ def DirectLimit [DirectedSystem G fun i j h => f i j h] [IsDirected ι (· ≤ 
 
 attribute [local instance] DirectLimit.setoid
 
--- Porting note: Added local instance
+-- Porting note (#10754): Added local instance
 attribute [local instance] DirectLimit.sigmaStructure

f53b2399

style: reduce spacing variation in "porting note" comments (#10886)

In this pull request, I have systematically eliminated the leading whitespace preceding the colon (:) within all unlabelled or unclassified porting notes. This adjustment facilitates a more efficient review process for the remaining notes by ensuring no entries are overlooked due to formatting inconsistencies.

86b84c52

Diff

@@ -80,7 +80,7 @@ instance natLERec.directedSystem : DirectedSystem G' fun i j h => natLERec f' i
 
 end DirectedSystem
 
--- Porting note : Instead of `Σ i, G i`, we use the alias `Language.Structure.Sigma`
+-- Porting note: Instead of `Σ i, G i`, we use the alias `Language.Structure.Sigma`
 -- which depends on `f`. This way, Lean can infer what `L` and `f` are in the `Setoid` instance.
 -- Otherwise we have a "cannot find synthesization order" error. See the discussion at
 -- https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/local.20instance.20cannot.20find.20synthesization.20order.20in.20porting

f53b2399

chore: replace Lean 3 syntax λ x, in doc comments (#10727)

Use Lean 4 syntax fun x ↦ instead, matching the style guide. This is close to exhaustive for doc comments; mathlib has about 460 remaining uses of λ (not all in Lean 3 syntax).

4a99b7e2

Diff

@@ -40,13 +40,13 @@ variable (f : ∀ i j, i ≤ j → G i ↪[L] G j)
 namespace DirectedSystem
 
 /-- A copy of `DirectedSystem.map_self` specialized to `L`-embeddings, as otherwise the
-`λ i j h, f i j h` can confuse the simplifier. -/
+`fun i j h ↦ f i j h` can confuse the simplifier. -/
 nonrec theorem map_self [DirectedSystem G fun i j h => f i j h] (i x h) : f i i h x = x :=
   DirectedSystem.map_self (fun i j h => f i j h) i x h
 #align first_order.language.directed_system.map_self FirstOrder.Language.DirectedSystem.map_self
 
 /-- A copy of `DirectedSystem.map_map` specialized to `L`-embeddings, as otherwise the
-`λ i j h, f i j h` can confuse the simplifier. -/
+`fun i j h ↦ f i j h` can confuse the simplifier. -/
 nonrec theorem map_map [DirectedSystem G fun i j h => f i j h] {i j k} (hij hjk x) :
     f j k hjk (f i j hij x) = f i k (le_trans hij hjk) x :=
   DirectedSystem.map_map (fun i j h => f i j h) hij hjk x

f53b2399

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

f4c4ca61

Diff

@@ -3,6 +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 Mathlib.Init.Align
 import Mathlib.Data.Fintype.Order
 import Mathlib.Algebra.DirectLimit
 import Mathlib.ModelTheory.Quotients

f53b2399

chore(Fintype/Order): generalize Fintype to Finite in Directed lemmas (#9754)

Co-authored-by: Junyan Xu <junyanxu.math@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

0b934338

Diff

@@ -148,12 +148,12 @@ noncomputable def sigmaStructure [IsDirected ι (· ≤ ·)] [Nonempty ι] : L.S
   funMap F x :=
     ⟨_,
       funMap F
-        (unify f x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1))
-          (Classical.choose_spec (Fintype.bddAbove_range fun a => (x a).1)))⟩
+        (unify f x (Classical.choose (Finite.bddAbove_range fun a => (x a).1))
+          (Classical.choose_spec (Finite.bddAbove_range fun a => (x a).1)))⟩
   RelMap R x :=
     RelMap R
-      (unify f x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1))
-        (Classical.choose_spec (Fintype.bddAbove_range fun a => (x a).1)))
+      (unify f x (Classical.choose (Finite.bddAbove_range fun a => (x a).1))
+        (Classical.choose_spec (Finite.bddAbove_range fun a => (x a).1)))
 #align first_order.language.direct_limit.sigma_structure FirstOrder.Language.DirectLimit.sigmaStructure
 
 end DirectLimit
@@ -210,7 +210,7 @@ variable [Nonempty ι]
 theorem exists_unify_eq {α : Type*} [Fintype α] {x y : α → Σˣ f} (xy : x ≈ y) :
     ∃ (i : ι)(hx : i ∈ upperBounds (range (Sigma.fst ∘ x)))(hy :
       i ∈ upperBounds (range (Sigma.fst ∘ y))), unify f x i hx = unify f y i hy := by
-  obtain ⟨i, hi⟩ := Fintype.bddAbove_range (Sum.elim (fun a => (x a).1) fun a => (y a).1)
+  obtain ⟨i, hi⟩ := Finite.bddAbove_range (Sum.elim (fun a => (x a).1) fun a => (y a).1)
   rw [Sum.elim_range, upperBounds_union] at hi
   simp_rw [← Function.comp_apply (f := Sigma.fst)] at hi
   exact ⟨i, hi.1, hi.2, funext fun a => (equiv_iff G f _ _).1 (xy a)⟩
@@ -219,13 +219,13 @@ theorem exists_unify_eq {α : Type*} [Fintype α] {x y : α → Σˣ f} (xy : x
 theorem funMap_equiv_unify {n : ℕ} (F : L.Functions n) (x : Fin n → Σˣ f) (i : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     funMap F x ≈ .mk f _ (funMap F (unify f x i hi)) :=
-  funMap_unify_equiv G f F x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
+  funMap_unify_equiv G f F x (Classical.choose (Finite.bddAbove_range fun a => (x a).1)) i _ hi
 #align first_order.language.direct_limit.fun_map_equiv_unify FirstOrder.Language.DirectLimit.funMap_equiv_unify
 
 theorem relMap_equiv_unify {n : ℕ} (R : L.Relations n) (x : Fin n → Σˣ f) (i : ι)
     (hi : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     RelMap R x = RelMap R (unify f x i hi) :=
-  relMap_unify_equiv G f R x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
+  relMap_unify_equiv G f R x (Classical.choose (Finite.bddAbove_range fun a => (x a).1)) i _ hi
 #align first_order.language.direct_limit.rel_map_equiv_unify FirstOrder.Language.DirectLimit.relMap_equiv_unify
 
 /-- The direct limit `setoid` respects the structure `sigmaStructure`, so quotienting by it
@@ -256,7 +256,7 @@ theorem funMap_quotient_mk'_sigma_mk' {n : ℕ} {F : L.Functions n} {i : ι} {x
     funMap F (fun a => (⟦.mk f i (x a)⟧ : DirectLimit G f)) = ⟦.mk f i (funMap F x)⟧ := by
   simp only [funMap_quotient_mk', Quotient.eq]
   obtain ⟨k, ik, jk⟩ :=
-    directed_of (· ≤ ·) i (Classical.choose (Fintype.bddAbove_range fun _ : Fin n => i))
+    directed_of (· ≤ ·) i (Classical.choose (Finite.bddAbove_range fun _ : Fin n => i))
   refine' ⟨k, jk, ik, _⟩
   simp only [Embedding.map_fun, comp_unify]
   rfl
@@ -267,14 +267,14 @@ theorem relMap_quotient_mk'_sigma_mk' {n : ℕ} {R : L.Relations n} {i : ι} {x
     RelMap R (fun a => (⟦.mk f i (x a)⟧ : DirectLimit G f)) = RelMap R x := by
   rw [relMap_quotient_mk']
   obtain ⟨k, _, _⟩ :=
-    directed_of (· ≤ ·) i (Classical.choose (Fintype.bddAbove_range fun _ : Fin n => i))
+    directed_of (· ≤ ·) i (Classical.choose (Finite.bddAbove_range fun _ : Fin n => i))
   rw [relMap_equiv_unify G f R (fun a => .mk f i (x a)) i]
   rw [unify_sigma_mk_self]
 #align first_order.language.direct_limit.rel_map_quotient_mk_sigma_mk FirstOrder.Language.DirectLimit.relMap_quotient_mk'_sigma_mk'
 
 theorem exists_quotient_mk'_sigma_mk'_eq {α : Type*} [Fintype α] (x : α → DirectLimit G f) :
     ∃ (i : ι) (y : α → G i), x = fun a => ⟦.mk f i (y a)⟧ := by
-  obtain ⟨i, hi⟩ := Fintype.bddAbove_range fun a => (x a).out.1
+  obtain ⟨i, hi⟩ := Finite.bddAbove_range fun a => (x a).out.1
   refine' ⟨i, unify f (Quotient.out ∘ x) i hi, _⟩
   ext a
   rw [Quotient.eq_mk_iff_out, unify]

f53b2399

refactor: Split off basic Nat file (#9551)

Data.Nat.Basic is currently made of two things:

Basic lemmas that continue the theory in Std (and could belong there, really)
Basic algebraic order instances

I need the first ones earlier in the algebraic order hierarchy, hence the split.

Part of #9411. Similar to #9443

497ed074

Diff

@@ -73,7 +73,7 @@ theorem coe_natLERec (m n : ℕ) (h : m ≤ n) :
 #align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLERec
 
 instance natLERec.directedSystem : DirectedSystem G' fun i j h => natLERec f' i j h :=
-  ⟨fun i x h => congr (congr rfl (Nat.leRecOn_self _)) rfl,
+  ⟨fun i x _ => congr (congr rfl (Nat.leRecOn_self _)) rfl,
    fun hij hjk => by simp [Nat.leRecOn_trans hij hjk]⟩
 #align first_order.language.directed_system.nat_le_rec.directed_system FirstOrder.Language.DirectedSystem.natLERec.directedSystem

f53b2399

chore: remove nonterminal simp (#7580)

Removes nonterminal simps on lines looking like simp [...]

6fc8e6ec

Diff

@@ -254,7 +254,7 @@ set_option linter.uppercaseLean3 false in
 @[simp]
 theorem funMap_quotient_mk'_sigma_mk' {n : ℕ} {F : L.Functions n} {i : ι} {x : Fin n → G i} :
     funMap F (fun a => (⟦.mk f i (x a)⟧ : DirectLimit G f)) = ⟦.mk f i (funMap F x)⟧ := by
-  simp [Function.comp_apply, funMap_quotient_mk', Quotient.eq']
+  simp only [funMap_quotient_mk', Quotient.eq]
   obtain ⟨k, ik, jk⟩ :=
     directed_of (· ≤ ·) i (Classical.choose (Fintype.bddAbove_range fun _ : Fin n => i))
   refine' ⟨k, jk, ik, _⟩

f53b2399

Revert "chore: revert #7703 (#7710)"

This reverts commit f3695eb2.

ab56fa28

Diff

@@ -65,8 +65,10 @@ theorem coe_natLERec (m n : ℕ) (h : m ≤ n) :
   obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le h
   ext x
   induction' k with k ih
-  · rw [natLERec, Nat.leRecOn_self, Embedding.refl_apply, Nat.leRecOn_self]
-  · rw [Nat.leRecOn_succ le_self_add, natLERec, Nat.leRecOn_succ le_self_add, ← natLERec,
+  · -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [natLERec, Nat.leRecOn_self, Embedding.refl_apply, Nat.leRecOn_self]
+  · -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [Nat.leRecOn_succ le_self_add, natLERec, Nat.leRecOn_succ le_self_add, ← natLERec,
       Embedding.comp_apply, ih]
 #align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLERec

f53b2399

chore: revert #7703 (#7710)

This reverts commit 26eb2b0a.

f3695eb2

Diff

@@ -65,10 +65,8 @@ theorem coe_natLERec (m n : ℕ) (h : m ≤ n) :
   obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le h
   ext x
   induction' k with k ih
-  · -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-    erw [natLERec, Nat.leRecOn_self, Embedding.refl_apply, Nat.leRecOn_self]
-  · -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
-    erw [Nat.leRecOn_succ le_self_add, natLERec, Nat.leRecOn_succ le_self_add, ← natLERec,
+  · rw [natLERec, Nat.leRecOn_self, Embedding.refl_apply, Nat.leRecOn_self]
+  · rw [Nat.leRecOn_succ le_self_add, natLERec, Nat.leRecOn_succ le_self_add, ← natLERec,
       Embedding.comp_apply, ih]
 #align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLERec

f53b2399

chore: bump toolchain to v4.2.0-rc2 (#7703)

This includes all the changes from #7606.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

26eb2b0a

Diff

@@ -65,8 +65,10 @@ theorem coe_natLERec (m n : ℕ) (h : m ≤ n) :
   obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le h
   ext x
   induction' k with k ih
-  · rw [natLERec, Nat.leRecOn_self, Embedding.refl_apply, Nat.leRecOn_self]
-  · rw [Nat.leRecOn_succ le_self_add, natLERec, Nat.leRecOn_succ le_self_add, ← natLERec,
+  · -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [natLERec, Nat.leRecOn_self, Embedding.refl_apply, Nat.leRecOn_self]
+  · -- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
+    erw [Nat.leRecOn_succ le_self_add, natLERec, Nat.leRecOn_succ le_self_add, ← natLERec,
       Embedding.comp_apply, ih]
 #align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLERec

f53b2399

chore: fix nonterminal simps (#7497)

Fixes the nonterminal simps identified by #7496

19ca95b1

Diff

@@ -295,7 +295,7 @@ def of (i : ι) : G i ↪[L] DirectLimit G f where
     obtain ⟨j, h1, _, h3⟩ := h
     exact (f i j h1).injective h3
   map_fun' F x := by
-    simp
+    simp only
     rw [← funMap_quotient_mk'_sigma_mk']
     rfl
   map_rel' := by
@@ -346,7 +346,7 @@ to a unique map out of the direct limit. -/
 def lift : DirectLimit G f ↪[L] P where
   toFun :=
     Quotient.lift (fun x : Σˣ f => (g x.1) x.2) fun x y xy => by
-      simp
+      simp only
       obtain ⟨i, hx, hy⟩ := directed_of (· ≤ ·) x.1 y.1
       rw [← Hg x.1 i hx, ← Hg y.1 i hy]
       exact congr_arg _ ((equiv_iff ..).1 xy)

f53b2399

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -96,7 +96,7 @@ abbrev Structure.Sigma.mk (i : ι) (x : G i) : Σˣ f := ⟨i, x⟩
 namespace DirectLimit
 
 /-- Raises a family of elements in the `Σ`-type to the same level along the embeddings. -/
-def unify {α : Type _} (x : α → Σˣ f) (i : ι) (h : i ∈ upperBounds (range (Sigma.fst ∘ x)))
+def unify {α : Type*} (x : α → Σˣ f) (i : ι) (h : i ∈ upperBounds (range (Sigma.fst ∘ x)))
     (a : α) : G i :=
   f (x a).1 i (h (mem_range_self a)) (x a).2
 #align first_order.language.direct_limit.unify FirstOrder.Language.DirectLimit.unify
@@ -104,7 +104,7 @@ def unify {α : Type _} (x : α → Σˣ f) (i : ι) (h : i ∈ upperBounds (ran
 variable [DirectedSystem G fun i j h => f i j h]
 
 @[simp]
-theorem unify_sigma_mk_self {α : Type _} {i : ι} {x : α → G i} :
+theorem unify_sigma_mk_self {α : Type*} {i : ι} {x : α → G i} :
     (unify f (fun a => .mk f i (x a)) i fun j ⟨a, hj⟩ =>
       _root_.trans (le_of_eq hj.symm) (refl _)) = x := by
   ext a
@@ -112,7 +112,7 @@ theorem unify_sigma_mk_self {α : Type _} {i : ι} {x : α → G i} :
   apply DirectedSystem.map_self
 #align first_order.language.direct_limit.unify_sigma_mk_self FirstOrder.Language.DirectLimit.unify_sigma_mk_self
 
-theorem comp_unify {α : Type _} {x : α → Σˣ f} {i j : ι} (ij : i ≤ j)
+theorem comp_unify {α : Type*} {x : α → Σˣ f} {i j : ι} (ij : i ≤ j)
     (h : i ∈ upperBounds (range (Sigma.fst ∘ x))) :
     f i j ij ∘ unify f x i h = unify f x j
       fun k hk => _root_.trans (mem_upperBounds.1 h k hk) ij := by
@@ -205,7 +205,7 @@ theorem relMap_unify_equiv {n : ℕ} (R : L.Relations n) (x : Fin n → Σˣ f)
 
 variable [Nonempty ι]
 
-theorem exists_unify_eq {α : Type _} [Fintype α] {x y : α → Σˣ f} (xy : x ≈ y) :
+theorem exists_unify_eq {α : Type*} [Fintype α] {x y : α → Σˣ f} (xy : x ≈ y) :
     ∃ (i : ι)(hx : i ∈ upperBounds (range (Sigma.fst ∘ x)))(hy :
       i ∈ upperBounds (range (Sigma.fst ∘ y))), unify f x i hx = unify f y i hy := by
   obtain ⟨i, hi⟩ := Fintype.bddAbove_range (Sum.elim (fun a => (x a).1) fun a => (y a).1)
@@ -270,7 +270,7 @@ theorem relMap_quotient_mk'_sigma_mk' {n : ℕ} {R : L.Relations n} {i : ι} {x
   rw [unify_sigma_mk_self]
 #align first_order.language.direct_limit.rel_map_quotient_mk_sigma_mk FirstOrder.Language.DirectLimit.relMap_quotient_mk'_sigma_mk'
 
-theorem exists_quotient_mk'_sigma_mk'_eq {α : Type _} [Fintype α] (x : α → DirectLimit G f) :
+theorem exists_quotient_mk'_sigma_mk'_eq {α : Type*} [Fintype α] (x : α → DirectLimit G f) :
     ∃ (i : ι) (y : α → G i), x = fun a => ⟦.mk f i (y a)⟧ := by
   obtain ⟨i, hi⟩ := Fintype.bddAbove_range fun a => (x a).out.1
   refine' ⟨i, unify f (Quotient.out ∘ x) i hi, _⟩
@@ -389,7 +389,7 @@ theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
 
 /-- The direct limit of countably many countably generated structures is countably generated. -/
-theorem cg {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
+theorem cg {ι : Type*} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     (h : ∀ i, Structure.CG L (G i)) [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) := by
@@ -406,7 +406,7 @@ theorem cg {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)
     · simp only [Embedding.coe_toHom, DirectLimit.of_apply, Sigma.eta, Quotient.out_eq]
 #align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cg
 
-instance cg' {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
+instance cg' {ι : Type*} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     [h : ∀ i, Structure.CG L (G i)] [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) :=

f53b2399

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,17 +2,14 @@
 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.direct_limit
-! leanprover-community/mathlib commit f53b23994ac4c13afa38d31195c588a1121d1860
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fintype.Order
 import Mathlib.Algebra.DirectLimit
 import Mathlib.ModelTheory.Quotients
 import Mathlib.ModelTheory.FinitelyGenerated
 
+#align_import model_theory.direct_limit from "leanprover-community/mathlib"@"f53b23994ac4c13afa38d31195c588a1121d1860"
+
 /-!
 # Direct Limits of First-Order Structures
 This file constructs the direct limit of a directed system of first-order embeddings.

f53b2399

chore: cleanup whitespace (#5988)

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

12343aa5

Diff

@@ -303,7 +303,7 @@ def of (i : ι) : G i ↪[L] DirectLimit G f where
     rfl
   map_rel' := by
     intro n R x
-    change RelMap R (fun a =>  (⟦.mk f i (x a)⟧ : DirectLimit G f)) ↔ _
+    change RelMap R (fun a => (⟦.mk f i (x a)⟧ : DirectLimit G f)) ↔ _
     simp only [relMap_quotient_mk'_sigma_mk']

f53b2399

chore: tidy various files (#5840)

6a00552b

Diff

@@ -18,7 +18,7 @@ import Mathlib.ModelTheory.FinitelyGenerated
 This file constructs the direct limit of a directed system of first-order embeddings.
 
 ## Main Definitions
-* `FirstOrder.language.direct_limit G f`  is the direct limit of the directed system `f` of
+* `FirstOrder.Language.DirectLimit G f` is the direct limit of the directed system `f` of
   first-order embeddings between the structures indexed by `G`.
 -/
 
@@ -41,13 +41,13 @@ variable (f : ∀ i j, i ≤ j → G i ↪[L] G j)
 
 namespace DirectedSystem
 
-/-- A copy of `directed_system.map_self` specialized to `L`-embeddings, as otherwise the
+/-- A copy of `DirectedSystem.map_self` specialized to `L`-embeddings, as otherwise the
 `λ i j h, f i j h` can confuse the simplifier. -/
 nonrec theorem map_self [DirectedSystem G fun i j h => f i j h] (i x h) : f i i h x = x :=
   DirectedSystem.map_self (fun i j h => f i j h) i x h
 #align first_order.language.directed_system.map_self FirstOrder.Language.DirectedSystem.map_self
 
-/-- A copy of `directed_system.map_map` specialized to `L`-embeddings, as otherwise the
+/-- A copy of `DirectedSystem.map_map` specialized to `L`-embeddings, as otherwise the
 `λ i j h, f i j h` can confuse the simplifier. -/
 nonrec theorem map_map [DirectedSystem G fun i j h => f i j h] {i j k} (hij hjk x) :
     f j k hjk (f i j hij x) = f i k (le_trans hij hjk) x :=
@@ -56,27 +56,27 @@ nonrec theorem map_map [DirectedSystem G fun i j h => f i j h] {i j k} (hij hjk
 
 variable {G' : ℕ → Type w} [∀ i, L.Structure (G' i)] (f' : ∀ n : ℕ, G' n ↪[L] G' (n + 1))
 
-/-- Given a chain of embeddings of structures indexed by `ℕ`, defines a `directed_system` by
+/-- Given a chain of embeddings of structures indexed by `ℕ`, defines a `DirectedSystem` by
 composing them. -/
-def natLeRec (m n : ℕ) (h : m ≤ n) : G' m ↪[L] G' n :=
+def natLERec (m n : ℕ) (h : m ≤ n) : G' m ↪[L] G' n :=
   Nat.leRecOn h (@fun k g => (f' k).comp g) (Embedding.refl L _)
-#align first_order.language.directed_system.nat_le_rec FirstOrder.Language.DirectedSystem.natLeRec
+#align first_order.language.directed_system.nat_le_rec FirstOrder.Language.DirectedSystem.natLERec
 
 @[simp]
-theorem coe_natLeRec (m n : ℕ) (h : m ≤ n) :
-    (natLeRec f' m n h : G' m → G' n) = Nat.leRecOn h (@fun k => f' k) := by
+theorem coe_natLERec (m n : ℕ) (h : m ≤ n) :
+    (natLERec f' m n h : G' m → G' n) = Nat.leRecOn h (@fun k => f' k) := by
   obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le h
   ext x
   induction' k with k ih
-  · rw [natLeRec, Nat.leRecOn_self, Embedding.refl_apply, Nat.leRecOn_self]
-  · rw [Nat.leRecOn_succ le_self_add, natLeRec, Nat.leRecOn_succ le_self_add, ← natLeRec,
+  · rw [natLERec, Nat.leRecOn_self, Embedding.refl_apply, Nat.leRecOn_self]
+  · rw [Nat.leRecOn_succ le_self_add, natLERec, Nat.leRecOn_succ le_self_add, ← natLERec,
       Embedding.comp_apply, ih]
-#align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLeRec
+#align first_order.language.directed_system.coe_nat_le_rec FirstOrder.Language.DirectedSystem.coe_natLERec
 
-instance natLeRec.directedSystem : DirectedSystem G' fun i j h => natLeRec f' i j h :=
-  ⟨fun i x h => congr (congr rfl (Nat.leRecOn_self _)) rfl, fun hij hjk => by
-    simp [Nat.leRecOn_trans hij hjk]⟩
-#align first_order.language.directed_system.nat_le_rec.directed_system FirstOrder.Language.DirectedSystem.natLeRec.directedSystem
+instance natLERec.directedSystem : DirectedSystem G' fun i j h => natLERec f' i j h :=
+  ⟨fun i x h => congr (congr rfl (Nat.leRecOn_self _)) rfl,
+   fun hij hjk => by simp [Nat.leRecOn_trans hij hjk]⟩
+#align first_order.language.directed_system.nat_le_rec.directed_system FirstOrder.Language.DirectedSystem.natLERec.directedSystem
 
 end DirectedSystem
 
@@ -229,7 +229,7 @@ theorem relMap_equiv_unify {n : ℕ} (R : L.Relations n) (x : Fin n → Σˣ f)
   relMap_unify_equiv G f R x (Classical.choose (Fintype.bddAbove_range fun a => (x a).1)) i _ hi
 #align first_order.language.direct_limit.rel_map_equiv_unify FirstOrder.Language.DirectLimit.relMap_equiv_unify
 
-/-- The direct limit `setoid` respects the structure `sigma_structure`, so quotienting by it
+/-- The direct limit `setoid` respects the structure `sigmaStructure`, so quotienting by it
   gives rise to a valid structure. -/
 noncomputable instance prestructure : L.Prestructure (DirectLimit.setoid G f) where
   toStructure := sigmaStructure G f
@@ -249,9 +249,8 @@ noncomputable instance prestructure : L.Prestructure (DirectLimit.setoid G f) wh
 /-- The `L.Structure` on a direct limit of `L.Structure`s. -/
 noncomputable instance instStructureDirectLimit : L.Structure (DirectLimit G f) :=
   Language.quotientStructure
-set_option linter.uppercaseLean3 false
+set_option linter.uppercaseLean3 false in
 #align first_order.language.direct_limit.Structure FirstOrder.Language.DirectLimit.instStructureDirectLimit
-set_option linter.uppercaseLean3 true
 
 @[simp]
 theorem funMap_quotient_mk'_sigma_mk' {n : ℕ} {F : L.Functions n} {i : ι} {x : Fin n → G i} :
@@ -342,8 +341,6 @@ variable {P : Type u₁} [L.Structure P] (g : ∀ i, G i ↪[L] P)
 
 variable (Hg : ∀ i j hij x, g j (f i j hij x) = g i x)
 
---Porting note: removed `include Hg`
-
 variable (L ι G f)
 
 /-- The universal property of the direct limit: maps from the components to another module
@@ -378,9 +375,6 @@ def lift : DirectLimit G f ↪[L] P where
 
 variable {L ι G f}
 
---Porting note: removed `omit Hg`
-
-
 @[simp]
 theorem lift_quotient_mk'_sigma_mk' {i} (x : G i) : lift L ι G f g Hg ⟦.mk f i x⟧ = (g i) x := by
   change (lift L ι G f g Hg).toFun ⟦.mk f i x⟧ = _

f53b2399

feat: port ModelTheory.Fraisse (#4565)

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: Xavier-François Roblot <46200072+xroblot@users.noreply.github.com> Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Matthew Ballard <matt@mrb.email>

b07960ca

Diff

@@ -398,7 +398,7 @@ theorem lift_unique (F : DirectLimit G f ↪[L] P) (x) :
 #align first_order.language.direct_limit.lift_unique FirstOrder.Language.DirectLimit.lift_unique
 
 /-- The direct limit of countably many countably generated structures is countably generated. -/
-theorem cG {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
+theorem cg {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     (h : ∀ i, Structure.CG L (G i)) [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) := by
@@ -413,13 +413,13 @@ theorem cG {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)
     · rw [(Classical.choose_spec (h (out x).1).out).2]
       trivial
     · simp only [Embedding.coe_toHom, DirectLimit.of_apply, Sigma.eta, Quotient.out_eq]
-#align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cG
+#align first_order.language.direct_limit.cg FirstOrder.Language.DirectLimit.cg
 
 instance cg' {ι : Type _} [Encodable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] [Nonempty ι]
     {G : ι → Type w} [∀ i, L.Structure (G i)] (f : ∀ i j, i ≤ j → G i ↪[L] G j)
     [h : ∀ i, Structure.CG L (G i)] [DirectedSystem G fun i j h => f i j h] :
     Structure.CG L (DirectLimit G f) :=
-  cG f h
+  cg f h
 #align first_order.language.direct_limit.cg' FirstOrder.Language.DirectLimit.cg'
 
 end DirectLimit

f53b2399

feat: port ModelTheory.DirectLimit (#4391)

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Kyle Miller <kmill31415@gmail.com>

d57f6f35

`model_theory.direct_limit` ⟷ `Mathlib.ModelTheory.DirectLimit`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 527

model_theory.direct_limit ⟷ Mathlib.ModelTheory.DirectLimit

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 527

`model_theory.direct_limit` ⟷ `Mathlib.ModelTheory.DirectLimit`