category_theory.sigma.basic ⟷ Mathlib.CategoryTheory.Sigma.Basic

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

@@ -108,12 +108,12 @@ theorem incl_obj {i : I} (X : C i) : (incl i).obj X = ⟨i, X⟩ :=
 #align category_theory.sigma.incl_obj CategoryTheory.Sigma.incl_obj
 -/
 
-instance (i : I) : Full (incl i : C i ⥤ Σ i, C i)
+instance (i : I) : CategoryTheory.Functor.Full (incl i : C i ⥤ Σ i, C i)
     where
   preimage := fun X Y ⟨f⟩ => f
   witness' := fun X Y ⟨f⟩ => rfl
 
-instance (i : I) : Faithful (incl i : C i ⥤ Σ i, C i) where
+instance (i : I) : CategoryTheory.Functor.Faithful (incl i : C i ⥤ Σ i, C i) where
 
 section
 

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

@@ -5,7 +5,7 @@ Authors: Bhavik Mehta
 -/
 import CategoryTheory.Whiskering
 import CategoryTheory.Functor.FullyFaithful
-import CategoryTheory.NaturalIsomorphism
+import CategoryTheory.NatIso
 
 #align_import category_theory.sigma.basic from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
 

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

@@ -3,9 +3,9 @@ Copyright (c) 2020 Bhavik Mehta. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bhavik Mehta
 -/
-import Mathbin.CategoryTheory.Whiskering
-import Mathbin.CategoryTheory.Functor.FullyFaithful
-import Mathbin.CategoryTheory.NaturalIsomorphism
+import CategoryTheory.Whiskering
+import CategoryTheory.Functor.FullyFaithful
+import CategoryTheory.NaturalIsomorphism
 
 #align_import category_theory.sigma.basic from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
 

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

@@ -2,16 +2,13 @@
 Copyright (c) 2020 Bhavik Mehta. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bhavik Mehta
-
-! This file was ported from Lean 3 source module category_theory.sigma.basic
-! leanprover-community/mathlib commit 0ebfdb71919ac6ca5d7fbc61a082fa2519556818
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Whiskering
 import Mathbin.CategoryTheory.Functor.FullyFaithful
 import Mathbin.CategoryTheory.NaturalIsomorphism
 
+#align_import category_theory.sigma.basic from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
+
 /-!
 # Disjoint union of categories
 

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

@@ -59,22 +59,30 @@ instance : CategoryStruct (Σ i, C i) where
   id := id
   comp X Y Z f g := comp f g
 
+#print CategoryTheory.Sigma.SigmaHom.comp_def /-
 @[simp]
 theorem comp_def (i : I) (X Y Z : C i) (f : X ⟶ Y) (g : Y ⟶ Z) : comp (mk f) (mk g) = mk (f ≫ g) :=
   rfl
 #align category_theory.sigma.sigma_hom.comp_def CategoryTheory.Sigma.SigmaHom.comp_def
+-/
 
+#print CategoryTheory.Sigma.SigmaHom.assoc /-
 theorem assoc : ∀ (X Y Z W : Σ i, C i) (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W), (f ≫ g) ≫ h = f ≫ g ≫ h
   | _, _, _, _, mk f, mk g, mk h => congr_arg mk (Category.assoc _ _ _)
 #align category_theory.sigma.sigma_hom.assoc CategoryTheory.Sigma.SigmaHom.assoc
+-/
 
+#print CategoryTheory.Sigma.SigmaHom.id_comp /-
 theorem id_comp : ∀ (X Y : Σ i, C i) (f : X ⟶ Y), 𝟙 X ≫ f = f
   | _, _, mk f => congr_arg mk (Category.id_comp _)
 #align category_theory.sigma.sigma_hom.id_comp CategoryTheory.Sigma.SigmaHom.id_comp
+-/
 
+#print CategoryTheory.Sigma.SigmaHom.comp_id /-
 theorem comp_id : ∀ (X Y : Σ i, C i) (f : X ⟶ Y), f ≫ 𝟙 Y = f
   | _, _, mk f => congr_arg mk (Category.comp_id _)
 #align category_theory.sigma.sigma_hom.comp_id CategoryTheory.Sigma.SigmaHom.comp_id
+-/
 
 end SigmaHom
 
@@ -96,10 +104,12 @@ def incl (i : I) : C i ⥤ Σ i, C i where
 #align category_theory.sigma.incl CategoryTheory.Sigma.incl
 -/
 
+#print CategoryTheory.Sigma.incl_obj /-
 @[simp]
 theorem incl_obj {i : I} (X : C i) : (incl i).obj X = ⟨i, X⟩ :=
   rfl
 #align category_theory.sigma.incl_obj CategoryTheory.Sigma.incl_obj
+-/
 
 instance (i : I) : Full (incl i : C i ⥤ Σ i, C i)
     where
