category_theory.limits.filtered_colimit_commutes_finite_limit

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

3f409bd9

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

f2b757fc

bump to nightly-2024-04-14-09

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

f736ea6b

Diff

@@ -361,7 +361,8 @@ end
 attribute [local instance] reflects_limits_of_shape_of_reflects_isomorphisms
 
 noncomputable instance [PreservesFiniteLimits (forget C)] [PreservesFilteredColimits (forget C)]
-    [HasFiniteLimits C] [HasColimitsOfShape K C] [ReflectsIsomorphisms (forget C)] :
+    [HasFiniteLimits C] [HasColimitsOfShape K C]
+    [CategoryTheory.Functor.ReflectsIsomorphisms (forget C)] :
     PreservesFiniteLimits (colim : (K ⥤ C) ⥤ _) :=
   by
   apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{v}

f2b757fc

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -74,13 +74,13 @@ theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitT
   -- These elements of the colimit have representatives somewhere:
   obtain ⟨kx, x, rfl⟩ := jointly_surjective'.{v, v} x
   obtain ⟨ky, y, rfl⟩ := jointly_surjective'.{v, v} y
-  dsimp at x y 
+  dsimp at x y
   -- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
   -- (indexed by `j : J`),
   replace h := fun j => congr_arg (limit.π (curry.obj F ⋙ colim) j) h
   -- and they are equations in a filtered colimit,
   -- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
-  simp [colimit_eq_iff.{v, v}] at h 
+  simp [colimit_eq_iff.{v, v}] at h
   let k j := (h j).some
   let f : ∀ j, kx ⟶ k j := fun j => (h j).choose_spec.some
   let g : ∀ j, ky ⟶ k j := fun j => (h j).choose_spec.choose_spec.some
@@ -187,7 +187,7 @@ theorem colimitLimitToLimitColimit_surjective :
   -- Because `K` is filtered, we can restate this as saying that
   -- for each such `f`, there is some place to the right of `k'`
   -- where these images of `y j` and `y j'` become equal.
-  simp_rw [colimit_eq_iff.{v, v}] at w 
+  simp_rw [colimit_eq_iff.{v, v}] at w
   -- We take a moment to restate `w` more conveniently.
   let kf : ∀ {j j'} (f : j ⟶ j'), K := fun _ _ f => (w f).some
   let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.some
@@ -202,8 +202,8 @@ theorem colimitLimitToLimitColimit_surjective :
       ((curry.obj F).obj j').map (gf f) (F.map _ (y j')) =
         ((curry.obj F).obj j').map (hf f) (F.map _ (y j)) :=
       (w f).choose_spec.choose_spec.choose_spec
-    dsimp at q 
-    simp_rw [← functor_to_types.map_comp_apply] at q 
+    dsimp at q
+    simp_rw [← functor_to_types.map_comp_apply] at q
     convert q <;> simp only [comp_id]
   clear_value kf gf hf
   -- and clean up some things that are no longer needed.

f2b757fc

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -65,24 +65,74 @@ variable [Finite J]
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 -/
 theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitToLimitColimit F) :=
