category_theory.sums.basic ⟷ Mathlib.CategoryTheory.Sums.Basic

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

@@ -156,8 +156,8 @@ def equivalence : Sum C D ≌ Sum D C :=
 -/
 
 #print CategoryTheory.Sum.Swap.isEquivalence /-
-instance isEquivalence : IsEquivalence (swap C D) :=
-  (by infer_instance : IsEquivalence (equivalence C D).Functor)
+instance isEquivalence : CategoryTheory.Functor.IsEquivalence (swap C D) :=
+  (by infer_instance : CategoryTheory.Functor.IsEquivalence (equivalence C D).Functor)
 #align category_theory.sum.swap.is_equivalence CategoryTheory.Sum.Swap.isEquivalence
 -/
 

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

@@ -3,7 +3,7 @@ Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathbin.CategoryTheory.EqToHom
+import CategoryTheory.EqToHom
 
 #align_import category_theory.sums.basic from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
 

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

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module category_theory.sums.basic
-! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.EqToHom
 
+#align_import category_theory.sums.basic from "leanprover-community/mathlib"@"23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6"
+
 /-!
 # Binary disjoint unions of categories
 

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

@@ -119,34 +119,44 @@ def swap : Sum C D ⥤ Sum D C
 #align category_theory.sum.swap CategoryTheory.Sum.swap
 -/
 
+#print CategoryTheory.Sum.swap_obj_inl /-
 @[simp]
 theorem swap_obj_inl (X : C) : (swap C D).obj (inl X) = inr X :=
   rfl
 #align category_theory.sum.swap_obj_inl CategoryTheory.Sum.swap_obj_inl
+-/
 
+#print CategoryTheory.Sum.swap_obj_inr /-
 @[simp]
 theorem swap_obj_inr (X : D) : (swap C D).obj (inr X) = inl X :=
   rfl
 #align category_theory.sum.swap_obj_inr CategoryTheory.Sum.swap_obj_inr
+-/
 
+#print CategoryTheory.Sum.swap_map_inl /-
 @[simp]
 theorem swap_map_inl {X Y : C} {f : inl X ⟶ inl Y} : (swap C D).map f = f :=
   rfl
 #align category_theory.sum.swap_map_inl CategoryTheory.Sum.swap_map_inl
+-/
 
+#print CategoryTheory.Sum.swap_map_inr /-
 @[simp]
 theorem swap_map_inr {X Y : D} {f : inr X ⟶ inr Y} : (swap C D).map f = f :=
   rfl
 #align category_theory.sum.swap_map_inr CategoryTheory.Sum.swap_map_inr
+-/
 
 namespace Swap
 
+#print CategoryTheory.Sum.Swap.equivalence /-
 /-- `swap` gives an equivalence between `C ⊕ D` and `D ⊕ C`. -/
 def equivalence : Sum C D ≌ Sum D C :=
   Equivalence.mk (swap C D) (swap D C)
     (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by tidy))
     (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) (by tidy))
 #align category_theory.sum.swap.equivalence CategoryTheory.Sum.Swap.equivalence
+-/
 
 #print CategoryTheory.Sum.Swap.isEquivalence /-
 instance isEquivalence : IsEquivalence (swap C D) :=
@@ -190,27 +200,35 @@ def sum (F : A ⥤ B) (G : C ⥤ D) : Sum A C ⥤ Sum B D
 #align category_theory.functor.sum CategoryTheory.Functor.sum
 -/
 
+#print CategoryTheory.Functor.sum_obj_inl /-
 @[simp]
 theorem sum_obj_inl (F : A ⥤ B) (G : C ⥤ D) (a : A) : (F.Sum G).obj (inl a) = inl (F.obj a) :=
   rfl
 #align category_theory.functor.sum_obj_inl CategoryTheory.Functor.sum_obj_inl
+-/
 
+#print CategoryTheory.Functor.sum_obj_inr /-
 @[simp]
 theorem sum_obj_inr (F : A ⥤ B) (G : C ⥤ D) (c : C) : (F.Sum G).obj (inr c) = inr (G.obj c) :=
   rfl
 #align category_theory.functor.sum_obj_inr CategoryTheory.Functor.sum_obj_inr
+-/
 
+#print CategoryTheory.Functor.sum_map_inl /-
 @[simp]
 theorem sum_map_inl (F : A ⥤ B) (G : C ⥤ D) {a a' : A} (f : inl a ⟶ inl a') :
     (F.Sum G).map f = F.map f :=
   rfl
 #align category_theory.functor.sum_map_inl CategoryTheory.Functor.sum_map_inl
+-/
 
+#print CategoryTheory.Functor.sum_map_inr /-
 @[simp]
 theorem sum_map_inr (F : A ⥤ B) (G : C ⥤ D) {c c' : C} (f : inr c ⟶ inr c') :
     (F.Sum G).map f = G.map f :=
   rfl
 #align category_theory.functor.sum_map_inr CategoryTheory.Functor.sum_map_inr
+-/
 
 end Functor
 
@@ -231,17 +249,21 @@ def sum {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) : F.Sum H
 #align category_theory.nat_trans.sum CategoryTheory.NatTrans.sum
 -/
 
+#print CategoryTheory.NatTrans.sum_app_inl /-
 @[simp]
 theorem sum_app_inl {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) (a : A) :
     (sum α β).app (inl a) = α.app a :=
   rfl
 #align category_theory.nat_trans.sum_app_inl CategoryTheory.NatTrans.sum_app_inl
+-/
 