@@ -124,11 +134,13 @@ def natTrans {F G : (Σ i, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i 
 #align category_theory.sigma.nat_trans CategoryTheory.Sigma.natTrans
 -/
 
+#print CategoryTheory.Sigma.natTrans_app /-
 @[simp]
 theorem natTrans_app {F G : (Σ i, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i ⋙ G) (i : I)
     (X : C i) : (natTrans h).app ⟨i, X⟩ = (h i).app X :=
   rfl
 #align category_theory.sigma.nat_trans_app CategoryTheory.Sigma.natTrans_app
+-/
 
 /-- (Implementation). An auxiliary definition to build the functor `desc`. -/
 def descMap : ∀ X Y : Σ i, C i, (X ⟶ Y) → ((F X.1).obj X.2 ⟶ (F Y.1).obj Y.2)
@@ -153,10 +165,12 @@ def desc : (Σ i, C i) ⥤ D where
 #align category_theory.sigma.desc CategoryTheory.Sigma.desc
 -/
 
+#print CategoryTheory.Sigma.desc_map_mk /-
 @[simp]
 theorem desc_map_mk {i : I} (X Y : C i) (f : X ⟶ Y) : (desc F).map (SigmaHom.mk f) = (F i).map f :=
   rfl
 #align category_theory.sigma.desc_map_mk CategoryTheory.Sigma.desc_map_mk
+-/
 
 #print CategoryTheory.Sigma.inclDesc /-
 -- We hand-generate the simp lemmas about this since they come out cleaner.
@@ -168,15 +182,19 @@ def inclDesc (i : I) : incl i ⋙ desc F ≅ F i :=
 #align category_theory.sigma.incl_desc CategoryTheory.Sigma.inclDesc
 -/
 
+#print CategoryTheory.Sigma.inclDesc_hom_app /-
 @[simp]
 theorem inclDesc_hom_app (i : I) (X : C i) : (inclDesc F i).Hom.app X = 𝟙 ((F i).obj X) :=
   rfl
 #align category_theory.sigma.incl_desc_hom_app CategoryTheory.Sigma.inclDesc_hom_app
+-/
 
+#print CategoryTheory.Sigma.inclDesc_inv_app /-
 @[simp]
 theorem inclDesc_inv_app (i : I) (X : C i) : (inclDesc F i).inv.app X = 𝟙 ((F i).obj X) :=
   rfl
 #align category_theory.sigma.incl_desc_inv_app CategoryTheory.Sigma.inclDesc_inv_app
+-/
 
 #print CategoryTheory.Sigma.descUniq /-
 /-- If `q` when restricted to each subcategory `C i` agrees with `F i`, then `q` is isomorphic to
@@ -188,17 +206,21 @@ def descUniq (q : (Σ i, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) : q ≅ d
 #align category_theory.sigma.desc_uniq CategoryTheory.Sigma.descUniq
 -/
 
+#print CategoryTheory.Sigma.descUniq_hom_app /-
 @[simp]
 theorem descUniq_hom_app (q : (Σ i, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
     (descUniq F q h).Hom.app ⟨i, X⟩ = (h i).Hom.app X :=
   rfl
 #align category_theory.sigma.desc_uniq_hom_app CategoryTheory.Sigma.descUniq_hom_app
+-/
 
+#print CategoryTheory.Sigma.descUniq_inv_app /-
 @[simp]
 theorem descUniq_inv_app (q : (Σ i, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
     (descUniq F q h).inv.app ⟨i, X⟩ = (h i).inv.app X :=
   rfl
 #align category_theory.sigma.desc_uniq_inv_app CategoryTheory.Sigma.descUniq_inv_app
+-/
 
 #print CategoryTheory.Sigma.natIso /-
 /--
@@ -225,16 +247,20 @@ def map : (Σ j : J, C (g j)) ⥤ Σ i : I, C i :=
 #align category_theory.sigma.map CategoryTheory.Sigma.map
 -/
 
+#print CategoryTheory.Sigma.map_obj /-
 @[simp]
 theorem map_obj (j : J) (X : C (g j)) : (Sigma.map C g).obj ⟨j, X⟩ = ⟨g j, X⟩ :=
   rfl
 #align category_theory.sigma.map_obj CategoryTheory.Sigma.map_obj
+-/
 
+#print CategoryTheory.Sigma.map_map /-
 @[simp]
 theorem map_map {j : J} {X Y : C (g j)} (f : X ⟶ Y) :
     (Sigma.map C g).map (SigmaHom.mk f) = SigmaHom.mk f :=
   rfl
 #align category_theory.sigma.map_map CategoryTheory.Sigma.map_map
+-/
 
 #print CategoryTheory.Sigma.inclCompMap /-
 /-- The functor `sigma.map C g` restricted to the subcategory `C j` acts as the inclusion of `g j`.

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

@@ -34,7 +34,7 @@ variable {I : Type w₁} {C : I → Type u₁} [∀ i, Category.{v₁} (C i)]
 /-- The type of morphisms of a disjoint union of categories: for `X : C i` and `Y : C j`, a morphism
 `(i, X) ⟶ (j, Y)` if `i = j` is just a morphism `X ⟶ Y`, and if `i ≠ j` there are no such morphisms.
 -/
-inductive SigmaHom : (Σi, C i) → (Σi, C i) → Type max w₁ v₁ u₁
+inductive SigmaHom : (Σ i, C i) → (Σ i, C i) → Type max w₁ v₁ u₁
   | mk : ∀ {i : I} {X Y : C i}, (X ⟶ Y) → sigma_hom ⟨i, X⟩ ⟨i, Y⟩
 #align category_theory.sigma.sigma_hom CategoryTheory.Sigma.SigmaHom
 -/
@@ -42,19 +42,19 @@ inductive SigmaHom : (Σi, C i) → (Σi, C i) → Type max w₁ v₁ u₁
 namespace SigmaHom
 
 /-- The identity morphism on an object. -/
-def id : ∀ X : Σi, C i, SigmaHom X X
+def id : ∀ X : Σ i, C i, SigmaHom X X
   | ⟨i, X⟩ => mk (𝟙 _)
 #align category_theory.sigma.sigma_hom.id CategoryTheory.Sigma.SigmaHom.idₓ
 
-instance (X : Σi, C i) : Inhabited (SigmaHom X X) :=
+instance (X : Σ i, C i) : Inhabited (SigmaHom X X) :=
   ⟨id X⟩
 
 /-- Composition of sigma homomorphisms. -/
-def comp : ∀ {X Y Z : Σi, C i}, SigmaHom X Y → SigmaHom Y Z → SigmaHom X Z
+def comp : ∀ {X Y Z : Σ i, C i}, SigmaHom X Y → SigmaHom Y Z → SigmaHom X Z
   | _, _, _, mk f, mk g => mk (f ≫ g)
 #align category_theory.sigma.sigma_hom.comp CategoryTheory.Sigma.SigmaHom.compₓ
 
-instance : CategoryStruct (Σi, C i) where
+instance : CategoryStruct (Σ i, C i) where
   Hom := SigmaHom
   id := id
   comp X Y Z f g := comp f g
@@ -64,22 +64,22 @@ theorem comp_def (i : I) (X Y Z : C i) (f : X ⟶ Y) (g : Y ⟶ Z) : comp (mk f)
   rfl
 #align category_theory.sigma.sigma_hom.comp_def CategoryTheory.Sigma.SigmaHom.comp_def
 
-theorem assoc : ∀ (X Y Z W : Σi, C i) (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W), (f ≫ g) ≫ h = f ≫ g ≫ h
+theorem assoc : ∀ (X Y Z W : Σ i, C i) (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W), (f ≫ g) ≫ h = f ≫ g ≫ h
   | _, _, _, _, mk f, mk g, mk h => congr_arg mk (Category.assoc _ _ _)
 #align category_theory.sigma.sigma_hom.assoc CategoryTheory.Sigma.SigmaHom.assoc
 
-theorem id_comp : ∀ (X Y : Σi, C i) (f : X ⟶ Y), 𝟙 X ≫ f = f
+theorem id_comp : ∀ (X Y : Σ i, C i) (f : X ⟶ Y), 𝟙 X ≫ f = f
   | _, _, mk f => congr_arg mk (Category.id_comp _)
 #align category_theory.sigma.sigma_hom.id_comp CategoryTheory.Sigma.SigmaHom.id_comp
 
-theorem comp_id : ∀ (X Y : Σi, C i) (f : X ⟶ Y), f ≫ 𝟙 Y = f
+theorem comp_id : ∀ (X Y : Σ i, C i) (f : X ⟶ Y), f ≫ 𝟙 Y = f
   | _, _, mk f => congr_arg mk (Category.comp_id _)
 #align category_theory.sigma.sigma_hom.comp_id CategoryTheory.Sigma.SigmaHom.comp_id
 
 end SigmaHom
 
 #print CategoryTheory.Sigma.sigma /-
-instance sigma : Category (Σi, C i)
+instance sigma : Category (Σ i, C i)
     where
   id_comp' := SigmaHom.id_comp
   comp_id' := SigmaHom.comp_id
@@ -90,7 +90,7 @@ instance sigma : Category (Σi, C i)
 #print CategoryTheory.Sigma.incl /-
 /-- The inclusion functor into the disjoint union of categories. -/
 @[simps map]
-def incl (i : I) : C i ⥤ Σi, C i where
+def incl (i : I) : C i ⥤ Σ i, C i where
   obj X := ⟨i, X⟩
   map X Y := SigmaHom.mk
 #align category_theory.sigma.incl CategoryTheory.Sigma.incl
@@ -101,12 +101,12 @@ theorem incl_obj {i : I} (X : C i) : (incl i).obj X = ⟨i, X⟩ :=
   rfl
 #align category_theory.sigma.incl_obj CategoryTheory.Sigma.incl_obj
 
-instance (i : I) : Full (incl i : C i ⥤ Σi, C i)
+instance (i : I) : Full (incl i : C i ⥤ Σ i, C i)
     where
   preimage := fun X Y ⟨f⟩ => f
   witness' := fun X Y ⟨f⟩ => rfl
 
-instance (i : I) : Faithful (incl i : C i ⥤ Σi, C i) where
+instance (i : I) : Faithful (incl i : C i ⥤ Σ i, C i) where
 
 section
 
@@ -117,7 +117,7 @@ variable {D : Type u₂} [Category.{v₂} D] (F : ∀ i, C i ⥤ D)
 To build a natural transformation over the sigma category, it suffices to specify it restricted to
 each subcategory.
 -/
-def natTrans {F G : (Σi, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i ⋙ G) : F ⟶ G
+def natTrans {F G : (Σ i, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i ⋙ G) : F ⟶ G
     where
   app := fun ⟨j, X⟩ => (h j).app X
   naturality' := by rintro ⟨j, X⟩ ⟨_, _⟩ ⟨f⟩; apply (h j).naturality
@@ -125,13 +125,13 @@ def natTrans {F G : (Σi, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i 
 -/
 
 @[simp]
-theorem natTrans_app {F G : (Σi, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i ⋙ G) (i : I)
+theorem natTrans_app {F G : (Σ i, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i ⋙ G) (i : I)
     (X : C i) : (natTrans h).app ⟨i, X⟩ = (h i).app X :=
   rfl
 #align category_theory.sigma.nat_trans_app CategoryTheory.Sigma.natTrans_app
 
 /-- (Implementation). An auxiliary definition to build the functor `desc`. -/
-def descMap : ∀ X Y : Σi, C i, (X ⟶ Y) → ((F X.1).obj X.2 ⟶ (F Y.1).obj Y.2)
+def descMap : ∀ X Y : Σ i, C i, (X ⟶ Y) → ((F X.1).obj X.2 ⟶ (F Y.1).obj Y.2)
   | _, _, sigma_hom.mk g => (F _).map g
 #align category_theory.sigma.desc_map CategoryTheory.Sigma.descMapₓ
 
@@ -145,7 +145,7 @@ this property.
 This witnesses that the sigma-type is the coproduct in Cat.
 -/
 @[simps obj]
-def desc : (Σi, C i) ⥤ D where
+def desc : (Σ i, C i) ⥤ D where
   obj X := (F X.1).obj X.2
   map X Y g := descMap F X Y g
   map_id' := by rintro ⟨i, X⟩; apply (F i).map_id
@@ -182,20 +182,20 @@ theorem inclDesc_inv_app (i : I) (X : C i) : (inclDesc F i).inv.app X = 𝟙 ((F
 /-- If `q` when restricted to each subcategory `C i` agrees with `F i`, then `q` is isomorphic to
 `desc F`.
 -/
-def descUniq (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) : q ≅ desc F :=
+def descUniq (q : (Σ i, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) : q ≅ desc F :=
   (NatIso.ofComponents fun ⟨i, X⟩ => (h i).app X) <| by rintro ⟨i, X⟩ ⟨_, _⟩ ⟨f⟩;
     apply (h i).Hom.naturality f
 #align category_theory.sigma.desc_uniq CategoryTheory.Sigma.descUniq
 -/
 
 @[simp]
-theorem descUniq_hom_app (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
+theorem descUniq_hom_app (q : (Σ i, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
     (descUniq F q h).Hom.app ⟨i, X⟩ = (h i).Hom.app X :=
   rfl
 #align category_theory.sigma.desc_uniq_hom_app CategoryTheory.Sigma.descUniq_hom_app
 
 @[simp]
-theorem descUniq_inv_app (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
+theorem descUniq_inv_app (q : (Σ i, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
     (descUniq F q h).inv.app ⟨i, X⟩ = (h i).inv.app X :=
   rfl
 #align category_theory.sigma.desc_uniq_inv_app CategoryTheory.Sigma.descUniq_inv_app
@@ -205,7 +205,7 @@ theorem descUniq_inv_app (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i
 If `q₁` and `q₂` when restricted to each subcategory `C i` agree, then `q₁` and `q₂` are isomorphic.
 -/
 @[simps]
-def natIso {q₁ q₂ : (Σi, C i) ⥤ D} (h : ∀ i, incl i ⋙ q₁ ≅ incl i ⋙ q₂) : q₁ ≅ q₂
+def natIso {q₁ q₂ : (Σ i, C i) ⥤ D} (h : ∀ i, incl i ⋙ q₁ ≅ incl i ⋙ q₂) : q₁ ≅ q₂
     where
   Hom := natTrans fun i => (h i).Hom
   inv := natTrans fun i => (h i).inv
@@ -220,7 +220,7 @@ variable (C) {J : Type w₂} (g : J → I)
 
 #print CategoryTheory.Sigma.map /-
 /-- A function `J → I` induces a functor `Σ j, C (g j) ⥤ Σ i, C i`. -/
-def map : (Σj : J, C (g j)) ⥤ Σi : I, C i :=
+def map : (Σ j : J, C (g j)) ⥤ Σ i : I, C i :=
   desc fun j => incl (g j)
 #align category_theory.sigma.map CategoryTheory.Sigma.map
 -/
@@ -250,7 +250,7 @@ variable (I)
 #print CategoryTheory.Sigma.mapId /-
 /-- The functor `sigma.map` applied to the identity function is just the identity functor. -/
 @[simps]
-def mapId : map C (id : I → I) ≅ 𝟭 (Σi, C i) :=
+def mapId : map C (id : I → I) ≅ 𝟭 (Σ i, C i) :=
   natIso fun i => NatIso.ofComponents (fun X => Iso.refl _) (by tidy)
 #align category_theory.sigma.map_id CategoryTheory.Sigma.mapId
 -/
@@ -277,7 +277,7 @@ variable {D : I → Type u₁} [∀ i, Category.{v₁} (D i)]
 #print CategoryTheory.Sigma.Functor.sigma /-
 /-- Assemble an `I`-indexed family of functors into a functor between the sigma types.
 -/
-def sigma (F : ∀ i, C i ⥤ D i) : (Σi, C i) ⥤ Σi, D i :=
+def sigma (F : ∀ i, C i ⥤ D i) : (Σ i, C i) ⥤ Σ i, D i :=
   desc fun i => F i ⋙ incl i
 #align category_theory.sigma.functor.sigma CategoryTheory.Sigma.Functor.sigma
 -/

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

@@ -41,12 +41,6 @@ inductive SigmaHom : (Σi, C i) → (Σi, C i) → Type max w₁ v₁ u₁
 
 namespace SigmaHom
 
-/- warning: category_theory.sigma.sigma_hom.id -> CategoryTheory.Sigma.SigmaHom.idₓ is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] (X : Sigma.{u1, u3} I (fun (i : I) => C i)), CategoryTheory.Sigma.SigmaHom.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) X X
-but is expected to have type
-  forall {I : Type.{u3}} {C : I -> Type.{u1}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u1} (C i)] (X : Sigma.{u3, u1} I (fun (i : I) => C i)), CategoryTheory.Sigma.SigmaHom.{u3, u2, u1} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) X X
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.sigma_hom.id CategoryTheory.Sigma.SigmaHom.idₓₓ'. -/
 /-- The identity morphism on an object. -/
 def id : ∀ X : Σi, C i, SigmaHom X X
   | ⟨i, X⟩ => mk (𝟙 _)
@@ -55,12 +49,6 @@ def id : ∀ X : Σi, C i, SigmaHom X X
 instance (X : Σi, C i) : Inhabited (SigmaHom X X) :=
   ⟨id X⟩
 
-/- warning: category_theory.sigma.sigma_hom.comp -> CategoryTheory.Sigma.SigmaHom.compₓ is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] {X : Sigma.{u1, u3} I (fun (i : I) => C i)} {Y : Sigma.{u1, u3} I (fun (i : I) => C i)} {Z : Sigma.{u1, u3} I (fun (i : I) => C i)}, (CategoryTheory.Sigma.SigmaHom.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) X Y) -> (CategoryTheory.Sigma.SigmaHom.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) Y Z) -> (CategoryTheory.Sigma.SigmaHom.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) X Z)
-but is expected to have type
-  forall {I : Type.{u3}} {C : I -> Type.{u1}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u1} (C i)] {X : Sigma.{u3, u1} I (fun (i : I) => C i)} {Y : Sigma.{u3, u1} I (fun (i : I) => C i)} {Z : Sigma.{u3, u1} I (fun (i : I) => C i)}, (CategoryTheory.Sigma.SigmaHom.{u3, u2, u1} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) X Y) -> (CategoryTheory.Sigma.SigmaHom.{u3, u2, u1} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) Y Z) -> (CategoryTheory.Sigma.SigmaHom.{u3, u2, u1} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) X Z)
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.sigma_hom.comp CategoryTheory.Sigma.SigmaHom.compₓₓ'. -/
 /-- Composition of sigma homomorphisms. -/
 def comp : ∀ {X Y Z : Σi, C i}, SigmaHom X Y → SigmaHom Y Z → SigmaHom X Z
   | _, _, _, mk f, mk g => mk (f ≫ g)
@@ -71,43 +59,19 @@ instance : CategoryStruct (Σi, C i) where
   id := id
   comp X Y Z f g := comp f g
 
-/- warning: category_theory.sigma.sigma_hom.comp_def -> CategoryTheory.Sigma.SigmaHom.comp_def is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] (i : I) (X : C i) (Y : C i) (Z : C i) (f : Quiver.Hom.{succ u2, u3} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u3} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u3} (C i) (_inst_1 i))) X Y) (g : Quiver.Hom.{succ u2, u3} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u3} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u3} (C i) (_inst_1 i))) Y Z), Eq.{succ (max u1 u2 u3)} (CategoryTheory.Sigma.SigmaHom.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i X) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i Z)) (CategoryTheory.Sigma.SigmaHom.compₓ.{u1, u2, u3} I C (fun (i : I) => _inst_1 i) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i X) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i Y) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i Z) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i X Y f) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i Y Z g)) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i X Z (CategoryTheory.CategoryStruct.comp.{u2, u3} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u3} (C i) (_inst_1 i)) X Y Z f g))
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] (i : I) (X : C i) (Y : C i) (Z : C i) (f : Quiver.Hom.{succ u2, u3} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u3} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u3} (C i) (_inst_1 i))) X Y) (g : Quiver.Hom.{succ u2, u3} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u3} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u3} (C i) (_inst_1 i))) Y Z), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (CategoryTheory.Sigma.SigmaHom.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i X) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i Z)) (CategoryTheory.Sigma.SigmaHom.comp.{u1, u2, u3} I C (fun (i : I) => _inst_1 i) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i X) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i Y) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i Z) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i X Y f) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i Y Z g)) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u2, u3} I C (fun (i : I) => _inst_1 i) i X Z (CategoryTheory.CategoryStruct.comp.{u2, u3} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u3} (C i) (_inst_1 i)) X Y Z f g))
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.sigma_hom.comp_def CategoryTheory.Sigma.SigmaHom.comp_defₓ'. -/
 @[simp]
 theorem comp_def (i : I) (X Y Z : C i) (f : X ⟶ Y) (g : Y ⟶ Z) : comp (mk f) (mk g) = mk (f ≫ g) :=
   rfl
 #align category_theory.sigma.sigma_hom.comp_def CategoryTheory.Sigma.SigmaHom.comp_def
 