-  by classical
+  by
+  classical
+  cases nonempty_fintype J
+  -- Suppose we have two terms `x y` in the colimit (over `K`) of the limits (over `J`),
+  -- and that these have the same image under `colimit_limit_to_limit_colimit F`.
+  intro x y h
+  -- These elements of the colimit have representatives somewhere:
+  obtain ⟨kx, x, rfl⟩ := jointly_surjective'.{v, v} x
+  obtain ⟨ky, y, rfl⟩ := jointly_surjective'.{v, v} y
+  dsimp at x y 
+  -- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
+  -- (indexed by `j : J`),
+  replace h := fun j => congr_arg (limit.π (curry.obj F ⋙ colim) j) h
+  -- and they are equations in a filtered colimit,
+  -- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
+  simp [colimit_eq_iff.{v, v}] at h 
+  let k j := (h j).some
+  let f : ∀ j, kx ⟶ k j := fun j => (h j).choose_spec.some
+  let g : ∀ j, ky ⟶ k j := fun j => (h j).choose_spec.choose_spec.some
+  -- where the images of the components of the representatives become equal:
+  have w :
+    ∀ j,
+      F.map ((𝟙 j, f j) : (j, kx) ⟶ (j, k j)) (limit.π ((curry.obj (swap K J ⋙ F)).obj kx) j x) =
+        F.map ((𝟙 j, g j) : (j, ky) ⟶ (j, k j)) (limit.π ((curry.obj (swap K J ⋙ F)).obj ky) j y) :=
+    fun j => (h j).choose_spec.choose_spec.choose_spec
+  -- We now use that `K` is filtered, picking some point to the right of all these
+  -- morphisms `f j` and `g j`.
+  let O : Finset K := finset.univ.image k ∪ {kx, ky}
+  have kxO : kx ∈ O := finset.mem_union.mpr (Or.inr (by simp))
+  have kyO : ky ∈ O := finset.mem_union.mpr (Or.inr (by simp))
+  have kjO : ∀ j, k j ∈ O := fun j => finset.mem_union.mpr (Or.inl (by simp))
+  let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
+    (Finset.univ.image fun j : J => ⟨kx, k j, kxO, finset.mem_union.mpr (Or.inl (by simp)), f j⟩) ∪
+      Finset.univ.image fun j : J => ⟨ky, k j, kyO, finset.mem_union.mpr (Or.inl (by simp)), g j⟩
+  obtain ⟨S, T, W⟩ := is_filtered.sup_exists O H
+  have fH : ∀ j, (⟨kx, k j, kxO, kjO j, f j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
+    fun j =>
+    finset.mem_union.mpr
+      (Or.inl
+        (by
+          simp only [true_and_iff, Finset.mem_univ, eq_self_iff_true, exists_prop_of_true,
+            Finset.mem_image, heq_iff_eq]
+          refine' ⟨j, rfl, _⟩
+          simp only [heq_iff_eq]
+          exact ⟨rfl, rfl, rfl⟩))
+  have gH : ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
+    fun j =>
+    finset.mem_union.mpr
+      (Or.inr
+        (by
+          simp only [true_and_iff, Finset.mem_univ, eq_self_iff_true, exists_prop_of_true,
+            Finset.mem_image, heq_iff_eq]
+          refine' ⟨j, rfl, _⟩
+          simp only [heq_iff_eq]
+          exact ⟨rfl, rfl, rfl⟩))
+  -- Our goal is now an equation between equivalence classes of representatives of a colimit,
+  -- and so it suffices to show those representative become equal somewhere, in particular at `S`.
+  apply colimit_sound'.{v, v} (T kxO) (T kyO)
+  -- We can check if two elements of a limit (in `Type`) are equal by comparing them componentwise.
+  ext
+  -- Now it's just a calculation using `W` and `w`.
+  simp only [functor.comp_map, limit.map_π_apply, curry_obj_map_app, swap_map]
+  rw [← W _ _ (fH j)]
+  rw [← W _ _ (gH j)]
+  simp [w]
 #align category_theory.limits.colimit_limit_to_limit_colimit_injective CategoryTheory.Limits.colimitLimitToLimitColimit_injective
 -/
 
--- Suppose we have two terms `x y` in the colimit (over `K`) of the limits (over `J`),
--- and that these have the same image under `colimit_limit_to_limit_colimit F`.
--- These elements of the colimit have representatives somewhere:
--- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
--- (indexed by `j : J`),
--- and they are equations in a filtered colimit,
--- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
--- where the images of the components of the representatives become equal:
--- We now use that `K` is filtered, picking some point to the right of all these
--- morphisms `f j` and `g j`.
--- Our goal is now an equation between equivalence classes of representatives of a colimit,
--- and so it suffices to show those representative become equal somewhere, in particular at `S`.
--- We can check if two elements of a limit (in `Type`) are equal by comparing them componentwise.
--- Now it's just a calculation using `W` and `w`.
 end
 
 variable [FinCategory J]
@@ -93,49 +143,169 @@ variable [FinCategory J]
 although with different names.
 -/
 theorem colimitLimitToLimitColimit_surjective :
-    Function.Surjective (colimitLimitToLimitColimit F) := by classical
+    Function.Surjective (colimitLimitToLimitColimit F) := by
+  classical
+  -- We begin with some element `x` in the limit (over J) over the colimits (over K),
+  intro x
+  -- This consists of some coherent family of elements in the various colimits,
+  -- and so our first task is to pick representatives of these elements.
+  have z := fun j => jointly_surjective'.{v, v} (limit.π (curry.obj F ⋙ limits.colim) j x)
+  -- `k : J ⟶ K` records where the representative of the element in the `j`-th element of `x` lives
+  let k : J → K := fun j => (z j).some
+  -- `y j : F.obj (j, k j)` is the representative
+  let y : ∀ j, F.obj (j, k j) := fun j => (z j).choose_spec.some
+  -- and we record that these representatives, when mapped back into the relevant colimits,
+  -- are actually the components of `x`.
+  have e :
+    ∀ j, colimit.ι ((curry.obj F).obj j) (k j) (y j) = limit.π (curry.obj F ⋙ limits.colim) j x :=
+    fun j => (z j).choose_spec.choose_spec
+  clear_value k y
+  -- A little tidying up of things we no longer need.
+  clear z
+  -- As a first step, we use that `K` is filtered to pick some point `k' : K` above all the `k j`
+  let k' : K := is_filtered.sup (finset.univ.image k) ∅
+  -- and name the morphisms as `g j : k j ⟶ k'`.
+  have g : ∀ j, k j ⟶ k' := fun j => is_filtered.to_sup (finset.univ.image k) ∅ (by simp)
+  clear_value k'
+  -- Recalling that the components of `x`, which are indexed by `j : J`, are "coherent",
+  -- in other words preserved by morphisms in the `J` direction,
+  -- we see that for any morphism `f : j ⟶ j'` in `J`,
+  -- the images of `y j` and `y j'`, when mapped to `F.obj (j', k')` respectively by
+  -- `(f, g j)` and `(𝟙 j', g j')`, both represent the same element in the colimit.
+  have w :
+    ∀ {j j' : J} (f : j ⟶ j'),
+      colimit.ι ((curry.obj F).obj j') k' (F.map ((𝟙 j', g j') : (j', k j') ⟶ (j', k')) (y j')) =
+        colimit.ι ((curry.obj F).obj j') k' (F.map ((f, g j) : (j, k j) ⟶ (j', k')) (y j)) :=
+    by
+    intro j j' f
+    have t :
+      (f, g j) = (((f, 𝟙 (k j)) : (j, k j) ⟶ (j', k j)) ≫ (𝟙 j', g j) : (j, k j) ⟶ (j', k')) := by
+      simp only [id_comp, comp_id, prod_comp]
+    erw [colimit.w_apply', t, functor_to_types.map_comp_apply, colimit.w_apply', e, ←
+      limit.w_apply' f, ← e]
+    simp
+  -- Because `K` is filtered, we can restate this as saying that
+  -- for each such `f`, there is some place to the right of `k'`
+  -- where these images of `y j` and `y j'` become equal.
+  simp_rw [colimit_eq_iff.{v, v}] at w 
+  -- We take a moment to restate `w` more conveniently.
+  let kf : ∀ {j j'} (f : j ⟶ j'), K := fun _ _ f => (w f).some
+  let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.some
+  let hf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.choose_spec.some
+  have wf :
+    ∀ {j j'} (f : j ⟶ j'),
+      F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j') =
+        F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j) :=
+    fun j j' f =>
+    by
+    have q :
+      ((curry.obj F).obj j').map (gf f) (F.map _ (y j')) =
+        ((curry.obj F).obj j').map (hf f) (F.map _ (y j)) :=
+      (w f).choose_spec.choose_spec.choose_spec
+    dsimp at q 
+    simp_rw [← functor_to_types.map_comp_apply] at q 
+    convert q <;> simp only [comp_id]
+  clear_value kf gf hf
+  -- and clean up some things that are no longer needed.
+  clear w
+  -- We're now ready to use the fact that `K` is filtered a second time,
+  -- picking some place to the right of all of
+  -- the morphisms `gf f : k' ⟶ kh f` and `hf f : k' ⟶ kf f`.
+  -- At this point we're relying on there being only finitely morphisms in `J`.
+  let O :=
+    (finset.univ.bUnion fun j => finset.univ.bUnion fun j' => finset.univ.image (@kf j j')) ∪ {k'}
+  have kfO : ∀ {j j'} (f : j ⟶ j'), kf f ∈ O := fun j j' f =>
+    finset.mem_union.mpr
+      (Or.inl
+        (by
+          rw [Finset.mem_biUnion]
+          refine' ⟨j, Finset.mem_univ j, _⟩
+          rw [Finset.mem_biUnion]
+          refine' ⟨j', Finset.mem_univ j', _⟩
+          rw [Finset.mem_image]
+          refine' ⟨f, Finset.mem_univ _, _⟩
+          rfl))
+  have k'O : k' ∈ O := finset.mem_union.mpr (Or.inr (finset.mem_singleton.mpr rfl))
+  let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
+    finset.univ.bUnion fun j : J =>
+      finset.univ.bUnion fun j' : J =>
+        finset.univ.bUnion fun f : j ⟶ j' =>
+          {⟨k', kf f, k'O, kfO f, gf f⟩, ⟨k', kf f, k'O, kfO f, hf f⟩}
+  obtain ⟨k'', i', s'⟩ := is_filtered.sup_exists O H
+  -- We then restate this slightly more conveniently, as a family of morphism `i f : kf f ⟶ k''`,
+  -- satisfying `gf f ≫ i f = hf f' ≫ i f'`.
+  let i : ∀ {j j'} (f : j ⟶ j'), kf f ⟶ k'' := fun j j' f => i' (kfO f)
+  have s : ∀ {j₁ j₂ j₃ j₄} (f : j₁ ⟶ j₂) (f' : j₃ ⟶ j₄), gf f ≫ i f = hf f' ≫ i f' :=
+    by
+    intros
+    rw [s', s']
+    swap
+    exact k'O
+    swap
+    · rw [Finset.mem_biUnion]
+      refine' ⟨j₁, Finset.mem_univ _, _⟩
+      rw [Finset.mem_biUnion]
+      refine' ⟨j₂, Finset.mem_univ _, _⟩
+      rw [Finset.mem_biUnion]
+      refine' ⟨f, Finset.mem_univ _, _⟩
+      simp only [true_or_iff, eq_self_iff_true, and_self_iff, Finset.mem_insert, heq_iff_eq]
+    · rw [Finset.mem_biUnion]
+      refine' ⟨j₃, Finset.mem_univ _, _⟩
+      rw [Finset.mem_biUnion]
+      refine' ⟨j₄, Finset.mem_univ _, _⟩
+      rw [Finset.mem_biUnion]
+      refine' ⟨f', Finset.mem_univ _, _⟩
+      simp only [eq_self_iff_true, or_true_iff, and_self_iff, Finset.mem_insert,
+        Finset.mem_singleton, heq_iff_eq]
+  clear_value i
+  clear s' i' H kfO k'O O
+  -- We're finally ready to construct the pre-image, and verify it really maps to `x`.
+  fconstructor
+  · -- We construct the pre-image (which, recall is meant to be a point
+    -- in the colimit (over `K`) of the limits (over `J`)) via a representative at `k''`.
+    apply colimit.ι (curry.obj (swap K J ⋙ F) ⋙ limits.lim) k'' _
+    dsimp
+    -- This representative is meant to be an element of a limit,
+    -- so we need to construct a family of elements in `F.obj (j, k'')` for varying `j`,
+    -- then show that are coherent with respect to morphisms in the `j` direction.
+    apply Limit.mk.{v, v};
+    swap
+    ·-- We construct the elements as the images of the `y j`.
+      exact fun j => F.map (⟨𝟙 j, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)⟩ : (j, k j) ⟶ (j, k'')) (y j)
+    · -- After which it's just a calculation, using `s` and `wf`, to see they are coherent.
+      dsimp
+      intro j j' f
+      simp only [← functor_to_types.map_comp_apply, prod_comp, id_comp, comp_id]
+      calc
+        F.map ((f, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)) : (j, k j) ⟶ (j', k'')) (y j) =
+            F.map ((f, g j ≫ hf f ≫ i f) : (j, k j) ⟶ (j', k'')) (y j) :=
+          by rw [s (𝟙 j) f]
+        _ =
+            F.map ((𝟙 j', i f) : (j', kf f) ⟶ (j', k''))
+              (F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j)) :=
+          by rw [← functor_to_types.map_comp_apply, prod_comp, comp_id, assoc]
+        _ =
+            F.map ((𝟙 j', i f) : (j', kf f) ⟶ (j', k''))
+              (F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j')) :=
+          by rw [← wf f]
+        _ = F.map ((𝟙 j', g j' ≫ gf f ≫ i f) : (j', k j') ⟶ (j', k'')) (y j') := by
+          rw [← functor_to_types.map_comp_apply, prod_comp, id_comp, assoc]
+        _ = F.map ((𝟙 j', g j' ≫ gf (𝟙 j') ≫ i (𝟙 j')) : (j', k j') ⟶ (j', k'')) (y j') := by
+          rw [s f (𝟙 j'), ← s (𝟙 j') (𝟙 j')]
+  -- Finally we check that this maps to `x`.
+  · -- We can do this componentwise:
+    apply limit_ext'
+    intro j
+    -- and as each component is an equation in a colimit, we can verify it by
+    -- pointing out the morphism which carries one representative to the other:
+    simp only [← e, colimit_eq_iff.{v, v}, curry_obj_obj_map, limit.π_mk', bifunctor.map_id_comp,
+      id.def, types_comp_apply, limits.ι_colimit_limit_to_limit_colimit_π_apply]
+    refine' ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), _⟩
+    simp only [bifunctor.map_id_comp, types_comp_apply, bifunctor.map_id, types_id_apply]
 #align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjective
 -/
 
 #print CategoryTheory.Limits.colimitLimitToLimitColimit_isIso /-
--- We begin with some element `x` in the limit (over J) over the colimits (over K),
--- This consists of some coherent family of elements in the various colimits,
--- and so our first task is to pick representatives of these elements.
--- `k : J ⟶ K` records where the representative of the element in the `j`-th element of `x` lives
--- `y j : F.obj (j, k j)` is the representative
--- and we record that these representatives, when mapped back into the relevant colimits,
--- are actually the components of `x`.
--- A little tidying up of things we no longer need.
--- As a first step, we use that `K` is filtered to pick some point `k' : K` above all the `k j`
--- and name the morphisms as `g j : k j ⟶ k'`.
--- Recalling that the components of `x`, which are indexed by `j : J`, are "coherent",
--- in other words preserved by morphisms in the `J` direction,
--- we see that for any morphism `f : j ⟶ j'` in `J`,
--- the images of `y j` and `y j'`, when mapped to `F.obj (j', k')` respectively by
--- `(f, g j)` and `(𝟙 j', g j')`, both represent the same element in the colimit.
--- Because `K` is filtered, we can restate this as saying that
--- for each such `f`, there is some place to the right of `k'`
--- where these images of `y j` and `y j'` become equal.
--- We take a moment to restate `w` more conveniently.
--- and clean up some things that are no longer needed.
--- We're now ready to use the fact that `K` is filtered a second time,
--- picking some place to the right of all of
--- the morphisms `gf f : k' ⟶ kh f` and `hf f : k' ⟶ kf f`.
--- At this point we're relying on there being only finitely morphisms in `J`.
--- We then restate this slightly more conveniently, as a family of morphism `i f : kf f ⟶ k''`,
--- satisfying `gf f ≫ i f = hf f' ≫ i f'`.
--- We're finally ready to construct the pre-image, and verify it really maps to `x`.
--- We construct the pre-image (which, recall is meant to be a point
--- in the colimit (over `K`) of the limits (over `J`)) via a representative at `k''`.
--- This representative is meant to be an element of a limit,
--- so we need to construct a family of elements in `F.obj (j, k'')` for varying `j`,
--- then show that are coherent with respect to morphisms in the `j` direction.
--- We construct the elements as the images of the `y j`.
--- After which it's just a calculation, using `s` and `wf`, to see they are coherent.
--- Finally we check that this maps to `x`.
--- We can do this componentwise:
--- and as each component is an equation in a colimit, we can verify it by
--- pointing out the morphism which carries one representative to the other:
 instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F) :=
   (isIso_iff_bijective _).mpr
     ⟨colimitLimitToLimitColimit_injective F, colimitLimitToLimitColimit_surjective F⟩

f2b757fc

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -65,74 +65,24 @@ variable [Finite J]
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 -/
 theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitToLimitColimit F) :=
-  by
-  classical
-  cases nonempty_fintype J
-  -- Suppose we have two terms `x y` in the colimit (over `K`) of the limits (over `J`),
-  -- and that these have the same image under `colimit_limit_to_limit_colimit F`.
-  intro x y h
-  -- These elements of the colimit have representatives somewhere:
-  obtain ⟨kx, x, rfl⟩ := jointly_surjective'.{v, v} x
-  obtain ⟨ky, y, rfl⟩ := jointly_surjective'.{v, v} y
-  dsimp at x y 
-  -- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
-  -- (indexed by `j : J`),
-  replace h := fun j => congr_arg (limit.π (curry.obj F ⋙ colim) j) h
-  -- and they are equations in a filtered colimit,
-  -- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
-  simp [colimit_eq_iff.{v, v}] at h 
-  let k j := (h j).some
-  let f : ∀ j, kx ⟶ k j := fun j => (h j).choose_spec.some
-  let g : ∀ j, ky ⟶ k j := fun j => (h j).choose_spec.choose_spec.some
-  -- where the images of the components of the representatives become equal:
-  have w :
-    ∀ j,
-      F.map ((𝟙 j, f j) : (j, kx) ⟶ (j, k j)) (limit.π ((curry.obj (swap K J ⋙ F)).obj kx) j x) =
-        F.map ((𝟙 j, g j) : (j, ky) ⟶ (j, k j)) (limit.π ((curry.obj (swap K J ⋙ F)).obj ky) j y) :=
-    fun j => (h j).choose_spec.choose_spec.choose_spec
-  -- We now use that `K` is filtered, picking some point to the right of all these
-  -- morphisms `f j` and `g j`.
-  let O : Finset K := finset.univ.image k ∪ {kx, ky}
-  have kxO : kx ∈ O := finset.mem_union.mpr (Or.inr (by simp))
-  have kyO : ky ∈ O := finset.mem_union.mpr (Or.inr (by simp))
-  have kjO : ∀ j, k j ∈ O := fun j => finset.mem_union.mpr (Or.inl (by simp))
-  let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
-    (Finset.univ.image fun j : J => ⟨kx, k j, kxO, finset.mem_union.mpr (Or.inl (by simp)), f j⟩) ∪
-      Finset.univ.image fun j : J => ⟨ky, k j, kyO, finset.mem_union.mpr (Or.inl (by simp)), g j⟩
-  obtain ⟨S, T, W⟩ := is_filtered.sup_exists O H
-  have fH : ∀ j, (⟨kx, k j, kxO, kjO j, f j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
-    fun j =>
-    finset.mem_union.mpr
-      (Or.inl
-        (by
-          simp only [true_and_iff, Finset.mem_univ, eq_self_iff_true, exists_prop_of_true,
-            Finset.mem_image, heq_iff_eq]
-          refine' ⟨j, rfl, _⟩
-          simp only [heq_iff_eq]
-          exact ⟨rfl, rfl, rfl⟩))
-  have gH : ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
-    fun j =>
-    finset.mem_union.mpr
-      (Or.inr
-        (by
-          simp only [true_and_iff, Finset.mem_univ, eq_self_iff_true, exists_prop_of_true,
-            Finset.mem_image, heq_iff_eq]
-          refine' ⟨j, rfl, _⟩
-          simp only [heq_iff_eq]
-          exact ⟨rfl, rfl, rfl⟩))
-  -- Our goal is now an equation between equivalence classes of representatives of a colimit,
-  -- and so it suffices to show those representative become equal somewhere, in particular at `S`.
-  apply colimit_sound'.{v, v} (T kxO) (T kyO)
-  -- We can check if two elements of a limit (in `Type`) are equal by comparing them componentwise.
-  ext
-  -- Now it's just a calculation using `W` and `w`.
-  simp only [functor.comp_map, limit.map_π_apply, curry_obj_map_app, swap_map]
-  rw [← W _ _ (fH j)]
-  rw [← W _ _ (gH j)]
-  simp [w]
+  by classical
 #align category_theory.limits.colimit_limit_to_limit_colimit_injective CategoryTheory.Limits.colimitLimitToLimitColimit_injective
 -/
 
+-- Suppose we have two terms `x y` in the colimit (over `K`) of the limits (over `J`),
+-- and that these have the same image under `colimit_limit_to_limit_colimit F`.
+-- These elements of the colimit have representatives somewhere:
+-- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
+-- (indexed by `j : J`),
+-- and they are equations in a filtered colimit,
+-- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
+-- where the images of the components of the representatives become equal:
+-- We now use that `K` is filtered, picking some point to the right of all these
+-- morphisms `f j` and `g j`.
+-- Our goal is now an equation between equivalence classes of representatives of a colimit,
+-- and so it suffices to show those representative become equal somewhere, in particular at `S`.
+-- We can check if two elements of a limit (in `Type`) are equal by comparing them componentwise.
+-- Now it's just a calculation using `W` and `w`.
 end
 
 variable [FinCategory J]
@@ -143,169 +93,49 @@ variable [FinCategory J]
 although with different names.
 -/
 theorem colimitLimitToLimitColimit_surjective :
-    Function.Surjective (colimitLimitToLimitColimit F) := by
-  classical
-  -- We begin with some element `x` in the limit (over J) over the colimits (over K),
-  intro x
-  -- This consists of some coherent family of elements in the various colimits,
-  -- and so our first task is to pick representatives of these elements.
-  have z := fun j => jointly_surjective'.{v, v} (limit.π (curry.obj F ⋙ limits.colim) j x)
-  -- `k : J ⟶ K` records where the representative of the element in the `j`-th element of `x` lives
-  let k : J → K := fun j => (z j).some
-  -- `y j : F.obj (j, k j)` is the representative
-  let y : ∀ j, F.obj (j, k j) := fun j => (z j).choose_spec.some
-  -- and we record that these representatives, when mapped back into the relevant colimits,
-  -- are actually the components of `x`.
-  have e :
-    ∀ j, colimit.ι ((curry.obj F).obj j) (k j) (y j) = limit.π (curry.obj F ⋙ limits.colim) j x :=
-    fun j => (z j).choose_spec.choose_spec
-  clear_value k y
-  -- A little tidying up of things we no longer need.
-  clear z
-  -- As a first step, we use that `K` is filtered to pick some point `k' : K` above all the `k j`
-  let k' : K := is_filtered.sup (finset.univ.image k) ∅
-  -- and name the morphisms as `g j : k j ⟶ k'`.
-  have g : ∀ j, k j ⟶ k' := fun j => is_filtered.to_sup (finset.univ.image k) ∅ (by simp)
-  clear_value k'
-  -- Recalling that the components of `x`, which are indexed by `j : J`, are "coherent",
-  -- in other words preserved by morphisms in the `J` direction,
-  -- we see that for any morphism `f : j ⟶ j'` in `J`,
-  -- the images of `y j` and `y j'`, when mapped to `F.obj (j', k')` respectively by
-  -- `(f, g j)` and `(𝟙 j', g j')`, both represent the same element in the colimit.
-  have w :
-    ∀ {j j' : J} (f : j ⟶ j'),
-      colimit.ι ((curry.obj F).obj j') k' (F.map ((𝟙 j', g j') : (j', k j') ⟶ (j', k')) (y j')) =
-        colimit.ι ((curry.obj F).obj j') k' (F.map ((f, g j) : (j, k j) ⟶ (j', k')) (y j)) :=
-    by
-    intro j j' f
-    have t :
-      (f, g j) = (((f, 𝟙 (k j)) : (j, k j) ⟶ (j', k j)) ≫ (𝟙 j', g j) : (j, k j) ⟶ (j', k')) := by
-      simp only [id_comp, comp_id, prod_comp]
-    erw [colimit.w_apply', t, functor_to_types.map_comp_apply, colimit.w_apply', e, ←
-      limit.w_apply' f, ← e]
-    simp
-  -- Because `K` is filtered, we can restate this as saying that
-  -- for each such `f`, there is some place to the right of `k'`
-  -- where these images of `y j` and `y j'` become equal.
-  simp_rw [colimit_eq_iff.{v, v}] at w 
-  -- We take a moment to restate `w` more conveniently.
-  let kf : ∀ {j j'} (f : j ⟶ j'), K := fun _ _ f => (w f).some
-  let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.some
-  let hf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.choose_spec.some
-  have wf :
-    ∀ {j j'} (f : j ⟶ j'),
-      F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j') =
-        F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j) :=
-    fun j j' f =>
-    by
-    have q :
-      ((curry.obj F).obj j').map (gf f) (F.map _ (y j')) =
-        ((curry.obj F).obj j').map (hf f) (F.map _ (y j)) :=
-      (w f).choose_spec.choose_spec.choose_spec
-    dsimp at q 
-    simp_rw [← functor_to_types.map_comp_apply] at q 
-    convert q <;> simp only [comp_id]
-  clear_value kf gf hf
-  -- and clean up some things that are no longer needed.
-  clear w
-  -- We're now ready to use the fact that `K` is filtered a second time,
-  -- picking some place to the right of all of
-  -- the morphisms `gf f : k' ⟶ kh f` and `hf f : k' ⟶ kf f`.
-  -- At this point we're relying on there being only finitely morphisms in `J`.
-  let O :=
-    (finset.univ.bUnion fun j => finset.univ.bUnion fun j' => finset.univ.image (@kf j j')) ∪ {k'}
-  have kfO : ∀ {j j'} (f : j ⟶ j'), kf f ∈ O := fun j j' f =>
-    finset.mem_union.mpr
-      (Or.inl
-        (by
-          rw [Finset.mem_biUnion]
-          refine' ⟨j, Finset.mem_univ j, _⟩
-          rw [Finset.mem_biUnion]
-          refine' ⟨j', Finset.mem_univ j', _⟩
-          rw [Finset.mem_image]
-          refine' ⟨f, Finset.mem_univ _, _⟩
-          rfl))
-  have k'O : k' ∈ O := finset.mem_union.mpr (Or.inr (finset.mem_singleton.mpr rfl))
-  let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
-    finset.univ.bUnion fun j : J =>
-      finset.univ.bUnion fun j' : J =>
-        finset.univ.bUnion fun f : j ⟶ j' =>
-          {⟨k', kf f, k'O, kfO f, gf f⟩, ⟨k', kf f, k'O, kfO f, hf f⟩}
-  obtain ⟨k'', i', s'⟩ := is_filtered.sup_exists O H
-  -- We then restate this slightly more conveniently, as a family of morphism `i f : kf f ⟶ k''`,
-  -- satisfying `gf f ≫ i f = hf f' ≫ i f'`.
-  let i : ∀ {j j'} (f : j ⟶ j'), kf f ⟶ k'' := fun j j' f => i' (kfO f)
-  have s : ∀ {j₁ j₂ j₃ j₄} (f : j₁ ⟶ j₂) (f' : j₃ ⟶ j₄), gf f ≫ i f = hf f' ≫ i f' :=
-    by
-    intros
-    rw [s', s']
-    swap
-    exact k'O
-    swap
-    · rw [Finset.mem_biUnion]
-      refine' ⟨j₁, Finset.mem_univ _, _⟩
-      rw [Finset.mem_biUnion]
-      refine' ⟨j₂, Finset.mem_univ _, _⟩
-      rw [Finset.mem_biUnion]
-      refine' ⟨f, Finset.mem_univ _, _⟩
-      simp only [true_or_iff, eq_self_iff_true, and_self_iff, Finset.mem_insert, heq_iff_eq]
-    · rw [Finset.mem_biUnion]
-      refine' ⟨j₃, Finset.mem_univ _, _⟩
-      rw [Finset.mem_biUnion]
-      refine' ⟨j₄, Finset.mem_univ _, _⟩
-      rw [Finset.mem_biUnion]
-      refine' ⟨f', Finset.mem_univ _, _⟩
-      simp only [eq_self_iff_true, or_true_iff, and_self_iff, Finset.mem_insert,
-        Finset.mem_singleton, heq_iff_eq]
-  clear_value i
-  clear s' i' H kfO k'O O
-  -- We're finally ready to construct the pre-image, and verify it really maps to `x`.
-  fconstructor
-  · -- We construct the pre-image (which, recall is meant to be a point
-    -- in the colimit (over `K`) of the limits (over `J`)) via a representative at `k''`.
-    apply colimit.ι (curry.obj (swap K J ⋙ F) ⋙ limits.lim) k'' _
-    dsimp
-    -- This representative is meant to be an element of a limit,
-    -- so we need to construct a family of elements in `F.obj (j, k'')` for varying `j`,
-    -- then show that are coherent with respect to morphisms in the `j` direction.
-    apply Limit.mk.{v, v};
-    swap
-    ·-- We construct the elements as the images of the `y j`.
-      exact fun j => F.map (⟨𝟙 j, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)⟩ : (j, k j) ⟶ (j, k'')) (y j)
-    · -- After which it's just a calculation, using `s` and `wf`, to see they are coherent.
-      dsimp
-      intro j j' f
-      simp only [← functor_to_types.map_comp_apply, prod_comp, id_comp, comp_id]
-      calc
-        F.map ((f, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)) : (j, k j) ⟶ (j', k'')) (y j) =
-            F.map ((f, g j ≫ hf f ≫ i f) : (j, k j) ⟶ (j', k'')) (y j) :=
-          by rw [s (𝟙 j) f]
-        _ =
-            F.map ((𝟙 j', i f) : (j', kf f) ⟶ (j', k''))
-              (F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j)) :=
-          by rw [← functor_to_types.map_comp_apply, prod_comp, comp_id, assoc]
-        _ =
-            F.map ((𝟙 j', i f) : (j', kf f) ⟶ (j', k''))
-              (F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j')) :=
-          by rw [← wf f]
-        _ = F.map ((𝟙 j', g j' ≫ gf f ≫ i f) : (j', k j') ⟶ (j', k'')) (y j') := by
-          rw [← functor_to_types.map_comp_apply, prod_comp, id_comp, assoc]
-        _ = F.map ((𝟙 j', g j' ≫ gf (𝟙 j') ≫ i (𝟙 j')) : (j', k j') ⟶ (j', k'')) (y j') := by
-          rw [s f (𝟙 j'), ← s (𝟙 j') (𝟙 j')]
-  -- Finally we check that this maps to `x`.
-  · -- We can do this componentwise:
-    apply limit_ext'
-    intro j
-    -- and as each component is an equation in a colimit, we can verify it by
-    -- pointing out the morphism which carries one representative to the other:
-    simp only [← e, colimit_eq_iff.{v, v}, curry_obj_obj_map, limit.π_mk', bifunctor.map_id_comp,
-      id.def, types_comp_apply, limits.ι_colimit_limit_to_limit_colimit_π_apply]
-    refine' ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), _⟩
-    simp only [bifunctor.map_id_comp, types_comp_apply, bifunctor.map_id, types_id_apply]
+    Function.Surjective (colimitLimitToLimitColimit F) := by classical
 #align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjective
 -/
 
 #print CategoryTheory.Limits.colimitLimitToLimitColimit_isIso /-
+-- We begin with some element `x` in the limit (over J) over the colimits (over K),
+-- This consists of some coherent family of elements in the various colimits,
+-- and so our first task is to pick representatives of these elements.
+-- `k : J ⟶ K` records where the representative of the element in the `j`-th element of `x` lives
+-- `y j : F.obj (j, k j)` is the representative
+-- and we record that these representatives, when mapped back into the relevant colimits,
+-- are actually the components of `x`.
+-- A little tidying up of things we no longer need.
+-- As a first step, we use that `K` is filtered to pick some point `k' : K` above all the `k j`
+-- and name the morphisms as `g j : k j ⟶ k'`.
+-- Recalling that the components of `x`, which are indexed by `j : J`, are "coherent",
+-- in other words preserved by morphisms in the `J` direction,
+-- we see that for any morphism `f : j ⟶ j'` in `J`,
+-- the images of `y j` and `y j'`, when mapped to `F.obj (j', k')` respectively by
+-- `(f, g j)` and `(𝟙 j', g j')`, both represent the same element in the colimit.
+-- Because `K` is filtered, we can restate this as saying that
+-- for each such `f`, there is some place to the right of `k'`
+-- where these images of `y j` and `y j'` become equal.
+-- We take a moment to restate `w` more conveniently.
+-- and clean up some things that are no longer needed.
+-- We're now ready to use the fact that `K` is filtered a second time,
+-- picking some place to the right of all of
+-- the morphisms `gf f : k' ⟶ kh f` and `hf f : k' ⟶ kf f`.
+-- At this point we're relying on there being only finitely morphisms in `J`.
+-- We then restate this slightly more conveniently, as a family of morphism `i f : kf f ⟶ k''`,
+-- satisfying `gf f ≫ i f = hf f' ≫ i f'`.
+-- We're finally ready to construct the pre-image, and verify it really maps to `x`.
+-- We construct the pre-image (which, recall is meant to be a point
+-- in the colimit (over `K`) of the limits (over `J`)) via a representative at `k''`.
+-- This representative is meant to be an element of a limit,
+-- so we need to construct a family of elements in `F.obj (j, k'')` for varying `j`,
+-- then show that are coherent with respect to morphisms in the `j` direction.
+-- We construct the elements as the images of the `y j`.
+-- After which it's just a calculation, using `s` and `wf`, to see they are coherent.
+-- Finally we check that this maps to `x`.
+-- We can do this componentwise:
+-- and as each component is an equation in a colimit, we can verify it by
+-- pointing out the morphism which carries one representative to the other:
 instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F) :=
   (isIso_iff_bijective _).mpr
     ⟨colimitLimitToLimitColimit_injective F, colimitLimitToLimitColimit_surjective F⟩

f2b757fc

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,12 +3,12 @@ Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathbin.CategoryTheory.Limits.ColimitLimit
-import Mathbin.CategoryTheory.Limits.Preserves.FunctorCategory
-import Mathbin.CategoryTheory.Limits.Preserves.Finite
-import Mathbin.CategoryTheory.Limits.Shapes.FiniteLimits
-import Mathbin.CategoryTheory.Limits.Preserves.Filtered
-import Mathbin.CategoryTheory.ConcreteCategory.Basic
+import CategoryTheory.Limits.ColimitLimit
+import CategoryTheory.Limits.Preserves.FunctorCategory
+import CategoryTheory.Limits.Preserves.Finite
+import CategoryTheory.Limits.Shapes.FiniteLimits
+import CategoryTheory.Limits.Preserves.Filtered
+import CategoryTheory.ConcreteCategory.Basic
 
 #align_import category_theory.limits.filtered_colimit_commutes_finite_limit from "leanprover-community/mathlib"@"f2b757fc5c341d88741b9c4630b1e8ba973c5726"

f2b757fc

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,11 +2,6 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module category_theory.limits.filtered_colimit_commutes_finite_limit
-! leanprover-community/mathlib commit f2b757fc5c341d88741b9c4630b1e8ba973c5726
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Limits.ColimitLimit
 import Mathbin.CategoryTheory.Limits.Preserves.FunctorCategory
@@ -15,6 +10,8 @@ import Mathbin.CategoryTheory.Limits.Shapes.FiniteLimits
 import Mathbin.CategoryTheory.Limits.Preserves.Filtered
 import Mathbin.CategoryTheory.ConcreteCategory.Basic
 
+#align_import category_theory.limits.filtered_colimit_commutes_finite_limit from "leanprover-community/mathlib"@"f2b757fc5c341d88741b9c4630b1e8ba973c5726"
+
 /-!
 # Filtered colimits commute with finite limits.

f2b757fc

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -63,6 +63,7 @@ only that there are finitely many objects.
 
 variable [Finite J]
 
+#print CategoryTheory.Limits.colimitLimitToLimitColimit_injective /-
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 -/
@@ -133,11 +134,13 @@ theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitT
   rw [← W _ _ (gH j)]
   simp [w]
 #align category_theory.limits.colimit_limit_to_limit_colimit_injective CategoryTheory.Limits.colimitLimitToLimitColimit_injective
+-/
 
 end
 
 variable [FinCategory J]
 
+#print CategoryTheory.Limits.colimitLimitToLimitColimit_surjective /-
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 although with different names.
@@ -303,12 +306,16 @@ theorem colimitLimitToLimitColimit_surjective :
     refine' ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), _⟩
     simp only [bifunctor.map_id_comp, types_comp_apply, bifunctor.map_id, types_id_apply]
 #align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjective
+-/
 
+#print CategoryTheory.Limits.colimitLimitToLimitColimit_isIso /-
 instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F) :=
   (isIso_iff_bijective _).mpr
     ⟨colimitLimitToLimitColimit_injective F, colimitLimitToLimitColimit_surjective F⟩
 #align category_theory.limits.colimit_limit_to_limit_colimit_is_iso CategoryTheory.Limits.colimitLimitToLimitColimit_isIso
+-/
 
+#print CategoryTheory.Limits.colimitLimitToLimitColimitCone_iso /-
 instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
     IsIso (colimitLimitToLimitColimitCone F) :=
   by
@@ -316,6 +323,7 @@ instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
     dsimp only [colimit_limit_to_limit_colimit_cone]; infer_instance
   apply cones.cone_iso_of_hom_iso
 #align category_theory.limits.colimit_limit_to_limit_colimit_cone_iso CategoryTheory.Limits.colimitLimitToLimitColimitCone_iso
+-/
 
 #print CategoryTheory.Limits.filteredColimPreservesFiniteLimitsOfTypes /-
 noncomputable instance filteredColimPreservesFiniteLimitsOfTypes :
@@ -378,6 +386,7 @@ noncomputable def colimitLimitIso (F : J ⥤ K ⥤ C) : colimit (limit F) ≅ li
 #align category_theory.limits.colimit_limit_iso CategoryTheory.Limits.colimitLimitIso
 -/
 
+#print CategoryTheory.Limits.ι_colimitLimitIso_limit_π /-
 @[simp, reassoc]
 theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
     colimit.ι (limit F) a ≫ (colimitLimitIso F).Hom ≫ limit.π (colimit F.flip) b =
@@ -395,6 +404,7 @@ theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
   dsimp
   simp
 #align category_theory.limits.ι_colimit_limit_iso_limit_π CategoryTheory.Limits.ι_colimitLimitIso_limit_π
+-/
 
 end

f2b757fc

bump to nightly-2023-06-09-07

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

16afdc39

Diff

@@ -292,7 +292,6 @@ theorem colimitLimitToLimitColimit_surjective :
           rw [← functor_to_types.map_comp_apply, prod_comp, id_comp, assoc]
         _ = F.map ((𝟙 j', g j' ≫ gf (𝟙 j') ≫ i (𝟙 j')) : (j', k j') ⟶ (j', k'')) (y j') := by
           rw [s f (𝟙 j'), ← s (𝟙 j') (𝟙 j')]
-        
   -- Finally we check that this maps to `x`.
   · -- We can do this componentwise:
     apply limit_ext'

f2b757fc

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -69,73 +69,69 @@ variable [Finite J]
 theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitToLimitColimit F) :=
   by
   classical
-    cases nonempty_fintype J
-    -- Suppose we have two terms `x y` in the colimit (over `K`) of the limits (over `J`),
-    -- and that these have the same image under `colimit_limit_to_limit_colimit F`.
-    intro x y h
-    -- These elements of the colimit have representatives somewhere:
-    obtain ⟨kx, x, rfl⟩ := jointly_surjective'.{v, v} x
-    obtain ⟨ky, y, rfl⟩ := jointly_surjective'.{v, v} y
-    dsimp at x y 
-    -- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
-    -- (indexed by `j : J`),
-    replace h := fun j => congr_arg (limit.π (curry.obj F ⋙ colim) j) h
-    -- and they are equations in a filtered colimit,
-    -- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
-    simp [colimit_eq_iff.{v, v}] at h 
-    let k j := (h j).some
-    let f : ∀ j, kx ⟶ k j := fun j => (h j).choose_spec.some
-    let g : ∀ j, ky ⟶ k j := fun j => (h j).choose_spec.choose_spec.some
-    -- where the images of the components of the representatives become equal:
-    have w :
-      ∀ j,
-        F.map ((𝟙 j, f j) : (j, kx) ⟶ (j, k j)) (limit.π ((curry.obj (swap K J ⋙ F)).obj kx) j x) =
-          F.map ((𝟙 j, g j) : (j, ky) ⟶ (j, k j))
-            (limit.π ((curry.obj (swap K J ⋙ F)).obj ky) j y) :=
-      fun j => (h j).choose_spec.choose_spec.choose_spec
-    -- We now use that `K` is filtered, picking some point to the right of all these
-    -- morphisms `f j` and `g j`.
-    let O : Finset K := finset.univ.image k ∪ {kx, ky}
-    have kxO : kx ∈ O := finset.mem_union.mpr (Or.inr (by simp))
-    have kyO : ky ∈ O := finset.mem_union.mpr (Or.inr (by simp))
-    have kjO : ∀ j, k j ∈ O := fun j => finset.mem_union.mpr (Or.inl (by simp))
-    let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
-      (Finset.univ.image fun j : J =>
-          ⟨kx, k j, kxO, finset.mem_union.mpr (Or.inl (by simp)), f j⟩) ∪
-        Finset.univ.image fun j : J => ⟨ky, k j, kyO, finset.mem_union.mpr (Or.inl (by simp)), g j⟩
-    obtain ⟨S, T, W⟩ := is_filtered.sup_exists O H
-    have fH :
-      ∀ j, (⟨kx, k j, kxO, kjO j, f j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
-      fun j =>
-      finset.mem_union.mpr
-        (Or.inl
-          (by
-            simp only [true_and_iff, Finset.mem_univ, eq_self_iff_true, exists_prop_of_true,
-              Finset.mem_image, heq_iff_eq]
-            refine' ⟨j, rfl, _⟩
-            simp only [heq_iff_eq]
-            exact ⟨rfl, rfl, rfl⟩))
-    have gH :
-      ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
-      fun j =>
-      finset.mem_union.mpr
-        (Or.inr
-          (by
-            simp only [true_and_iff, Finset.mem_univ, eq_self_iff_true, exists_prop_of_true,
-              Finset.mem_image, heq_iff_eq]
-            refine' ⟨j, rfl, _⟩
-            simp only [heq_iff_eq]
-            exact ⟨rfl, rfl, rfl⟩))
-    -- Our goal is now an equation between equivalence classes of representatives of a colimit,
-    -- and so it suffices to show those representative become equal somewhere, in particular at `S`.
-    apply colimit_sound'.{v, v} (T kxO) (T kyO)
-    -- We can check if two elements of a limit (in `Type`) are equal by comparing them componentwise.
-    ext
-    -- Now it's just a calculation using `W` and `w`.
-    simp only [functor.comp_map, limit.map_π_apply, curry_obj_map_app, swap_map]
-    rw [← W _ _ (fH j)]
-    rw [← W _ _ (gH j)]
-    simp [w]
+  cases nonempty_fintype J
+  -- Suppose we have two terms `x y` in the colimit (over `K`) of the limits (over `J`),
+  -- and that these have the same image under `colimit_limit_to_limit_colimit F`.
+  intro x y h
+  -- These elements of the colimit have representatives somewhere:
+  obtain ⟨kx, x, rfl⟩ := jointly_surjective'.{v, v} x
+  obtain ⟨ky, y, rfl⟩ := jointly_surjective'.{v, v} y
+  dsimp at x y 
+  -- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
+  -- (indexed by `j : J`),
+  replace h := fun j => congr_arg (limit.π (curry.obj F ⋙ colim) j) h
+  -- and they are equations in a filtered colimit,
+  -- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
+  simp [colimit_eq_iff.{v, v}] at h 
+  let k j := (h j).some
+  let f : ∀ j, kx ⟶ k j := fun j => (h j).choose_spec.some
+  let g : ∀ j, ky ⟶ k j := fun j => (h j).choose_spec.choose_spec.some
+  -- where the images of the components of the representatives become equal:
+  have w :
+    ∀ j,
+      F.map ((𝟙 j, f j) : (j, kx) ⟶ (j, k j)) (limit.π ((curry.obj (swap K J ⋙ F)).obj kx) j x) =
+        F.map ((𝟙 j, g j) : (j, ky) ⟶ (j, k j)) (limit.π ((curry.obj (swap K J ⋙ F)).obj ky) j y) :=
+    fun j => (h j).choose_spec.choose_spec.choose_spec
+  -- We now use that `K` is filtered, picking some point to the right of all these
+  -- morphisms `f j` and `g j`.
+  let O : Finset K := finset.univ.image k ∪ {kx, ky}
+  have kxO : kx ∈ O := finset.mem_union.mpr (Or.inr (by simp))
+  have kyO : ky ∈ O := finset.mem_union.mpr (Or.inr (by simp))
+  have kjO : ∀ j, k j ∈ O := fun j => finset.mem_union.mpr (Or.inl (by simp))
+  let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
+    (Finset.univ.image fun j : J => ⟨kx, k j, kxO, finset.mem_union.mpr (Or.inl (by simp)), f j⟩) ∪
+      Finset.univ.image fun j : J => ⟨ky, k j, kyO, finset.mem_union.mpr (Or.inl (by simp)), g j⟩
+  obtain ⟨S, T, W⟩ := is_filtered.sup_exists O H
+  have fH : ∀ j, (⟨kx, k j, kxO, kjO j, f j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
+    fun j =>
+    finset.mem_union.mpr
+      (Or.inl
+        (by
+          simp only [true_and_iff, Finset.mem_univ, eq_self_iff_true, exists_prop_of_true,
+            Finset.mem_image, heq_iff_eq]
+          refine' ⟨j, rfl, _⟩
+          simp only [heq_iff_eq]
+          exact ⟨rfl, rfl, rfl⟩))
+  have gH : ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
+    fun j =>
+    finset.mem_union.mpr
+      (Or.inr
+        (by
+          simp only [true_and_iff, Finset.mem_univ, eq_self_iff_true, exists_prop_of_true,
+            Finset.mem_image, heq_iff_eq]
+          refine' ⟨j, rfl, _⟩
+          simp only [heq_iff_eq]
+          exact ⟨rfl, rfl, rfl⟩))
+  -- Our goal is now an equation between equivalence classes of representatives of a colimit,
+  -- and so it suffices to show those representative become equal somewhere, in particular at `S`.
+  apply colimit_sound'.{v, v} (T kxO) (T kyO)
+  -- We can check if two elements of a limit (in `Type`) are equal by comparing them componentwise.
+  ext
+  -- Now it's just a calculation using `W` and `w`.
+  simp only [functor.comp_map, limit.map_π_apply, curry_obj_map_app, swap_map]
+  rw [← W _ _ (fH j)]
+  rw [← W _ _ (gH j)]
+  simp [w]
 #align category_theory.limits.colimit_limit_to_limit_colimit_injective CategoryTheory.Limits.colimitLimitToLimitColimit_injective
 
 end
@@ -149,164 +145,164 @@ although with different names.
 theorem colimitLimitToLimitColimit_surjective :
     Function.Surjective (colimitLimitToLimitColimit F) := by
   classical
-    -- We begin with some element `x` in the limit (over J) over the colimits (over K),
-    intro x
-    -- This consists of some coherent family of elements in the various colimits,
-    -- and so our first task is to pick representatives of these elements.
-    have z := fun j => jointly_surjective'.{v, v} (limit.π (curry.obj F ⋙ limits.colim) j x)
-    -- `k : J ⟶ K` records where the representative of the element in the `j`-th element of `x` lives
-    let k : J → K := fun j => (z j).some
-    -- `y j : F.obj (j, k j)` is the representative
-    let y : ∀ j, F.obj (j, k j) := fun j => (z j).choose_spec.some
-    -- and we record that these representatives, when mapped back into the relevant colimits,
-    -- are actually the components of `x`.
-    have e :
-      ∀ j, colimit.ι ((curry.obj F).obj j) (k j) (y j) = limit.π (curry.obj F ⋙ limits.colim) j x :=
-      fun j => (z j).choose_spec.choose_spec
-    clear_value k y
-    -- A little tidying up of things we no longer need.
-    clear z
-    -- As a first step, we use that `K` is filtered to pick some point `k' : K` above all the `k j`
-    let k' : K := is_filtered.sup (finset.univ.image k) ∅
-    -- and name the morphisms as `g j : k j ⟶ k'`.
-    have g : ∀ j, k j ⟶ k' := fun j => is_filtered.to_sup (finset.univ.image k) ∅ (by simp)
-    clear_value k'
-    -- Recalling that the components of `x`, which are indexed by `j : J`, are "coherent",
-    -- in other words preserved by morphisms in the `J` direction,
-    -- we see that for any morphism `f : j ⟶ j'` in `J`,
-    -- the images of `y j` and `y j'`, when mapped to `F.obj (j', k')` respectively by
-    -- `(f, g j)` and `(𝟙 j', g j')`, both represent the same element in the colimit.
-    have w :
-      ∀ {j j' : J} (f : j ⟶ j'),
-        colimit.ι ((curry.obj F).obj j') k' (F.map ((𝟙 j', g j') : (j', k j') ⟶ (j', k')) (y j')) =
-          colimit.ι ((curry.obj F).obj j') k' (F.map ((f, g j) : (j, k j) ⟶ (j', k')) (y j)) :=
-      by
-      intro j j' f
-      have t :
-        (f, g j) = (((f, 𝟙 (k j)) : (j, k j) ⟶ (j', k j)) ≫ (𝟙 j', g j) : (j, k j) ⟶ (j', k')) := by
-        simp only [id_comp, comp_id, prod_comp]
-      erw [colimit.w_apply', t, functor_to_types.map_comp_apply, colimit.w_apply', e, ←
-        limit.w_apply' f, ← e]
-      simp
-    -- Because `K` is filtered, we can restate this as saying that
-    -- for each such `f`, there is some place to the right of `k'`
-    -- where these images of `y j` and `y j'` become equal.
-    simp_rw [colimit_eq_iff.{v, v}] at w 
-    -- We take a moment to restate `w` more conveniently.
-    let kf : ∀ {j j'} (f : j ⟶ j'), K := fun _ _ f => (w f).some
-    let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.some
-    let hf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.choose_spec.some
-    have wf :
-      ∀ {j j'} (f : j ⟶ j'),
-        F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j') =
-          F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j) :=
-      fun j j' f =>
-      by
-      have q :
-        ((curry.obj F).obj j').map (gf f) (F.map _ (y j')) =
-          ((curry.obj F).obj j').map (hf f) (F.map _ (y j)) :=
-        (w f).choose_spec.choose_spec.choose_spec
-      dsimp at q 
-      simp_rw [← functor_to_types.map_comp_apply] at q 
-      convert q <;> simp only [comp_id]
-    clear_value kf gf hf
-    -- and clean up some things that are no longer needed.
-    clear w
-    -- We're now ready to use the fact that `K` is filtered a second time,
-    -- picking some place to the right of all of
-    -- the morphisms `gf f : k' ⟶ kh f` and `hf f : k' ⟶ kf f`.
-    -- At this point we're relying on there being only finitely morphisms in `J`.
-    let O :=
-      (finset.univ.bUnion fun j => finset.univ.bUnion fun j' => finset.univ.image (@kf j j')) ∪ {k'}
-    have kfO : ∀ {j j'} (f : j ⟶ j'), kf f ∈ O := fun j j' f =>
-      finset.mem_union.mpr
-        (Or.inl
-          (by
-            rw [Finset.mem_biUnion]
-            refine' ⟨j, Finset.mem_univ j, _⟩
-            rw [Finset.mem_biUnion]
-            refine' ⟨j', Finset.mem_univ j', _⟩
-            rw [Finset.mem_image]
-            refine' ⟨f, Finset.mem_univ _, _⟩
-            rfl))
-    have k'O : k' ∈ O := finset.mem_union.mpr (Or.inr (finset.mem_singleton.mpr rfl))
-    let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
-      finset.univ.bUnion fun j : J =>
-        finset.univ.bUnion fun j' : J =>
-          finset.univ.bUnion fun f : j ⟶ j' =>
-            {⟨k', kf f, k'O, kfO f, gf f⟩, ⟨k', kf f, k'O, kfO f, hf f⟩}
-    obtain ⟨k'', i', s'⟩ := is_filtered.sup_exists O H
-    -- We then restate this slightly more conveniently, as a family of morphism `i f : kf f ⟶ k''`,
-    -- satisfying `gf f ≫ i f = hf f' ≫ i f'`.
-    let i : ∀ {j j'} (f : j ⟶ j'), kf f ⟶ k'' := fun j j' f => i' (kfO f)
-    have s : ∀ {j₁ j₂ j₃ j₄} (f : j₁ ⟶ j₂) (f' : j₃ ⟶ j₄), gf f ≫ i f = hf f' ≫ i f' :=
-      by
-      intros
-      rw [s', s']
-      swap
-      exact k'O
-      swap
-      · rw [Finset.mem_biUnion]
-        refine' ⟨j₁, Finset.mem_univ _, _⟩
-        rw [Finset.mem_biUnion]
-        refine' ⟨j₂, Finset.mem_univ _, _⟩
-        rw [Finset.mem_biUnion]
-        refine' ⟨f, Finset.mem_univ _, _⟩
-        simp only [true_or_iff, eq_self_iff_true, and_self_iff, Finset.mem_insert, heq_iff_eq]
-      · rw [Finset.mem_biUnion]
-        refine' ⟨j₃, Finset.mem_univ _, _⟩
-        rw [Finset.mem_biUnion]
-        refine' ⟨j₄, Finset.mem_univ _, _⟩
-        rw [Finset.mem_biUnion]
-        refine' ⟨f', Finset.mem_univ _, _⟩
-        simp only [eq_self_iff_true, or_true_iff, and_self_iff, Finset.mem_insert,
-          Finset.mem_singleton, heq_iff_eq]
-    clear_value i
-    clear s' i' H kfO k'O O
-    -- We're finally ready to construct the pre-image, and verify it really maps to `x`.
-    fconstructor
-    · -- We construct the pre-image (which, recall is meant to be a point
-      -- in the colimit (over `K`) of the limits (over `J`)) via a representative at `k''`.
-      apply colimit.ι (curry.obj (swap K J ⋙ F) ⋙ limits.lim) k'' _
+  -- We begin with some element `x` in the limit (over J) over the colimits (over K),
+  intro x
+  -- This consists of some coherent family of elements in the various colimits,
+  -- and so our first task is to pick representatives of these elements.
+  have z := fun j => jointly_surjective'.{v, v} (limit.π (curry.obj F ⋙ limits.colim) j x)
+  -- `k : J ⟶ K` records where the representative of the element in the `j`-th element of `x` lives
+  let k : J → K := fun j => (z j).some
+  -- `y j : F.obj (j, k j)` is the representative
+  let y : ∀ j, F.obj (j, k j) := fun j => (z j).choose_spec.some
+  -- and we record that these representatives, when mapped back into the relevant colimits,
+  -- are actually the components of `x`.
+  have e :
+    ∀ j, colimit.ι ((curry.obj F).obj j) (k j) (y j) = limit.π (curry.obj F ⋙ limits.colim) j x :=
+    fun j => (z j).choose_spec.choose_spec
+  clear_value k y
+  -- A little tidying up of things we no longer need.
+  clear z
+  -- As a first step, we use that `K` is filtered to pick some point `k' : K` above all the `k j`
+  let k' : K := is_filtered.sup (finset.univ.image k) ∅
+  -- and name the morphisms as `g j : k j ⟶ k'`.
+  have g : ∀ j, k j ⟶ k' := fun j => is_filtered.to_sup (finset.univ.image k) ∅ (by simp)
+  clear_value k'
+  -- Recalling that the components of `x`, which are indexed by `j : J`, are "coherent",
+  -- in other words preserved by morphisms in the `J` direction,
+  -- we see that for any morphism `f : j ⟶ j'` in `J`,
+  -- the images of `y j` and `y j'`, when mapped to `F.obj (j', k')` respectively by
+  -- `(f, g j)` and `(𝟙 j', g j')`, both represent the same element in the colimit.
+  have w :
+    ∀ {j j' : J} (f : j ⟶ j'),
+      colimit.ι ((curry.obj F).obj j') k' (F.map ((𝟙 j', g j') : (j', k j') ⟶ (j', k')) (y j')) =
+        colimit.ι ((curry.obj F).obj j') k' (F.map ((f, g j) : (j, k j) ⟶ (j', k')) (y j)) :=
+    by
+    intro j j' f
+    have t :
+      (f, g j) = (((f, 𝟙 (k j)) : (j, k j) ⟶ (j', k j)) ≫ (𝟙 j', g j) : (j, k j) ⟶ (j', k')) := by
+      simp only [id_comp, comp_id, prod_comp]
+    erw [colimit.w_apply', t, functor_to_types.map_comp_apply, colimit.w_apply', e, ←
+      limit.w_apply' f, ← e]
+    simp
+  -- Because `K` is filtered, we can restate this as saying that
+  -- for each such `f`, there is some place to the right of `k'`
+  -- where these images of `y j` and `y j'` become equal.
+  simp_rw [colimit_eq_iff.{v, v}] at w 
+  -- We take a moment to restate `w` more conveniently.
+  let kf : ∀ {j j'} (f : j ⟶ j'), K := fun _ _ f => (w f).some
+  let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.some
+  let hf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.choose_spec.some
+  have wf :
+    ∀ {j j'} (f : j ⟶ j'),
+      F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j') =
+        F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j) :=
+    fun j j' f =>
+    by
+    have q :
+      ((curry.obj F).obj j').map (gf f) (F.map _ (y j')) =
+        ((curry.obj F).obj j').map (hf f) (F.map _ (y j)) :=
+      (w f).choose_spec.choose_spec.choose_spec
+    dsimp at q 
+    simp_rw [← functor_to_types.map_comp_apply] at q 
+    convert q <;> simp only [comp_id]
+  clear_value kf gf hf
+  -- and clean up some things that are no longer needed.
+  clear w
+  -- We're now ready to use the fact that `K` is filtered a second time,
+  -- picking some place to the right of all of
+  -- the morphisms `gf f : k' ⟶ kh f` and `hf f : k' ⟶ kf f`.
+  -- At this point we're relying on there being only finitely morphisms in `J`.
+  let O :=
+    (finset.univ.bUnion fun j => finset.univ.bUnion fun j' => finset.univ.image (@kf j j')) ∪ {k'}
+  have kfO : ∀ {j j'} (f : j ⟶ j'), kf f ∈ O := fun j j' f =>
+    finset.mem_union.mpr
+      (Or.inl
+        (by
+          rw [Finset.mem_biUnion]
+          refine' ⟨j, Finset.mem_univ j, _⟩
+          rw [Finset.mem_biUnion]
+          refine' ⟨j', Finset.mem_univ j', _⟩
+          rw [Finset.mem_image]
+          refine' ⟨f, Finset.mem_univ _, _⟩
+          rfl))
+  have k'O : k' ∈ O := finset.mem_union.mpr (Or.inr (finset.mem_singleton.mpr rfl))
+  let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
+    finset.univ.bUnion fun j : J =>
+      finset.univ.bUnion fun j' : J =>
+        finset.univ.bUnion fun f : j ⟶ j' =>
+          {⟨k', kf f, k'O, kfO f, gf f⟩, ⟨k', kf f, k'O, kfO f, hf f⟩}
+  obtain ⟨k'', i', s'⟩ := is_filtered.sup_exists O H
+  -- We then restate this slightly more conveniently, as a family of morphism `i f : kf f ⟶ k''`,
+  -- satisfying `gf f ≫ i f = hf f' ≫ i f'`.
+  let i : ∀ {j j'} (f : j ⟶ j'), kf f ⟶ k'' := fun j j' f => i' (kfO f)
+  have s : ∀ {j₁ j₂ j₃ j₄} (f : j₁ ⟶ j₂) (f' : j₃ ⟶ j₄), gf f ≫ i f = hf f' ≫ i f' :=
+    by
+    intros
+    rw [s', s']
+    swap
+    exact k'O
+    swap
+    · rw [Finset.mem_biUnion]
+      refine' ⟨j₁, Finset.mem_univ _, _⟩
+      rw [Finset.mem_biUnion]
+      refine' ⟨j₂, Finset.mem_univ _, _⟩
+      rw [Finset.mem_biUnion]
+      refine' ⟨f, Finset.mem_univ _, _⟩
+      simp only [true_or_iff, eq_self_iff_true, and_self_iff, Finset.mem_insert, heq_iff_eq]
+    · rw [Finset.mem_biUnion]
+      refine' ⟨j₃, Finset.mem_univ _, _⟩
+      rw [Finset.mem_biUnion]
+      refine' ⟨j₄, Finset.mem_univ _, _⟩
+      rw [Finset.mem_biUnion]
+      refine' ⟨f', Finset.mem_univ _, _⟩
+      simp only [eq_self_iff_true, or_true_iff, and_self_iff, Finset.mem_insert,
+        Finset.mem_singleton, heq_iff_eq]
+  clear_value i
+  clear s' i' H kfO k'O O
+  -- We're finally ready to construct the pre-image, and verify it really maps to `x`.
+  fconstructor
+  · -- We construct the pre-image (which, recall is meant to be a point
+    -- in the colimit (over `K`) of the limits (over `J`)) via a representative at `k''`.
+    apply colimit.ι (curry.obj (swap K J ⋙ F) ⋙ limits.lim) k'' _
+    dsimp
+    -- This representative is meant to be an element of a limit,
+    -- so we need to construct a family of elements in `F.obj (j, k'')` for varying `j`,
+    -- then show that are coherent with respect to morphisms in the `j` direction.
+    apply Limit.mk.{v, v};
+    swap
+    ·-- We construct the elements as the images of the `y j`.
+      exact fun j => F.map (⟨𝟙 j, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)⟩ : (j, k j) ⟶ (j, k'')) (y j)
+    · -- After which it's just a calculation, using `s` and `wf`, to see they are coherent.
       dsimp
-      -- This representative is meant to be an element of a limit,
-      -- so we need to construct a family of elements in `F.obj (j, k'')` for varying `j`,
-      -- then show that are coherent with respect to morphisms in the `j` direction.
-      apply Limit.mk.{v, v};
-      swap
-      ·-- We construct the elements as the images of the `y j`.
-        exact fun j => F.map (⟨𝟙 j, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)⟩ : (j, k j) ⟶ (j, k'')) (y j)
-      · -- After which it's just a calculation, using `s` and `wf`, to see they are coherent.
-        dsimp
-        intro j j' f
-        simp only [← functor_to_types.map_comp_apply, prod_comp, id_comp, comp_id]
-        calc
-          F.map ((f, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)) : (j, k j) ⟶ (j', k'')) (y j) =
-              F.map ((f, g j ≫ hf f ≫ i f) : (j, k j) ⟶ (j', k'')) (y j) :=
-            by rw [s (𝟙 j) f]
-          _ =
-              F.map ((𝟙 j', i f) : (j', kf f) ⟶ (j', k''))
-                (F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j)) :=
-            by rw [← functor_to_types.map_comp_apply, prod_comp, comp_id, assoc]
-          _ =
-              F.map ((𝟙 j', i f) : (j', kf f) ⟶ (j', k''))
-                (F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j')) :=
-            by rw [← wf f]
-          _ = F.map ((𝟙 j', g j' ≫ gf f ≫ i f) : (j', k j') ⟶ (j', k'')) (y j') := by
-            rw [← functor_to_types.map_comp_apply, prod_comp, id_comp, assoc]
-          _ = F.map ((𝟙 j', g j' ≫ gf (𝟙 j') ≫ i (𝟙 j')) : (j', k j') ⟶ (j', k'')) (y j') := by
-            rw [s f (𝟙 j'), ← s (𝟙 j') (𝟙 j')]
-          
-    -- Finally we check that this maps to `x`.
-    · -- We can do this componentwise:
-      apply limit_ext'
-      intro j
-      -- and as each component is an equation in a colimit, we can verify it by
-      -- pointing out the morphism which carries one representative to the other:
-      simp only [← e, colimit_eq_iff.{v, v}, curry_obj_obj_map, limit.π_mk', bifunctor.map_id_comp,
-        id.def, types_comp_apply, limits.ι_colimit_limit_to_limit_colimit_π_apply]
-      refine' ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), _⟩
-      simp only [bifunctor.map_id_comp, types_comp_apply, bifunctor.map_id, types_id_apply]
+      intro j j' f
+      simp only [← functor_to_types.map_comp_apply, prod_comp, id_comp, comp_id]
+      calc
+        F.map ((f, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)) : (j, k j) ⟶ (j', k'')) (y j) =
+            F.map ((f, g j ≫ hf f ≫ i f) : (j, k j) ⟶ (j', k'')) (y j) :=
+          by rw [s (𝟙 j) f]
+        _ =
+            F.map ((𝟙 j', i f) : (j', kf f) ⟶ (j', k''))
+              (F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j)) :=
+          by rw [← functor_to_types.map_comp_apply, prod_comp, comp_id, assoc]
+        _ =
+            F.map ((𝟙 j', i f) : (j', kf f) ⟶ (j', k''))
+              (F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j')) :=
+          by rw [← wf f]
+        _ = F.map ((𝟙 j', g j' ≫ gf f ≫ i f) : (j', k j') ⟶ (j', k'')) (y j') := by
+          rw [← functor_to_types.map_comp_apply, prod_comp, id_comp, assoc]
+        _ = F.map ((𝟙 j', g j' ≫ gf (𝟙 j') ≫ i (𝟙 j')) : (j', k j') ⟶ (j', k'')) (y j') := by
+          rw [s f (𝟙 j'), ← s (𝟙 j') (𝟙 j')]
+        
+  -- Finally we check that this maps to `x`.
+  · -- We can do this componentwise:
+    apply limit_ext'
+    intro j
+    -- and as each component is an equation in a colimit, we can verify it by
+    -- pointing out the morphism which carries one representative to the other:
+    simp only [← e, colimit_eq_iff.{v, v}, curry_obj_obj_map, limit.π_mk', bifunctor.map_id_comp,
+      id.def, types_comp_apply, limits.ι_colimit_limit_to_limit_colimit_π_apply]
+    refine' ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), _⟩
+    simp only [bifunctor.map_id_comp, types_comp_apply, bifunctor.map_id, types_id_apply]
 #align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjective
 
 instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F) :=

f2b757fc

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -76,13 +76,13 @@ theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitT
     -- These elements of the colimit have representatives somewhere:
     obtain ⟨kx, x, rfl⟩ := jointly_surjective'.{v, v} x
     obtain ⟨ky, y, rfl⟩ := jointly_surjective'.{v, v} y
-    dsimp at x y
+    dsimp at x y 
     -- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
     -- (indexed by `j : J`),
     replace h := fun j => congr_arg (limit.π (curry.obj F ⋙ colim) j) h
     -- and they are equations in a filtered colimit,
     -- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
-    simp [colimit_eq_iff.{v, v}] at h
+    simp [colimit_eq_iff.{v, v}] at h 
     let k j := (h j).some
     let f : ∀ j, kx ⟶ k j := fun j => (h j).choose_spec.some
     let g : ∀ j, ky ⟶ k j := fun j => (h j).choose_spec.choose_spec.some
@@ -99,12 +99,13 @@ theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitT
     have kxO : kx ∈ O := finset.mem_union.mpr (Or.inr (by simp))
     have kyO : ky ∈ O := finset.mem_union.mpr (Or.inr (by simp))
     have kjO : ∀ j, k j ∈ O := fun j => finset.mem_union.mpr (Or.inl (by simp))
-    let H : Finset (Σ'(X Y : K)(mX : X ∈ O)(mY : Y ∈ O), X ⟶ Y) :=
+    let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
       (Finset.univ.image fun j : J =>
           ⟨kx, k j, kxO, finset.mem_union.mpr (Or.inl (by simp)), f j⟩) ∪
         Finset.univ.image fun j : J => ⟨ky, k j, kyO, finset.mem_union.mpr (Or.inl (by simp)), g j⟩
     obtain ⟨S, T, W⟩ := is_filtered.sup_exists O H
-    have fH : ∀ j, (⟨kx, k j, kxO, kjO j, f j⟩ : Σ'(X Y : K)(mX : X ∈ O)(mY : Y ∈ O), X ⟶ Y) ∈ H :=
+    have fH :
+      ∀ j, (⟨kx, k j, kxO, kjO j, f j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
       fun j =>
       finset.mem_union.mpr
         (Or.inl
@@ -114,7 +115,8 @@ theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitT
             refine' ⟨j, rfl, _⟩
             simp only [heq_iff_eq]
             exact ⟨rfl, rfl, rfl⟩))
-    have gH : ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ'(X Y : K)(mX : X ∈ O)(mY : Y ∈ O), X ⟶ Y) ∈ H :=
+    have gH :
+      ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) ∈ H :=
       fun j =>
       finset.mem_union.mpr
         (Or.inr
@@ -189,7 +191,7 @@ theorem colimitLimitToLimitColimit_surjective :
     -- Because `K` is filtered, we can restate this as saying that
     -- for each such `f`, there is some place to the right of `k'`
     -- where these images of `y j` and `y j'` become equal.
-    simp_rw [colimit_eq_iff.{v, v}] at w
+    simp_rw [colimit_eq_iff.{v, v}] at w 
     -- We take a moment to restate `w` more conveniently.
     let kf : ∀ {j j'} (f : j ⟶ j'), K := fun _ _ f => (w f).some
     let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun _ _ f => (w f).choose_spec.some
@@ -204,8 +206,8 @@ theorem colimitLimitToLimitColimit_surjective :
         ((curry.obj F).obj j').map (gf f) (F.map _ (y j')) =
           ((curry.obj F).obj j').map (hf f) (F.map _ (y j)) :=
         (w f).choose_spec.choose_spec.choose_spec
-      dsimp at q
-      simp_rw [← functor_to_types.map_comp_apply] at q
+      dsimp at q 
+      simp_rw [← functor_to_types.map_comp_apply] at q 
       convert q <;> simp only [comp_id]
     clear_value kf gf hf
     -- and clean up some things that are no longer needed.
@@ -228,7 +230,7 @@ theorem colimitLimitToLimitColimit_surjective :
             refine' ⟨f, Finset.mem_univ _, _⟩
             rfl))
     have k'O : k' ∈ O := finset.mem_union.mpr (Or.inr (finset.mem_singleton.mpr rfl))
-    let H : Finset (Σ'(X Y : K)(mX : X ∈ O)(mY : Y ∈ O), X ⟶ Y) :=
+    let H : Finset (Σ' (X Y : K) (mX : X ∈ O) (mY : Y ∈ O), X ⟶ Y) :=
       finset.univ.bUnion fun j : J =>
         finset.univ.bUnion fun j' : J =>
           finset.univ.bUnion fun f : j ⟶ j' =>

f2b757fc

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -63,9 +63,6 @@ only that there are finitely many objects.
 
 variable [Finite J]
 
-/- warning: category_theory.limits.colimit_limit_to_limit_colimit_injective -> CategoryTheory.Limits.colimitLimitToLimitColimit_injective is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_injective CategoryTheory.Limits.colimitLimitToLimitColimit_injectiveₓ'. -/
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 -/
@@ -143,9 +140,6 @@ end
 
 variable [FinCategory J]
 
-/- warning: category_theory.limits.colimit_limit_to_limit_colimit_surjective -> CategoryTheory.Limits.colimitLimitToLimitColimit_surjective is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjectiveₓ'. -/
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 although with different names.
@@ -313,17 +307,11 @@ theorem colimitLimitToLimitColimit_surjective :
       simp only [bifunctor.map_id_comp, types_comp_apply, bifunctor.map_id, types_id_apply]
 #align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjective
 
-/- warning: category_theory.limits.colimit_limit_to_limit_colimit_is_iso -> CategoryTheory.Limits.colimitLimitToLimitColimit_isIso is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_is_iso CategoryTheory.Limits.colimitLimitToLimitColimit_isIsoₓ'. -/
 instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F) :=
   (isIso_iff_bijective _).mpr
     ⟨colimitLimitToLimitColimit_injective F, colimitLimitToLimitColimit_surjective F⟩
 #align category_theory.limits.colimit_limit_to_limit_colimit_is_iso CategoryTheory.Limits.colimitLimitToLimitColimit_isIso
 
-/- warning: category_theory.limits.colimit_limit_to_limit_colimit_cone_iso -> CategoryTheory.Limits.colimitLimitToLimitColimitCone_iso is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_cone_iso CategoryTheory.Limits.colimitLimitToLimitColimitCone_isoₓ'. -/
 instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
     IsIso (colimitLimitToLimitColimitCone F) :=
   by
@@ -393,9 +381,6 @@ noncomputable def colimitLimitIso (F : J ⥤ K ⥤ C) : colimit (limit F) ≅ li
 #align category_theory.limits.colimit_limit_iso CategoryTheory.Limits.colimitLimitIso
 -/
 
-/- warning: category_theory.limits.ι_colimit_limit_iso_limit_π -> CategoryTheory.Limits.ι_colimitLimitIso_limit_π is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.limits.ι_colimit_limit_iso_limit_π CategoryTheory.Limits.ι_colimitLimitIso_limit_πₓ'. -/
 @[simp, reassoc]
 theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
     colimit.ι (limit F) a ≫ (colimitLimitIso F).Hom ≫ limit.π (colimit F.flip) b =

f2b757fc

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -276,7 +276,7 @@ theorem colimitLimitToLimitColimit_surjective :
       -- This representative is meant to be an element of a limit,
       -- so we need to construct a family of elements in `F.obj (j, k'')` for varying `j`,
       -- then show that are coherent with respect to morphisms in the `j` direction.
-      apply Limit.mk.{v, v}
+      apply Limit.mk.{v, v};
       swap
       ·-- We construct the elements as the images of the `y j`.
         exact fun j => F.map (⟨𝟙 j, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)⟩ : (j, k j) ⟶ (j, k'')) (y j)
@@ -327,10 +327,8 @@ Case conversion may be inaccurate. Consider using '#align category_theory.limits
 instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
     IsIso (colimitLimitToLimitColimitCone F) :=
   by
-  have : is_iso (colimit_limit_to_limit_colimit_cone F).Hom :=
-    by
-    dsimp only [colimit_limit_to_limit_colimit_cone]
-    infer_instance
+  have : is_iso (colimit_limit_to_limit_colimit_cone F).Hom := by
+    dsimp only [colimit_limit_to_limit_colimit_cone]; infer_instance
   apply cones.cone_iso_of_hom_iso
 #align category_theory.limits.colimit_limit_to_limit_colimit_cone_iso CategoryTheory.Limits.colimitLimitToLimitColimitCone_iso

f2b757fc

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -64,10 +64,7 @@ only that there are finitely many objects.
 variable [Finite J]
 
 /- warning: category_theory.limits.colimit_limit_to_limit_colimit_injective -> CategoryTheory.Limits.colimitLimitToLimitColimit_injective is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : Finite.{succ u1} J], Function.Injective.{succ u1, succ u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_1.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_2.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))
-but is expected to have type
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : Finite.{succ u1} J], Function.Injective.{succ u1, succ u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_injective CategoryTheory.Limits.colimitLimitToLimitColimit_injectiveₓ'. -/
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
@@ -147,10 +144,7 @@ end
 variable [FinCategory J]
 
 /- warning: category_theory.limits.colimit_limit_to_limit_colimit_surjective -> CategoryTheory.Limits.colimitLimitToLimitColimit_surjective is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1], Function.Surjective.{succ u1, succ u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_1.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_2.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))
-but is expected to have type
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1], Function.Surjective.{succ u1, succ u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})))) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})))))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjectiveₓ'. -/
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
@@ -320,10 +314,7 @@ theorem colimitLimitToLimitColimit_surjective :
 #align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjective
 
 /- warning: category_theory.limits.colimit_limit_to_limit_colimit_is_iso -> CategoryTheory.Limits.colimitLimitToLimitColimit_isIso is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1], CategoryTheory.IsIso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_1.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_2.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))
-but is expected to have type
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1], CategoryTheory.IsIso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})))) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})))))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_is_iso CategoryTheory.Limits.colimitLimitToLimitColimit_isIsoₓ'. -/
 instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F) :=
   (isIso_iff_bijective _).mpr
@@ -331,10 +322,7 @@ instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F)
 #align category_theory.limits.colimit_limit_to_limit_colimit_is_iso CategoryTheory.Limits.colimitLimitToLimitColimit_isIso
 
 /- warning: category_theory.limits.colimit_limit_to_limit_colimit_cone_iso -> CategoryTheory.Limits.colimitLimitToLimitColimitCone_iso is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})), CategoryTheory.IsIso.{u1, succ u1} (CategoryTheory.Limits.Cone.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1})))) (CategoryTheory.Limits.Cone.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1})))) (CategoryTheory.Functor.mapCone.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1})) (CategoryTheory.Limits.limit.cone.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 K _inst_2 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}))) F))) (CategoryTheory.Limits.limit.cone.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimitCone._proof_1.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}) F)) (CategoryTheory.Limits.colimitLimitToLimitColimitCone.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 K _inst_2 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}))) F))
-but is expected to have type
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})), CategoryTheory.IsIso.{u1, succ u1} (CategoryTheory.Limits.Cone.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1})))) (CategoryTheory.Limits.Cone.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1})))) (CategoryTheory.Functor.mapCone.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1})) F (CategoryTheory.Limits.limit.cone.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 K _inst_2 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}))) F))) (CategoryTheory.Limits.limit.cone.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.colimitLimitToLimitColimitCone.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 K _inst_2 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}))) F))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_cone_iso CategoryTheory.Limits.colimitLimitToLimitColimitCone_isoₓ'. -/
 instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
     IsIso (colimitLimitToLimitColimitCone F) :=