+#print CategoryTheory.NatTrans.sum_app_inr /-
 @[simp]
 theorem sum_app_inr {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) (c : C) :
     (sum α β).app (inr c) = β.app c :=
   rfl
 #align category_theory.nat_trans.sum_app_inr CategoryTheory.NatTrans.sum_app_inr
+-/
 
 end NatTrans
 

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

@@ -119,45 +119,21 @@ def swap : Sum C D ⥤ Sum D C
 #align category_theory.sum.swap CategoryTheory.Sum.swap
 -/
 
-/- warning: category_theory.sum.swap_obj_inl -> CategoryTheory.Sum.swap_obj_inl is a dubious translation:
-lean 3 declaration is
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D] (X : C), Eq.{succ u2} (Sum.{u2, u2} D C) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2) (Sum.inl.{u2, u2} C D X)) (Sum.inr.{u2, u2} D C X)
-but is expected to have type
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D] (X : C), Eq.{succ u2} (Sum.{u2, u2} D C) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2)) (Sum.inl.{u2, u2} C D X)) (Sum.inr.{u2, u2} D C X)
-Case conversion may be inaccurate. Consider using '#align category_theory.sum.swap_obj_inl CategoryTheory.Sum.swap_obj_inlₓ'. -/
 @[simp]
 theorem swap_obj_inl (X : C) : (swap C D).obj (inl X) = inr X :=
   rfl
 #align category_theory.sum.swap_obj_inl CategoryTheory.Sum.swap_obj_inl
 
-/- warning: category_theory.sum.swap_obj_inr -> CategoryTheory.Sum.swap_obj_inr is a dubious translation:
-lean 3 declaration is
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D] (X : D), Eq.{succ u2} (Sum.{u2, u2} D C) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2) (Sum.inr.{u2, u2} C D X)) (Sum.inl.{u2, u2} D C X)
-but is expected to have type
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D] (X : D), Eq.{succ u2} (Sum.{u2, u2} D C) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2)) (Sum.inr.{u2, u2} C D X)) (Sum.inl.{u2, u2} D C X)
-Case conversion may be inaccurate. Consider using '#align category_theory.sum.swap_obj_inr CategoryTheory.Sum.swap_obj_inrₓ'. -/
 @[simp]
 theorem swap_obj_inr (X : D) : (swap C D).obj (inr X) = inl X :=
   rfl
 #align category_theory.sum.swap_obj_inr CategoryTheory.Sum.swap_obj_inr
 
-/- warning: category_theory.sum.swap_map_inl -> CategoryTheory.Sum.swap_map_inl is a dubious translation:
-lean 3 declaration is
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.inl.{u2, u2} C D X) (Sum.inl.{u2, u2} C D Y)}, Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2) (Sum.inl.{u2, u2} C D X)) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2) (Sum.inl.{u2, u2} C D Y))) (CategoryTheory.Functor.map.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2) (Sum.inl.{u2, u2} C D X) (Sum.inl.{u2, u2} C D Y) f) f
-but is expected to have type
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D] {X : C} {Y : C} {f : Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.inl.{u2, u2} C D X) (Sum.inl.{u2, u2} C D Y)}, Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2)) (Sum.inl.{u2, u2} C D X)) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2)) (Sum.inl.{u2, u2} C D Y))) (Prefunctor.map.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2)) (Sum.inl.{u2, u2} C D X) (Sum.inl.{u2, u2} C D Y) f) f
-Case conversion may be inaccurate. Consider using '#align category_theory.sum.swap_map_inl CategoryTheory.Sum.swap_map_inlₓ'. -/
 @[simp]
 theorem swap_map_inl {X Y : C} {f : inl X ⟶ inl Y} : (swap C D).map f = f :=
   rfl
 #align category_theory.sum.swap_map_inl CategoryTheory.Sum.swap_map_inl
 
-/- warning: category_theory.sum.swap_map_inr -> CategoryTheory.Sum.swap_map_inr is a dubious translation:
-lean 3 declaration is
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D] {X : D} {Y : D} {f : Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.inr.{u2, u2} C D X) (Sum.inr.{u2, u2} C D Y)}, Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2) (Sum.inr.{u2, u2} C D X)) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2) (Sum.inr.{u2, u2} C D Y))) (CategoryTheory.Functor.map.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2) (Sum.inr.{u2, u2} C D X) (Sum.inr.{u2, u2} C D Y) f) f
-but is expected to have type
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D] {X : D} {Y : D} {f : Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.inr.{u2, u2} C D X) (Sum.inr.{u2, u2} C D Y)}, Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2)) (Sum.inr.{u2, u2} C D X)) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2)) (Sum.inr.{u2, u2} C D Y))) (Prefunctor.map.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2))) (Sum.{u2, u2} D C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1) (CategoryTheory.Sum.swap.{u1, u2} C _inst_1 D _inst_2)) (Sum.inr.{u2, u2} C D X) (Sum.inr.{u2, u2} C D Y) f) f
-Case conversion may be inaccurate. Consider using '#align category_theory.sum.swap_map_inr CategoryTheory.Sum.swap_map_inrₓ'. -/
 @[simp]
 theorem swap_map_inr {X Y : D} {f : inr X ⟶ inr Y} : (swap C D).map f = f :=
   rfl
@@ -165,12 +141,6 @@ theorem swap_map_inr {X Y : D} {f : inr X ⟶ inr Y} : (swap C D).map f = f :=
 
 namespace Swap
 