-/- warning: category_theory.sigma.sigma_hom.assoc -> CategoryTheory.Sigma.SigmaHom.assoc is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] (X : Sigma.{u1, u3} I (fun (i : I) => C i)) (Y : Sigma.{u1, u3} I (fun (i : I) => C i)) (Z : Sigma.{u1, u3} I (fun (i : I) => C i)) (W : Sigma.{u1, u3} I (fun (i : I) => C i)) (f : Quiver.Hom.{succ (max u1 u2 u3), max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y) (g : Quiver.Hom.{succ (max u1 u2 u3), max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) Y Z) (h : Quiver.Hom.{succ (max u1 u2 u3), max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) Z W), Eq.{succ (max u1 u2 u3)} (Quiver.Hom.{succ (max u1 u2 u3), max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X W) (CategoryTheory.CategoryStruct.comp.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X Z W (CategoryTheory.CategoryStruct.comp.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X Y Z f g) h) (CategoryTheory.CategoryStruct.comp.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X Y W f (CategoryTheory.CategoryStruct.comp.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) Y Z W g h))
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] {X : Sigma.{u1, u3} I (fun (i : I) => C i)} {Y : Sigma.{u1, u3} I (fun (i : I) => C i)} {Z : Sigma.{u1, u3} I (fun (i : I) => C i)} {W : Sigma.{u1, u3} I (fun (i : I) => C i)} (f : Quiver.Hom.{max (max (succ u3) (succ u2)) (succ u1), max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y) (g : Quiver.Hom.{max (max (succ u3) (succ u2)) (succ u1), max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) Y Z) (h : Quiver.Hom.{max (max (succ u3) (succ u2)) (succ u1), max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) Z W), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Quiver.Hom.{succ (max (max u3 u2) u1), max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X W) (CategoryTheory.CategoryStruct.comp.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X Z W (CategoryTheory.CategoryStruct.comp.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X Y Z f g) h) (CategoryTheory.CategoryStruct.comp.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X Y W f (CategoryTheory.CategoryStruct.comp.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) Y Z W g h))
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.sigma_hom.assoc CategoryTheory.Sigma.SigmaHom.assocₓ'. -/
 theorem assoc : ∀ (X Y Z W : Σi, C i) (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W), (f ≫ g) ≫ h = f ≫ g ≫ h
   | _, _, _, _, mk f, mk g, mk h => congr_arg mk (Category.assoc _ _ _)
 #align category_theory.sigma.sigma_hom.assoc CategoryTheory.Sigma.SigmaHom.assoc
 