@@ -408,10 +396,7 @@ noncomputable def colimitLimitIso (F : J ⥤ K ⥤ C) : colimit (limit F) ≅ li
 -/
 
 /- warning: category_theory.limits.ι_colimit_limit_iso_limit_π -> CategoryTheory.Limits.ι_colimitLimitIso_limit_π is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] {C : Type.{u2}} [_inst_5 : CategoryTheory.Category.{u1, u2} C] [_inst_6 : CategoryTheory.ConcreteCategory.{u1, u1, u2} C _inst_5] [_inst_7 : CategoryTheory.Limits.HasLimitsOfShape.{u1, u1, u1, u2} J _inst_1 C _inst_5] [_inst_8 : CategoryTheory.Limits.HasColimitsOfShape.{u1, u1, u1, u2} K _inst_2 C _inst_5] [_inst_9 : CategoryTheory.Limits.ReflectsLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_10 : CategoryTheory.Limits.PreservesColimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_11 : CategoryTheory.Limits.PreservesLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] (F : CategoryTheory.Functor.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5)) (a : K) (b : J), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) a) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) b)) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) b) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) (CategoryTheory.Limits.colimitLimitIso._proof_4.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 _inst_8 F)) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) b) (CategoryTheory.Iso.hom.{u1, u2} C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.colimitLimitIso._proof_1.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 F)) (CategoryTheory.Limits.colimitLimitIso._proof_2.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 _inst_8 F)) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) (CategoryTheory.Limits.colimitLimitIso._proof_4.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 _inst_8 F)) (CategoryTheory.Limits.colimitLimitIso.{u1, u2} J K _inst_1 _inst_2 _inst_3 _inst_4 C _inst_5 _inst_6 _inst_7 _inst_8 _inst_9 _inst_10 _inst_11 F)) (CategoryTheory.Limits.limit.π.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.colimitLimitIso._proof_4.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 _inst_8 F) b))) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) a) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Functor.obj.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F b) a) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) b) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Functor.obj.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F b) (CategoryTheory.Limits.limit.π.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F) b) a) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Functor.obj.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F) a) b))