-/- warning: category_theory.sum.swap.equivalence -> CategoryTheory.Sum.Swap.equivalence is a dubious translation:
-lean 3 declaration is
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D], CategoryTheory.Equivalence.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1)
-but is expected to have type
-  forall (C : Type.{u2}) [_inst_1 : CategoryTheory.Category.{u1, u2} C] (D : Type.{u2}) [_inst_2 : CategoryTheory.Category.{u1, u2} D], CategoryTheory.Equivalence.{u1, u1, u2, u2} (Sum.{u2, u2} C D) (Sum.{u2, u2} D C) (CategoryTheory.sum.{u1, u2} C _inst_1 D _inst_2) (CategoryTheory.sum.{u1, u2} D _inst_2 C _inst_1)
-Case conversion may be inaccurate. Consider using '#align category_theory.sum.swap.equivalence CategoryTheory.Sum.Swap.equivalenceₓ'. -/
 /-- `swap` gives an equivalence between `C ⊕ D` and `D ⊕ C`. -/
 def equivalence : Sum C D ≌ Sum D C :=
   Equivalence.mk (swap C D) (swap D C)
@@ -220,40 +190,22 @@ def sum (F : A ⥤ B) (G : C ⥤ D) : Sum A C ⥤ Sum B D
 #align category_theory.functor.sum CategoryTheory.Functor.sum
 -/
 
-/- warning: category_theory.functor.sum_obj_inl -> CategoryTheory.Functor.sum_obj_inl is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] (F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (G : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (a : A), Eq.{succ u2} (Sum.{u2, u2} B D) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G) (Sum.inl.{u2, u2} A C a)) (Sum.inl.{u2, u2} B D (CategoryTheory.Functor.obj.{u1, u1, u2, u2} A _inst_1 B _inst_2 F a))
-but is expected to have type
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] (F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (G : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (a : A), Eq.{succ u2} (Sum.{u2, u2} B D) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G)) (Sum.inl.{u2, u2} A C a)) (Sum.inl.{u2, u2} B D (Prefunctor.obj.{succ u1, succ u1, u2, u2} A (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} A (CategoryTheory.Category.toCategoryStruct.{u1, u2} A _inst_1)) B (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} B (CategoryTheory.Category.toCategoryStruct.{u1, u2} B _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} A _inst_1 B _inst_2 F) a))
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.sum_obj_inl CategoryTheory.Functor.sum_obj_inlₓ'. -/
 @[simp]
 theorem sum_obj_inl (F : A ⥤ B) (G : C ⥤ D) (a : A) : (F.Sum G).obj (inl a) = inl (F.obj a) :=
   rfl
 #align category_theory.functor.sum_obj_inl CategoryTheory.Functor.sum_obj_inl
 
-/- warning: category_theory.functor.sum_obj_inr -> CategoryTheory.Functor.sum_obj_inr is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] (F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (G : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (c : C), Eq.{succ u2} (Sum.{u2, u2} B D) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G) (Sum.inr.{u2, u2} A C c)) (Sum.inr.{u2, u2} B D (CategoryTheory.Functor.obj.{u1, u1, u2, u2} C _inst_3 D _inst_4 G c))
-but is expected to have type
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] (F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (G : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (c : C), Eq.{succ u2} (Sum.{u2, u2} B D) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G)) (Sum.inr.{u2, u2} A C c)) (Sum.inr.{u2, u2} B D (Prefunctor.obj.{succ u1, succ u1, u2, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_3)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} D (CategoryTheory.Category.toCategoryStruct.{u1, u2} D _inst_4)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} C _inst_3 D _inst_4 G) c))
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.sum_obj_inr CategoryTheory.Functor.sum_obj_inrₓ'. -/
 @[simp]
 theorem sum_obj_inr (F : A ⥤ B) (G : C ⥤ D) (c : C) : (F.Sum G).obj (inr c) = inr (G.obj c) :=
   rfl
 #align category_theory.functor.sum_obj_inr CategoryTheory.Functor.sum_obj_inr
 
-/- warning: category_theory.functor.sum_map_inl -> CategoryTheory.Functor.sum_map_inl is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.sum_map_inl CategoryTheory.Functor.sum_map_inlₓ'. -/
 @[simp]
 theorem sum_map_inl (F : A ⥤ B) (G : C ⥤ D) {a a' : A} (f : inl a ⟶ inl a') :
     (F.Sum G).map f = F.map f :=
   rfl
 #align category_theory.functor.sum_map_inl CategoryTheory.Functor.sum_map_inl
 
-/- warning: category_theory.functor.sum_map_inr -> CategoryTheory.Functor.sum_map_inr is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.functor.sum_map_inr CategoryTheory.Functor.sum_map_inrₓ'. -/
 @[simp]
 theorem sum_map_inr (F : A ⥤ B) (G : C ⥤ D) {c c' : C} (f : inr c ⟶ inr c') :
     (F.Sum G).map f = G.map f :=
@@ -279,18 +231,12 @@ def sum {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) : F.Sum H
 #align category_theory.nat_trans.sum CategoryTheory.NatTrans.sum
 -/
 
-/- warning: category_theory.nat_trans.sum_app_inl -> CategoryTheory.NatTrans.sum_app_inl is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.nat_trans.sum_app_inl CategoryTheory.NatTrans.sum_app_inlₓ'. -/
 @[simp]
 theorem sum_app_inl {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) (a : A) :
     (sum α β).app (inl a) = α.app a :=
   rfl
 #align category_theory.nat_trans.sum_app_inl CategoryTheory.NatTrans.sum_app_inl
 
-/- warning: category_theory.nat_trans.sum_app_inr -> CategoryTheory.NatTrans.sum_app_inr is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align category_theory.nat_trans.sum_app_inr CategoryTheory.NatTrans.sum_app_inrₓ'. -/
 @[simp]
 theorem sum_app_inr {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) (c : C) :
     (sum α β).app (inr c) = β.app c :=

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