-/- warning: category_theory.sigma.sigma_hom.id_comp -> CategoryTheory.Sigma.SigmaHom.id_comp is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] (X : Sigma.{u1, u3} I (fun (i : I) => C i)) (Y : Sigma.{u1, u3} I (fun (i : I) => C i)) (f : Quiver.Hom.{succ (max u1 u2 u3), max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y), Eq.{succ (max u1 u2 u3)} (Quiver.Hom.{succ (max u1 u2 u3), max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y) (CategoryTheory.CategoryStruct.comp.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X X Y (CategoryTheory.CategoryStruct.id.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X) f) f
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] {X : Sigma.{u1, u3} I (fun (i : I) => C i)} {Y : Sigma.{u1, u3} I (fun (i : I) => C i)} (f : Quiver.Hom.{max (max (succ u3) (succ u2)) (succ u1), max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Quiver.Hom.{succ (max (max u3 u2) u1), max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y) (CategoryTheory.CategoryStruct.comp.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X X Y (CategoryTheory.CategoryStruct.id.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X) f) f
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.sigma_hom.id_comp CategoryTheory.Sigma.SigmaHom.id_compₓ'. -/
 theorem id_comp : ∀ (X Y : Σi, C i) (f : X ⟶ Y), 𝟙 X ≫ f = f
   | _, _, mk f => congr_arg mk (Category.id_comp _)
 #align category_theory.sigma.sigma_hom.id_comp CategoryTheory.Sigma.SigmaHom.id_comp
 
-/- warning: category_theory.sigma.sigma_hom.comp_id -> CategoryTheory.Sigma.SigmaHom.comp_id is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] (X : Sigma.{u1, u3} I (fun (i : I) => C i)) (Y : Sigma.{u1, u3} I (fun (i : I) => C i)) (f : Quiver.Hom.{succ (max u1 u2 u3), max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y), Eq.{succ (max u1 u2 u3)} (Quiver.Hom.{succ (max u1 u2 u3), max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y) (CategoryTheory.CategoryStruct.comp.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X Y Y f (CategoryTheory.CategoryStruct.id.{max u1 u2 u3, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) Y)) f
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] {X : Sigma.{u1, u3} I (fun (i : I) => C i)} {Y : Sigma.{u1, u3} I (fun (i : I) => C i)} (f : Quiver.Hom.{max (max (succ u3) (succ u2)) (succ u1), max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y), Eq.{max (max (succ u3) (succ u2)) (succ u1)} (Quiver.Hom.{succ (max (max u3 u2) u1), max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y) (CategoryTheory.CategoryStruct.comp.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) X Y Y f (CategoryTheory.CategoryStruct.id.{max (max u3 u2) u1, max u3 u1} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.instCategoryStructSigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) Y)) f
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.sigma_hom.comp_id CategoryTheory.Sigma.SigmaHom.comp_idₓ'. -/
 theorem comp_id : ∀ (X Y : Σi, C i) (f : X ⟶ Y), f ≫ 𝟙 Y = f
   | _, _, mk f => congr_arg mk (Category.comp_id _)
 #align category_theory.sigma.sigma_hom.comp_id CategoryTheory.Sigma.SigmaHom.comp_id
@@ -132,12 +96,6 @@ def incl (i : I) : C i ⥤ Σi, C i where
 #align category_theory.sigma.incl CategoryTheory.Sigma.incl
 -/
 
-/- warning: category_theory.sigma.incl_obj -> CategoryTheory.Sigma.incl_obj is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] {i : I} (X : C i), Eq.{max (succ u1) (succ u3)} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Functor.obj.{u2, max u1 u2 u3, u3, max u1 u3} (C i) (_inst_1 i) (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) (CategoryTheory.Sigma.incl.{u1, u2, u3} I (fun {i : I} => C i) (fun (i : I) => _inst_1 i) i) X) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i X)
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u3}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u3} (C i)] {i : I} (X : C i), Eq.{max (succ u3) (succ u1)} (Sigma.{u1, u3} I (fun (i : I) => C i)) (Prefunctor.obj.{succ u2, max (max (succ u1) (succ u3)) (succ u2), u3, max u1 u3} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u3} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u3} (C i) (_inst_1 i))) (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u1 u3) u2, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u1 u3) u2, max u1 u3} (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) (CategoryTheory.Functor.toPrefunctor.{u2, max (max u1 u3) u2, u3, max u1 u3} (C i) (_inst_1 i) (Sigma.{u1, u3} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u3} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) (CategoryTheory.Sigma.incl.{u1, u2, u3} I C (fun (i : I) => _inst_1 i) i)) X) (Sigma.mk.{u1, u3} I (fun (i : I) => C i) i X)
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.incl_obj CategoryTheory.Sigma.incl_objₓ'. -/
 @[simp]
 theorem incl_obj {i : I} (X : C i) : (incl i).obj X = ⟨i, X⟩ :=
   rfl