-but is expected to have type
-  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] {C : Type.{u2}} [_inst_5 : CategoryTheory.Category.{u1, u2} C] [_inst_6 : CategoryTheory.ConcreteCategory.{u1, u1, u2} C _inst_5] [_inst_7 : CategoryTheory.Limits.HasLimitsOfShape.{u1, u1, u1, u2} J _inst_1 C _inst_5] [_inst_8 : CategoryTheory.Limits.HasColimitsOfShape.{u1, u1, u1, u2} K _inst_2 C _inst_5] [_inst_9 : CategoryTheory.Limits.ReflectsLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_10 : CategoryTheory.Limits.PreservesColimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_11 : CategoryTheory.Limits.PreservesLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] (F : CategoryTheory.Functor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5)) (a : K) (b : J), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b)) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))))) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.Iso.hom.{u1, u2} C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))))) (CategoryTheory.Limits.colimitLimitIso.{u1, u2} J K _inst_1 _inst_2 _inst_3 _inst_4 C _inst_5 _inst_6 _inst_7 _inst_8 _inst_9 _inst_10 _inst_11 F)) (CategoryTheory.Limits.limit.π.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b))) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F) b)) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F) b) (CategoryTheory.Limits.limit.π.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F) b) a) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} J _inst_1 C _inst_5 (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)) a) b))
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.limits.ι_colimit_limit_iso_limit_π CategoryTheory.Limits.ι_colimitLimitIso_limit_πₓ'. -/
 @[simp, reassoc]
 theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :

f2b757fc

bump to nightly-2023-05-23-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/75e7fca56381d056096ce5d05e938f63a6567828

ed98987c

Diff

@@ -413,7 +413,7 @@ lean 3 declaration is
 but is expected to have type
   forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] {C : Type.{u2}} [_inst_5 : CategoryTheory.Category.{u1, u2} C] [_inst_6 : CategoryTheory.ConcreteCategory.{u1, u1, u2} C _inst_5] [_inst_7 : CategoryTheory.Limits.HasLimitsOfShape.{u1, u1, u1, u2} J _inst_1 C _inst_5] [_inst_8 : CategoryTheory.Limits.HasColimitsOfShape.{u1, u1, u1, u2} K _inst_2 C _inst_5] [_inst_9 : CategoryTheory.Limits.ReflectsLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_10 : CategoryTheory.Limits.PreservesColimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_11 : CategoryTheory.Limits.PreservesLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] (F : CategoryTheory.Functor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5)) (a : K) (b : J), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b)) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))))) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.Iso.hom.{u1, u2} C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))))) (CategoryTheory.Limits.colimitLimitIso.{u1, u2} J K _inst_1 _inst_2 _inst_3 _inst_4 C _inst_5 _inst_6 _inst_7 _inst_8 _inst_9 _inst_10 _inst_11 F)) (CategoryTheory.Limits.limit.π.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b))) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F) b)) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F) b) (CategoryTheory.Limits.limit.π.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F) b) a) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} J _inst_1 C _inst_5 (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)) a) b))
 Case conversion may be inaccurate. Consider using '#align category_theory.limits.ι_colimit_limit_iso_limit_π CategoryTheory.Limits.ι_colimitLimitIso_limit_πₓ'. -/
-@[simp, reassoc.1]
+@[simp, reassoc]
 theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
     colimit.ι (limit F) a ≫ (colimitLimitIso F).Hom ≫ limit.π (colimit F.flip) b =
       (limit.π F b).app a ≫ (colimit.ι F.flip a).app b :=

f2b757fc

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -232,9 +232,9 @@ theorem colimitLimitToLimitColimit_surjective :
       finset.mem_union.mpr
         (Or.inl
           (by
-            rw [Finset.mem_bunionᵢ]
+            rw [Finset.mem_biUnion]
             refine' ⟨j, Finset.mem_univ j, _⟩
-            rw [Finset.mem_bunionᵢ]
+            rw [Finset.mem_biUnion]
             refine' ⟨j', Finset.mem_univ j', _⟩
             rw [Finset.mem_image]
             refine' ⟨f, Finset.mem_univ _, _⟩
@@ -256,18 +256,18 @@ theorem colimitLimitToLimitColimit_surjective :
       swap
       exact k'O
       swap
-      · rw [Finset.mem_bunionᵢ]
+      · rw [Finset.mem_biUnion]
         refine' ⟨j₁, Finset.mem_univ _, _⟩
-        rw [Finset.mem_bunionᵢ]
+        rw [Finset.mem_biUnion]
         refine' ⟨j₂, Finset.mem_univ _, _⟩
-        rw [Finset.mem_bunionᵢ]
+        rw [Finset.mem_biUnion]
         refine' ⟨f, Finset.mem_univ _, _⟩
         simp only [true_or_iff, eq_self_iff_true, and_self_iff, Finset.mem_insert, heq_iff_eq]
-      · rw [Finset.mem_bunionᵢ]
+      · rw [Finset.mem_biUnion]
         refine' ⟨j₃, Finset.mem_univ _, _⟩
-        rw [Finset.mem_bunionᵢ]
+        rw [Finset.mem_biUnion]
         refine' ⟨j₄, Finset.mem_univ _, _⟩
-        rw [Finset.mem_bunionᵢ]
+        rw [Finset.mem_biUnion]
         refine' ⟨f', Finset.mem_univ _, _⟩
         simp only [eq_self_iff_true, or_true_iff, and_self_iff, Finset.mem_insert,
           Finset.mem_singleton, heq_iff_eq]

f2b757fc

bump to nightly-2023-04-30-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/86d04064ca33ee3d3405fbfc497d494fd2dd4796

648ff713

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 
 ! This file was ported from Lean 3 source module category_theory.limits.filtered_colimit_commutes_finite_limit
-! leanprover-community/mathlib commit 3f409bd9df181d26dd223170da7b6830ece18442
+! leanprover-community/mathlib commit f2b757fc5c341d88741b9c4630b1e8ba973c5726
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -18,6 +18,9 @@ import Mathbin.CategoryTheory.ConcreteCategory.Basic
 /-!
 # Filtered colimits commute with finite limits.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We show that for a functor `F : J × K ⥤ Type v`, when `J` is finite and `K` is filtered,
 the universal morphism `colimit_limit_to_limit_colimit F` comparing the
 colimit (over `K`) of the limits (over `J`) with the limit of the colimits is an isomorphism.

3f409bd9

bump to nightly-2023-04-28-02

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

473bb540

Diff

@@ -60,6 +60,12 @@ only that there are finitely many objects.
 
 variable [Finite J]
 
+/- warning: category_theory.limits.colimit_limit_to_limit_colimit_injective -> CategoryTheory.Limits.colimitLimitToLimitColimit_injective is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : Finite.{succ u1} J], Function.Injective.{succ u1, succ u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_1.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_2.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))
+but is expected to have type
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : Finite.{succ u1} J], Function.Injective.{succ u1, succ u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_injective CategoryTheory.Limits.colimitLimitToLimitColimit_injectiveₓ'. -/
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 -/
@@ -137,6 +143,12 @@ end
 
 variable [FinCategory J]
 
+/- warning: category_theory.limits.colimit_limit_to_limit_colimit_surjective -> CategoryTheory.Limits.colimitLimitToLimitColimit_surjective is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1], Function.Surjective.{succ u1, succ u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_1.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_2.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))
+but is expected to have type
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1], Function.Surjective.{succ u1, succ u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})))) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})))))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjectiveₓ'. -/
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 although with different names.
@@ -304,11 +316,23 @@ theorem colimitLimitToLimitColimit_surjective :
       simp only [bifunctor.map_id_comp, types_comp_apply, bifunctor.map_id, types_id_apply]
 #align category_theory.limits.colimit_limit_to_limit_colimit_surjective CategoryTheory.Limits.colimitLimitToLimitColimit_surjective
 
+/- warning: category_theory.limits.colimit_limit_to_limit_colimit_is_iso -> CategoryTheory.Limits.colimitLimitToLimitColimit_isIso is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1], CategoryTheory.IsIso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_1.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.obj.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit._proof_2.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))
+but is expected to have type
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.uniformProd.{u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1], CategoryTheory.IsIso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.colimit.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})))) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} K _inst_2 J _inst_1 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, u1, succ u1} (Prod.{u1, u1} K J) (CategoryTheory.prod.{u1, u1, u1, u1} K _inst_2 J _inst_1) (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Prod.swap.{u1, u1, u1, u1} K _inst_2 J _inst_1) F)) (CategoryTheory.Limits.lim.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})))))) (CategoryTheory.Limits.limit.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}))) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} (Prod.{u1, u1} J K) (CategoryTheory.prod.{u1, u1, u1, u1} J _inst_1 K _inst_2) Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.curry.{u1, u1, u1, u1, u1, succ u1} J _inst_1 K _inst_2 Type.{u1} CategoryTheory.types.{u1})) F) (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.colimitLimitToLimitColimit.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_is_iso CategoryTheory.Limits.colimitLimitToLimitColimit_isIsoₓ'. -/
 instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F) :=
   (isIso_iff_bijective _).mpr
     ⟨colimitLimitToLimitColimit_injective F, colimitLimitToLimitColimit_surjective F⟩
 #align category_theory.limits.colimit_limit_to_limit_colimit_is_iso CategoryTheory.Limits.colimitLimitToLimitColimit_isIso
 