@@ -215,14 +215,8 @@ def sum (F : A ⥤ B) (G : C ⥤ D) : Sum A C ⥤ Sum B D
   map_id' X := by cases X <;> unfold_aux; erw [F.map_id]; rfl; erw [G.map_id]; rfl
   map_comp' X Y Z f g :=
     match X, Y, Z, f, g with
-    | inl X, inl Y, inl Z, f, g => by
-      unfold_aux
-      erw [F.map_comp]
-      rfl
-    | inr X, inr Y, inr Z, f, g => by
-      unfold_aux
-      erw [G.map_comp]
-      rfl
+    | inl X, inl Y, inl Z, f, g => by unfold_aux; erw [F.map_comp]; rfl
+    | inr X, inr Y, inr Z, f, g => by unfold_aux; erw [G.map_comp]; rfl
 #align category_theory.functor.sum CategoryTheory.Functor.sum
 -/
 

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

@@ -249,10 +249,7 @@ theorem sum_obj_inr (F : A ⥤ B) (G : C ⥤ D) (c : C) : (F.Sum G).obj (inr c)
 #align category_theory.functor.sum_obj_inr CategoryTheory.Functor.sum_obj_inr
 
 /- warning: category_theory.functor.sum_map_inl -> CategoryTheory.Functor.sum_map_inl is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] (F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (G : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) {a : A} {a' : A} (f : Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.inl.{u2, u2} A C a) (Sum.inl.{u2, u2} A C a')), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G) (Sum.inl.{u2, u2} A C a)) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G) (Sum.inl.{u2, u2} A C a'))) (CategoryTheory.Functor.map.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G) (Sum.inl.{u2, u2} A C a) (Sum.inl.{u2, u2} A C a') f) (CategoryTheory.Functor.map.{u1, u1, u2, u2} A _inst_1 B _inst_2 F a a' f)
-but is expected to have type
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] (F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (G : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) {a : A} {a' : A} (f : Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.inl.{u2, u2} A C a) (Sum.inl.{u2, u2} A C a')), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G)) (Sum.inl.{u2, u2} A C a)) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G)) (Sum.inl.{u2, u2} A C a'))) (Prefunctor.map.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G)) (Sum.inl.{u2, u2} A C a) (Sum.inl.{u2, u2} A C a') f) (Prefunctor.map.{succ u1, succ u1, u2, u2} A (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} A (CategoryTheory.Category.toCategoryStruct.{u1, u2} A _inst_1)) B (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} B (CategoryTheory.Category.toCategoryStruct.{u1, u2} B _inst_2)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} A _inst_1 B _inst_2 F) a a' f)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.functor.sum_map_inl CategoryTheory.Functor.sum_map_inlₓ'. -/
 @[simp]
 theorem sum_map_inl (F : A ⥤ B) (G : C ⥤ D) {a a' : A} (f : inl a ⟶ inl a') :
@@ -261,10 +258,7 @@ theorem sum_map_inl (F : A ⥤ B) (G : C ⥤ D) {a a' : A} (f : inl a ⟶ inl a'
 #align category_theory.functor.sum_map_inl CategoryTheory.Functor.sum_map_inl
 
 /- warning: category_theory.functor.sum_map_inr -> CategoryTheory.Functor.sum_map_inr is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] (F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (G : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) {c : C} {c' : C} (f : Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.inr.{u2, u2} A C c) (Sum.inr.{u2, u2} A C c')), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G) (Sum.inr.{u2, u2} A C c)) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G) (Sum.inr.{u2, u2} A C c'))) (CategoryTheory.Functor.map.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G) (Sum.inr.{u2, u2} A C c) (Sum.inr.{u2, u2} A C c') f) (CategoryTheory.Functor.map.{u1, u1, u2, u2} C _inst_3 D _inst_4 G c c' f)
-but is expected to have type
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] (F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (G : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) {c : C} {c' : C} (f : Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.inr.{u2, u2} A C c) (Sum.inr.{u2, u2} A C c')), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G)) (Sum.inr.{u2, u2} A C c)) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G)) (Sum.inr.{u2, u2} A C c'))) (Prefunctor.map.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G)) (Sum.inr.{u2, u2} A C c) (Sum.inr.{u2, u2} A C c') f) (Prefunctor.map.{succ u1, succ u1, u2, u2} C (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} C (CategoryTheory.Category.toCategoryStruct.{u1, u2} C _inst_3)) D (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} D (CategoryTheory.Category.toCategoryStruct.{u1, u2} D _inst_4)) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} C _inst_3 D _inst_4 G) c c' f)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.functor.sum_map_inr CategoryTheory.Functor.sum_map_inrₓ'. -/
 @[simp]
 theorem sum_map_inr (F : A ⥤ B) (G : C ⥤ D) {c c' : C} (f : inr c ⟶ inr c') :
@@ -292,10 +286,7 @@ def sum {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) : F.Sum H
 -/
 
 /- warning: category_theory.nat_trans.sum_app_inl -> CategoryTheory.NatTrans.sum_app_inl is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] {F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2} {G : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2} {H : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4} {I : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4} (α : Quiver.Hom.{succ (max u2 u1), max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.Functor.category.{u1, u1, u2, u2} A _inst_1 B _inst_2))) F G) (β : Quiver.Hom.{succ (max u2 u1), max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.Functor.category.{u1, u1, u2, u2} C _inst_3 D _inst_4))) H I) (a : A), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F H) (Sum.inl.{u2, u2} A C a)) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 G I) (Sum.inl.{u2, u2} A C a))) (CategoryTheory.NatTrans.app.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F H) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 G I) (CategoryTheory.NatTrans.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G H I α β) (Sum.inl.{u2, u2} A C a)) (CategoryTheory.NatTrans.app.{u1, u1, u2, u2} A _inst_1 B _inst_2 F G α a)