@@ -166,24 +124,12 @@ def natTrans {F G : (Σi, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i 
 #align category_theory.sigma.nat_trans CategoryTheory.Sigma.natTrans
 -/
 
-/- warning: category_theory.sigma.nat_trans_app -> CategoryTheory.Sigma.natTrans_app is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] {F : CategoryTheory.Functor.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2} {G : CategoryTheory.Functor.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2} (h : forall (i : I), Quiver.Hom.{succ (max u4 u3), max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u3, max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u3, max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2))) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) F) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I C (fun (i : I) => _inst_1 i) i) G)) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.obj.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 F (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.Functor.obj.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 G (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X))) (CategoryTheory.NatTrans.app.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 F G (CategoryTheory.Sigma.natTrans.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F G h) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) F) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I C (fun (i : I) => _inst_1 i) i) G) (h i) X)
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] {F : CategoryTheory.Functor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2} {G : CategoryTheory.Functor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2} (h : forall (i : I), Quiver.Hom.{max (succ u4) (succ u3), max (max (max u5 u4) u3) u2} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u4 u3, max (max (max u4 u5) u2) u3} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u4 u3, max (max (max u4 u5) u2) u3} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2))) (CategoryTheory.Functor.comp.{u2, max (max u1 u4) u2, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) F) (CategoryTheory.Functor.comp.{u2, max (max u4 u1) u2, u3, u4, max u4 u1, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I C (fun (i : I) => _inst_1 i) i) G)) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (Prefunctor.obj.{succ (max (max u4 u2) u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 F) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (Prefunctor.obj.{succ (max (max u4 u2) u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 G) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X))) (CategoryTheory.NatTrans.app.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 F G (CategoryTheory.Sigma.natTrans.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F G h) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max (max u1 u4) u2, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) F) (CategoryTheory.Functor.comp.{u2, max (max u4 u1) u2, u3, u4, max u4 u1, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I C (fun (i : I) => _inst_1 i) i) G) (h i) X)
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.nat_trans_app CategoryTheory.Sigma.natTrans_appₓ'. -/
 @[simp]
 theorem natTrans_app {F G : (Σi, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i ⋙ G) (i : I)
     (X : C i) : (natTrans h).app ⟨i, X⟩ = (h i).app X :=
   rfl
 #align category_theory.sigma.nat_trans_app CategoryTheory.Sigma.natTrans_app
 
-/- warning: category_theory.sigma.desc_map -> CategoryTheory.Sigma.descMapₓ is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (X : Sigma.{u1, u4} I (fun (i : I) => C i)) (Y : Sigma.{u1, u4} I (fun (i : I) => C i)), (Quiver.Hom.{succ (max u1 u2 u4), max u1 u4} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2 u4, max u1 u4} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y) -> (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.obj.{u2, u3, u4, u5} (C (Sigma.fst.{u1, u4} I (fun (i : I) => C i) X)) (_inst_1 (Sigma.fst.{u1, u4} I (fun (i : I) => C i) X)) D _inst_2 (F (Sigma.fst.{u1, u4} I (fun (i : I) => C i) X)) (Sigma.snd.{u1, u4} I (fun (i : I) => C i) X)) (CategoryTheory.Functor.obj.{u2, u3, u4, u5} (C (Sigma.fst.{u1, u4} I (fun (i : I) => C i) Y)) (_inst_1 (Sigma.fst.{u1, u4} I (fun (i : I) => C i) Y)) D _inst_2 (F (Sigma.fst.{u1, u4} I (fun (i : I) => C i) Y)) (Sigma.snd.{u1, u4} I (fun (i : I) => C i) Y)))
-but is expected to have type
-  forall {I : Type.{u5}} {C : I -> Type.{u1}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u3, u1} (C i)] {D : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u4, u2} D] (F : forall (i : I), CategoryTheory.Functor.{u3, u4, u1, u2} (C i) (_inst_1 i) D _inst_2) (X : Sigma.{u5, u1} I (fun (i : I) => C i)) (Y : Sigma.{u5, u1} I (fun (i : I) => C i)), (Quiver.Hom.{succ (max u5 u3 u1), max u5 u1} (Sigma.{u5, u1} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u5 u3 u1, max u5 u1} (Sigma.{u5, u1} I (fun (i : I) => C i)) (CategoryTheory.Sigma.SigmaHom.Sigma.CategoryTheory.categoryStruct.{u5, u3, u1} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i))) X Y) -> (Quiver.Hom.{succ u4, u2} D (CategoryTheory.CategoryStruct.toQuiver.{u4, u2} D (CategoryTheory.Category.toCategoryStruct.{u4, u2} D _inst_2)) (CategoryTheory.Functor.obj.{u3, u4, u1, u2} (C (Sigma.fst.{u5, u1} I (fun (i : I) => C i) X)) (_inst_1 (Sigma.fst.{u5, u1} I (fun (i : I) => C i) X)) D _inst_2 (F (Sigma.fst.{u5, u1} I (fun (i : I) => C i) X)) (Sigma.snd.{u5, u1} I (fun (i : I) => C i) X)) (CategoryTheory.Functor.obj.{u3, u4, u1, u2} (C (Sigma.fst.{u5, u1} I (fun (i : I) => C i) Y)) (_inst_1 (Sigma.fst.{u5, u1} I (fun (i : I) => C i) Y)) D _inst_2 (F (Sigma.fst.{u5, u1} I (fun (i : I) => C i) Y)) (Sigma.snd.{u5, u1} I (fun (i : I) => C i) Y)))
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.desc_map CategoryTheory.Sigma.descMapₓₓ'. -/
 /-- (Implementation). An auxiliary definition to build the functor `desc`. -/
 def descMap : ∀ X Y : Σi, C i, (X ⟶ Y) → ((F X.1).obj X.2 ⟶ (F Y.1).obj Y.2)
   | _, _, sigma_hom.mk g => (F _).map g
@@ -207,12 +153,6 @@ def desc : (Σi, C i) ⥤ D where
 #align category_theory.sigma.desc CategoryTheory.Sigma.desc
 -/
 
-/- warning: category_theory.sigma.desc_map_mk -> CategoryTheory.Sigma.desc_map_mk is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) {i : I} (X : C i) (Y : C i) (f : Quiver.Hom.{succ u2, u4} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) X Y), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.obj.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i X)) (CategoryTheory.Functor.obj.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i Y))) (CategoryTheory.Functor.map.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i X) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i Y) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u2, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) (fun (i : I) => (fun (i : I) => (fun (i : I) => _inst_1 i) i) i) i X Y f)) (CategoryTheory.Functor.map.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) (Sigma.snd.{u1, u4} I (fun (i : I) => (fun (i : I) => C i) i) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i X)) (Sigma.snd.{u1, u4} I (fun (i : I) => (fun (i : I) => C i) i) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i Y)) f)
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) {i : I} (X : C i) (Y : C i) (f : Quiver.Hom.{succ u2, u4} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) X Y), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (Prefunctor.obj.{max (max (succ u4) (succ u2)) (succ u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i X)) (Prefunctor.obj.{max (max (succ u4) (succ u2)) (succ u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i Y))) (Prefunctor.map.{max (max (succ u4) (succ u2)) (succ u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i X) (Sigma.mk.{u1, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) i Y) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u2, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) (fun (i : I) => (fun (i : I) => (fun (i : I) => _inst_1 i) i) i) i X Y f)) (Prefunctor.map.{succ u2, succ u3, u4, u5} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i)) X Y f)
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.desc_map_mk CategoryTheory.Sigma.desc_map_mkₓ'. -/
 @[simp]
 theorem desc_map_mk {i : I} (X Y : C i) (f : X ⟶ Y) : (desc F).map (SigmaHom.mk f) = (F i).map f :=
   rfl
@@ -228,23 +168,11 @@ def inclDesc (i : I) : incl i ⋙ desc F ≅ F i :=
 #align category_theory.sigma.incl_desc CategoryTheory.Sigma.inclDesc
 -/
 
-/- warning: category_theory.sigma.incl_desc_hom_app -> CategoryTheory.Sigma.inclDesc_hom_app is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.obj.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) X) (CategoryTheory.Functor.obj.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (F i) (CategoryTheory.Iso.hom.{max u4 u3, max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (F i) (CategoryTheory.Sigma.inclDesc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F i)) X) (CategoryTheory.CategoryStruct.id.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2) (CategoryTheory.Functor.obj.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) X))
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (Prefunctor.obj.{succ u2, succ u3, u4, u5} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max (max u1 u4) u2, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F))) X) (Prefunctor.obj.{succ u2, succ u3, u4, u5} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i)) X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max (max u1 u4) u2, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (F i) (CategoryTheory.Iso.hom.{max u4 u3, max (max (max u4 u5) u2) u3} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max (max u1 u4) u2, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (F i) (CategoryTheory.Sigma.inclDesc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F i)) X) (CategoryTheory.CategoryStruct.id.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2) (Prefunctor.obj.{succ u2, succ u3, u4, u5} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i)) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.incl_desc_hom_app CategoryTheory.Sigma.inclDesc_hom_appₓ'. -/
 @[simp]
 theorem inclDesc_hom_app (i : I) (X : C i) : (inclDesc F i).Hom.app X = 𝟙 ((F i).obj X) :=
   rfl
 #align category_theory.sigma.incl_desc_hom_app CategoryTheory.Sigma.inclDesc_hom_app
 
-/- warning: category_theory.sigma.incl_desc_inv_app -> CategoryTheory.Sigma.inclDesc_inv_app is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.obj.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) X) (CategoryTheory.Functor.obj.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (CategoryTheory.Iso.inv.{max u4 u3, max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (F i) (CategoryTheory.Sigma.inclDesc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F i)) X) (CategoryTheory.CategoryStruct.id.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2) (CategoryTheory.Functor.obj.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) X))
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (Prefunctor.obj.{succ u2, succ u3, u4, u5} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i)) X) (Prefunctor.obj.{succ u2, succ u3, u4, u5} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max (max u1 u4) u2, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F))) X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) (CategoryTheory.Functor.comp.{u2, max (max u1 u4) u2, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (CategoryTheory.Iso.inv.{max u4 u3, max (max (max u4 u5) u2) u3} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max (max u1 u4) u2, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (F i) (CategoryTheory.Sigma.inclDesc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F i)) X) (CategoryTheory.CategoryStruct.id.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2) (Prefunctor.obj.{succ u2, succ u3, u4, u5} (C i) (CategoryTheory.CategoryStruct.toQuiver.{u2, u4} (C i) (CategoryTheory.Category.toCategoryStruct.{u2, u4} (C i) (_inst_1 i))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i)) X))
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.incl_desc_inv_app CategoryTheory.Sigma.inclDesc_inv_appₓ'. -/
 @[simp]
 theorem inclDesc_inv_app (i : I) (X : C i) : (inclDesc F i).inv.app X = 𝟙 ((F i).obj X) :=
   rfl
@@ -260,24 +188,12 @@ def descUniq (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) : q ≅ de
 #align category_theory.sigma.desc_uniq CategoryTheory.Sigma.descUniq
 -/
 
-/- warning: category_theory.sigma.desc_uniq_hom_app -> CategoryTheory.Sigma.descUniq_hom_app is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (q : CategoryTheory.Functor.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) (h : forall (i : I), CategoryTheory.Iso.{max u4 u3, max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i)) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.obj.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 q (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.Functor.obj.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X))) (CategoryTheory.NatTrans.app.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 q (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (CategoryTheory.Iso.hom.{max (max u1 u4) u3, max (max u1 u2 u4) u3 (max u1 u4) u5} (CategoryTheory.Functor.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) (CategoryTheory.Functor.category.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) q (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (CategoryTheory.Sigma.descUniq.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F q h)) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i) (CategoryTheory.Iso.hom.{max u4 u3, max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i) (h i)) X)
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (q : CategoryTheory.Functor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) (h : forall (i : I), CategoryTheory.Iso.{max u4 u3, max (max (max u5 u4) u3) u2} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max (max u4 u2) u1, u3, u4, max u4 u1, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i)) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (Prefunctor.obj.{succ (max (max u4 u2) u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 q) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (Prefunctor.obj.{succ (max (max u4 u2) u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X))) (CategoryTheory.NatTrans.app.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 q (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (CategoryTheory.Iso.hom.{max (max u4 u3) u1, max (max (max (max u4 u5) u2) u3) u1} (CategoryTheory.Functor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) (CategoryTheory.Functor.category.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) q (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (CategoryTheory.Sigma.descUniq.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F q h)) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (CategoryTheory.Functor.comp.{u2, max (max u4 u2) u1, u3, u4, max u4 u1, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i) (CategoryTheory.Iso.hom.{max u4 u3, max (max (max u4 u5) u2) u3} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max (max u4 u2) u1, u3, u4, max u4 u1, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i) (h i)) X)
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.desc_uniq_hom_app CategoryTheory.Sigma.descUniq_hom_appₓ'. -/
 @[simp]
 theorem descUniq_hom_app (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
     (descUniq F q h).Hom.app ⟨i, X⟩ = (h i).Hom.app X :=
   rfl
 #align category_theory.sigma.desc_uniq_hom_app CategoryTheory.Sigma.descUniq_hom_app
 
-/- warning: category_theory.sigma.desc_uniq_inv_app -> CategoryTheory.Sigma.descUniq_inv_app is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (q : CategoryTheory.Functor.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) (h : forall (i : I), CategoryTheory.Iso.{max u4 u3, max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i)) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.obj.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.Functor.obj.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 q (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X))) (CategoryTheory.NatTrans.app.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) q (CategoryTheory.Iso.inv.{max (max u1 u4) u3, max (max u1 u2 u4) u3 (max u1 u4) u5} (CategoryTheory.Functor.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) (CategoryTheory.Functor.category.{max u1 u2 u4, u3, max u1 u4, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) q (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (CategoryTheory.Sigma.descUniq.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F q h)) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (CategoryTheory.Iso.inv.{max u4 u3, max u2 u3 u4 u5} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max u1 u2 u4, u3, u4, max u1 u4, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i) (h i)) X)
-but is expected to have type
-  forall {I : Type.{u1}} {C : I -> Type.{u4}} [_inst_1 : forall (i : I), CategoryTheory.Category.{u2, u4} (C i)] {D : Type.{u5}} [_inst_2 : CategoryTheory.Category.{u3, u5} D] (F : forall (i : I), CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (q : CategoryTheory.Functor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) (h : forall (i : I), CategoryTheory.Iso.{max u4 u3, max (max (max u5 u4) u3) u2} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max (max u4 u2) u1, u3, u4, max u4 u1, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i)) (i : I) (X : C i), Eq.{succ u3} (Quiver.Hom.{succ u3, u5} D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (Prefunctor.obj.{succ (max (max u4 u2) u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F)) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (Prefunctor.obj.{succ (max (max u4 u2) u1), succ u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u2) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) D (CategoryTheory.CategoryStruct.toQuiver.{u3, u5} D (CategoryTheory.Category.toCategoryStruct.{u3, u5} D _inst_2)) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 q) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X))) (CategoryTheory.NatTrans.app.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) q (CategoryTheory.Iso.inv.{max (max u4 u3) u1, max (max (max (max u4 u5) u2) u3) u1} (CategoryTheory.Functor.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) (CategoryTheory.Functor.category.{max (max u4 u2) u1, u3, max u4 u1, u5} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2) q (CategoryTheory.Sigma.desc.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F) (CategoryTheory.Sigma.descUniq.{u1, u2, u3, u4, u5} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) D _inst_2 F q h)) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) i X)) (CategoryTheory.NatTrans.app.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2 (F i) (CategoryTheory.Functor.comp.{u2, max (max u4 u2) u1, u3, u4, max u4 u1, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (CategoryTheory.Iso.inv.{max u4 u3, max (max (max u4 u5) u2) u3} (CategoryTheory.Functor.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.category.{u2, u3, u4, u5} (C i) (_inst_1 i) D _inst_2) (CategoryTheory.Functor.comp.{u2, max (max u4 u2) u1, u3, u4, max u4 u1, u5} (C i) (_inst_1 i) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) D _inst_2 (CategoryTheory.Sigma.incl.{u1, u2, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i) i) q) (F i) (h i)) X)
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.desc_uniq_inv_app CategoryTheory.Sigma.descUniq_inv_appₓ'. -/
 @[simp]
 theorem descUniq_inv_app (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) (i : I) (X : C i) :
     (descUniq F q h).inv.app ⟨i, X⟩ = (h i).inv.app X :=
@@ -309,23 +225,11 @@ def map : (Σj : J, C (g j)) ⥤ Σi : I, C i :=
 #align category_theory.sigma.map CategoryTheory.Sigma.map
 -/
 
-/- warning: category_theory.sigma.map_obj -> CategoryTheory.Sigma.map_obj is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} (C : I -> Type.{u4}) [_inst_1 : forall (i : I), CategoryTheory.Category.{u3, u4} (C i)] {J : Type.{u2}} (g : J -> I) (j : J) (X : C (g j)), Eq.{max (succ u1) (succ u4)} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Functor.obj.{max u2 u3 u4, max u1 u3 u4, max u2 u4, max u1 u4} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => (fun (i : I) => _inst_1 i) (g i))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => (fun (i : I) => _inst_1 i) i)) (CategoryTheory.Sigma.map.{u1, u2, u3, u4} I C (fun (i : I) => _inst_1 i) J g) (Sigma.mk.{u2, u4} J (fun (j : J) => C (g j)) j X)) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) (g j) X)
-but is expected to have type
-  forall {I : Type.{u1}} (C : I -> Type.{u4}) [_inst_1 : forall (i : I), CategoryTheory.Category.{u3, u4} (C i)] {J : Type.{u2}} (g : J -> I) (j : J) (X : C (g j)), Eq.{max (succ u4) (succ u1)} (Sigma.{u1, u4} I (fun (i : I) => C i)) (Prefunctor.obj.{max (max (succ u4) (succ u3)) (succ u2), max (max (succ u4) (succ u3)) (succ u1), max u4 u2, max u4 u1} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u2, max u4 u2} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u2, max u4 u2} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => _inst_1 (g i))))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u3) u2, max (max u4 u3) u1, max u4 u2, max u4 u1} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => _inst_1 (g i))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) (CategoryTheory.Sigma.map.{u1, u2, u3, u4} I C (fun (i : I) => _inst_1 i) J g)) (Sigma.mk.{u2, u4} J (fun (j : J) => C (g j)) j X)) (Sigma.mk.{u1, u4} I (fun (i : I) => C i) (g j) X)
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.map_obj CategoryTheory.Sigma.map_objₓ'. -/
 @[simp]
 theorem map_obj (j : J) (X : C (g j)) : (Sigma.map C g).obj ⟨j, X⟩ = ⟨g j, X⟩ :=
   rfl
 #align category_theory.sigma.map_obj CategoryTheory.Sigma.map_obj
 
-/- warning: category_theory.sigma.map_map -> CategoryTheory.Sigma.map_map is a dubious translation:
-lean 3 declaration is
-  forall {I : Type.{u1}} (C : I -> Type.{u4}) [_inst_1 : forall (i : I), CategoryTheory.Category.{u3, u4} (C i)] {J : Type.{u2}} (g : J -> I) {j : J} {X : C (g j)} {Y : C (g j)} (f : Quiver.Hom.{succ u3, u4} (C (g j)) (CategoryTheory.CategoryStruct.toQuiver.{u3, u4} (C (g j)) (CategoryTheory.Category.toCategoryStruct.{u3, u4} (C (g j)) (_inst_1 (g j)))) X Y), Eq.{succ (max u1 u3 u4)} (Quiver.Hom.{succ (max u1 u3 u4), max u1 u4} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max u1 u3 u4, max u1 u4} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max u1 u3 u4, max u1 u4} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => (fun (i : I) => _inst_1 i) i)))) (CategoryTheory.Functor.obj.{max u2 u3 u4, max u1 u3 u4, max u2 u4, max u1 u4} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => (fun (i : I) => _inst_1 i) (g i))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => (fun (i : I) => _inst_1 i) i)) (CategoryTheory.Sigma.map.{u1, u2, u3, u4} I C (fun (i : I) => _inst_1 i) J g) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j X)) (CategoryTheory.Functor.obj.{max u2 u3 u4, max u1 u3 u4, max u2 u4, max u1 u4} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => (fun (i : I) => _inst_1 i) (g i))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => (fun (i : I) => _inst_1 i) i)) (CategoryTheory.Sigma.map.{u1, u2, u3, u4} I C (fun (i : I) => _inst_1 i) J g) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j Y))) (CategoryTheory.Functor.map.{max u2 u3 u4, max u1 u3 u4, max u2 u4, max u1 u4} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => (fun (i : I) => _inst_1 i) (g i))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => (fun (i : I) => _inst_1 i) i)) (CategoryTheory.Sigma.map.{u1, u2, u3, u4} I C (fun (i : I) => _inst_1 i) J g) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j X) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j Y) (CategoryTheory.Sigma.SigmaHom.mk.{u2, u3, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) (fun (i : J) => (fun (i : J) => (fun (i : J) => (fun (i : I) => _inst_1 i) (g i)) i) i) j X Y f)) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u3, u4} I (fun (i : I) => (fun (i : I) => (fun (i : I) => C i) i) i) (fun (i : I) => (fun (i : I) => (fun (i : I) => (fun (i : I) => _inst_1 i) i) i) i) (g (Sigma.fst.{u2, u4} J (fun (i : J) => (fun (j : J) => C (g j)) i) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j X))) (Sigma.snd.{u2, u4} J (fun (i : J) => (fun (j : J) => C (g j)) i) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j X)) (Sigma.snd.{u2, u4} J (fun (i : J) => (fun (j : J) => C (g j)) i) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j Y)) f)
-but is expected to have type
-  forall {I : Type.{u1}} (C : I -> Type.{u4}) [_inst_1 : forall (i : I), CategoryTheory.Category.{u3, u4} (C i)] {J : Type.{u2}} (g : J -> I) {j : J} {X : C (g j)} {Y : C (g j)} (f : Quiver.Hom.{succ u3, u4} (C (g j)) (CategoryTheory.CategoryStruct.toQuiver.{u3, u4} (C (g j)) (CategoryTheory.Category.toCategoryStruct.{u3, u4} (C (g j)) (_inst_1 (g j)))) X Y), Eq.{max (max (succ u4) (succ u3)) (succ u1)} (Quiver.Hom.{max (max (succ u4) (succ u3)) (succ u1), max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) (Prefunctor.obj.{max (max (succ u4) (succ u3)) (succ u2), max (max (succ u4) (succ u3)) (succ u1), max u4 u2, max u4 u1} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u2, max u4 u2} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u2, max u4 u2} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => _inst_1 (g i))))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u3) u2, max (max u4 u3) u1, max u4 u2, max u4 u1} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => _inst_1 (g i))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) (CategoryTheory.Sigma.map.{u1, u2, u3, u4} I C (fun (i : I) => _inst_1 i) J g)) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j X)) (Prefunctor.obj.{max (max (succ u4) (succ u3)) (succ u2), max (max (succ u4) (succ u3)) (succ u1), max u4 u2, max u4 u1} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u2, max u4 u2} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u2, max u4 u2} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => _inst_1 (g i))))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u3) u2, max (max u4 u3) u1, max u4 u2, max u4 u1} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => _inst_1 (g i))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) (CategoryTheory.Sigma.map.{u1, u2, u3, u4} I C (fun (i : I) => _inst_1 i) J g)) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j Y))) (Prefunctor.map.{max (max (succ u4) (succ u3)) (succ u2), max (max (succ u4) (succ u3)) (succ u1), max u4 u2, max u4 u1} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u2, max u4 u2} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u2, max u4 u2} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => _inst_1 (g i))))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.CategoryStruct.toQuiver.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Category.toCategoryStruct.{max (max u4 u3) u1, max u4 u1} (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)))) (CategoryTheory.Functor.toPrefunctor.{max (max u4 u3) u2, max (max u4 u3) u1, max u4 u2, max u4 u1} (Sigma.{u2, u4} J (fun (j : J) => C (g j))) (CategoryTheory.Sigma.sigma.{u2, u3, u4} J (fun (j : J) => C (g j)) (fun (i : J) => _inst_1 (g i))) (Sigma.{u1, u4} I (fun (i : I) => C i)) (CategoryTheory.Sigma.sigma.{u1, u3, u4} I (fun (i : I) => C i) (fun (i : I) => _inst_1 i)) (CategoryTheory.Sigma.map.{u1, u2, u3, u4} I C (fun (i : I) => _inst_1 i) J g)) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j X) (Sigma.mk.{u2, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) j Y) (CategoryTheory.Sigma.SigmaHom.mk.{u2, u3, u4} J (fun (i : J) => (fun (i : J) => (fun (j : J) => C (g j)) i) i) (fun (i : J) => (fun (i : J) => (fun (i : J) => _inst_1 (g i)) i) i) j X Y f)) (CategoryTheory.Sigma.SigmaHom.mk.{u1, u3, u4} I C (fun (i : I) => _inst_1 i) (g j) X Y f)
-Case conversion may be inaccurate. Consider using '#align category_theory.sigma.map_map CategoryTheory.Sigma.map_mapₓ'. -/
 @[simp]
 theorem map_map {j : J} {X Y : C (g j)} (f : X ⟶ Y) :
     (Sigma.map C g).map (SigmaHom.mk f) = SigmaHom.mk f :=

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

@@ -162,9 +162,7 @@ each subcategory.
 def natTrans {F G : (Σi, C i) ⥤ D} (h : ∀ i : I, incl i ⋙ F ⟶ incl i ⋙ G) : F ⟶ G
     where
   app := fun ⟨j, X⟩ => (h j).app X
-  naturality' := by
-    rintro ⟨j, X⟩ ⟨_, _⟩ ⟨f⟩
-    apply (h j).naturality
+  naturality' := by rintro ⟨j, X⟩ ⟨_, _⟩ ⟨f⟩; apply (h j).naturality
 #align category_theory.sigma.nat_trans CategoryTheory.Sigma.natTrans
 -/
 
@@ -204,12 +202,8 @@ This witnesses that the sigma-type is the coproduct in Cat.
 def desc : (Σi, C i) ⥤ D where
   obj X := (F X.1).obj X.2
   map X Y g := descMap F X Y g
-  map_id' := by
-    rintro ⟨i, X⟩
-    apply (F i).map_id
-  map_comp' := by
-    rintro ⟨i, X⟩ ⟨_, Y⟩ ⟨_, Z⟩ ⟨f⟩ ⟨g⟩
-    apply (F i).map_comp
+  map_id' := by rintro ⟨i, X⟩; apply (F i).map_id
+  map_comp' := by rintro ⟨i, X⟩ ⟨_, Y⟩ ⟨_, Z⟩ ⟨f⟩ ⟨g⟩; apply (F i).map_comp
 #align category_theory.sigma.desc CategoryTheory.Sigma.desc
 -/
 