+/- warning: category_theory.limits.colimit_limit_to_limit_colimit_cone_iso -> CategoryTheory.Limits.colimitLimitToLimitColimitCone_iso is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})), CategoryTheory.IsIso.{u1, succ u1} (CategoryTheory.Limits.Cone.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1})))) (CategoryTheory.Limits.Cone.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1})))) (CategoryTheory.Functor.mapCone.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1})) (CategoryTheory.Limits.limit.cone.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 K _inst_2 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}))) F))) (CategoryTheory.Limits.limit.cone.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}))) (CategoryTheory.Limits.colimitLimitToLimitColimitCone._proof_1.{succ u1, u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}) F)) (CategoryTheory.Limits.colimitLimitToLimitColimitCone.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasColimits.{u1}) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 K _inst_2 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.Sort.CategoryTheory.Limits.hasLimits.{u1}))) F))
+but is expected to have type
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] (F : CategoryTheory.Functor.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1})), CategoryTheory.IsIso.{u1, succ u1} (CategoryTheory.Limits.Cone.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1})))) (CategoryTheory.Limits.Cone.category.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1})))) (CategoryTheory.Functor.mapCone.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1})) F (CategoryTheory.Limits.limit.cone.{u1, u1, u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 K _inst_2 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}))) F))) (CategoryTheory.Limits.limit.cone.{u1, u1, u1, succ u1} J _inst_1 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Functor.comp.{u1, u1, u1, u1, succ u1, succ u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) Type.{u1} CategoryTheory.types.{u1} F (CategoryTheory.Limits.colim.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}))))) (CategoryTheory.Limits.colimitLimitToLimitColimitCone.{u1, succ u1} J K _inst_1 _inst_2 Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1})) (CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize.{u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} K _inst_2 CategoryTheory.Limits.Types.instHasColimitsTypeTypes.{u1}) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, succ u1} (CategoryTheory.Functor.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) (CategoryTheory.Functor.category.{u1, u1, u1, succ u1} K _inst_2 Type.{u1} CategoryTheory.types.{u1}) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 K _inst_2 (CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits.{u1, u1, succ u1} Type.{u1} CategoryTheory.types.{u1} J _inst_1 _inst_4 (CategoryTheory.Limits.hasFiniteLimits_of_hasLimits.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} CategoryTheory.Limits.Types.instHasLimitsTypeTypes.{u1}))) F))
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.colimit_limit_to_limit_colimit_cone_iso CategoryTheory.Limits.colimitLimitToLimitColimitCone_isoₓ'. -/
 instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
     IsIso (colimitLimitToLimitColimitCone F) :=
   by
@@ -319,6 +343,7 @@ instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
   apply cones.cone_iso_of_hom_iso
 #align category_theory.limits.colimit_limit_to_limit_colimit_cone_iso CategoryTheory.Limits.colimitLimitToLimitColimitCone_iso
 
+#print CategoryTheory.Limits.filteredColimPreservesFiniteLimitsOfTypes /-
 noncomputable instance filteredColimPreservesFiniteLimitsOfTypes :
     PreservesFiniteLimits (colim : (K ⥤ Type v) ⥤ _) :=
   by
@@ -331,6 +356,7 @@ noncomputable instance filteredColimPreservesFiniteLimitsOfTypes :
   exact functor.map_iso _ (hc.unique_up_to_iso (limit.is_limit F))
   exact as_iso (colimitLimitToLimitColimitCone.{v, v + 1} F)
 #align category_theory.limits.filtered_colim_preserves_finite_limits_of_types CategoryTheory.Limits.filteredColimPreservesFiniteLimitsOfTypes
+-/
 
 variable {C : Type u} [Category.{v} C] [ConcreteCategory.{v} C]
 
@@ -342,12 +368,14 @@ variable [ReflectsLimitsOfShape J (forget C)] [PreservesColimitsOfShape K (forge
 
 variable [PreservesLimitsOfShape J (forget C)]
 
+#print CategoryTheory.Limits.filteredColimPreservesFiniteLimits /-
 noncomputable instance filteredColimPreservesFiniteLimits :
     PreservesLimitsOfShape J (colim : (K ⥤ C) ⥤ _) :=
   haveI : preserves_limits_of_shape J ((colim : (K ⥤ C) ⥤ _) ⋙ forget C) :=
     preserves_limits_of_shape_of_nat_iso (preserves_colimit_nat_iso _).symm
   preserves_limits_of_shape_of_reflects_of_preserves _ (forget C)
 #align category_theory.limits.filtered_colim_preserves_finite_limits CategoryTheory.Limits.filteredColimPreservesFiniteLimits
+-/
 
 end
 
@@ -368,12 +396,20 @@ variable [ReflectsLimitsOfShape J (forget C)] [PreservesColimitsOfShape K (forge
 
 variable [PreservesLimitsOfShape J (forget C)]
 
+#print CategoryTheory.Limits.colimitLimitIso /-
 /-- A curried version of the fact that filtered colimits commute with finite limits. -/
 noncomputable def colimitLimitIso (F : J ⥤ K ⥤ C) : colimit (limit F) ≅ limit (colimit F.flip) :=
   (isLimitOfPreserves colim (limit.isLimit _)).conePointUniqueUpToIso (limit.isLimit _) ≪≫
     HasLimit.isoOfNatIso (colimitFlipIsoCompColim _).symm
 #align category_theory.limits.colimit_limit_iso CategoryTheory.Limits.colimitLimitIso
+-/
 
+/- warning: category_theory.limits.ι_colimit_limit_iso_limit_π -> CategoryTheory.Limits.ι_colimitLimitIso_limit_π is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] {C : Type.{u2}} [_inst_5 : CategoryTheory.Category.{u1, u2} C] [_inst_6 : CategoryTheory.ConcreteCategory.{u1, u1, u2} C _inst_5] [_inst_7 : CategoryTheory.Limits.HasLimitsOfShape.{u1, u1, u1, u2} J _inst_1 C _inst_5] [_inst_8 : CategoryTheory.Limits.HasColimitsOfShape.{u1, u1, u1, u2} K _inst_2 C _inst_5] [_inst_9 : CategoryTheory.Limits.ReflectsLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_10 : CategoryTheory.Limits.PreservesColimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_11 : CategoryTheory.Limits.PreservesLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] (F : CategoryTheory.Functor.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5)) (a : K) (b : J), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) a) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) b)) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) b) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) (CategoryTheory.Limits.colimitLimitIso._proof_4.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 _inst_8 F)) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) b) (CategoryTheory.Iso.hom.{u1, u2} C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.colimitLimitIso._proof_1.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 F)) (CategoryTheory.Limits.colimitLimitIso._proof_2.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 _inst_8 F)) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) (CategoryTheory.Limits.colimitLimitIso._proof_4.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 _inst_8 F)) (CategoryTheory.Limits.colimitLimitIso.{u1, u2} J K _inst_1 _inst_2 _inst_3 _inst_4 C _inst_5 _inst_6 _inst_7 _inst_8 _inst_9 _inst_10 _inst_11 F)) (CategoryTheory.Limits.limit.π.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.colimitLimitIso._proof_4.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_7 _inst_8 F) b))) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) a) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Functor.obj.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F b) a) (CategoryTheory.Functor.obj.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) b) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Functor.obj.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F b) (CategoryTheory.Limits.limit.π.{u1, u1, u1, max u1 u2} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F) b) a) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Functor.obj.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F)) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, max u1 u2} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.colimitLimitIso._proof_3.{u2, u1} J K _inst_1 _inst_2 C _inst_5 _inst_8 F) a) b))
+but is expected to have type
+  forall {J : Type.{u1}} {K : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] [_inst_2 : CategoryTheory.SmallCategory.{u1} K] [_inst_3 : CategoryTheory.IsFiltered.{u1, u1} K _inst_2] [_inst_4 : CategoryTheory.FinCategory.{u1} J _inst_1] {C : Type.{u2}} [_inst_5 : CategoryTheory.Category.{u1, u2} C] [_inst_6 : CategoryTheory.ConcreteCategory.{u1, u1, u2} C _inst_5] [_inst_7 : CategoryTheory.Limits.HasLimitsOfShape.{u1, u1, u1, u2} J _inst_1 C _inst_5] [_inst_8 : CategoryTheory.Limits.HasColimitsOfShape.{u1, u1, u1, u2} K _inst_2 C _inst_5] [_inst_9 : CategoryTheory.Limits.ReflectsLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_10 : CategoryTheory.Limits.PreservesColimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} K _inst_2 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] [_inst_11 : CategoryTheory.Limits.PreservesLimitsOfShape.{u1, u1, u1, u1, u2, succ u1} C _inst_5 Type.{u1} CategoryTheory.types.{u1} J _inst_1 (CategoryTheory.forget.{u2, u1, u1} C _inst_5 _inst_6)] (F : CategoryTheory.Functor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5)) (a : K) (b : J), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b)) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))))) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.Iso.hom.{u1, u2} C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, u2} C _inst_5 K _inst_2 _inst_8 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)))) (CategoryTheory.Limits.limit.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))))) (CategoryTheory.Limits.colimitLimitIso.{u1, u2} J K _inst_1 _inst_2 _inst_3 _inst_4 C _inst_5 _inst_6 _inst_7 _inst_8 _inst_9 _inst_10 _inst_11 F)) (CategoryTheory.Limits.limit.π.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, u2} C _inst_5 J _inst_1 _inst_7 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b))) (CategoryTheory.CategoryStruct.comp.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F))) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} K _inst_2 C _inst_5 (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F) b)) a) (Prefunctor.obj.{succ u1, succ u1, u1, u2} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_5)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, u2} J _inst_1 C _inst_5 (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)))) b) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} K _inst_2 C _inst_5 (CategoryTheory.Limits.limit.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F)) (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F) b) (CategoryTheory.Limits.limit.π.{u1, u1, u1, max u2 u1} J _inst_1 (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) F (CategoryTheory.Limits.hasLimitOfHasLimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} K _inst_2 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} K _inst_2 C _inst_5) J _inst_1 (CategoryTheory.Limits.functorCategoryHasLimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 J _inst_1 K _inst_2 _inst_7) F) b) a) (CategoryTheory.NatTrans.app.{u1, u1, u1, u2} J _inst_1 C _inst_5 (Prefunctor.obj.{succ u1, succ u1, u1, max u2 u1} K (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} K (CategoryTheory.Category.toCategoryStruct.{u1, u1} K _inst_2)) (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.CategoryStruct.toQuiver.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Category.toCategoryStruct.{u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)) a) (CategoryTheory.Limits.colimit.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F))) (CategoryTheory.Limits.colimit.ι.{u1, u1, u1, max u2 u1} K _inst_2 (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F) (CategoryTheory.Limits.hasColimitOfHasColimitsOfShape.{u1, u1, u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u1, u2} J _inst_1 C _inst_5) (CategoryTheory.Functor.category.{u1, u1, u1, u2} J _inst_1 C _inst_5) K _inst_2 (CategoryTheory.Limits.functorCategoryHasColimitsOfShape.{u1, u1, u1, u1, u1, u2} C _inst_5 K _inst_2 J _inst_1 _inst_8) (CategoryTheory.Functor.flip.{u1, u1, u1, u1, u1, u2} J _inst_1 K _inst_2 C _inst_5 F)) a) b))
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.ι_colimit_limit_iso_limit_π CategoryTheory.Limits.ι_colimitLimitIso_limit_πₓ'. -/
 @[simp, reassoc.1]
 theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
     colimit.ι (limit F) a ≫ (colimitLimitIso F).Hom ≫ limit.π (colimit F.flip) b =

3f409bd9

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

3f409bd9