-but is expected to have type
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] {F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2} {G : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2} {H : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4} {I : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4} (α : Quiver.Hom.{max (succ u2) (succ u1), max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.Functor.category.{u1, u1, u2, u2} A _inst_1 B _inst_2))) F G) (β : Quiver.Hom.{max (succ u2) (succ u1), max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.Functor.category.{u1, u1, u2, u2} C _inst_3 D _inst_4))) H I) (a : A), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F H)) (Sum.inl.{u2, u2} A C a)) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 G I)) (Sum.inl.{u2, u2} A C a))) (CategoryTheory.NatTrans.app.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F H) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 G I) (CategoryTheory.NatTrans.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G H I α β) (Sum.inl.{u2, u2} A C a)) (CategoryTheory.NatTrans.app.{u1, u1, u2, u2} A _inst_1 B _inst_2 F G α a)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.nat_trans.sum_app_inl CategoryTheory.NatTrans.sum_app_inlₓ'. -/
 @[simp]
 theorem sum_app_inl {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) (a : A) :
@@ -304,10 +295,7 @@ theorem sum_app_inl {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I
 #align category_theory.nat_trans.sum_app_inl CategoryTheory.NatTrans.sum_app_inl
 
 /- warning: category_theory.nat_trans.sum_app_inr -> CategoryTheory.NatTrans.sum_app_inr is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] {F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2} {G : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2} {H : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4} {I : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4} (α : Quiver.Hom.{succ (max u2 u1), max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.Functor.category.{u1, u1, u2, u2} A _inst_1 B _inst_2))) F G) (β : Quiver.Hom.{succ (max u2 u1), max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max u1 u2} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.Functor.category.{u1, u1, u2, u2} C _inst_3 D _inst_4))) H I) (c : C), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F H) (Sum.inr.{u2, u2} A C c)) (CategoryTheory.Functor.obj.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 G I) (Sum.inr.{u2, u2} A C c))) (CategoryTheory.NatTrans.app.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F H) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 G I) (CategoryTheory.NatTrans.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G H I α β) (Sum.inr.{u2, u2} A C c)) (CategoryTheory.NatTrans.app.{u1, u1, u2, u2} C _inst_3 D _inst_4 H I β c)
-but is expected to have type
-  forall {A : Type.{u2}} [_inst_1 : CategoryTheory.Category.{u1, u2} A] {B : Type.{u2}} [_inst_2 : CategoryTheory.Category.{u1, u2} B] {C : Type.{u2}} [_inst_3 : CategoryTheory.Category.{u1, u2} C] {D : Type.{u2}} [_inst_4 : CategoryTheory.Category.{u1, u2} D] {F : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2} {G : CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2} {H : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4} {I : CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4} (α : Quiver.Hom.{max (succ u2) (succ u1), max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} A _inst_1 B _inst_2) (CategoryTheory.Functor.category.{u1, u1, u2, u2} A _inst_1 B _inst_2))) F G) (β : Quiver.Hom.{max (succ u2) (succ u1), max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max u2 u1} (CategoryTheory.Functor.{u1, u1, u2, u2} C _inst_3 D _inst_4) (CategoryTheory.Functor.category.{u1, u1, u2, u2} C _inst_3 D _inst_4))) H I) (c : C), Eq.{succ u1} (Quiver.Hom.{succ u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F H)) (Sum.inr.{u2, u2} A C c)) (Prefunctor.obj.{succ u1, succ u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3))) (Sum.{u2, u2} B D) (CategoryTheory.CategoryStruct.toQuiver.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.Category.toCategoryStruct.{u1, u2} (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4))) (CategoryTheory.Functor.toPrefunctor.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 G I)) (Sum.inr.{u2, u2} A C c))) (CategoryTheory.NatTrans.app.{u1, u1, u2, u2} (Sum.{u2, u2} A C) (CategoryTheory.sum.{u1, u2} A _inst_1 C _inst_3) (Sum.{u2, u2} B D) (CategoryTheory.sum.{u1, u2} B _inst_2 D _inst_4) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F H) (CategoryTheory.Functor.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 G I) (CategoryTheory.NatTrans.sum.{u1, u2} A _inst_1 B _inst_2 C _inst_3 D _inst_4 F G H I α β) (Sum.inr.{u2, u2} A C c)) (CategoryTheory.NatTrans.app.{u1, u1, u2, u2} C _inst_3 D _inst_4 H I β c)
+<too large>
 Case conversion may be inaccurate. Consider using '#align category_theory.nat_trans.sum_app_inr CategoryTheory.NatTrans.sum_app_inrₓ'. -/
 @[simp]
 theorem sum_app_inr {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) (c : C) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/3ade05ac9447ae31a22d2ea5423435e054131240

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 
 ! This file was ported from Lean 3 source module category_theory.sums.basic
-! leanprover-community/mathlib commit 7e781a8eff6f56c97d71d629901fa88e5174e346
+! leanprover-community/mathlib commit 23aa88e32dcc9d2a24cca7bc23268567ed4cd7d6
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.CategoryTheory.EqToHom
 /-!
 # Binary disjoint unions of categories
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We define the category instance on `C ⊕ D` when `C` and `D` are categories.
 
 We define:

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

We add Functor.sum' a variant of Functor.sum. This situation is dual to docs#CategoryTheory.Functor.prod'.

We also add inl_sum' and inr_sum' which prove that the sum functor F.sum' G precomposed with the left (resp. right) inclusion functor is isomorphic to F (resp. G).

@@ -48,11 +48,11 @@ instance sum : Category.{v₁} (Sum C D) where
     match X with
     | inl X => 𝟙 X
     | inr X => 𝟙 X
-  comp := @fun X Y Z f g =>
+  comp {X Y Z} f g :=
     match X, Y, Z, f, g with
     | inl X, inl Y, inl Z, f, g => f ≫ g
     | inr X, inr Y, inr Z, f, g => f ≫ g
-  assoc := @fun W X Y Z f g h =>
+  assoc {W X Y Z} f g h :=
     match X, Y, Z, W with
     | inl X, inl Y, inl Z, inl W => Category.assoc f g h
     | inr X, inr Y, inr Z, inr W => Category.assoc f g h
@@ -93,14 +93,14 @@ variable (C : Type u₁) [Category.{v₁} C] (D : Type u₁) [Category.{v₁} D]
 @[simps]
 def inl_ : C ⥤ Sum C D where
   obj X := inl X
-  map := @fun X Y f => f
+  map {X Y} f := f
 #align category_theory.sum.inl_ CategoryTheory.Sum.inl_
 
 /-- `inr_` is the functor `X ↦ inr X`. -/
 @[simps]
 def inr_ : D ⥤ Sum C D where
   obj X := inr X
-  map := @fun X Y f => f
+  map {X Y} f := f
 #align category_theory.sum.inr_ CategoryTheory.Sum.inr_
 
 /- Porting note: `aesop_cat` not firing on `map_comp` where autotac in Lean 3 did
@@ -176,17 +176,44 @@ def sum (F : A ⥤ B) (G : C ⥤ D) : Sum A C ⥤ Sum B D
     match X with
     | inl X => inl (F.obj X)
     | inr X => inr (G.obj X)
-  map := @fun X Y f =>
+  map {X Y} f :=
     match X, Y, f with
     | inl X, inl Y, f => F.map f
     | inr X, inr Y, f => G.map f
-  map_id := @fun X => by cases X <;> (erw [Functor.map_id]; rfl)
-  map_comp := @fun X Y Z f g =>
+  map_id {X} := by cases X <;> (erw [Functor.map_id]; rfl)
+  map_comp {X Y Z} f g:=
     match X, Y, Z, f, g with
     | inl X, inl Y, inl Z, f, g => by erw [F.map_comp]; rfl
     | inr X, inr Y, inr Z, f, g => by erw [G.map_comp]; rfl
 #align category_theory.functor.sum CategoryTheory.Functor.sum
 
+/-- Similar to `sum`, but both functors land in the same category `C` -/
+def sum' (F : A ⥤ C) (G : B ⥤ C) : Sum A B ⥤ C
+    where
+  obj X :=
+    match X with
+    | inl X => F.obj X
+    | inr X => G.obj X
+  map {X Y} f :=
+    match X, Y, f with
+    | inl _, inl _, f => F.map f
+    | inr _, inr _, f => G.map f
+  map_id {X} := by cases X <;> erw [Functor.map_id]
+  map_comp {X Y Z} f g :=
+    match X, Y, Z, f, g with
+    | inl _, inl _, inl _, f, g => by erw [F.map_comp]
+    | inr _, inr _, inr _, f, g => by erw [G.map_comp]
+
+/-- The sum `F.sum' G` precomposed with the left inclusion functor is isomorphic to `F` -/
+@[simps!]
+def inlCompSum' (F : A ⥤ C) (G : B ⥤ C) : Sum.inl_ A B ⋙ F.sum' G ≅ F :=
+  NatIso.ofComponents fun X => Iso.refl _
+
+/-- The sum `F.sum' G` precomposed with the right inclusion functor is isomorphic to `G` -/
+@[simps!]
+def inrCompSum' (F : A ⥤ C) (G : B ⥤ C) : Sum.inr_ A B ⋙ F.sum' G ≅ G :=
+  NatIso.ofComponents fun X => Iso.refl _
+
 @[simp]
 theorem sum_obj_inl (F : A ⥤ B) (G : C ⥤ D) (a : A) : (F.sum G).obj (inl a) = inl (F.obj a) :=
   rfl

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

@@ -151,8 +151,8 @@ def equivalence : Sum C D ≌ Sum D C :=
     (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)))
 #align category_theory.sum.swap.equivalence CategoryTheory.Sum.Swap.equivalence
 
-instance isEquivalence : IsEquivalence (swap C D) :=
-  (by infer_instance : IsEquivalence (equivalence C D).functor)
+instance isEquivalence : (swap C D).IsEquivalence :=
+  (by infer_instance : (equivalence C D).functor.IsEquivalence)
 #align category_theory.sum.swap.is_equivalence CategoryTheory.Sum.Swap.isEquivalence
 
 /-- The double swap on `C ⊕ D` is naturally isomorphic to the identity functor. -/

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

@@ -58,11 +58,11 @@ instance sum : Category.{v₁} (Sum C D) where
     | inr X, inr Y, inr Z, inr W => Category.assoc f g h
 #align category_theory.sum CategoryTheory.sum
 
-@[aesop norm -10 destruct (rule_sets [CategoryTheory])]
+@[aesop norm -10 destruct (rule_sets := [CategoryTheory])]
 theorem hom_inl_inr_false {X : C} {Y : D} (f : Sum.inl X ⟶ Sum.inr Y) : False := by
   cases f
 
-@[aesop norm -10 destruct (rule_sets [CategoryTheory])]
+@[aesop norm -10 destruct (rule_sets := [CategoryTheory])]
 theorem hom_inr_inl_false {X : C} {Y : D} (f : Sum.inr X ⟶ Sum.inl Y) : False := by
   cases f
 

aesop_cat_nonterminal is a non-terminal variant of aesop. It's not supposed to be used in production code since it's even worse than non-terminal simp. However, there were a few occurrences left (presumably from the port), which this PR removes.

The only nontrivial change is that I add mathlib's rfl tactic to the CategoryTheory Aesop rule set.

@@ -58,6 +58,14 @@ instance sum : Category.{v₁} (Sum C D) where
     | inr X, inr Y, inr Z, inr W => Category.assoc f g h
 #align category_theory.sum CategoryTheory.sum
 
+@[aesop norm -10 destruct (rule_sets [CategoryTheory])]
+theorem hom_inl_inr_false {X : C} {Y : D} (f : Sum.inl X ⟶ Sum.inr Y) : False := by
+  cases f
+
+@[aesop norm -10 destruct (rule_sets [CategoryTheory])]
+theorem hom_inr_inl_false {X : C} {Y : D} (f : Sum.inr X ⟶ Sum.inl Y) : False := by
+  cases f
+
 /- Porting note: seems similar to Mathlib4#1036 issue so marked as nolint  -/
 @[simp, nolint simpComm]
 theorem sum_comp_inl {P Q R : C} (f : (inl P : Sum C D) ⟶ inl Q) (g : (inl Q : Sum C D) ⟶ inl R) :
@@ -136,15 +144,11 @@ theorem swap_map_inr {X Y : D} {f : inr X ⟶ inr Y} : (swap C D).map f = f :=
 
 namespace Swap
 
-/- Porting note: had to manually call `cases f` for `f : PEmpty` -/
-
 /-- `swap` gives an equivalence between `C ⊕ D` and `D ⊕ C`. -/
 def equivalence : Sum C D ≌ Sum D C :=
   Equivalence.mk (swap C D) (swap D C)
-    (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl))
-      (by simp only [swap]; aesop_cat_nonterminal; cases f; cases f))
-    (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl))
-      (by simp only [swap]; aesop_cat_nonterminal; cases f; cases f))
+    (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)))
+    (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)))
 #align category_theory.sum.swap.equivalence CategoryTheory.Sum.Swap.equivalence
 
 instance isEquivalence : IsEquivalence (swap C D) :=
@@ -176,17 +180,11 @@ def sum (F : A ⥤ B) (G : C ⥤ D) : Sum A C ⥤ Sum B D
     match X, Y, f with
     | inl X, inl Y, f => F.map f
     | inr X, inr Y, f => G.map f
-  map_id := @fun X => by cases X <;> aesop_cat_nonterminal; erw [F.map_id]; rfl; erw [G.map_id]; rfl
+  map_id := @fun X => by cases X <;> (erw [Functor.map_id]; rfl)
   map_comp := @fun X Y Z f g =>
     match X, Y, Z, f, g with
-    | inl X, inl Y, inl Z, f, g => by
-      aesop_cat_nonterminal <;>
-      erw [F.map_comp] <;>
-      rfl
-    | inr X, inr Y, inr Z, f, g => by
-      aesop_cat_nonterminal <;>
-      erw [G.map_comp] <;>
-      rfl
+    | inl X, inl Y, inl Z, f, g => by erw [F.map_comp]; rfl
+    | inr X, inr Y, inr Z, f, g => by erw [G.map_comp]; rfl
 #align category_theory.functor.sum CategoryTheory.Functor.sum
 
 @[simp]
@@ -224,8 +222,8 @@ def sum {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) : F.sum H
     | inr X => β.app X
   naturality X Y f :=
     match X, Y, f with
-    | inl X, inl Y, f => by aesop_cat_nonterminal <;> erw [α.naturality] <;> rfl
-    | inr X, inr Y, f => by aesop_cat_nonterminal <;> erw [β.naturality] <;> rfl
+    | inl X, inl Y, f => by erw [α.naturality]; rfl
+    | inr X, inr Y, f => by erw [β.naturality]; rfl
 #align category_theory.nat_trans.sum CategoryTheory.NatTrans.sum
 
 @[simp]

• depends on: #5966

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

@@ -2,14 +2,11 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module category_theory.sums.basic
-! leanprover-community/mathlib commit dc6c365e751e34d100e80fe6e314c3c3e0fd2988
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.EqToHom
 
+#align_import category_theory.sums.basic from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
+
 /-!
 # Binary disjoint unions 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>

@@ -40,8 +40,7 @@ variable (C : Type u₁) [Category.{v₁} C] (D : Type u₁) [Category.{v₁} D]
 
 /-- `sum C D` gives the direct sum of two categories.
 -/
-instance sum : Category.{v₁} (Sum C D)
-    where
+instance sum : Category.{v₁} (Sum C D) where
   Hom X Y :=
     match X, Y with
     | inl X, inl Y => X ⟶ Y
@@ -103,8 +102,7 @@ def inr_ : D ⥤ Sum C D where
 but `map_id` was ok. -/
 
 /-- The functor exchanging two direct summand categories. -/
-def swap : Sum C D ⥤ Sum D C
-    where
+def swap : Sum C D ⥤ Sum D C where
   obj X :=
     match X with
     | inl X => inr X
@@ -147,9 +145,9 @@ namespace Swap
 def equivalence : Sum C D ≌ Sum D C :=
   Equivalence.mk (swap C D) (swap D C)
     (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl))
-    (by simp only [swap]; aesop_cat_nonterminal; cases f; cases f))
+      (by simp only [swap]; aesop_cat_nonterminal; cases f; cases f))
     (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl))
-    (by simp only [swap]; aesop_cat_nonterminal; cases f; cases f))
+      (by simp only [swap]; aesop_cat_nonterminal; cases f; cases f))
 #align category_theory.sum.swap.equivalence CategoryTheory.Sum.Swap.equivalence
 
 instance isEquivalence : IsEquivalence (swap C D) :=

This commit makes aesop_cat and aesop_graph terminal (i.e. they either solve the goal or fail). This appears to solve issues where non-terminal tactics, when used as auto-params, introduce unknown universe variables. See

https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Goal.20state.20not.20updating.2C.20bugs.2C.20etc.2E

Since there are some intended nonterminal uses of aesop_cat, we introduce aesop_cat_nonterminal as the nonterminal equivalent of aesop_cat.

@@ -147,9 +147,9 @@ namespace Swap
 def equivalence : Sum C D ≌ Sum D C :=
   Equivalence.mk (swap C D) (swap D C)
     (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl))
-    (by simp only [swap]; aesop_cat; cases f; cases f))
+    (by simp only [swap]; aesop_cat_nonterminal; cases f; cases f))
     (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl))
-    (by simp only [swap]; aesop_cat; cases f; cases f))
+    (by simp only [swap]; aesop_cat_nonterminal; cases f; cases f))
 #align category_theory.sum.swap.equivalence CategoryTheory.Sum.Swap.equivalence
 
 instance isEquivalence : IsEquivalence (swap C D) :=
@@ -181,15 +181,15 @@ def sum (F : A ⥤ B) (G : C ⥤ D) : Sum A C ⥤ Sum B D
     match X, Y, f with
     | inl X, inl Y, f => F.map f
     | inr X, inr Y, f => G.map f
-  map_id := @fun X => by cases X <;> aesop_cat; erw [F.map_id]; rfl; erw [G.map_id]; rfl
+  map_id := @fun X => by cases X <;> aesop_cat_nonterminal; erw [F.map_id]; rfl; erw [G.map_id]; rfl
   map_comp := @fun X Y Z f g =>
     match X, Y, Z, f, g with
     | inl X, inl Y, inl Z, f, g => by
-      aesop_cat <;>
+      aesop_cat_nonterminal <;>
       erw [F.map_comp] <;>
       rfl
     | inr X, inr Y, inr Z, f, g => by
-      aesop_cat <;>
+      aesop_cat_nonterminal <;>
       erw [G.map_comp] <;>
       rfl
 #align category_theory.functor.sum CategoryTheory.Functor.sum
@@ -229,8 +229,8 @@ def sum {F G : A ⥤ B} {H I : C ⥤ D} (α : F ⟶ G) (β : H ⟶ I) : F.sum H
     | inr X => β.app X
   naturality X Y f :=
     match X, Y, f with
-    | inl X, inl Y, f => by aesop_cat <;> erw [α.naturality] <;> rfl
-    | inr X, inr Y, f => by aesop_cat <;> erw [β.naturality] <;> rfl
+    | inl X, inl Y, f => by aesop_cat_nonterminal <;> erw [α.naturality] <;> rfl
+    | inr X, inr Y, f => by aesop_cat_nonterminal <;> erw [β.naturality] <;> rfl
 #align category_theory.nat_trans.sum CategoryTheory.NatTrans.sum
 
 @[simp]

vscode is already configured by .vscode/settings.json to trim these on save. It's not clear how they've managed to stick around.

By doing this all in one PR now, it avoids getting random whitespace diffs in PRs later.

This was done with a regex search in vscode,

@@ -56,9 +56,9 @@ instance sum : Category.{v₁} (Sum C D)
     match X, Y, Z, f, g with
     | inl X, inl Y, inl Z, f, g => f ≫ g
     | inr X, inr Y, inr Z, f, g => f ≫ g
-  assoc := @fun W X Y Z f g h => 
-    match X, Y, Z, W with 
-    | inl X, inl Y, inl Z, inl W => Category.assoc f g h  
+  assoc := @fun W X Y Z f g h =>
+    match X, Y, Z, W with
+    | inl X, inl Y, inl Z, inl W => Category.assoc f g h
     | inr X, inr Y, inr Z, inr W => Category.assoc f g h
 #align category_theory.sum CategoryTheory.sum
 
@@ -113,10 +113,10 @@ def swap : Sum C D ⥤ Sum D C
     match X, Y, f with
     | inl _, inl _, f => f
     | inr _, inr _, f => f
-  map_comp := fun {X} {Y} {Z} _ _ => 
-    match X, Y, Z with 
-    | inl X, inl Y, inl Z => by rfl 
-    | inr X, inr Y, inr Z => by rfl 
+  map_comp := fun {X} {Y} {Z} _ _ =>
+    match X, Y, Z with
+    | inl X, inl Y, inl Z => by rfl
+    | inr X, inr Y, inr Z => by rfl
 #align category_theory.sum.swap CategoryTheory.Sum.swap
 
 @[simp]
@@ -146,7 +146,7 @@ namespace Swap
 /-- `swap` gives an equivalence between `C ⊕ D` and `D ⊕ C`. -/
 def equivalence : Sum C D ≌ Sum D C :=
   Equivalence.mk (swap C D) (swap D C)
-    (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl)) 
+    (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl))
     (by simp only [swap]; aesop_cat; cases f; cases f))
     (NatIso.ofComponents (fun X => eqToIso (by cases X <;> rfl))
     (by simp only [swap]; aesop_cat; cases f; cases f))

Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: Arien Malec <arien.malec@gmail.com> Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Johan Commelin <johan@commelin.net>