@@ -261,9 +255,7 @@ theorem inclDesc_inv_app (i : I) (X : C i) : (inclDesc F i).inv.app X = 𝟙 ((F
 `desc F`.
 -/
 def descUniq (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) : q ≅ desc F :=
-  (NatIso.ofComponents fun ⟨i, X⟩ => (h i).app X) <|
-    by
-    rintro ⟨i, X⟩ ⟨_, _⟩ ⟨f⟩
+  (NatIso.ofComponents fun ⟨i, X⟩ => (h i).app X) <| by rintro ⟨i, X⟩ ⟨_, _⟩ ⟨f⟩;
     apply (h i).Hom.naturality f
 #align category_theory.sigma.desc_uniq CategoryTheory.Sigma.descUniq
 -/

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

Before this PR, Functor.Full contained the data of the preimage of maps by a full functor F. This PR makes Functor.Full a proposition. This is to prevent any diamond to appear.

The lemma Functor.image_preimage is also renamed Functor.map_preimage.

Co-authored-by: Joël Riou <37772949+joelriou@users.noreply.github.com>

@@ -91,8 +91,7 @@ lemma incl_obj {i : I} (X : C i) : (incl i).obj X = ⟨i, X⟩ :=
 #align category_theory.sigma.incl_obj CategoryTheory.Sigma.incl_obj
 
 instance (i : I) : Functor.Full (incl i : C i ⥤ Σi, C i) where
-  preimage := fun ⟨f⟩ => f
-  witness := fun ⟨_⟩ => rfl
+  map_surjective := fun ⟨f⟩ => ⟨f, rfl⟩
 
 instance (i : I) : Functor.Faithful (incl i : C i ⥤ Σi, C i) where
   -- Porting note (#10936): was `tidy`

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

@@ -90,11 +90,11 @@ lemma incl_obj {i : I} (X : C i) : (incl i).obj X = ⟨i, X⟩ :=
   rfl
 #align category_theory.sigma.incl_obj CategoryTheory.Sigma.incl_obj
 
-instance (i : I) : Full (incl i : C i ⥤ Σi, C i) where
+instance (i : I) : Functor.Full (incl i : C i ⥤ Σi, C i) where
   preimage := fun ⟨f⟩ => f
   witness := fun ⟨_⟩ => rfl
 
-instance (i : I) : Faithful (incl i : C i ⥤ Σi, C i) where
+instance (i : I) : Functor.Faithful (incl i : C i ⥤ Σi, C i) where
   -- Porting note (#10936): was `tidy`
   map_injective {_ _ _ _} h := by injection h
 

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)

@@ -251,7 +251,6 @@ end
 namespace Functor
 
 -- variable {C}
-
 variable {D : I → Type u₁} [∀ i, Category.{v₁} (D i)]
 
 /-- Assemble an `I`-indexed family of functors into a functor between the sigma types.
@@ -265,7 +264,6 @@ end Functor
 namespace natTrans
 
 variable {D : I → Type u₁} [∀ i, Category.{v₁} (D i)]
-
 variable {F G : ∀ i, C i ⥤ D i}
 
 /-- Assemble an `I`-indexed family of natural transformations into a single natural transformation.

Classifies by adding issue number (#10936) to porting notes claiming anything semantically equivalent to:

• "used to be tidy"
• "was tidy "

@@ -95,7 +95,7 @@ instance (i : I) : Full (incl i : C i ⥤ Σi, C i) where
   witness := fun ⟨_⟩ => rfl
 
 instance (i : I) : Faithful (incl i : C i ⥤ Σi, C i) where
-  -- Porting note: was `tidy`
+  -- Porting note (#10936): was `tidy`
   map_injective {_ _ _ _} h := by injection h
 
 section

A linter that throws on seeing a colon at the start of a line, according to the style guideline that says these operators should go before linebreaks.

@@ -58,8 +58,7 @@ lemma comp_def (i : I) (X Y Z : C i) (f : X ⟶ Y) (g : Y ⟶ Z) : comp (mk f) (
   rfl
 #align category_theory.sigma.sigma_hom.comp_def CategoryTheory.Sigma.SigmaHom.comp_def
 
-lemma assoc
-  : ∀ {X Y Z W : Σi, C i} (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W), (f ≫ g) ≫ h = f ≫ g ≫ h
+lemma assoc : ∀ {X Y Z W : Σi, C i} (f : X ⟶ Y) (g : Y ⟶ Z) (h : Z ⟶ W), (f ≫ g) ≫ h = f ≫ g ≫ h
   | _, _, _, _, mk _, mk _, mk _ => congr_arg mk (Category.assoc _ _ _)
 #align category_theory.sigma.sigma_hom.assoc CategoryTheory.Sigma.SigmaHom.assoc
 

• depends on: #5966

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

@@ -2,16 +2,13 @@
 Copyright (c) 2020 Bhavik Mehta. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Bhavik Mehta
-
-! This file was ported from Lean 3 source module category_theory.sigma.basic
-! leanprover-community/mathlib commit ba2245edf0c8bb155f1569fd9b9492a9b384cde6
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Whiskering
 import Mathlib.CategoryTheory.Functor.FullyFaithful
 import Mathlib.CategoryTheory.NatIso
 
+#align_import category_theory.sigma.basic from "leanprover-community/mathlib"@"ba2245edf0c8bb155f1569fd9b9492a9b384cde6"
+
 /-!
 # Disjoint union of categories
 

Clean up of automation in the category theory library. Leaving out unnecessary proof steps, or fields done by aesop_cat, and making more use of available autoparameters.

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

@@ -159,7 +159,7 @@ lemma desc_map_mk {i : I} (X Y : C i) (f : X ⟶ Y) : (desc F).map (SigmaHom.mk
 `F i`.
 -/
 def inclDesc (i : I) : incl i ⋙ desc F ≅ F i :=
-  NatIso.ofComponents (fun X => Iso.refl _) (by aesop)
+  NatIso.ofComponents fun X => Iso.refl _
 #align category_theory.sigma.incl_desc CategoryTheory.Sigma.inclDesc
 
 @[simp]
@@ -176,7 +176,7 @@ lemma inclDesc_inv_app (i : I) (X : C i) : (inclDesc F i).inv.app X = 𝟙 ((F i
 `desc F`.
 -/
 def descUniq (q : (Σi, C i) ⥤ D) (h : ∀ i, incl i ⋙ q ≅ F i) : q ≅ desc F :=
-  (NatIso.ofComponents fun ⟨i, X⟩ => (h i).app X) <| by
+  NatIso.ofComponents (fun ⟨i, X⟩ => (h i).app X) <| by
     rintro ⟨i, X⟩ ⟨_, _⟩ ⟨f⟩
     apply (h i).hom.naturality f
 #align category_theory.sigma.desc_uniq CategoryTheory.Sigma.descUniq
@@ -236,7 +236,7 @@ variable (I)
 /-- The functor `Sigma.map` applied to the identity function is just the identity functor. -/
 @[simps!]
 def mapId : map C (id : I → I) ≅ 𝟭 (Σi, C i) :=
-  natIso fun i => NatIso.ofComponents (fun X => Iso.refl _) (by aesop)
+  natIso fun i => NatIso.ofComponents fun X => Iso.refl _
 #align category_theory.sigma.map_id CategoryTheory.Sigma.mapId
 
 variable {I} {K : Type w₃}

I ran codespell Mathlib and got tired halfway through the suggestions.

@@ -242,7 +242,7 @@ def mapId : map C (id : I → I) ≅ 𝟭 (Σi, C i) :=
 variable {I} {K : Type w₃}
 
 -- Porting note: Had to expand (G ∘ g) to (fun i => C (g i)) in lemma statement
--- so that the suitable cateogry instances could be found
+-- so that the suitable category instances could be found
 /-- The functor `Sigma.map` applied to a composition is a composition of functors. -/
 @[simps!]
 def mapComp (f : K → J) (g : J → I) : map (fun x => C (g x)) f ⋙ (map C g : _) ≅ map C (g ∘ f) :=

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

@@ -243,7 +243,7 @@ variable {I} {K : Type w₃}
 
 -- Porting note: Had to expand (G ∘ g) to (fun i => C (g i)) in lemma statement
 -- so that the suitable cateogry instances could be found
-/-- The functor `sigma.map` applied to a composition is a composition of functors. -/
+/-- The functor `Sigma.map` applied to a composition is a composition of functors. -/
 @[simps!]
 def mapComp (f : K → J) (g : J → I) : map (fun x => C (g x)) f ⋙ (map C g : _) ≅ map C (g ∘ f) :=
   (descUniq _ _) fun k =>

• This does not change the behavior of simps, just raises a linter error if you run simps in a more expensive mode without writing !.
• Fixed some incorrect occurrences of to_additive, simps. Will do that systematically in future PR.
• Fix port of OmegaCompletePartialOrder.ContinuousHom.ofMono a bit

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -226,7 +226,7 @@ lemma map_map {j : J} {X Y : C (g j)} (f : X ⟶ Y) :
 
 /-- The functor `Sigma.map C g` restricted to the subcategory `C j` acts as the inclusion of `g j`.
 -/
-@[simps]
+@[simps!]
 def inclCompMap (j : J) : incl j ⋙ map C g ≅ incl (g j) :=
   Iso.refl _
 #align category_theory.sigma.incl_comp_map CategoryTheory.Sigma.inclCompMap
@@ -234,7 +234,7 @@ def inclCompMap (j : J) : incl j ⋙ map C g ≅ incl (g j) :=
 variable (I)
 
 /-- The functor `Sigma.map` applied to the identity function is just the identity functor. -/
-@[simps]
+@[simps!]
 def mapId : map C (id : I → I) ≅ 𝟭 (Σi, C i) :=
   natIso fun i => NatIso.ofComponents (fun X => Iso.refl _) (by aesop)
 #align category_theory.sigma.map_id CategoryTheory.Sigma.mapId
@@ -244,7 +244,7 @@ variable {I} {K : Type w₃}
 -- Porting note: Had to expand (G ∘ g) to (fun i => C (g i)) in lemma statement
 -- so that the suitable cateogry instances could be found
 /-- The functor `sigma.map` applied to a composition is a composition of functors. -/
-@[simps]
+@[simps!]
 def mapComp (f : K → J) (g : J → I) : map (fun x => C (g x)) f ⋙ (map C g : _) ≅ map C (g ∘ f) :=
   (descUniq _ _) fun k =>
     (isoWhiskerRight (inclCompMap (fun i => C (g i)) f k) (map C g : _) : _) ≪≫ inclCompMap _ _ _

Co-authored-by: Jad Ghalayini <jad.ghalayini@protonmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Joachim Breitner <mail@joachim-breitner.de>