chore: avoid id.def (adaptation for nightly-2024-03-27) (#11829)

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

b8a0f589

Diff

@@ -319,7 +319,7 @@ theorem colimitLimitToLimitColimit_surjective :
       intro j
       -- and as each component is an equation in a colimit, we can verify it by
       -- pointing out the morphism which carries one representative to the other:
-      simp only [id.def, ← e, Limits.ι_colimitLimitToLimitColimit_π_apply,
+      simp only [id, ← e, Limits.ι_colimitLimitToLimitColimit_π_apply,
           colimit_eq_iff, Bifunctor.map_id_comp, types_comp_apply, curry_obj_obj_map,
           Functor.comp_obj, colim_obj, Limit.π_mk]
       refine ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), ?_⟩

3f409bd9

chore: resolve some simp-related porting notes (#12074)

In all cases, the original proof works now. I presume this is due to simp changes in Lean 4.7, but haven't verified.

fef3b89b

Diff

@@ -137,13 +137,10 @@ theorem colimitLimitToLimitColimit_injective :
     ext j
     -- Now it's just a calculation using `W` and `w`.
     simp only [Functor.comp_map, Limit.map_π_apply, curry_obj_map_app, swap_map]
-    rw [← W _ _ (fH j)]
-    rw [← W _ _ (gH j)]
-    -- Porting note: this was `simp [w]` in lean 3; this is presumably a confluence issue
-    rw [lim_map, lim_map, Limit.map_π_apply, Limit.map_π_apply, Functor.map_comp,
-      Functor.map_comp, FunctorToTypes.comp, FunctorToTypes.comp, curry_obj_map_app,
-      curry_obj_map_app, curry_obj_map_app, Functor.comp_map, Functor.comp_map,
-      Functor.comp_map, swap_map, swap_map, swap_map, w]
+    rw [← W _ _ (fH j), ← W _ _ (gH j)]
+    -- Porting note(#10745): had to add `Limit.map_π_apply`
+    -- (which was un-tagged simp since "simp can prove it")
+    simp [Limit.map_π_apply, w]
 #align category_theory.limits.colimit_limit_to_limit_colimit_injective CategoryTheory.Limits.colimitLimitToLimitColimit_injective
 
 end

3f409bd9

chore(CategoryTheory): move Full, Faithful, EssSurj, IsEquivalence and ReflectsIsomorphisms to the Functor namespace (#11985)

These notions on functors are now Functor.Full, Functor.Faithful, Functor.EssSurj, Functor.IsEquivalence, Functor.ReflectsIsomorphisms. Deprecated aliases are introduced for the previous names.

65b7affc

Diff

@@ -379,7 +379,7 @@ end
 attribute [local instance] reflectsLimitsOfShapeOfReflectsIsomorphisms
 
 noncomputable instance [PreservesFiniteLimits (forget C)] [PreservesColimitsOfShape K (forget C)]
-    [HasFiniteLimits C] [HasColimitsOfShape K C] [ReflectsIsomorphisms (forget C)] :
+    [HasFiniteLimits C] [HasColimitsOfShape K C] [(forget C).ReflectsIsomorphisms] :
     PreservesFiniteLimits (colim : (K ⥤ C) ⥤ _) := by
   apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{v}
   intro J _ _

3f409bd9

feat: existence of a limit in a concrete category implies smallness (#11625)

In this PR, it is shown that if a functor G : J ⥤ C to a concrete category has a limit and that forget C is corepresentable, then G ⋙ forget C).sections is small. As the corepresentability property holds in many concrete categories (e.g. groups, abelian groups) and that we already know since #11420 that limits exist under the smallness assumption in such categories, then this lemma may be used in future PR in order to show that usual forgetful functors preserve all limits (regardless of universe assumptions). This shall be convenient in the development of sheaves of modules.

In this PR, universes assumptions have also been generalized in the file Limits.Yoneda. In order to do this, a small refactor of the file Limits.Types was necessary. This introduces bijections like compCoyonedaSectionsEquiv (F : J ⥤ C) (X : C) : (F ⋙ coyoneda.obj (op X)).sections ≃ ((const J).obj X ⟶ F) with general universe parameters. In order to reduce imports in Limits.Yoneda, part of the file Limits.Types was moved to a new file Limits.TypesFiltered.

Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr>

3cb545c7

Diff

@@ -7,6 +7,7 @@ import Mathlib.CategoryTheory.Limits.ColimitLimit
 import Mathlib.CategoryTheory.Limits.Preserves.FunctorCategory
 import Mathlib.CategoryTheory.Limits.Preserves.Finite
 import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
+import Mathlib.CategoryTheory.Limits.TypesFiltered
 import Mathlib.CategoryTheory.ConcreteCategory.Basic
 import Mathlib.CategoryTheory.Products.Bifunctor
 import Mathlib.Data.Countable.Small

3f409bd9

refactor: generalize universes for commuting filtered colimits and finite limits (#11325)

a57ceda5

Diff

@@ -7,9 +7,9 @@ import Mathlib.CategoryTheory.Limits.ColimitLimit
 import Mathlib.CategoryTheory.Limits.Preserves.FunctorCategory
 import Mathlib.CategoryTheory.Limits.Preserves.Finite
 import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
-import Mathlib.CategoryTheory.Limits.Preserves.Filtered
 import Mathlib.CategoryTheory.ConcreteCategory.Basic
 import Mathlib.CategoryTheory.Products.Bifunctor
+import Mathlib.Data.Countable.Small
 
 #align_import category_theory.limits.filtered_colimit_commutes_finite_limit from "leanprover-community/mathlib"@"3f409bd9df181d26dd223170da7b6830ece18442"
 
@@ -34,20 +34,22 @@ assert_not_exists Field
  -- TODO: We should morally be able to strengthen this to `assert_not_exists GroupWithZero`, but
  -- finiteness currently relies on more algebra than it needs.
 
-universe v u
+universe w v₁ v₂ v u₁ u₂ u
 
 open CategoryTheory CategoryTheory.Category CategoryTheory.Limits.Types
   CategoryTheory.Limits.Types.FilteredColimit
 
 namespace CategoryTheory.Limits
 
-variable {J K : Type v} [SmallCategory J] [SmallCategory K]
+section
+
+variable {J : Type u₁} {K : Type u₂} [Category.{v₁} J] [Category.{v₂} K] [Small.{v} K]
 
 /-- `(G ⋙ lim).obj j` = `limit (G.obj j)` definitionally, so this
 is just a variant of `limit_ext'`. -/
 @[ext] lemma comp_lim_obj_ext {j : J} {G : J ⥤ K ⥤ Type v} (x y : (G ⋙ lim).obj j)
     (w : ∀ (k : K), limit.π (G.obj j) k x = limit.π (G.obj j) k y) : x = y :=
-  limit_ext' _ x y w
+  limit_ext _ x y w
 
 variable (F : J × K ⥤ Type v)
 
@@ -75,17 +77,17 @@ theorem colimitLimitToLimitColimit_injective :
     -- and that these have the same image under `colimitLimitToLimitColimit F`.
     intro x y h
     -- These elements of the colimit have representatives somewhere:
-    obtain ⟨kx, x, rfl⟩ := jointly_surjective'.{v, v} x
-    obtain ⟨ky, y, rfl⟩ := jointly_surjective'.{v, v} y
+    obtain ⟨kx, x, rfl⟩ := jointly_surjective' x
+    obtain ⟨ky, y, rfl⟩ := jointly_surjective' y
     dsimp at x y
     -- Since the images of `x` and `y` are equal in a limit, they are equal componentwise
     -- (indexed by `j : J`),
     replace h := fun j => congr_arg (limit.π (curry.obj F ⋙ colim) j) h
     -- and they are equations in a filtered colimit,
     -- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
-    simp? [colimit_eq_iff.{v, v}] at h says
+    simp? [colimit_eq_iff] at h says
       simp only [Functor.comp_obj, colim_obj, ι_colimitLimitToLimitColimit_π_apply,
-        colimit_eq_iff.{v, v}, curry_obj_obj_obj, curry_obj_obj_map] at h
+        colimit_eq_iff, curry_obj_obj_obj, curry_obj_obj_map] at h
     let k j := (h j).choose
     let f : ∀ j, kx ⟶ k j := fun j => (h j).choose_spec.choose
     let g : ∀ j, ky ⟶ k j := fun j => (h j).choose_spec.choose_spec.choose
@@ -128,7 +130,7 @@ theorem colimitLimitToLimitColimit_injective :
             simp only [heq_iff_eq]))
     -- Our goal is now an equation between equivalence classes of representatives of a colimit,
     -- and so it suffices to show those representative become equal somewhere, in particular at `S`.
-    apply colimit_sound'.{v, v} (T kxO) (T kyO)
+    apply colimit_sound' (T kxO) (T kyO)
     -- We can check if two elements of a limit (in `Type`)
     -- are equal by comparing them componentwise.
     ext j
@@ -137,7 +139,7 @@ theorem colimitLimitToLimitColimit_injective :
     rw [← W _ _ (fH j)]
     rw [← W _ _ (gH j)]
     -- Porting note: this was `simp [w]` in lean 3; this is presumably a confluence issue
-    rw [lim_map, lim_map, Limit.map_π_apply', Limit.map_π_apply', Functor.map_comp,
+    rw [lim_map, lim_map, Limit.map_π_apply, Limit.map_π_apply, Functor.map_comp,
       Functor.map_comp, FunctorToTypes.comp, FunctorToTypes.comp, curry_obj_map_app,
       curry_obj_map_app, curry_obj_map_app, Functor.comp_map, Functor.comp_map,
       Functor.comp_map, swap_map, swap_map, swap_map, w]
@@ -145,8 +147,20 @@ theorem colimitLimitToLimitColimit_injective :
 
 end
 
+end
+
+section
+
+variable {J : Type u₁} {K : Type u₂} [SmallCategory J] [Category.{v₂} K] [Small.{v} K]
+
 variable [FinCategory J]
 
+variable (F : J × K ⥤ Type v)
+
+open CategoryTheory.Prod
+
+variable [IsFiltered K]
+
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 although with different names.
@@ -158,7 +172,7 @@ theorem colimitLimitToLimitColimit_surjective :
     intro x
     -- This consists of some coherent family of elements in the various colimits,
     -- and so our first task is to pick representatives of these elements.
-    have z := fun j => jointly_surjective'.{v, v} (limit.π (curry.obj F ⋙ Limits.colim) j x)
+    have z := fun j => jointly_surjective' (limit.π (curry.obj F ⋙ Limits.colim) j x)
     -- `k : J ⟶ K` records where the representative of the
     -- element in the `j`-th element of `x` lives
     let k : J → K := fun j => (z j).choose
@@ -190,13 +204,13 @@ theorem colimitLimitToLimitColimit_surjective :
       have t : (f, g j) =
           (((f, 𝟙 (k j)) : (j, k j) ⟶ (j', k j)) ≫ (𝟙 j', g j) : (j, k j) ⟶ (j', k')) := by
         simp only [id_comp, comp_id, prod_comp]
-      erw [Colimit.w_apply', t, FunctorToTypes.map_comp_apply, Colimit.w_apply', e, ←
-        Limit.w_apply' f, ← e]
-      simp
+      erw [Colimit.w_apply, t, FunctorToTypes.map_comp_apply, Colimit.w_apply, e,
+        ← Limit.w_apply.{u₁, v, u₁} f, ← e]
+      simp only [Functor.comp_map, Types.Colimit.ι_map_apply, curry_obj_map_app]
     -- Because `K` is filtered, we can restate this as saying that
     -- for each such `f`, there is some place to the right of `k'`
     -- where these images of `y j` and `y j'` become equal.
-    simp_rw [colimit_eq_iff.{v, v}] at w
+    simp_rw [colimit_eq_iff] at w
     -- We take a moment to restate `w` more conveniently.
     let kf : ∀ {j j'} (_ : j ⟶ j'), K := fun f => (w f).choose
     let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun f => (w f).choose_spec.choose
@@ -277,7 +291,7 @@ theorem colimitLimitToLimitColimit_surjective :
       -- This representative is meant to be an element of a limit,
       -- so we need to construct a family of elements in `F.obj (j, k'')` for varying `j`,
       -- then show that are coherent with respect to morphisms in the `j` direction.
-      apply Limit.mk.{v, v}
+      apply Limit.mk
       swap
       ·-- We construct the elements as the images of the `y j`.
         exact fun j => F.map (⟨𝟙 j, g j ≫ gf (𝟙 j) ≫ i (𝟙 j)⟩ : (j, k j) ⟶ (j, k'')) (y j)
@@ -303,12 +317,12 @@ theorem colimitLimitToLimitColimit_surjective :
             rw [s f (𝟙 j'), ← s (𝟙 j') (𝟙 j')]
     -- Finally we check that this maps to `x`.
     · -- We can do this componentwise:
-      apply limit_ext'
+      apply limit_ext
       intro j
       -- and as each component is an equation in a colimit, we can verify it by
       -- pointing out the morphism which carries one representative to the other:
       simp only [id.def, ← e, Limits.ι_colimitLimitToLimitColimit_π_apply,
-          colimit_eq_iff.{v, v}, Bifunctor.map_id_comp, types_comp_apply, curry_obj_obj_map,
+          colimit_eq_iff, Bifunctor.map_id_comp, types_comp_apply, curry_obj_obj_map,
           Functor.comp_obj, colim_obj, Limit.π_mk]
       refine ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), ?_⟩
       -- Porting note: the lean 3 proof finished with
@@ -335,13 +349,13 @@ instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
 
 noncomputable instance filteredColimPreservesFiniteLimitsOfTypes :
     PreservesFiniteLimits (colim : (K ⥤ Type v) ⥤ _) := by
-  apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{v}
+  apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{v₂}
   intro J _ _
   refine ⟨fun {F} => ⟨fun {c} hc => IsLimit.ofIsoLimit (limit.isLimit _) ?_⟩⟩
   symm
   trans colim.mapCone (limit.cone F)
   · exact Functor.mapIso _ (hc.uniqueUpToIso (limit.isLimit F))
-  · exact asIso (colimitLimitToLimitColimitCone.{v, v + 1} F)
+  · exact asIso (colimitLimitToLimitColimitCone F)
 #align category_theory.limits.filtered_colim_preserves_finite_limits_of_types CategoryTheory.Limits.filteredColimPreservesFiniteLimitsOfTypes
 
 variable {C : Type u} [Category.{v} C] [ConcreteCategory.{v} C]
@@ -363,7 +377,7 @@ end
 
 attribute [local instance] reflectsLimitsOfShapeOfReflectsIsomorphisms
 
-noncomputable instance [PreservesFiniteLimits (forget C)] [PreservesFilteredColimits (forget C)]
+noncomputable instance [PreservesFiniteLimits (forget C)] [PreservesColimitsOfShape K (forget C)]
     [HasFiniteLimits C] [HasColimitsOfShape K C] [ReflectsIsomorphisms (forget C)] :
     PreservesFiniteLimits (colim : (K ⥤ C) ⥤ _) := by
   apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{v}
@@ -401,4 +415,6 @@ theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
 
 end
 
+end
+
 end CategoryTheory.Limits

3f409bd9

chore: Move GroupWithZero lemmas earlier (#10919)

Move from Algebra.GroupWithZero.Units.Lemmas to Algebra.GroupWithZero.Units.Basic the lemmas that can be moved.

8ff9aa61

Diff

@@ -27,6 +27,12 @@ colimit (over `K`) of the limits (over `J`) with the limit of the colimits is an
 * [Stacks: Filtered colimits](https://stacks.math.columbia.edu/tag/002W)
 -/
 
+-- Various pieces of algebra that have previously been spuriously imported here:
+assert_not_exists zero_zpow
+assert_not_exists map_ne_zero
+assert_not_exists Field
+ -- TODO: We should morally be able to strengthen this to `assert_not_exists GroupWithZero`, but
+ -- finiteness currently relies on more algebra than it needs.
 
 universe v u
 
@@ -396,8 +402,3 @@ theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
 end
 
 end CategoryTheory.Limits
-
--- Various pieces of algebra that have previously been spuriously imported here:
-assert_not_exists zero_zpow
-assert_not_exists div_self
-assert_not_exists Field

3f409bd9

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

@@ -343,9 +343,7 @@ variable {C : Type u} [Category.{v} C] [ConcreteCategory.{v} C]
 section
 
 variable [HasLimitsOfShape J C] [HasColimitsOfShape K C]
-
 variable [ReflectsLimitsOfShape J (forget C)] [PreservesColimitsOfShape K (forget C)]
-
 variable [PreservesLimitsOfShape J (forget C)]
 
 noncomputable instance filteredColimPreservesFiniteLimits :
@@ -369,9 +367,7 @@ noncomputable instance [PreservesFiniteLimits (forget C)] [PreservesFilteredColi
 section
 
 variable [HasLimitsOfShape J C] [HasColimitsOfShape K C]
-
 variable [ReflectsLimitsOfShape J (forget C)] [PreservesColimitsOfShape K (forget C)]
-
 variable [PreservesLimitsOfShape J (forget C)]
 
 /-- A curried version of the fact that filtered colimits commute with finite limits. -/

3f409bd9

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -130,7 +130,7 @@ theorem colimitLimitToLimitColimit_injective :
     simp only [Functor.comp_map, Limit.map_π_apply, curry_obj_map_app, swap_map]
     rw [← W _ _ (fH j)]
     rw [← W _ _ (gH j)]
-    -- porting note: this was `simp [w]` in lean 3; this is presumably a confluence issue
+    -- Porting note: this was `simp [w]` in lean 3; this is presumably a confluence issue
     rw [lim_map, lim_map, Limit.map_π_apply', Limit.map_π_apply', Functor.map_comp,
       Functor.map_comp, FunctorToTypes.comp, FunctorToTypes.comp, curry_obj_map_app,
       curry_obj_map_app, curry_obj_map_app, Functor.comp_map, Functor.comp_map,
@@ -206,7 +206,7 @@ theorem colimitLimitToLimitColimit_surjective :
           ((curry.obj F).obj j').map (hf f) (F.map ((f, g j) : (j, k j) ⟶ (j', k')) (y j)) :=
         (w f).choose_spec.choose_spec.choose_spec
       rw [curry_obj_obj_map, curry_obj_obj_map] at q
-      -- porting note: Lean 4 `dsimp` unfolds `gf` and `hf` in `q` :-(
+      -- Porting note: Lean 4 `dsimp` unfolds `gf` and `hf` in `q` :-(
       -- See discussion at https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/.60dsimp.60.20unfolding.20local.20lets
       simp_rw [← FunctorToTypes.map_comp_apply, CategoryStruct.comp] at q
       convert q <;> simp only [comp_id]
@@ -239,7 +239,7 @@ theorem colimitLimitToLimitColimit_surjective :
     have s : ∀ {j₁ j₂ j₃ j₄} (f : j₁ ⟶ j₂) (f' : j₃ ⟶ j₄), gf f ≫ i f = hf f' ≫ i f' := by
       intros j₁ j₂ j₃ j₄ f f'
       rw [s', s']
-      -- porting note: the three goals here in Lean 3 were in a different order
+      -- Porting note: the three goals here in Lean 3 were in a different order
       · exact k'O
       · exact Finset.mem_biUnion.mpr ⟨j₃, Finset.mem_univ _,
           Finset.mem_biUnion.mpr ⟨j₄, Finset.mem_univ _,
@@ -305,7 +305,7 @@ theorem colimitLimitToLimitColimit_surjective :
           colimit_eq_iff.{v, v}, Bifunctor.map_id_comp, types_comp_apply, curry_obj_obj_map,
           Functor.comp_obj, colim_obj, Limit.π_mk]
       refine ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), ?_⟩
-      -- porting note: the lean 3 proof finished with
+      -- Porting note: the lean 3 proof finished with
       -- `simp only [Bifunctor.map_id_comp, types_comp_apply, Bifunctor.map_id, types_id_apply]`
       -- which doesn't work; the corresponding `rw` works fine:
       rw [Bifunctor.map_id_comp, Bifunctor.map_id_comp, types_comp_apply, types_comp_apply,

3f409bd9

chore: remove spurious imports of positivity (#9924)

Some of these are already transitively imported, others aren't used at all (but not handled by noshake in #9772).

Mostly I wanted to avoid needing all of algebra imported (but unused!) in FilteredColimitCommutesFiniteLimit; there are now some assert_not_exists to preserve this.

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

26c5ad69

Diff

@@ -400,3 +400,8 @@ theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
 end
 
 end CategoryTheory.Limits
+
+-- Various pieces of algebra that have previously been spuriously imported here:
+assert_not_exists zero_zpow
+assert_not_exists div_self
+assert_not_exists Field

3f409bd9

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

@@ -9,6 +9,7 @@ import Mathlib.CategoryTheory.Limits.Preserves.Finite
 import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
 import Mathlib.CategoryTheory.Limits.Preserves.Filtered
 import Mathlib.CategoryTheory.ConcreteCategory.Basic
+import Mathlib.CategoryTheory.Products.Bifunctor
 
 #align_import category_theory.limits.filtered_colimit_commutes_finite_limit from "leanprover-community/mathlib"@"3f409bd9df181d26dd223170da7b6830ece18442"

3f409bd9

chore: reduce heartbeats variation in FilteredColimitCommutesFiniteLimit (#9732)

Per discussion at zulip. This proof has been showing up spuriously in benchmark results.

This change reduces the heartbeats variance from around 25% to around 5%.

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

241edd49

Diff

@@ -222,14 +222,9 @@ theorem colimitLimitToLimitColimit_surjective :
     have kfO : ∀ {j j'} (f : j ⟶ j'), kf f ∈ O := fun {j} {j'} f =>
       Finset.mem_union.mpr
         (Or.inl
-          (by
-            rw [Finset.mem_biUnion]
-            refine' ⟨j, Finset.mem_univ j, _⟩
-            rw [Finset.mem_biUnion]
-            refine' ⟨j', Finset.mem_univ j', _⟩
-            rw [Finset.mem_image]
-            refine' ⟨f, Finset.mem_univ _, _⟩
-            rfl))
+          (Finset.mem_biUnion.mpr ⟨j, Finset.mem_univ j,
+            Finset.mem_biUnion.mpr ⟨j', Finset.mem_univ j',
+              Finset.mem_image.mpr ⟨f, Finset.mem_univ _, rfl⟩⟩⟩))
     have k'O : k' ∈ O := Finset.mem_union.mpr (Or.inr (Finset.mem_singleton.mpr rfl))
     let H : Finset (Σ' (X Y : K) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) :=
       Finset.univ.biUnion fun j : J =>
@@ -244,23 +239,25 @@ theorem colimitLimitToLimitColimit_surjective :
       intros j₁ j₂ j₃ j₄ f f'
       rw [s', s']
       -- porting note: the three goals here in Lean 3 were in a different order
-      exact k'O
-      swap
-      · rw [Finset.mem_biUnion]
-        refine' ⟨j₁, Finset.mem_univ _, _⟩
-        rw [Finset.mem_biUnion]
-        refine' ⟨j₂, Finset.mem_univ _, _⟩
-        rw [Finset.mem_biUnion]
-        refine' ⟨f, Finset.mem_univ _, _⟩
-        simp only [true_or_iff, eq_self_iff_true, and_self_iff, Finset.mem_insert, heq_iff_eq]
-      · rw [Finset.mem_biUnion]
-        refine' ⟨j₃, Finset.mem_univ _, _⟩
-        rw [Finset.mem_biUnion]
-        refine' ⟨j₄, Finset.mem_univ _, _⟩
-        rw [Finset.mem_biUnion]
-        refine' ⟨f', Finset.mem_univ _, _⟩
-        simp only [eq_self_iff_true, or_true_iff, and_self_iff, Finset.mem_insert,
-          Finset.mem_singleton, heq_iff_eq]
+      · exact k'O
+      · exact Finset.mem_biUnion.mpr ⟨j₃, Finset.mem_univ _,
+          Finset.mem_biUnion.mpr ⟨j₄, Finset.mem_univ _,
+            Finset.mem_biUnion.mpr ⟨f', Finset.mem_univ _, by
+              -- This works by `simp`, but has very high variation in heartbeats.
+              rw [Finset.mem_insert, PSigma.mk.injEq, heq_eq_eq, PSigma.mk.injEq, heq_eq_eq,
+                PSigma.mk.injEq, heq_eq_eq, PSigma.mk.injEq, heq_eq_eq, eq_self, true_and, eq_self,
+                true_and, eq_self, true_and, eq_self, true_and, Finset.mem_singleton, eq_self,
+                or_true]
+              trivial⟩⟩⟩
+      · exact Finset.mem_biUnion.mpr ⟨j₁, Finset.mem_univ _,
+          Finset.mem_biUnion.mpr ⟨j₂, Finset.mem_univ _,
+            Finset.mem_biUnion.mpr ⟨f, Finset.mem_univ _, by
+              -- This works by `simp`, but has very high variation in heartbeats.
+              rw [Finset.mem_insert, PSigma.mk.injEq, heq_eq_eq, PSigma.mk.injEq, heq_eq_eq,
+                PSigma.mk.injEq, heq_eq_eq, PSigma.mk.injEq, heq_eq_eq, eq_self, true_and, eq_self,
+                true_and, eq_self, true_and, eq_self, true_and, Finset.mem_singleton, eq_self,
+                true_or]
+              trivial⟩⟩⟩
     clear_value i
     clear s' i' H kfO k'O O
     -- We're finally ready to construct the pre-image, and verify it really maps to `x`.
@@ -306,7 +303,7 @@ theorem colimitLimitToLimitColimit_surjective :
       simp only [id.def, ← e, Limits.ι_colimitLimitToLimitColimit_π_apply,
           colimit_eq_iff.{v, v}, Bifunctor.map_id_comp, types_comp_apply, curry_obj_obj_map,
           Functor.comp_obj, colim_obj, Limit.π_mk]
-      refine' ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), _⟩
+      refine ⟨k'', 𝟙 k'', g j ≫ gf (𝟙 j) ≫ i (𝟙 j), ?_⟩
       -- porting note: the lean 3 proof finished with
       -- `simp only [Bifunctor.map_id_comp, types_comp_apply, Bifunctor.map_id, types_id_apply]`
       -- which doesn't work; the corresponding `rw` works fine:

3f409bd9

chore: Remove nonterminal simp at (#7795)

Removes nonterminal uses of simp at. Replaces most of these with instances of simp? ... says.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

4160b2aa

Diff

@@ -76,7 +76,9 @@ theorem colimitLimitToLimitColimit_injective :
     replace h := fun j => congr_arg (limit.π (curry.obj F ⋙ colim) j) h
     -- and they are equations in a filtered colimit,
     -- so for each `j` we have some place `k j` to the right of both `kx` and `ky`
-    simp [colimit_eq_iff.{v, v}] at h
+    simp? [colimit_eq_iff.{v, v}] at h says
+      simp only [Functor.comp_obj, colim_obj, ι_colimitLimitToLimitColimit_π_apply,
+        colimit_eq_iff.{v, v}, curry_obj_obj_obj, curry_obj_obj_map] at h
     let k j := (h j).choose
     let f : ∀ j, kx ⟶ k j := fun j => (h j).choose_spec.choose
     let g : ∀ j, ky ⟶ k j := fun j => (h j).choose_spec.choose_spec.choose

3f409bd9

chore: replace ConeMorphism.Hom by ConeMorphism.hom (#7176)

3e44bb07

Diff

@@ -319,7 +319,7 @@ instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F)
 
 instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
     IsIso (colimitLimitToLimitColimitCone F) := by
-  have : IsIso (colimitLimitToLimitColimitCone F).Hom := by
+  have : IsIso (colimitLimitToLimitColimitCone F).hom := by
     suffices IsIso (colimitLimitToLimitColimit (uncurry.obj F) ≫
         lim.map (whiskerRight (currying.unitIso.app F).inv colim)) by
       apply IsIso.comp_isIso

3f409bd9

chore: avoid lean3 style have/suffices (#6964)

Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... := or suffices ... from/by.

This PR updates a fraction of these to the preferred Lean 4 style.

I think a good goal would be to delete the "deferred" versions of have, suffices, and let at the bottom of Mathlib.Tactic.Have

(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)

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

bdc47f68

Diff

@@ -320,9 +320,9 @@ instance colimitLimitToLimitColimit_isIso : IsIso (colimitLimitToLimitColimit F)
 instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
     IsIso (colimitLimitToLimitColimitCone F) := by
   have : IsIso (colimitLimitToLimitColimitCone F).Hom := by
-    suffices : IsIso (colimitLimitToLimitColimit (uncurry.obj F) ≫
-      lim.map (whiskerRight (currying.unitIso.app F).inv colim))
-    apply IsIso.comp_isIso
+    suffices IsIso (colimitLimitToLimitColimit (uncurry.obj F) ≫
+        lim.map (whiskerRight (currying.unitIso.app F).inv colim)) by
+      apply IsIso.comp_isIso
     infer_instance
   apply Cones.cone_iso_of_hom_iso
 #align category_theory.limits.colimit_limit_to_limit_colimit_cone_iso CategoryTheory.Limits.colimitLimitToLimitColimitCone_iso

3f409bd9

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,11 +2,6 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module category_theory.limits.filtered_colimit_commutes_finite_limit
-! leanprover-community/mathlib commit 3f409bd9df181d26dd223170da7b6830ece18442
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.ColimitLimit
 import Mathlib.CategoryTheory.Limits.Preserves.FunctorCategory
@@ -15,6 +10,8 @@ import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
 import Mathlib.CategoryTheory.Limits.Preserves.Filtered
 import Mathlib.CategoryTheory.ConcreteCategory.Basic
 
+#align_import category_theory.limits.filtered_colimit_commutes_finite_limit from "leanprover-community/mathlib"@"3f409bd9df181d26dd223170da7b6830ece18442"
+
 /-!
 # Filtered colimits commute with finite limits.

3f409bd9

chore: disable relaxedAutoImplicit (#5277)

We disable the "relaxed" auto-implicit feature, so only single character identifiers become eligible as auto-implicits. See discussion on zulip and 2.

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

52d95f2b

Diff

@@ -39,10 +39,10 @@ namespace CategoryTheory.Limits
 
 variable {J K : Type v} [SmallCategory J] [SmallCategory K]
 
-/-- `(G ⋙ lim).obj S` = `limit (G.obj S)` definitionally, so this
+/-- `(G ⋙ lim).obj j` = `limit (G.obj j)` definitionally, so this
 is just a variant of `limit_ext'`. -/
-@[ext] lemma comp_lim_obj_ext {G : J ⥤ K ⥤ Type v} (x y : (G ⋙ lim).obj S) (w : ∀ (j : K),
-    limit.π (G.obj S) j x = limit.π (G.obj S) j y) : x = y :=
+@[ext] lemma comp_lim_obj_ext {j : J} {G : J ⥤ K ⥤ Type v} (x y : (G ⋙ lim).obj j)
+    (w : ∀ (k : K), limit.π (G.obj j) k x = limit.π (G.obj j) k y) : x = y :=
   limit_ext' _ x y w
 
 variable (F : J × K ⥤ Type v)
@@ -110,7 +110,7 @@ theorem colimitLimitToLimitColimit_injective :
               Finset.mem_image, heq_iff_eq]
             refine' ⟨j, _⟩
             simp only [heq_iff_eq] ))
-    have gH : 
+    have gH :
       ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ' (X Y : K) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) ∈ H :=
       fun j =>
       Finset.mem_union.mpr

3f409bd9

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -96,12 +96,12 @@ theorem colimitLimitToLimitColimit_injective :
     have kxO : kx ∈ O := Finset.mem_union.mpr (Or.inr (by simp))
     have kyO : ky ∈ O := Finset.mem_union.mpr (Or.inr (by simp))
     have kjO : ∀ j, k j ∈ O := fun j => Finset.mem_union.mpr (Or.inl (by simp))
-    let H : Finset (Σ'(X Y : K)(_ : X ∈ O)(_ : Y ∈ O), X ⟶ Y) :=
+    let H : Finset (Σ' (X Y : K) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) :=
       (Finset.univ.image fun j : J =>
           ⟨kx, k j, kxO, Finset.mem_union.mpr (Or.inl (by simp)), f j⟩) ∪
         Finset.univ.image fun j : J => ⟨ky, k j, kyO, Finset.mem_union.mpr (Or.inl (by simp)), g j⟩
     obtain ⟨S, T, W⟩ := IsFiltered.sup_exists O H
-    have fH : ∀ j, (⟨kx, k j, kxO, kjO j, f j⟩ : Σ'(X Y : K)(_ : X ∈ O)(_ : Y ∈ O), X ⟶ Y) ∈ H :=
+    have fH : ∀ j, (⟨kx, k j, kxO, kjO j, f j⟩ : Σ' (X Y : K) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) ∈ H :=
       fun j =>
       Finset.mem_union.mpr
         (Or.inl
@@ -110,7 +110,8 @@ theorem colimitLimitToLimitColimit_injective :
               Finset.mem_image, heq_iff_eq]
             refine' ⟨j, _⟩
             simp only [heq_iff_eq] ))
-    have gH : ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ'(X Y : K)(_ : X ∈ O)(_ : Y ∈ O), X ⟶ Y) ∈ H :=
+    have gH : 
+      ∀ j, (⟨ky, k j, kyO, kjO j, g j⟩ : Σ' (X Y : K) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) ∈ H :=
       fun j =>
       Finset.mem_union.mpr
         (Or.inr
@@ -231,7 +232,7 @@ theorem colimitLimitToLimitColimit_surjective :
             refine' ⟨f, Finset.mem_univ _, _⟩
             rfl))
     have k'O : k' ∈ O := Finset.mem_union.mpr (Or.inr (Finset.mem_singleton.mpr rfl))
-    let H : Finset (Σ'(X Y : K)(_ : X ∈ O)(_ : Y ∈ O), X ⟶ Y) :=
+    let H : Finset (Σ' (X Y : K) (_ : X ∈ O) (_ : Y ∈ O), X ⟶ Y) :=
       Finset.univ.biUnion fun j : J =>
         Finset.univ.biUnion fun j' : J =>
           Finset.univ.biUnion fun f : j ⟶ j' =>

3f409bd9

chore: Rename to sSup/iSup (#3938)

As discussed on Zulip

Renames

supₛ → sSup
infₛ → sInf
supᵢ → iSup
infᵢ → iInf
bsupₛ → bsSup
binfₛ → bsInf
bsupᵢ → biSup
binfᵢ → biInf
csupₛ → csSup
cinfₛ → csInf
csupᵢ → ciSup
cinfᵢ → ciInf
unionₛ → sUnion
interₛ → sInter
unionᵢ → iUnion
interᵢ → iInter
bunionₛ → bsUnion
binterₛ → bsInter
bunionᵢ → biUnion
binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

d1eb6264

Diff

@@ -217,24 +217,24 @@ theorem colimitLimitToLimitColimit_surjective :
     -- the morphisms `gf f : k' ⟶ kh f` and `hf f : k' ⟶ kf f`.
     -- At this point we're relying on there being only finitely morphisms in `J`.
     let O :=
-      (Finset.univ.bunionᵢ fun j => Finset.univ.bunionᵢ fun j' => Finset.univ.image
+      (Finset.univ.biUnion fun j => Finset.univ.biUnion fun j' => Finset.univ.image
         (@kf j j')) ∪ {k'}
     have kfO : ∀ {j j'} (f : j ⟶ j'), kf f ∈ O := fun {j} {j'} f =>
       Finset.mem_union.mpr
         (Or.inl
           (by
-            rw [Finset.mem_bunionᵢ]
+            rw [Finset.mem_biUnion]
             refine' ⟨j, Finset.mem_univ j, _⟩
-            rw [Finset.mem_bunionᵢ]
+            rw [Finset.mem_biUnion]
             refine' ⟨j', Finset.mem_univ j', _⟩
             rw [Finset.mem_image]
             refine' ⟨f, Finset.mem_univ _, _⟩
             rfl))
     have k'O : k' ∈ O := Finset.mem_union.mpr (Or.inr (Finset.mem_singleton.mpr rfl))
     let H : Finset (Σ'(X Y : K)(_ : X ∈ O)(_ : Y ∈ O), X ⟶ Y) :=
-      Finset.univ.bunionᵢ fun j : J =>
-        Finset.univ.bunionᵢ fun j' : J =>
-          Finset.univ.bunionᵢ fun f : j ⟶ j' =>
+      Finset.univ.biUnion fun j : J =>
+        Finset.univ.biUnion fun j' : J =>
+          Finset.univ.biUnion fun f : j ⟶ j' =>
             {⟨k', kf f, k'O, kfO f, gf f⟩, ⟨k', kf f, k'O, kfO f, hf f⟩}
     obtain ⟨k'', i', s'⟩ := IsFiltered.sup_exists O H
     -- We then restate this slightly more conveniently, as a family of morphism `i f : kf f ⟶ k''`,
@@ -246,18 +246,18 @@ theorem colimitLimitToLimitColimit_surjective :
       -- porting note: the three goals here in Lean 3 were in a different order
       exact k'O
       swap
-      · rw [Finset.mem_bunionᵢ]
+      · rw [Finset.mem_biUnion]
         refine' ⟨j₁, Finset.mem_univ _, _⟩
-        rw [Finset.mem_bunionᵢ]
+        rw [Finset.mem_biUnion]
         refine' ⟨j₂, Finset.mem_univ _, _⟩
-        rw [Finset.mem_bunionᵢ]
+        rw [Finset.mem_biUnion]
         refine' ⟨f, Finset.mem_univ _, _⟩
         simp only [true_or_iff, eq_self_iff_true, and_self_iff, Finset.mem_insert, heq_iff_eq]
-      · rw [Finset.mem_bunionᵢ]
+      · rw [Finset.mem_biUnion]
         refine' ⟨j₃, Finset.mem_univ _, _⟩
-        rw [Finset.mem_bunionᵢ]
+        rw [Finset.mem_biUnion]
         refine' ⟨j₄, Finset.mem_univ _, _⟩
-        rw [Finset.mem_bunionᵢ]
+        rw [Finset.mem_biUnion]
         refine' ⟨f', Finset.mem_univ _, _⟩
         simp only [eq_self_iff_true, or_true_iff, and_self_iff, Finset.mem_insert,
           Finset.mem_singleton, heq_iff_eq]

3f409bd9

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -63,8 +63,8 @@ variable [Finite J]
 /-- This follows this proof from
 * Borceux, Handbook of categorical algebra 1, Theorem 2.13.4
 -/
-theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitToLimitColimit F) :=
-  by
+theorem colimitLimitToLimitColimit_injective :
+    Function.Injective (colimitLimitToLimitColimit F) := by
   classical
     cases nonempty_fintype J
     -- Suppose we have two terms `x y` in the colimit (over `K`) of the limits (over `J`),

3f409bd9

chore: tidy various files (#3718)

2215ff4f

Diff

@@ -19,7 +19,7 @@ import Mathlib.CategoryTheory.ConcreteCategory.Basic
 # Filtered colimits commute with finite limits.
 
 We show that for a functor `F : J × K ⥤ Type v`, when `J` is finite and `K` is filtered,
-the universal morphism `colimit_limit_to_limit_colimit F` comparing the
+the universal morphism `colimitLimitToLimitColimit F` comparing the
 colimit (over `K`) of the limits (over `J`) with the limit of the colimits is an isomorphism.
 
 (In fact, to prove that it is injective only requires that `J` has finitely many objects.)
@@ -32,13 +32,8 @@ colimit (over `K`) of the limits (over `J`) with the limit of the colimits is an
 
 universe v u
 
-open CategoryTheory
-
-open CategoryTheory.Category
-
-open CategoryTheory.Limits.Types
-
-open CategoryTheory.Limits.Types.FilteredColimit
+open CategoryTheory CategoryTheory.Category CategoryTheory.Limits.Types
+  CategoryTheory.Limits.Types.FilteredColimit
 
 namespace CategoryTheory.Limits
 
@@ -73,7 +68,7 @@ theorem colimitLimitToLimitColimit_injective : Function.Injective (colimitLimitT
   classical
     cases nonempty_fintype J
     -- Suppose we have two terms `x y` in the colimit (over `K`) of the limits (over `J`),
-    -- and that these have the same image under `colimit_limit_to_limit_colimit F`.
+    -- and that these have the same image under `colimitLimitToLimitColimit F`.
     intro x y h
     -- These elements of the colimit have representatives somewhere:
     obtain ⟨kx, x, rfl⟩ := jointly_surjective'.{v, v} x
@@ -196,15 +191,15 @@ theorem colimitLimitToLimitColimit_surjective :
     -- where these images of `y j` and `y j'` become equal.
     simp_rw [colimit_eq_iff.{v, v}] at w
     -- We take a moment to restate `w` more conveniently.
-    let kf : ∀ {j j'} (_ : j ⟶ j'), K := fun {_} {_} f => (w f).choose
-    let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun {_} {_} f => (w f).choose_spec.choose
-    let hf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun {_} {_} f =>
+    let kf : ∀ {j j'} (_ : j ⟶ j'), K := fun f => (w f).choose
+    let gf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun f => (w f).choose_spec.choose
+    let hf : ∀ {j j'} (f : j ⟶ j'), k' ⟶ kf f := fun f =>
       (w f).choose_spec.choose_spec.choose
     have wf :
       ∀ {j j'} (f : j ⟶ j'),
         F.map ((𝟙 j', g j' ≫ gf f) : (j', k j') ⟶ (j', kf f)) (y j') =
           F.map ((f, g j ≫ hf f) : (j, k j) ⟶ (j', kf f)) (y j) :=
-      fun {j} {j'} f => by
+      fun {j j'} f => by
       have q :
         ((curry.obj F).obj j').map (gf f) (F.map ((𝟙 j', g j') : (j', k j') ⟶ (j', k')) (y j')) =
           ((curry.obj F).obj j').map (hf f) (F.map ((f, g j) : (j, k j) ⟶ (j', k')) (y j)) :=
@@ -337,13 +332,12 @@ instance colimitLimitToLimitColimitCone_iso (F : J ⥤ K ⥤ Type v) :
 noncomputable instance filteredColimPreservesFiniteLimitsOfTypes :
     PreservesFiniteLimits (colim : (K ⥤ Type v) ⥤ _) := by
   apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{v}
-  intro J _ _; skip; constructor
-  intro F; constructor
-  intro c hc
-  apply IsLimit.ofIsoLimit (limit.isLimit _)
-  symm; trans colim.mapCone (limit.cone F)
-  exact Functor.mapIso _ (hc.uniqueUpToIso (limit.isLimit F))
-  exact asIso (colimitLimitToLimitColimitCone.{v, v + 1} F)
+  intro J _ _
+  refine ⟨fun {F} => ⟨fun {c} hc => IsLimit.ofIsoLimit (limit.isLimit _) ?_⟩⟩
+  symm
+  trans colim.mapCone (limit.cone F)
+  · exact Functor.mapIso _ (hc.uniqueUpToIso (limit.isLimit F))
+  · exact asIso (colimitLimitToLimitColimitCone.{v, v + 1} F)
 #align category_theory.limits.filtered_colim_preserves_finite_limits_of_types CategoryTheory.Limits.filteredColimPreservesFiniteLimitsOfTypes
 
 variable {C : Type u} [Category.{v} C] [ConcreteCategory.{v} C]
@@ -371,7 +365,8 @@ noncomputable instance [PreservesFiniteLimits (forget C)] [PreservesFilteredColi
     [HasFiniteLimits C] [HasColimitsOfShape K C] [ReflectsIsomorphisms (forget C)] :
     PreservesFiniteLimits (colim : (K ⥤ C) ⥤ _) := by
   apply preservesFiniteLimitsOfPreservesFiniteLimitsOfSize.{v}
-  intro J _ _; skip; infer_instance
+  intro J _ _
+  infer_instance
 
 section

3f409bd9

feat : port CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit (#3605)

This was harder than it looked (the proofs are long and broke).

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

4e9ad32a

`category_theory.limits.filtered_colimit_commutes_finite_limit` ⟷ `Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 2 + 255

category_theory.limits.filtered_colimit_commutes_finite_limit ⟷ Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Renames

Dependencies 2 + 255

`category_theory.limits.filtered_colimit_commutes_finite_limit` ⟷ `Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit`