category_theory.limits.opposites | Mathlib porting status

Changes since the initial port

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

Changes in mathlib3

ac3ae212

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

69c6a5a1

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -38,30 +38,34 @@ variable {C : Type u₁} [Category.{v₁} C]
 
 variable {J : Type u₂} [Category.{v₂} J]
 
-#print CategoryTheory.Limits.isLimitCoconeOp /-
+/- warning: category_theory.limits.is_limit_cocone_op clashes with category_theory.limits.is_colimit.op -> CategoryTheory.Limits.IsColimit.op
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.is_limit_cocone_op CategoryTheory.Limits.IsColimit.opₓ'. -/
+#print CategoryTheory.Limits.IsColimit.op /-
 /-- Turn a colimit for `F : J ⥤ C` into a limit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ`. -/
 @[simps]
-def isLimitCoconeOp (F : J ⥤ C) {c : Cocone F} (hc : IsColimit c) : IsLimit c.op
+def CategoryTheory.Limits.IsColimit.op (F : J ⥤ C) {c : Cocone F} (hc : IsColimit c) : IsLimit c.op
     where
   lift s := (hc.desc s.unop).op
   fac s j := Quiver.Hom.unop_inj (by simpa)
   uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac] using w (op j)
-#align category_theory.limits.is_limit_cocone_op CategoryTheory.Limits.isLimitCoconeOp
+#align category_theory.limits.is_limit_cocone_op CategoryTheory.Limits.IsColimit.op
 -/
 
-#print CategoryTheory.Limits.isColimitConeOp /-
+/- warning: category_theory.limits.is_colimit_cone_op clashes with category_theory.limits.is_limit.op -> CategoryTheory.Limits.IsLimit.op
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.is_colimit_cone_op CategoryTheory.Limits.IsLimit.opₓ'. -/
+#print CategoryTheory.Limits.IsLimit.op /-
 /-- Turn a limit for `F : J ⥤ C` into a colimit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ`. -/
 @[simps]
-def isColimitConeOp (F : J ⥤ C) {c : Cone F} (hc : IsLimit c) : IsColimit c.op
+def CategoryTheory.Limits.IsLimit.op (F : J ⥤ C) {c : Cone F} (hc : IsLimit c) : IsColimit c.op
     where
   desc s := (hc.lift s.unop).op
   fac s j := Quiver.Hom.unop_inj (by simpa)
   uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac] using w (op j)
-#align category_theory.limits.is_colimit_cone_op CategoryTheory.Limits.isColimitConeOp
+#align category_theory.limits.is_colimit_cone_op CategoryTheory.Limits.IsLimit.op
 -/
 
 #print CategoryTheory.Limits.isLimitConeLeftOpOfCocone /-
@@ -154,30 +158,34 @@ def isColimitCoconeUnopOfCone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLim
 #align category_theory.limits.is_colimit_cocone_unop_of_cone CategoryTheory.Limits.isColimitCoconeUnopOfCone
 -/
 
-#print CategoryTheory.Limits.isLimitCoconeUnop /-
+/- warning: category_theory.limits.is_limit_cocone_unop clashes with category_theory.limits.is_colimit.unop -> CategoryTheory.Limits.IsColimit.unop
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.is_limit_cocone_unop CategoryTheory.Limits.IsColimit.unopₓ'. -/
+#print CategoryTheory.Limits.IsColimit.unop /-
 /-- Turn a colimit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ` into a limit for `F : J ⥤ C`. -/
 @[simps]
-def isLimitCoconeUnop (F : J ⥤ C) {c : Cocone F.op} (hc : IsColimit c) : IsLimit c.unop
-    where
+def CategoryTheory.Limits.IsColimit.unop (F : J ⥤ C) {c : Cocone F.op} (hc : IsColimit c) :
+    IsLimit c.unop where
   lift s := (hc.desc s.op).unop
   fac s j := Quiver.Hom.op_inj (by simpa)
   uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac] using w (unop j)
-#align category_theory.limits.is_limit_cocone_unop CategoryTheory.Limits.isLimitCoconeUnop
+#align category_theory.limits.is_limit_cocone_unop CategoryTheory.Limits.IsColimit.unop
 -/
 
-#print CategoryTheory.Limits.isColimitConeUnop /-
+/- warning: category_theory.limits.is_colimit_cone_unop clashes with category_theory.limits.is_limit.unop -> CategoryTheory.Limits.IsLimit.unop
+Case conversion may be inaccurate. Consider using '#align category_theory.limits.is_colimit_cone_unop CategoryTheory.Limits.IsLimit.unopₓ'. -/
+#print CategoryTheory.Limits.IsLimit.unop /-
 /-- Turn a limit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ` into a colimit for `F : J ⥤ C`. -/
 @[simps]
-def isColimitConeUnop (F : J ⥤ C) {c : Cone F.op} (hc : IsLimit c) : IsColimit c.unop
-    where
+def CategoryTheory.Limits.IsLimit.unop (F : J ⥤ C) {c : Cone F.op} (hc : IsLimit c) :
+    IsColimit c.unop where
   desc s := (hc.lift s.op).unop
   fac s j := Quiver.Hom.op_inj (by simpa)
   uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac] using w (unop j)
-#align category_theory.limits.is_colimit_cone_unop CategoryTheory.Limits.isColimitConeUnop
+#align category_theory.limits.is_colimit_cone_unop CategoryTheory.Limits.IsLimit.unop
 -/
 
 #print CategoryTheory.Limits.isLimitConeOfCoconeLeftOp /-
@@ -284,7 +292,7 @@ theorem hasLimit_of_hasColimit_leftOp (F : J ⥤ Cᵒᵖ) [HasColimit F.leftOp]
 theorem hasLimit_of_hasColimit_op (F : J ⥤ C) [HasColimit F.op] : HasLimit F :=
   HasLimit.mk
     { Cone := (colimit.cocone F.op).unop
-      IsLimit := isLimitCoconeUnop _ (colimit.isColimit _) }
+      IsLimit := CategoryTheory.Limits.IsColimit.unop _ (colimit.isColimit _) }
 #align category_theory.limits.has_limit_of_has_colimit_op CategoryTheory.Limits.hasLimit_of_hasColimit_op
 -/
 
@@ -348,7 +356,7 @@ theorem hasColimit_of_hasLimit_leftOp (F : J ⥤ Cᵒᵖ) [HasLimit F.leftOp] :
 theorem hasColimit_of_hasLimit_op (F : J ⥤ C) [HasLimit F.op] : HasColimit F :=
   HasColimit.mk
     { Cocone := (limit.cone F.op).unop
-      IsColimit := isColimitConeUnop _ (limit.isLimit _) }
+      IsColimit := CategoryTheory.Limits.IsLimit.unop _ (limit.isLimit _) }
 #align category_theory.limits.has_colimit_of_has_limit_op CategoryTheory.Limits.hasColimit_of_hasLimit_op
 -/

69c6a5a1

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Floris van Doorn
 -/
-import Mathbin.CategoryTheory.Limits.Filtered
-import Mathbin.CategoryTheory.Limits.Shapes.FiniteProducts
-import Mathbin.CategoryTheory.DiscreteCategory
-import Mathbin.Tactic.EquivRw
+import CategoryTheory.Limits.Filtered
+import CategoryTheory.Limits.Shapes.FiniteProducts
+import CategoryTheory.DiscreteCategory
+import Tactic.EquivRw
 
 #align_import category_theory.limits.opposites from "leanprover-community/mathlib"@"69c6a5a12d8a2b159f20933e60115a4f2de62b58"

69c6a5a1

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Floris van Doorn
-
-! This file was ported from Lean 3 source module category_theory.limits.opposites
-! leanprover-community/mathlib commit 69c6a5a12d8a2b159f20933e60115a4f2de62b58
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.CategoryTheory.Limits.Filtered
 import Mathbin.CategoryTheory.Limits.Shapes.FiniteProducts
 import Mathbin.CategoryTheory.DiscreteCategory
 import Mathbin.Tactic.EquivRw
 
+#align_import category_theory.limits.opposites from "leanprover-community/mathlib"@"69c6a5a12d8a2b159f20933e60115a4f2de62b58"
+
 /-!
 # Limits in `C` give colimits in `Cᵒᵖ`.

69c6a5a1

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -555,7 +555,6 @@ def opCospan {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
     _ ≅ walkingCospanOpEquiv.Functor ⋙ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
       (Functor.associator _ _ _)
     _ ≅ walkingCospanOpEquiv.Functor ⋙ span f.op g.op := isoWhiskerLeft _ (spanOp f g).symm
-    
 #align category_theory.limits.op_cospan CategoryTheory.Limits.opCospan
 -/
 
@@ -581,7 +580,6 @@ def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
     _ ≅ walkingSpanOpEquiv.Functor ⋙ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
       (Functor.associator _ _ _)
     _ ≅ walkingSpanOpEquiv.Functor ⋙ cospan f.op g.op := isoWhiskerLeft _ (cospanOp f g).symm
-    
 #align category_theory.limits.op_span CategoryTheory.Limits.opSpan
 -/

69c6a5a1

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -743,13 +743,13 @@ def isColimitEquivIsLimitOp {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : Pushout
   apply equivOfSubsingletonOfSubsingleton
   · intro h
     equiv_rw is_limit.postcompose_hom_equiv _ _
-    equiv_rw(is_limit.whisker_equivalence_equiv walking_span_op_equiv.symm).symm
+    equiv_rw (is_limit.whisker_equivalence_equiv walking_span_op_equiv.symm).symm
     exact is_limit_cocone_op _ h
   · intro h
     equiv_rw is_colimit.equiv_iso_colimit c.op_unop.symm
     apply is_colimit_cone_unop
     equiv_rw is_limit.postcompose_hom_equiv _ _
-    equiv_rw(is_limit.whisker_equivalence_equiv _).symm
+    equiv_rw (is_limit.whisker_equivalence_equiv _).symm
     exact h
 #align category_theory.limits.pushout_cocone.is_colimit_equiv_is_limit_op CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitOp
 -/
@@ -764,12 +764,12 @@ def isColimitEquivIsLimitUnop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c :
   · intro h
     apply is_limit_cocone_unop
     equiv_rw is_colimit.precompose_hom_equiv _ _
-    equiv_rw(is_colimit.whisker_equivalence_equiv _).symm
+    equiv_rw (is_colimit.whisker_equivalence_equiv _).symm
     exact h
   · intro h
     equiv_rw is_colimit.equiv_iso_colimit c.unop_op.symm
     equiv_rw is_colimit.precompose_hom_equiv _ _
-    equiv_rw(is_colimit.whisker_equivalence_equiv walking_cospan_op_equiv.symm).symm
+    equiv_rw (is_colimit.whisker_equivalence_equiv walking_cospan_op_equiv.symm).symm
     exact is_colimit_cone_op _ h
 #align category_theory.limits.pushout_cocone.is_colimit_equiv_is_limit_unop CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitUnop
 -/

69c6a5a1

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -505,17 +505,13 @@ instance hasCoequalizers_opposite [HasEqualizers C] : HasCoequalizers Cᵒᵖ :=
 
 #print CategoryTheory.Limits.hasFiniteColimits_opposite /-
 instance hasFiniteColimits_opposite [HasFiniteLimits C] : HasFiniteColimits Cᵒᵖ
-    where out J 𝒟 𝒥 := by
-    skip
-    infer_instance
+    where out J 𝒟 𝒥 := by skip; infer_instance
 #align category_theory.limits.has_finite_colimits_opposite CategoryTheory.Limits.hasFiniteColimits_opposite
 -/
 
 #print CategoryTheory.Limits.hasFiniteLimits_opposite /-
 instance hasFiniteLimits_opposite [HasFiniteColimits C] : HasFiniteLimits Cᵒᵖ
-    where out J 𝒟 𝒥 := by
-    skip
-    infer_instance
+    where out J 𝒟 𝒥 := by skip; infer_instance
 #align category_theory.limits.has_finite_limits_opposite CategoryTheory.Limits.hasFiniteLimits_opposite
 -/
 
@@ -608,8 +604,7 @@ theorem unop_fst {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocon
     c.unop.fst = c.inl.unop :=
   by
   change (_ : limits.cone _).π.app _ = _
-  simp only [pushout_cocone.ι_app_left, pushout_cocone.unop_π_app]
-  tidy
+  simp only [pushout_cocone.ι_app_left, pushout_cocone.unop_π_app]; tidy
 #align category_theory.limits.pushout_cocone.unop_fst CategoryTheory.Limits.PushoutCocone.unop_fst
 -/
 
@@ -619,8 +614,7 @@ theorem unop_snd {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocon
     c.unop.snd = c.inr.unop :=
   by
   change (_ : limits.cone _).π.app _ = _
-  simp only [pushout_cocone.unop_π_app, pushout_cocone.ι_app_right]
-  tidy
+  simp only [pushout_cocone.unop_π_app, pushout_cocone.ι_app_right]; tidy
 #align category_theory.limits.pushout_cocone.unop_snd CategoryTheory.Limits.PushoutCocone.unop_snd
 -/
 
@@ -636,18 +630,14 @@ def op {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : Pullbac
 #print CategoryTheory.Limits.PushoutCocone.op_fst /-
 @[simp]
 theorem op_fst {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : c.op.fst = c.inl.op :=
-  by
-  change (_ : limits.cone _).π.app _ = _
-  apply category.comp_id
+  by change (_ : limits.cone _).π.app _ = _; apply category.comp_id
 #align category_theory.limits.pushout_cocone.op_fst CategoryTheory.Limits.PushoutCocone.op_fst
 -/
 
 #print CategoryTheory.Limits.PushoutCocone.op_snd /-
 @[simp]
 theorem op_snd {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : c.op.snd = c.inr.op :=
-  by
-  change (_ : limits.cone _).π.app _ = _
-  apply category.comp_id
+  by change (_ : limits.cone _).π.app _ = _; apply category.comp_id
 #align category_theory.limits.pushout_cocone.op_snd CategoryTheory.Limits.PushoutCocone.op_snd
 -/
 
@@ -701,18 +691,14 @@ def op {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : PushoutC
 #print CategoryTheory.Limits.PullbackCone.op_inl /-
 @[simp]
 theorem op_inl {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : c.op.inl = c.fst.op :=
-  by
-  change (_ : limits.cocone _).ι.app _ = _
-  apply category.id_comp
+  by change (_ : limits.cocone _).ι.app _ = _; apply category.id_comp
 #align category_theory.limits.pullback_cone.op_inl CategoryTheory.Limits.PullbackCone.op_inl
 -/
 
 #print CategoryTheory.Limits.PullbackCone.op_inr /-
 @[simp]
 theorem op_inr {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : c.op.inr = c.snd.op :=
-  by
-  change (_ : limits.cocone _).ι.app _ = _
-  apply category.id_comp
+  by change (_ : limits.cocone _).ι.app _ = _; apply category.id_comp
 #align category_theory.limits.pullback_cone.op_inr CategoryTheory.Limits.PullbackCone.op_inr
 -/

69c6a5a1

bump to nightly-2023-05-23-03

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

ed98987c

Diff

@@ -827,7 +827,7 @@ noncomputable def pullbackIsoUnopPushout {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
 -/
 
 #print CategoryTheory.Limits.pullbackIsoUnopPushout_inv_fst /-
-@[simp, reassoc.1]
+@[simp, reassoc]
 theorem pullbackIsoUnopPushout_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] :
     (pullbackIsoUnopPushout f g).inv ≫ pullback.fst = (pushout.inl : _ ⟶ pushout f.op g.op).unop :=
@@ -836,7 +836,7 @@ theorem pullbackIsoUnopPushout_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [
 -/
 
 #print CategoryTheory.Limits.pullbackIsoUnopPushout_inv_snd /-
-@[simp, reassoc.1]
+@[simp, reassoc]
 theorem pullbackIsoUnopPushout_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] :
     (pullbackIsoUnopPushout f g).inv ≫ pullback.snd = (pushout.inr : _ ⟶ pushout f.op g.op).unop :=
@@ -845,7 +845,7 @@ theorem pullbackIsoUnopPushout_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [
 -/
 
 #print CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inl /-
-@[simp, reassoc.1]
+@[simp, reassoc]
 theorem pullbackIsoUnopPushout_hom_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] : pushout.inl ≫ (pullbackIsoUnopPushout f g).hom.op = pullback.fst.op :=
   by
@@ -856,7 +856,7 @@ theorem pullbackIsoUnopPushout_hom_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [
 -/
 
 #print CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inr /-
-@[simp, reassoc.1]
+@[simp, reassoc]
 theorem pullbackIsoUnopPushout_hom_inr {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] : pushout.inr ≫ (pullbackIsoUnopPushout f g).hom.op = pullback.snd.op :=
   by
@@ -881,7 +881,7 @@ noncomputable def pushoutIsoUnopPullback {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y)
 -/
 
 #print CategoryTheory.Limits.pushoutIsoUnopPullback_inl_hom /-
-@[simp, reassoc.1]
+@[simp, reassoc]
 theorem pushoutIsoUnopPullback_inl_hom {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
     [HasPullback f.op g.op] :
     pushout.inl ≫ (pushoutIsoUnopPullback f g).hom = (pullback.fst : pullback f.op g.op ⟶ _).unop :=
@@ -890,7 +890,7 @@ theorem pushoutIsoUnopPullback_inl_hom {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [
 -/
 
 #print CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom /-
-@[simp, reassoc.1]
+@[simp, reassoc]
 theorem pushoutIsoUnopPullback_inr_hom {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
     [HasPullback f.op g.op] :
     pushout.inr ≫ (pushoutIsoUnopPullback f g).hom = (pullback.snd : pullback f.op g.op ⟶ _).unop :=

69c6a5a1

bump to nightly-2023-03-14-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

d4b38a42

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Floris van Doorn
 
 ! This file was ported from Lean 3 source module category_theory.limits.opposites
-! leanprover-community/mathlib commit ac3ae212f394f508df43e37aa093722fa9b65d31
+! leanprover-community/mathlib commit 69c6a5a12d8a2b159f20933e60115a4f2de62b58
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -16,6 +16,9 @@ import Mathbin.Tactic.EquivRw
 /-!
 # Limits in `C` give colimits in `Cᵒᵖ`.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We also give special cases for (co)products,
 (co)equalizers, and pullbacks / pushouts.

ac3ae212

bump to nightly-2023-03-11-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

1d00e3b6

Diff

@@ -38,6 +38,7 @@ variable {C : Type u₁} [Category.{v₁} C]
 
 variable {J : Type u₂} [Category.{v₂} J]
 
+#print CategoryTheory.Limits.isLimitCoconeOp /-
 /-- Turn a colimit for `F : J ⥤ C` into a limit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ`. -/
 @[simps]
 def isLimitCoconeOp (F : J ⥤ C) {c : Cocone F} (hc : IsColimit c) : IsLimit c.op
@@ -48,7 +49,9 @@ def isLimitCoconeOp (F : J ⥤ C) {c : Cocone F} (hc : IsColimit c) : IsLimit c.
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac] using w (op j)
 #align category_theory.limits.is_limit_cocone_op CategoryTheory.Limits.isLimitCoconeOp
+-/
 
+#print CategoryTheory.Limits.isColimitConeOp /-
 /-- Turn a limit for `F : J ⥤ C` into a colimit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ`. -/
 @[simps]
 def isColimitConeOp (F : J ⥤ C) {c : Cone F} (hc : IsLimit c) : IsColimit c.op
@@ -59,7 +62,9 @@ def isColimitConeOp (F : J ⥤ C) {c : Cone F} (hc : IsLimit c) : IsColimit c.op
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac] using w (op j)
 #align category_theory.limits.is_colimit_cone_op CategoryTheory.Limits.isColimitConeOp
+-/
 
+#print CategoryTheory.Limits.isLimitConeLeftOpOfCocone /-
 /-- Turn a colimit for `F : J ⥤ Cᵒᵖ` into a limit for `F.left_op : Jᵒᵖ ⥤ C`. -/
 @[simps]
 def isLimitConeLeftOpOfCocone (F : J ⥤ Cᵒᵖ) {c : Cocone F} (hc : IsColimit c) :
@@ -74,7 +79,9 @@ def isLimitConeLeftOpOfCocone (F : J ⥤ Cᵒᵖ) {c : Cocone F} (hc : IsColimit
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac, cocone_of_cone_left_op_ι_app] using w (op j)
 #align category_theory.limits.is_limit_cone_left_op_of_cocone CategoryTheory.Limits.isLimitConeLeftOpOfCocone
+-/
 
+#print CategoryTheory.Limits.isColimitCoconeLeftOpOfCone /-
 /-- Turn a limit of `F : J ⥤ Cᵒᵖ` into a colimit of `F.left_op : Jᵒᵖ ⥤ C`. -/
 @[simps]
 def isColimitCoconeLeftOpOfCone (F : J ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLimit c) :
@@ -89,7 +96,9 @@ def isColimitCoconeLeftOpOfCone (F : J ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLimit c
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac, cone_of_cocone_left_op_π_app] using w (op j)
 #align category_theory.limits.is_colimit_cocone_left_op_of_cone CategoryTheory.Limits.isColimitCoconeLeftOpOfCone
+-/
 
+#print CategoryTheory.Limits.isLimitConeRightOpOfCocone /-
 /-- Turn a colimit for `F : Jᵒᵖ ⥤ C` into a limit for `F.right_op : J ⥤ Cᵒᵖ`. -/
 @[simps]
 def isLimitConeRightOpOfCocone (F : Jᵒᵖ ⥤ C) {c : Cocone F} (hc : IsColimit c) :
@@ -101,7 +110,9 @@ def isLimitConeRightOpOfCocone (F : Jᵒᵖ ⥤ C) {c : Cocone F} (hc : IsColimi
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac] using w (unop j)
 #align category_theory.limits.is_limit_cone_right_op_of_cocone CategoryTheory.Limits.isLimitConeRightOpOfCocone
+-/
 
+#print CategoryTheory.Limits.isColimitCoconeRightOpOfCone /-
 /-- Turn a limit for `F : Jᵒᵖ ⥤ C` into a colimit for `F.right_op : J ⥤ Cᵒᵖ`. -/
 @[simps]
 def isColimitCoconeRightOpOfCone (F : Jᵒᵖ ⥤ C) {c : Cone F} (hc : IsLimit c) :
@@ -113,7 +124,9 @@ def isColimitCoconeRightOpOfCone (F : Jᵒᵖ ⥤ C) {c : Cone F} (hc : IsLimit
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac] using w (unop j)
 #align category_theory.limits.is_colimit_cocone_right_op_of_cone CategoryTheory.Limits.isColimitCoconeRightOpOfCone
+-/
 
+#print CategoryTheory.Limits.isLimitConeUnopOfCocone /-
 /-- Turn a colimit for `F : Jᵒᵖ ⥤ Cᵒᵖ` into a limit for `F.unop : J ⥤ C`. -/
 @[simps]
 def isLimitConeUnopOfCocone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cocone F} (hc : IsColimit c) :
@@ -125,7 +138,9 @@ def isLimitConeUnopOfCocone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cocone F} (hc : IsCol
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac] using w (unop j)
 #align category_theory.limits.is_limit_cone_unop_of_cocone CategoryTheory.Limits.isLimitConeUnopOfCocone
+-/
 
+#print CategoryTheory.Limits.isColimitCoconeUnopOfCone /-
 /-- Turn a limit of `F : Jᵒᵖ ⥤ Cᵒᵖ` into a colimit of `F.unop : J ⥤ C`. -/
 @[simps]
 def isColimitCoconeUnopOfCone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLimit c) :
@@ -137,7 +152,9 @@ def isColimitCoconeUnopOfCone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLim
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac] using w (unop j)
 #align category_theory.limits.is_colimit_cocone_unop_of_cone CategoryTheory.Limits.isColimitCoconeUnopOfCone
+-/
 
+#print CategoryTheory.Limits.isLimitCoconeUnop /-
 /-- Turn a colimit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ` into a limit for `F : J ⥤ C`. -/
 @[simps]
 def isLimitCoconeUnop (F : J ⥤ C) {c : Cocone F.op} (hc : IsColimit c) : IsLimit c.unop
@@ -148,7 +165,9 @@ def isLimitCoconeUnop (F : J ⥤ C) {c : Cocone F.op} (hc : IsColimit c) : IsLim
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac] using w (unop j)
 #align category_theory.limits.is_limit_cocone_unop CategoryTheory.Limits.isLimitCoconeUnop
+-/
 
+#print CategoryTheory.Limits.isColimitConeUnop /-
 /-- Turn a limit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ` into a colimit for `F : J ⥤ C`. -/
 @[simps]
 def isColimitConeUnop (F : J ⥤ C) {c : Cone F.op} (hc : IsLimit c) : IsColimit c.unop
@@ -159,7 +178,9 @@ def isColimitConeUnop (F : J ⥤ C) {c : Cone F.op} (hc : IsLimit c) : IsColimit
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac] using w (unop j)
 #align category_theory.limits.is_colimit_cone_unop CategoryTheory.Limits.isColimitConeUnop
+-/
 
+#print CategoryTheory.Limits.isLimitConeOfCoconeLeftOp /-
 /-- Turn a colimit for `F.left_op : Jᵒᵖ ⥤ C` into a limit for `F : J ⥤ Cᵒᵖ`. -/
 @[simps]
 def isLimitConeOfCoconeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cocone F.leftOp} (hc : IsColimit c) :
@@ -174,7 +195,9 @@ def isLimitConeOfCoconeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cocone F.leftOp} (hc : Is
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac, cone_of_cocone_left_op_π_app] using w (unop j)
 #align category_theory.limits.is_limit_cone_of_cocone_left_op CategoryTheory.Limits.isLimitConeOfCoconeLeftOp
+-/
 
+#print CategoryTheory.Limits.isColimitCoconeOfConeLeftOp /-
 /-- Turn a limit of `F.left_op : Jᵒᵖ ⥤ C` into a colimit of `F : J ⥤ Cᵒᵖ`. -/
 @[simps]
 def isColimitCoconeOfConeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cone F.leftOp} (hc : IsLimit c) :
@@ -189,7 +212,9 @@ def isColimitCoconeOfConeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cone F.leftOp} (hc : Is
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac, cocone_of_cone_left_op_ι_app] using w (unop j)
 #align category_theory.limits.is_colimit_cocone_of_cone_left_op CategoryTheory.Limits.isColimitCoconeOfConeLeftOp
+-/
 
+#print CategoryTheory.Limits.isLimitConeOfCoconeRightOp /-
 /-- Turn a colimit for `F.right_op : J ⥤ Cᵒᵖ` into a limit for `F : Jᵒᵖ ⥤ C`. -/
 @[simps]
 def isLimitConeOfCoconeRightOp (F : Jᵒᵖ ⥤ C) {c : Cocone F.rightOp} (hc : IsColimit c) :
@@ -201,7 +226,9 @@ def isLimitConeOfCoconeRightOp (F : Jᵒᵖ ⥤ C) {c : Cocone F.rightOp} (hc :
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac] using w (op j)
 #align category_theory.limits.is_limit_cone_of_cocone_right_op CategoryTheory.Limits.isLimitConeOfCoconeRightOp
+-/
 
+#print CategoryTheory.Limits.isColimitCoconeOfConeRightOp /-
 /-- Turn a limit for `F.right_op : J ⥤ Cᵒᵖ` into a limit for `F : Jᵒᵖ ⥤ C`. -/
 @[simps]
 def isColimitCoconeOfConeRightOp (F : Jᵒᵖ ⥤ C) {c : Cone F.rightOp} (hc : IsLimit c) :
@@ -213,7 +240,9 @@ def isColimitCoconeOfConeRightOp (F : Jᵒᵖ ⥤ C) {c : Cone F.rightOp} (hc :
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac] using w (op j)
 #align category_theory.limits.is_colimit_cocone_of_cone_right_op CategoryTheory.Limits.isColimitCoconeOfConeRightOp
+-/
 
+#print CategoryTheory.Limits.isLimitConeOfCoconeUnop /-
 /-- Turn a colimit for `F.unop : J ⥤ C` into a limit for `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
 @[simps]
 def isLimitConeOfCoconeUnop (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cocone F.unop} (hc : IsColimit c) :
@@ -225,7 +254,9 @@ def isLimitConeOfCoconeUnop (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cocone F.unop} (hc :
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac] using w (op j)
 #align category_theory.limits.is_limit_cone_of_cocone_unop CategoryTheory.Limits.isLimitConeOfCoconeUnop
+-/
 
+#print CategoryTheory.Limits.isColimitConeOfCoconeUnop /-
 /-- Turn a limit for `F.unop : J ⥤ C` into a colimit for `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
 @[simps]
 def isColimitConeOfCoconeUnop (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F.unop} (hc : IsLimit c) :
@@ -237,7 +268,9 @@ def isColimitConeOfCoconeUnop (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F.unop} (hc :
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac] using w (op j)
 #align category_theory.limits.is_colimit_cone_of_cocone_unop CategoryTheory.Limits.isColimitConeOfCoconeUnop
+-/
 
+#print CategoryTheory.Limits.hasLimit_of_hasColimit_leftOp /-
 /-- If `F.left_op : Jᵒᵖ ⥤ C` has a colimit, we can construct a limit for `F : J ⥤ Cᵒᵖ`.
 -/
 theorem hasLimit_of_hasColimit_leftOp (F : J ⥤ Cᵒᵖ) [HasColimit F.leftOp] : HasLimit F :=
@@ -245,47 +278,63 @@ theorem hasLimit_of_hasColimit_leftOp (F : J ⥤ Cᵒᵖ) [HasColimit F.leftOp]
     { Cone := coneOfCoconeLeftOp (colimit.cocone F.leftOp)
       IsLimit := isLimitConeOfCoconeLeftOp _ (colimit.isColimit _) }
 #align category_theory.limits.has_limit_of_has_colimit_left_op CategoryTheory.Limits.hasLimit_of_hasColimit_leftOp
+-/
 
+#print CategoryTheory.Limits.hasLimit_of_hasColimit_op /-
 theorem hasLimit_of_hasColimit_op (F : J ⥤ C) [HasColimit F.op] : HasLimit F :=
   HasLimit.mk
     { Cone := (colimit.cocone F.op).unop
       IsLimit := isLimitCoconeUnop _ (colimit.isColimit _) }
 #align category_theory.limits.has_limit_of_has_colimit_op CategoryTheory.Limits.hasLimit_of_hasColimit_op
+-/
 
+#print CategoryTheory.Limits.hasLimitsOfShape_op_of_hasColimitsOfShape /-
 /-- If `C` has colimits of shape `Jᵒᵖ`, we can construct limits in `Cᵒᵖ` of shape `J`.
 -/
 theorem hasLimitsOfShape_op_of_hasColimitsOfShape [HasColimitsOfShape Jᵒᵖ C] :
     HasLimitsOfShape J Cᵒᵖ :=
   { HasLimit := fun F => hasLimit_of_hasColimit_leftOp F }
 #align category_theory.limits.has_limits_of_shape_op_of_has_colimits_of_shape CategoryTheory.Limits.hasLimitsOfShape_op_of_hasColimitsOfShape
+-/
 
+#print CategoryTheory.Limits.hasLimitsOfShape_of_hasColimitsOfShape_op /-
 theorem hasLimitsOfShape_of_hasColimitsOfShape_op [HasColimitsOfShape Jᵒᵖ Cᵒᵖ] :
     HasLimitsOfShape J C :=
   { HasLimit := fun F => hasLimit_of_hasColimit_op F }
 #align category_theory.limits.has_limits_of_shape_of_has_colimits_of_shape_op CategoryTheory.Limits.hasLimitsOfShape_of_hasColimitsOfShape_op
+-/
 
 attribute [local instance] has_limits_of_shape_op_of_has_colimits_of_shape
 
+#print CategoryTheory.Limits.hasLimits_op_of_hasColimits /-
 /-- If `C` has colimits, we can construct limits for `Cᵒᵖ`.
 -/
 instance hasLimits_op_of_hasColimits [HasColimits C] : HasLimits Cᵒᵖ :=
   ⟨inferInstance⟩
 #align category_theory.limits.has_limits_op_of_has_colimits CategoryTheory.Limits.hasLimits_op_of_hasColimits
+-/
 
+#print CategoryTheory.Limits.hasLimits_of_hasColimits_op /-
 theorem hasLimits_of_hasColimits_op [HasColimits Cᵒᵖ] : HasLimits C :=
   { HasLimitsOfShape := fun J hJ => has_limits_of_shape_of_has_colimits_of_shape_op }
 #align category_theory.limits.has_limits_of_has_colimits_op CategoryTheory.Limits.hasLimits_of_hasColimits_op
+-/
 
+#print CategoryTheory.Limits.has_cofiltered_limits_op_of_has_filtered_colimits /-
 instance has_cofiltered_limits_op_of_has_filtered_colimits [HasFilteredColimitsOfSize.{v₂, u₂} C] :
     HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ
     where HasLimitsOfShape I hI₁ hI₂ := has_limits_of_shape_op_of_has_colimits_of_shape
 #align category_theory.limits.has_cofiltered_limits_op_of_has_filtered_colimits CategoryTheory.Limits.has_cofiltered_limits_op_of_has_filtered_colimits
+-/
 
+#print CategoryTheory.Limits.has_cofiltered_limits_of_has_filtered_colimits_op /-
 theorem has_cofiltered_limits_of_has_filtered_colimits_op [HasFilteredColimitsOfSize.{v₂, u₂} Cᵒᵖ] :
     HasCofilteredLimitsOfSize.{v₂, u₂} C :=
   { HasLimitsOfShape := fun I hI₂ hI₂ => has_limits_of_shape_of_has_colimits_of_shape_op }
 #align category_theory.limits.has_cofiltered_limits_of_has_filtered_colimits_op CategoryTheory.Limits.has_cofiltered_limits_of_has_filtered_colimits_op
+-/
 
+#print CategoryTheory.Limits.hasColimit_of_hasLimit_leftOp /-
 /-- If `F.left_op : Jᵒᵖ ⥤ C` has a limit, we can construct a colimit for `F : J ⥤ Cᵒᵖ`.
 -/
 theorem hasColimit_of_hasLimit_leftOp (F : J ⥤ Cᵒᵖ) [HasLimit F.leftOp] : HasColimit F :=
@@ -293,45 +342,61 @@ theorem hasColimit_of_hasLimit_leftOp (F : J ⥤ Cᵒᵖ) [HasLimit F.leftOp] :
     { Cocone := coconeOfConeLeftOp (limit.cone F.leftOp)
       IsColimit := isColimitCoconeOfConeLeftOp _ (limit.isLimit _) }
 #align category_theory.limits.has_colimit_of_has_limit_left_op CategoryTheory.Limits.hasColimit_of_hasLimit_leftOp
+-/
 
+#print CategoryTheory.Limits.hasColimit_of_hasLimit_op /-
 theorem hasColimit_of_hasLimit_op (F : J ⥤ C) [HasLimit F.op] : HasColimit F :=
   HasColimit.mk
     { Cocone := (limit.cone F.op).unop
       IsColimit := isColimitConeUnop _ (limit.isLimit _) }
 #align category_theory.limits.has_colimit_of_has_limit_op CategoryTheory.Limits.hasColimit_of_hasLimit_op
+-/
 
+#print CategoryTheory.Limits.hasColimitsOfShape_op_of_hasLimitsOfShape /-
 /-- If `C` has colimits of shape `Jᵒᵖ`, we can construct limits in `Cᵒᵖ` of shape `J`.
 -/
 instance hasColimitsOfShape_op_of_hasLimitsOfShape [HasLimitsOfShape Jᵒᵖ C] :
     HasColimitsOfShape J Cᵒᵖ where HasColimit F := hasColimit_of_hasLimit_leftOp F
 #align category_theory.limits.has_colimits_of_shape_op_of_has_limits_of_shape CategoryTheory.Limits.hasColimitsOfShape_op_of_hasLimitsOfShape
+-/
 
+#print CategoryTheory.Limits.hasColimitsOfShape_of_hasLimitsOfShape_op /-
 theorem hasColimitsOfShape_of_hasLimitsOfShape_op [HasLimitsOfShape Jᵒᵖ Cᵒᵖ] :
     HasColimitsOfShape J C :=
   { HasColimit := fun F => hasColimit_of_hasLimit_op F }
 #align category_theory.limits.has_colimits_of_shape_of_has_limits_of_shape_op CategoryTheory.Limits.hasColimitsOfShape_of_hasLimitsOfShape_op
+-/
 
+#print CategoryTheory.Limits.hasColimits_op_of_hasLimits /-
 /-- If `C` has limits, we can construct colimits for `Cᵒᵖ`.
 -/
 instance hasColimits_op_of_hasLimits [HasLimits C] : HasColimits Cᵒᵖ :=
   ⟨inferInstance⟩
 #align category_theory.limits.has_colimits_op_of_has_limits CategoryTheory.Limits.hasColimits_op_of_hasLimits
+-/
 
+#print CategoryTheory.Limits.hasColimits_of_hasLimits_op /-
 theorem hasColimits_of_hasLimits_op [HasLimits Cᵒᵖ] : HasColimits C :=
   { HasColimitsOfShape := fun J hJ => has_colimits_of_shape_of_has_limits_of_shape_op }
 #align category_theory.limits.has_colimits_of_has_limits_op CategoryTheory.Limits.hasColimits_of_hasLimits_op
+-/
 
+#print CategoryTheory.Limits.has_filtered_colimits_op_of_has_cofiltered_limits /-
 instance has_filtered_colimits_op_of_has_cofiltered_limits [HasCofilteredLimitsOfSize.{v₂, u₂} C] :
     HasFilteredColimitsOfSize.{v₂, u₂} Cᵒᵖ where HasColimitsOfShape I hI₁ hI₂ := inferInstance
 #align category_theory.limits.has_filtered_colimits_op_of_has_cofiltered_limits CategoryTheory.Limits.has_filtered_colimits_op_of_has_cofiltered_limits
+-/
 
+#print CategoryTheory.Limits.has_filtered_colimits_of_has_cofiltered_limits_op /-
 theorem has_filtered_colimits_of_has_cofiltered_limits_op [HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ] :
     HasFilteredColimitsOfSize.{v₂, u₂} C :=
   { HasColimitsOfShape := fun I hI₁ hI₂ => has_colimits_of_shape_of_has_limits_of_shape_op }
 #align category_theory.limits.has_filtered_colimits_of_has_cofiltered_limits_op CategoryTheory.Limits.has_filtered_colimits_of_has_cofiltered_limits_op
+-/
 
 variable (X : Type v₂)
 
+#print CategoryTheory.Limits.hasCoproductsOfShape_opposite /-
 /-- If `C` has products indexed by `X`, then `Cᵒᵖ` has coproducts indexed by `X`.
 -/
 instance hasCoproductsOfShape_opposite [HasProductsOfShape X C] : HasCoproductsOfShape X Cᵒᵖ :=
@@ -340,13 +405,17 @@ instance hasCoproductsOfShape_opposite [HasProductsOfShape X C] : HasCoproductsO
     has_limits_of_shape_of_equivalence (discrete.opposite X).symm
   infer_instance
 #align category_theory.limits.has_coproducts_of_shape_opposite CategoryTheory.Limits.hasCoproductsOfShape_opposite
+-/
 
+#print CategoryTheory.Limits.hasCoproductsOfShape_of_opposite /-
 theorem hasCoproductsOfShape_of_opposite [HasProductsOfShape X Cᵒᵖ] : HasCoproductsOfShape X C :=
   haveI : has_limits_of_shape (discrete X)ᵒᵖ Cᵒᵖ :=
     has_limits_of_shape_of_equivalence (discrete.opposite X).symm
   has_colimits_of_shape_of_has_limits_of_shape_op
 #align category_theory.limits.has_coproducts_of_shape_of_opposite CategoryTheory.Limits.hasCoproductsOfShape_of_opposite
+-/
 
+#print CategoryTheory.Limits.hasProductsOfShape_opposite /-
 /-- If `C` has coproducts indexed by `X`, then `Cᵒᵖ` has products indexed by `X`.
 -/
 instance hasProductsOfShape_opposite [HasCoproductsOfShape X C] : HasProductsOfShape X Cᵒᵖ :=
@@ -355,85 +424,117 @@ instance hasProductsOfShape_opposite [HasCoproductsOfShape X C] : HasProductsOfS
     has_colimits_of_shape_of_equivalence (discrete.opposite X).symm
   infer_instance
 #align category_theory.limits.has_products_of_shape_opposite CategoryTheory.Limits.hasProductsOfShape_opposite
+-/
 
+#print CategoryTheory.Limits.hasProductsOfShape_of_opposite /-
 theorem hasProductsOfShape_of_opposite [HasCoproductsOfShape X Cᵒᵖ] : HasProductsOfShape X C :=
   haveI : has_colimits_of_shape (discrete X)ᵒᵖ Cᵒᵖ :=
     has_colimits_of_shape_of_equivalence (discrete.opposite X).symm
   has_limits_of_shape_of_has_colimits_of_shape_op
 #align category_theory.limits.has_products_of_shape_of_opposite CategoryTheory.Limits.hasProductsOfShape_of_opposite
+-/
 
+#print CategoryTheory.Limits.hasProducts_opposite /-
 instance hasProducts_opposite [HasCoproducts.{v₂} C] : HasProducts.{v₂} Cᵒᵖ := fun X =>
   inferInstance
 #align category_theory.limits.has_products_opposite CategoryTheory.Limits.hasProducts_opposite
+-/
 
+#print CategoryTheory.Limits.hasProducts_of_opposite /-
 theorem hasProducts_of_opposite [HasCoproducts.{v₂} Cᵒᵖ] : HasProducts.{v₂} C := fun X =>
   hasProductsOfShape_of_opposite X
 #align category_theory.limits.has_products_of_opposite CategoryTheory.Limits.hasProducts_of_opposite
+-/
 
+#print CategoryTheory.Limits.hasCoproducts_opposite /-
 instance hasCoproducts_opposite [HasProducts.{v₂} C] : HasCoproducts.{v₂} Cᵒᵖ := fun X =>
   inferInstance
 #align category_theory.limits.has_coproducts_opposite CategoryTheory.Limits.hasCoproducts_opposite
+-/
 
+#print CategoryTheory.Limits.hasCoproducts_of_opposite /-
 theorem hasCoproducts_of_opposite [HasProducts.{v₂} Cᵒᵖ] : HasCoproducts.{v₂} C := fun X =>
   hasCoproductsOfShape_of_opposite X
 #align category_theory.limits.has_coproducts_of_opposite CategoryTheory.Limits.hasCoproducts_of_opposite
+-/
 
+#print CategoryTheory.Limits.hasFiniteCoproducts_opposite /-
 instance hasFiniteCoproducts_opposite [HasFiniteProducts C] : HasFiniteCoproducts Cᵒᵖ
     where out n := Limits.hasCoproductsOfShape_opposite _
 #align category_theory.limits.has_finite_coproducts_opposite CategoryTheory.Limits.hasFiniteCoproducts_opposite
+-/
 
+#print CategoryTheory.Limits.hasFiniteCoproducts_of_opposite /-
 theorem hasFiniteCoproducts_of_opposite [HasFiniteProducts Cᵒᵖ] : HasFiniteCoproducts C :=
   { out := fun n => hasCoproductsOfShape_of_opposite _ }
 #align category_theory.limits.has_finite_coproducts_of_opposite CategoryTheory.Limits.hasFiniteCoproducts_of_opposite
+-/
 
+#print CategoryTheory.Limits.hasFiniteProducts_opposite /-
 instance hasFiniteProducts_opposite [HasFiniteCoproducts C] : HasFiniteProducts Cᵒᵖ
     where out n := inferInstance
 #align category_theory.limits.has_finite_products_opposite CategoryTheory.Limits.hasFiniteProducts_opposite
+-/
 
+#print CategoryTheory.Limits.hasFiniteProducts_of_opposite /-
 theorem hasFiniteProducts_of_opposite [HasFiniteCoproducts Cᵒᵖ] : HasFiniteProducts C :=
   { out := fun n => hasProductsOfShape_of_opposite _ }
 #align category_theory.limits.has_finite_products_of_opposite CategoryTheory.Limits.hasFiniteProducts_of_opposite
+-/
 
+#print CategoryTheory.Limits.hasEqualizers_opposite /-
 instance hasEqualizers_opposite [HasCoequalizers C] : HasEqualizers Cᵒᵖ :=
   by
   haveI : has_colimits_of_shape walking_parallel_pairᵒᵖ C :=
     has_colimits_of_shape_of_equivalence walking_parallel_pair_op_equiv
   infer_instance
 #align category_theory.limits.has_equalizers_opposite CategoryTheory.Limits.hasEqualizers_opposite
+-/
 
+#print CategoryTheory.Limits.hasCoequalizers_opposite /-
 instance hasCoequalizers_opposite [HasEqualizers C] : HasCoequalizers Cᵒᵖ :=
   by
   haveI : has_limits_of_shape walking_parallel_pairᵒᵖ C :=
     has_limits_of_shape_of_equivalence walking_parallel_pair_op_equiv
   infer_instance
 #align category_theory.limits.has_coequalizers_opposite CategoryTheory.Limits.hasCoequalizers_opposite
+-/
 
+#print CategoryTheory.Limits.hasFiniteColimits_opposite /-
 instance hasFiniteColimits_opposite [HasFiniteLimits C] : HasFiniteColimits Cᵒᵖ
     where out J 𝒟 𝒥 := by
     skip
     infer_instance
 #align category_theory.limits.has_finite_colimits_opposite CategoryTheory.Limits.hasFiniteColimits_opposite
+-/
 
+#print CategoryTheory.Limits.hasFiniteLimits_opposite /-
 instance hasFiniteLimits_opposite [HasFiniteColimits C] : HasFiniteLimits Cᵒᵖ
     where out J 𝒟 𝒥 := by
     skip
     infer_instance
 #align category_theory.limits.has_finite_limits_opposite CategoryTheory.Limits.hasFiniteLimits_opposite
+-/
 
+#print CategoryTheory.Limits.hasPullbacks_opposite /-
 instance hasPullbacks_opposite [HasPushouts C] : HasPullbacks Cᵒᵖ :=
   by
   haveI : has_colimits_of_shape walking_cospanᵒᵖ C :=
     has_colimits_of_shape_of_equivalence walking_cospan_op_equiv.symm
   apply has_limits_of_shape_op_of_has_colimits_of_shape
 #align category_theory.limits.has_pullbacks_opposite CategoryTheory.Limits.hasPullbacks_opposite
+-/
 
+#print CategoryTheory.Limits.hasPushouts_opposite /-
 instance hasPushouts_opposite [HasPullbacks C] : HasPushouts Cᵒᵖ :=
   by
   haveI : has_limits_of_shape walking_spanᵒᵖ C :=
     has_limits_of_shape_of_equivalence walking_span_op_equiv.symm
   infer_instance
 #align category_theory.limits.has_pushouts_opposite CategoryTheory.Limits.hasPushouts_opposite
+-/
 
+#print CategoryTheory.Limits.spanOp /-
 /-- The canonical isomorphism relating `span f.op g.op` and `(cospan f g).op` -/
 @[simps]
 def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
@@ -441,7 +542,9 @@ def spanOp {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
   NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
     (by rintro (_ | _ | _) (_ | _ | _) f <;> cases f <;> tidy)
 #align category_theory.limits.span_op CategoryTheory.Limits.spanOp
+-/
 
+#print CategoryTheory.Limits.opCospan /-
 /-- The canonical isomorphism relating `(cospan f g).op` and `span f.op g.op` -/
 @[simps]
 def opCospan {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
@@ -455,7 +558,9 @@ def opCospan {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
     _ ≅ walkingCospanOpEquiv.Functor ⋙ span f.op g.op := isoWhiskerLeft _ (spanOp f g).symm
     
 #align category_theory.limits.op_cospan CategoryTheory.Limits.opCospan
+-/
 
+#print CategoryTheory.Limits.cospanOp /-
 /-- The canonical isomorphism relating `cospan f.op g.op` and `(span f g).op` -/
 @[simps]
 def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
@@ -463,7 +568,9 @@ def cospanOp {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
   NatIso.ofComponents (by rintro (_ | _ | _) <;> rfl)
     (by rintro (_ | _ | _) (_ | _ | _) f <;> cases f <;> tidy)
 #align category_theory.limits.cospan_op CategoryTheory.Limits.cospanOp
+-/
 
+#print CategoryTheory.Limits.opSpan /-
 /-- The canonical isomorphism relating `(span f g).op` and `cospan f.op g.op` -/
 @[simps]
 def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
@@ -477,9 +584,11 @@ def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
     _ ≅ walkingSpanOpEquiv.Functor ⋙ cospan f.op g.op := isoWhiskerLeft _ (cospanOp f g).symm
     
 #align category_theory.limits.op_span CategoryTheory.Limits.opSpan
+-/
 
 namespace PushoutCocone
 
+#print CategoryTheory.Limits.PushoutCocone.unop /-
 /-- The obvious map `pushout_cocone f g → pullback_cone f.unop g.unop` -/
 @[simps (config := lemmasOnly)]
 def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
@@ -488,7 +597,9 @@ def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
     ((Cocones.precompose (opCospan f.unop g.unop).hom).obj
       (Cocone.whisker walkingCospanOpEquiv.Functor c))
 #align category_theory.limits.pushout_cocone.unop CategoryTheory.Limits.PushoutCocone.unop
+-/
 
+#print CategoryTheory.Limits.PushoutCocone.unop_fst /-
 @[simp]
 theorem unop_fst {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
     c.unop.fst = c.inl.unop :=
@@ -497,7 +608,9 @@ theorem unop_fst {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocon
   simp only [pushout_cocone.ι_app_left, pushout_cocone.unop_π_app]
   tidy
 #align category_theory.limits.pushout_cocone.unop_fst CategoryTheory.Limits.PushoutCocone.unop_fst
+-/
 
+#print CategoryTheory.Limits.PushoutCocone.unop_snd /-
 @[simp]
 theorem unop_snd {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
     c.unop.snd = c.inr.unop :=
@@ -506,32 +619,40 @@ theorem unop_snd {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocon
   simp only [pushout_cocone.unop_π_app, pushout_cocone.ι_app_right]
   tidy
 #align category_theory.limits.pushout_cocone.unop_snd CategoryTheory.Limits.PushoutCocone.unop_snd
+-/
 
+#print CategoryTheory.Limits.PushoutCocone.op /-
 /-- The obvious map `pushout_cocone f.op g.op → pullback_cone f g` -/
 @[simps (config := lemmasOnly)]
 def op {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : PullbackCone f.op g.op :=
   (Cones.postcompose (cospanOp f g).symm.hom).obj
     (Cone.whisker walkingSpanOpEquiv.inverse (Cocone.op c))
 #align category_theory.limits.pushout_cocone.op CategoryTheory.Limits.PushoutCocone.op
+-/
 
+#print CategoryTheory.Limits.PushoutCocone.op_fst /-
 @[simp]
 theorem op_fst {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : c.op.fst = c.inl.op :=
   by
   change (_ : limits.cone _).π.app _ = _
   apply category.comp_id
 #align category_theory.limits.pushout_cocone.op_fst CategoryTheory.Limits.PushoutCocone.op_fst
+-/
 
+#print CategoryTheory.Limits.PushoutCocone.op_snd /-
 @[simp]
 theorem op_snd {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : c.op.snd = c.inr.op :=
   by
   change (_ : limits.cone _).π.app _ = _
   apply category.comp_id
 #align category_theory.limits.pushout_cocone.op_snd CategoryTheory.Limits.PushoutCocone.op_snd
+-/
 
 end PushoutCocone
 
 namespace PullbackCone
 
+#print CategoryTheory.Limits.PullbackCone.unop /-
 /-- The obvious map `pullback_cone f g → pushout_cocone f.unop g.unop` -/
 @[simps (config := lemmasOnly)]
 def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
@@ -540,7 +661,9 @@ def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
     ((Cones.postcompose (opSpan f.unop g.unop).symm.hom).obj
       (Cone.whisker walkingSpanOpEquiv.Functor c))
 #align category_theory.limits.pullback_cone.unop CategoryTheory.Limits.PullbackCone.unop
+-/
 
+#print CategoryTheory.Limits.PullbackCone.unop_inl /-
 @[simp]
 theorem unop_inl {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
     c.unop.inl = c.fst.unop :=
@@ -549,7 +672,9 @@ theorem unop_inl {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone
   dsimp only [unop, op_span]
   simp; dsimp; simp; dsimp; simp
 #align category_theory.limits.pullback_cone.unop_inl CategoryTheory.Limits.PullbackCone.unop_inl
+-/
 
+#print CategoryTheory.Limits.PullbackCone.unop_inr /-
 @[simp]
 theorem unop_inr {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
     c.unop.inr = c.snd.unop :=
@@ -559,52 +684,68 @@ theorem unop_inr {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone
   simp [unop_ι_app]; dsimp; simp
   apply category.comp_id
 #align category_theory.limits.pullback_cone.unop_inr CategoryTheory.Limits.PullbackCone.unop_inr
+-/
 
+#print CategoryTheory.Limits.PullbackCone.op /-
 /-- The obvious map `pullback_cone f g → pushout_cocone f.op g.op` -/
 @[simps (config := lemmasOnly)]
 def op {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : PushoutCocone f.op g.op :=
   (Cocones.precompose (spanOp f g).hom).obj
     (Cocone.whisker walkingCospanOpEquiv.inverse (Cone.op c))
 #align category_theory.limits.pullback_cone.op CategoryTheory.Limits.PullbackCone.op
+-/
 
+#print CategoryTheory.Limits.PullbackCone.op_inl /-
 @[simp]
 theorem op_inl {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : c.op.inl = c.fst.op :=
   by
   change (_ : limits.cocone _).ι.app _ = _
   apply category.id_comp
 #align category_theory.limits.pullback_cone.op_inl CategoryTheory.Limits.PullbackCone.op_inl
+-/
 
+#print CategoryTheory.Limits.PullbackCone.op_inr /-
 @[simp]
 theorem op_inr {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : c.op.inr = c.snd.op :=
   by
   change (_ : limits.cocone _).ι.app _ = _
   apply category.id_comp
 #align category_theory.limits.pullback_cone.op_inr CategoryTheory.Limits.PullbackCone.op_inr
+-/
 
+#print CategoryTheory.Limits.PullbackCone.opUnop /-
 /-- If `c` is a pullback cone, then `c.op.unop` is isomorphic to `c`. -/
 def opUnop {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : c.op.unop ≅ c :=
   PullbackCone.ext (Iso.refl _) (by simp) (by simp)
 #align category_theory.limits.pullback_cone.op_unop CategoryTheory.Limits.PullbackCone.opUnop
+-/
 
+#print CategoryTheory.Limits.PullbackCone.unopOp /-
 /-- If `c` is a pullback cone in `Cᵒᵖ`, then `c.unop.op` is isomorphic to `c`. -/
 def unopOp {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : c.unop.op ≅ c :=
   PullbackCone.ext (Iso.refl _) (by simp) (by simp)
 #align category_theory.limits.pullback_cone.unop_op CategoryTheory.Limits.PullbackCone.unopOp
+-/
 
 end PullbackCone
 
 namespace PushoutCocone
 
+#print CategoryTheory.Limits.PushoutCocone.opUnop /-
 /-- If `c` is a pushout cocone, then `c.op.unop` is isomorphic to `c`. -/
 def opUnop {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : c.op.unop ≅ c :=
   PushoutCocone.ext (Iso.refl _) (by simp) (by simp)
 #align category_theory.limits.pushout_cocone.op_unop CategoryTheory.Limits.PushoutCocone.opUnop
+-/
 
+#print CategoryTheory.Limits.PushoutCocone.unopOp /-
 /-- If `c` is a pushout cocone in `Cᵒᵖ`, then `c.unop.op` is isomorphic to `c`. -/
 def unopOp {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : c.unop.op ≅ c :=
   PushoutCocone.ext (Iso.refl _) (by simp) (by simp)
 #align category_theory.limits.pushout_cocone.unop_op CategoryTheory.Limits.PushoutCocone.unopOp
+-/
 
+#print CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitOp /-
 /-- A pushout cone is a colimit cocone if and only if the corresponding pullback cone
 in the opposite category is a limit cone. -/
 def isColimitEquivIsLimitOp {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
@@ -622,7 +763,9 @@ def isColimitEquivIsLimitOp {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : Pushout
     equiv_rw(is_limit.whisker_equivalence_equiv _).symm
     exact h
 #align category_theory.limits.pushout_cocone.is_colimit_equiv_is_limit_op CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitOp
+-/
 
+#print CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitUnop /-
 /-- A pushout cone is a colimit cocone in `Cᵒᵖ` if and only if the corresponding pullback cone
 in `C` is a limit cone. -/
 def isColimitEquivIsLimitUnop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
@@ -640,24 +783,29 @@ def isColimitEquivIsLimitUnop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c :
     equiv_rw(is_colimit.whisker_equivalence_equiv walking_cospan_op_equiv.symm).symm
     exact is_colimit_cone_op _ h
 #align category_theory.limits.pushout_cocone.is_colimit_equiv_is_limit_unop CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitUnop
+-/
 
 end PushoutCocone
 
 namespace PullbackCone
 
+#print CategoryTheory.Limits.PullbackCone.isLimitEquivIsColimitOp /-
 /-- A pullback cone is a limit cone if and only if the corresponding pushout cocone
 in the opposite category is a colimit cocone. -/
 def isLimitEquivIsColimitOp {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
     IsLimit c ≃ IsColimit c.op :=
   (IsLimit.equivIsoLimit c.op_unop).symm.trans c.op.isColimitEquivIsLimitUnop.symm
 #align category_theory.limits.pullback_cone.is_limit_equiv_is_colimit_op CategoryTheory.Limits.PullbackCone.isLimitEquivIsColimitOp
+-/
 
+#print CategoryTheory.Limits.PullbackCone.isLimitEquivIsColimitUnop /-
 /-- A pullback cone is a limit cone in `Cᵒᵖ` if and only if the corresponding pushout cocone
 in `C` is a colimit cocone. -/
 def isLimitEquivIsColimitUnop {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
     IsLimit c ≃ IsColimit c.unop :=
   (IsLimit.equivIsoLimit c.unop_op).symm.trans c.unop.isColimitEquivIsLimitOp.symm
 #align category_theory.limits.pullback_cone.is_limit_equiv_is_colimit_unop CategoryTheory.Limits.PullbackCone.isLimitEquivIsColimitUnop
+-/
 
 end PullbackCone
 
@@ -665,6 +813,7 @@ section Pullback
 
 open Opposite
 
+#print CategoryTheory.Limits.pullbackIsoUnopPushout /-
 /-- The pullback of `f` and `g` in `C` is isomorphic to the pushout of
 `f.op` and `g.op` in `Cᵒᵖ`. -/
 noncomputable def pullbackIsoUnopPushout {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
@@ -672,21 +821,27 @@ noncomputable def pullbackIsoUnopPushout {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
   IsLimit.conePointUniqueUpToIso (limit.isLimit _)
     ((PushoutCocone.isColimitEquivIsLimitUnop _) (colimit.isColimit (span f.op g.op)))
 #align category_theory.limits.pullback_iso_unop_pushout CategoryTheory.Limits.pullbackIsoUnopPushout
+-/
 
+#print CategoryTheory.Limits.pullbackIsoUnopPushout_inv_fst /-
 @[simp, reassoc.1]
 theorem pullbackIsoUnopPushout_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] :
     (pullbackIsoUnopPushout f g).inv ≫ pullback.fst = (pushout.inl : _ ⟶ pushout f.op g.op).unop :=
   (IsLimit.conePointUniqueUpToIso_inv_comp _ _ _).trans (by simp)
 #align category_theory.limits.pullback_iso_unop_pushout_inv_fst CategoryTheory.Limits.pullbackIsoUnopPushout_inv_fst
+-/
 
+#print CategoryTheory.Limits.pullbackIsoUnopPushout_inv_snd /-
 @[simp, reassoc.1]
 theorem pullbackIsoUnopPushout_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] :
     (pullbackIsoUnopPushout f g).inv ≫ pullback.snd = (pushout.inr : _ ⟶ pushout f.op g.op).unop :=
   (IsLimit.conePointUniqueUpToIso_inv_comp _ _ _).trans (by simp)
 #align category_theory.limits.pullback_iso_unop_pushout_inv_snd CategoryTheory.Limits.pullbackIsoUnopPushout_inv_snd
+-/
 
+#print CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inl /-
 @[simp, reassoc.1]
 theorem pullbackIsoUnopPushout_hom_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] : pushout.inl ≫ (pullbackIsoUnopPushout f g).hom.op = pullback.fst.op :=
@@ -695,7 +850,9 @@ theorem pullbackIsoUnopPushout_hom_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [
   dsimp
   rw [← pullback_iso_unop_pushout_inv_fst, iso.hom_inv_id_assoc]
 #align category_theory.limits.pullback_iso_unop_pushout_hom_inl CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inl
+-/
 
+#print CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inr /-
 @[simp, reassoc.1]
 theorem pullbackIsoUnopPushout_hom_inr {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] : pushout.inr ≫ (pullbackIsoUnopPushout f g).hom.op = pullback.snd.op :=
@@ -704,11 +861,13 @@ theorem pullbackIsoUnopPushout_hom_inr {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [
   dsimp
   rw [← pullback_iso_unop_pushout_inv_snd, iso.hom_inv_id_assoc]
 #align category_theory.limits.pullback_iso_unop_pushout_hom_inr CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inr
+-/
 
 end Pullback
 
 section Pushout
 
+#print CategoryTheory.Limits.pushoutIsoUnopPullback /-
 /-- The pushout of `f` and `g` in `C` is isomorphic to the pullback of
  `f.op` and `g.op` in `Cᵒᵖ`. -/
 noncomputable def pushoutIsoUnopPullback {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
@@ -716,21 +875,27 @@ noncomputable def pushoutIsoUnopPullback {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y)
   IsColimit.coconePointUniqueUpToIso (colimit.isColimit _)
     ((PullbackCone.isLimitEquivIsColimitUnop _) (limit.isLimit (cospan f.op g.op)))
 #align category_theory.limits.pushout_iso_unop_pullback CategoryTheory.Limits.pushoutIsoUnopPullback
+-/
 
+#print CategoryTheory.Limits.pushoutIsoUnopPullback_inl_hom /-
 @[simp, reassoc.1]
 theorem pushoutIsoUnopPullback_inl_hom {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
     [HasPullback f.op g.op] :
     pushout.inl ≫ (pushoutIsoUnopPullback f g).hom = (pullback.fst : pullback f.op g.op ⟶ _).unop :=
   (IsColimit.comp_coconePointUniqueUpToIso_hom _ _ _).trans (by simp)
 #align category_theory.limits.pushout_iso_unop_pullback_inl_hom CategoryTheory.Limits.pushoutIsoUnopPullback_inl_hom
+-/
 
+#print CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom /-
 @[simp, reassoc.1]
 theorem pushoutIsoUnopPullback_inr_hom {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
     [HasPullback f.op g.op] :
     pushout.inr ≫ (pushoutIsoUnopPullback f g).hom = (pullback.snd : pullback f.op g.op ⟶ _).unop :=
   (IsColimit.comp_coconePointUniqueUpToIso_hom _ _ _).trans (by simp)
 #align category_theory.limits.pushout_iso_unop_pullback_inr_hom CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom
+-/
 
+#print CategoryTheory.Limits.pushoutIsoUnopPullback_inv_fst /-
 @[simp]
 theorem pushoutIsoUnopPullback_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
     [HasPullback f.op g.op] : (pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst = pushout.inl.op :=
@@ -739,7 +904,9 @@ theorem pushoutIsoUnopPullback_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [
   dsimp
   rw [← pushout_iso_unop_pullback_inl_hom, category.assoc, iso.hom_inv_id, category.comp_id]
 #align category_theory.limits.pushout_iso_unop_pullback_inv_fst CategoryTheory.Limits.pushoutIsoUnopPullback_inv_fst
+-/
 
+#print CategoryTheory.Limits.pushoutIsoUnopPullback_inv_snd /-
 @[simp]
 theorem pushoutIsoUnopPullback_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
     [HasPullback f.op g.op] : (pushoutIsoUnopPullback f g).inv.op ≫ pullback.snd = pushout.inr.op :=
@@ -748,6 +915,7 @@ theorem pushoutIsoUnopPullback_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [
   dsimp
   rw [← pushout_iso_unop_pullback_inr_hom, category.assoc, iso.hom_inv_id, category.comp_id]
 #align category_theory.limits.pushout_iso_unop_pullback_inv_snd CategoryTheory.Limits.pushoutIsoUnopPullback_inv_snd
+-/
 
 end Pushout

ac3ae212

bump to nightly-2023-03-01-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

20cadee0

Diff

@@ -449,9 +449,9 @@ def opCospan {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) :
   calc
     (cospan f g).op ≅ 𝟭 _ ⋙ (cospan f g).op := by rfl
     _ ≅ (walkingCospanOpEquiv.Functor ⋙ walkingCospanOpEquiv.inverse) ⋙ (cospan f g).op :=
-      isoWhiskerRight walkingCospanOpEquiv.unitIso _
+      (isoWhiskerRight walkingCospanOpEquiv.unitIso _)
     _ ≅ walkingCospanOpEquiv.Functor ⋙ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op :=
-      Functor.associator _ _ _
+      (Functor.associator _ _ _)
     _ ≅ walkingCospanOpEquiv.Functor ⋙ span f.op g.op := isoWhiskerLeft _ (spanOp f g).symm
     
 #align category_theory.limits.op_cospan CategoryTheory.Limits.opCospan
@@ -471,9 +471,9 @@ def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
   calc
     (span f g).op ≅ 𝟭 _ ⋙ (span f g).op := by rfl
     _ ≅ (walkingSpanOpEquiv.Functor ⋙ walkingSpanOpEquiv.inverse) ⋙ (span f g).op :=
-      isoWhiskerRight walkingSpanOpEquiv.unitIso _
+      (isoWhiskerRight walkingSpanOpEquiv.unitIso _)
     _ ≅ walkingSpanOpEquiv.Functor ⋙ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
-      Functor.associator _ _ _
+      (Functor.associator _ _ _)
     _ ≅ walkingSpanOpEquiv.Functor ⋙ cospan f.op g.op := isoWhiskerLeft _ (cospanOp f g).symm
     
 #align category_theory.limits.op_span CategoryTheory.Limits.opSpan

ac3ae212

bump to nightly-2023-02-28-22

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

1fb1623f

Diff

@@ -242,13 +242,13 @@ def isColimitConeOfCoconeUnop (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F.unop} (hc :
 -/
 theorem hasLimit_of_hasColimit_leftOp (F : J ⥤ Cᵒᵖ) [HasColimit F.leftOp] : HasLimit F :=
   HasLimit.mk
-    { Cone := coneOfCoconeLeftOp (Colimit.cocone F.leftOp)
+    { Cone := coneOfCoconeLeftOp (colimit.cocone F.leftOp)
       IsLimit := isLimitConeOfCoconeLeftOp _ (colimit.isColimit _) }
 #align category_theory.limits.has_limit_of_has_colimit_left_op CategoryTheory.Limits.hasLimit_of_hasColimit_leftOp
 
 theorem hasLimit_of_hasColimit_op (F : J ⥤ C) [HasColimit F.op] : HasLimit F :=
   HasLimit.mk
-    { Cone := (Colimit.cocone F.op).unop
+    { Cone := (colimit.cocone F.op).unop
       IsLimit := isLimitCoconeUnop _ (colimit.isColimit _) }
 #align category_theory.limits.has_limit_of_has_colimit_op CategoryTheory.Limits.hasLimit_of_hasColimit_op
 
@@ -290,13 +290,13 @@ theorem has_cofiltered_limits_of_has_filtered_colimits_op [HasFilteredColimitsOf
 -/
 theorem hasColimit_of_hasLimit_leftOp (F : J ⥤ Cᵒᵖ) [HasLimit F.leftOp] : HasColimit F :=
   HasColimit.mk
-    { Cocone := coconeOfConeLeftOp (Limit.cone F.leftOp)
+    { Cocone := coconeOfConeLeftOp (limit.cone F.leftOp)
       IsColimit := isColimitCoconeOfConeLeftOp _ (limit.isLimit _) }
 #align category_theory.limits.has_colimit_of_has_limit_left_op CategoryTheory.Limits.hasColimit_of_hasLimit_leftOp
 
 theorem hasColimit_of_hasLimit_op (F : J ⥤ C) [HasLimit F.op] : HasColimit F :=
   HasColimit.mk
-    { Cocone := (Limit.cone F.op).unop
+    { Cocone := (limit.cone F.op).unop
       IsColimit := isColimitConeUnop _ (limit.isLimit _) }
 #align category_theory.limits.has_colimit_of_has_limit_op CategoryTheory.Limits.hasColimit_of_hasLimit_op

ac3ae212

bump to nightly-2023-02-27-08

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

91d8c210

Diff

@@ -43,9 +43,8 @@ variable {J : Type u₂} [Category.{v₂} J]
 def isLimitCoconeOp (F : J ⥤ C) {c : Cocone F} (hc : IsColimit c) : IsLimit c.op
     where
   lift s := (hc.desc s.unop).op
-  fac' s j := Quiver.Hom.unop_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.unop_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac] using w (op j)
 #align category_theory.limits.is_limit_cocone_op CategoryTheory.Limits.isLimitCoconeOp
@@ -55,9 +54,8 @@ def isLimitCoconeOp (F : J ⥤ C) {c : Cocone F} (hc : IsColimit c) : IsLimit c.
 def isColimitConeOp (F : J ⥤ C) {c : Cone F} (hc : IsLimit c) : IsColimit c.op
     where
   desc s := (hc.lift s.unop).op
-  fac' s j := Quiver.Hom.unop_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.unop_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac] using w (op j)
 #align category_theory.limits.is_colimit_cone_op CategoryTheory.Limits.isColimitConeOp
@@ -68,12 +66,11 @@ def isLimitConeLeftOpOfCocone (F : J ⥤ Cᵒᵖ) {c : Cocone F} (hc : IsColimit
     IsLimit (coneLeftOpOfCocone c)
     where
   lift s := (hc.desc (coconeOfConeLeftOp s)).unop
-  fac' s j :=
+  fac s j :=
     Quiver.Hom.op_inj <| by
       simpa only [cone_left_op_of_cocone_π_app, op_comp, Quiver.Hom.op_unop, is_colimit.fac,
         cocone_of_cone_left_op_ι_app]
-  uniq' s m w :=
-    by
+  uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac, cocone_of_cone_left_op_ι_app] using w (op j)
 #align category_theory.limits.is_limit_cone_left_op_of_cocone CategoryTheory.Limits.isLimitConeLeftOpOfCocone
@@ -84,12 +81,11 @@ def isColimitCoconeLeftOpOfCone (F : J ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLimit c
     IsColimit (coconeLeftOpOfCone c)
     where
   desc s := (hc.lift (coneOfCoconeLeftOp s)).unop
-  fac' s j :=
+  fac s j :=
     Quiver.Hom.op_inj <| by
       simpa only [cocone_left_op_of_cone_ι_app, op_comp, Quiver.Hom.op_unop, is_limit.fac,
         cone_of_cocone_left_op_π_app]
-  uniq' s m w :=
-    by
+  uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac, cone_of_cocone_left_op_π_app] using w (op j)
 #align category_theory.limits.is_colimit_cocone_left_op_of_cone CategoryTheory.Limits.isColimitCoconeLeftOpOfCone
@@ -100,9 +96,8 @@ def isLimitConeRightOpOfCocone (F : Jᵒᵖ ⥤ C) {c : Cocone F} (hc : IsColimi
     IsLimit (coneRightOpOfCocone c)
     where
   lift s := (hc.desc (coconeOfConeRightOp s)).op
-  fac' s j := Quiver.Hom.unop_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.unop_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac] using w (unop j)
 #align category_theory.limits.is_limit_cone_right_op_of_cocone CategoryTheory.Limits.isLimitConeRightOpOfCocone
@@ -113,9 +108,8 @@ def isColimitCoconeRightOpOfCone (F : Jᵒᵖ ⥤ C) {c : Cone F} (hc : IsLimit
     IsColimit (coconeRightOpOfCone c)
     where
   desc s := (hc.lift (coneOfCoconeRightOp s)).op
-  fac' s j := Quiver.Hom.unop_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.unop_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac] using w (unop j)
 #align category_theory.limits.is_colimit_cocone_right_op_of_cone CategoryTheory.Limits.isColimitCoconeRightOpOfCone
@@ -126,9 +120,8 @@ def isLimitConeUnopOfCocone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cocone F} (hc : IsCol
     IsLimit (coneUnopOfCocone c)
     where
   lift s := (hc.desc (coconeOfConeUnop s)).unop
-  fac' s j := Quiver.Hom.op_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.op_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac] using w (unop j)
 #align category_theory.limits.is_limit_cone_unop_of_cocone CategoryTheory.Limits.isLimitConeUnopOfCocone
@@ -139,9 +132,8 @@ def isColimitCoconeUnopOfCone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLim
     IsColimit (coconeUnopOfCone c)
     where
   desc s := (hc.lift (coneOfCoconeUnop s)).unop
-  fac' s j := Quiver.Hom.op_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.op_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac] using w (unop j)
 #align category_theory.limits.is_colimit_cocone_unop_of_cone CategoryTheory.Limits.isColimitCoconeUnopOfCone
@@ -151,9 +143,8 @@ def isColimitCoconeUnopOfCone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLim
 def isLimitCoconeUnop (F : J ⥤ C) {c : Cocone F.op} (hc : IsColimit c) : IsLimit c.unop
     where
   lift s := (hc.desc s.op).unop
-  fac' s j := Quiver.Hom.op_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.op_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac] using w (unop j)
 #align category_theory.limits.is_limit_cocone_unop CategoryTheory.Limits.isLimitCoconeUnop
@@ -163,9 +154,8 @@ def isLimitCoconeUnop (F : J ⥤ C) {c : Cocone F.op} (hc : IsColimit c) : IsLim
 def isColimitConeUnop (F : J ⥤ C) {c : Cone F.op} (hc : IsLimit c) : IsColimit c.unop
     where
   desc s := (hc.lift s.op).unop
-  fac' s j := Quiver.Hom.op_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.op_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac] using w (unop j)
 #align category_theory.limits.is_colimit_cone_unop CategoryTheory.Limits.isColimitConeUnop
@@ -176,12 +166,11 @@ def isLimitConeOfCoconeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cocone F.leftOp} (hc : Is
     IsLimit (coneOfCoconeLeftOp c)
     where
   lift s := (hc.desc (coconeLeftOpOfCone s)).op
-  fac' s j :=
+  fac s j :=
     Quiver.Hom.unop_inj <| by
       simpa only [cone_of_cocone_left_op_π_app, unop_comp, Quiver.Hom.unop_op, is_colimit.fac,
         cocone_left_op_of_cone_ι_app]
-  uniq' s m w :=
-    by
+  uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac, cone_of_cocone_left_op_π_app] using w (unop j)
 #align category_theory.limits.is_limit_cone_of_cocone_left_op CategoryTheory.Limits.isLimitConeOfCoconeLeftOp
@@ -192,12 +181,11 @@ def isColimitCoconeOfConeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cone F.leftOp} (hc : Is
     IsColimit (coconeOfConeLeftOp c)
     where
   desc s := (hc.lift (coneLeftOpOfCocone s)).op
-  fac' s j :=
+  fac s j :=
     Quiver.Hom.unop_inj <| by
       simpa only [cocone_of_cone_left_op_ι_app, unop_comp, Quiver.Hom.unop_op, is_limit.fac,
         cone_left_op_of_cocone_π_app]
-  uniq' s m w :=
-    by
+  uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac, cocone_of_cone_left_op_ι_app] using w (unop j)
 #align category_theory.limits.is_colimit_cocone_of_cone_left_op CategoryTheory.Limits.isColimitCoconeOfConeLeftOp
@@ -208,9 +196,8 @@ def isLimitConeOfCoconeRightOp (F : Jᵒᵖ ⥤ C) {c : Cocone F.rightOp} (hc :
     IsLimit (coneOfCoconeRightOp c)
     where
   lift s := (hc.desc (coconeRightOpOfCone s)).unop
-  fac' s j := Quiver.Hom.op_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.op_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_colimit.fac] using w (op j)
 #align category_theory.limits.is_limit_cone_of_cocone_right_op CategoryTheory.Limits.isLimitConeOfCoconeRightOp
@@ -221,9 +208,8 @@ def isColimitCoconeOfConeRightOp (F : Jᵒᵖ ⥤ C) {c : Cone F.rightOp} (hc :
     IsColimit (coconeOfConeRightOp c)
     where
   desc s := (hc.lift (coneRightOpOfCocone s)).unop
-  fac' s j := Quiver.Hom.op_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.op_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
     simpa only [Quiver.Hom.op_unop, is_limit.fac] using w (op j)
 #align category_theory.limits.is_colimit_cocone_of_cone_right_op CategoryTheory.Limits.isColimitCoconeOfConeRightOp
@@ -234,9 +220,8 @@ def isLimitConeOfCoconeUnop (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cocone F.unop} (hc :
     IsLimit (coneOfCoconeUnop c)
     where
   lift s := (hc.desc (coconeUnopOfCone s)).op
-  fac' s j := Quiver.Hom.unop_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.unop_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_colimit.fac] using w (op j)
 #align category_theory.limits.is_limit_cone_of_cocone_unop CategoryTheory.Limits.isLimitConeOfCoconeUnop
@@ -247,38 +232,37 @@ def isColimitConeOfCoconeUnop (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F.unop} (hc :
     IsColimit (coconeOfConeUnop c)
     where
   desc s := (hc.lift (coneUnopOfCocone s)).op
-  fac' s j := Quiver.Hom.unop_inj (by simpa)
-  uniq' s m w :=
-    by
+  fac s j := Quiver.Hom.unop_inj (by simpa)
+  uniq s m w := by
     refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
     simpa only [Quiver.Hom.unop_op, is_limit.fac] using w (op j)
 #align category_theory.limits.is_colimit_cone_of_cocone_unop CategoryTheory.Limits.isColimitConeOfCoconeUnop
 
 /-- If `F.left_op : Jᵒᵖ ⥤ C` has a colimit, we can construct a limit for `F : J ⥤ Cᵒᵖ`.
 -/
-theorem hasLimitOfHasColimitLeftOp (F : J ⥤ Cᵒᵖ) [HasColimit F.leftOp] : HasLimit F :=
+theorem hasLimit_of_hasColimit_leftOp (F : J ⥤ Cᵒᵖ) [HasColimit F.leftOp] : HasLimit F :=
   HasLimit.mk
     { Cone := coneOfCoconeLeftOp (Colimit.cocone F.leftOp)
       IsLimit := isLimitConeOfCoconeLeftOp _ (colimit.isColimit _) }
-#align category_theory.limits.has_limit_of_has_colimit_left_op CategoryTheory.Limits.hasLimitOfHasColimitLeftOp
+#align category_theory.limits.has_limit_of_has_colimit_left_op CategoryTheory.Limits.hasLimit_of_hasColimit_leftOp
 
-theorem hasLimitOfHasColimitOp (F : J ⥤ C) [HasColimit F.op] : HasLimit F :=
+theorem hasLimit_of_hasColimit_op (F : J ⥤ C) [HasColimit F.op] : HasLimit F :=
   HasLimit.mk
     { Cone := (Colimit.cocone F.op).unop
       IsLimit := isLimitCoconeUnop _ (colimit.isColimit _) }
-#align category_theory.limits.has_limit_of_has_colimit_op CategoryTheory.Limits.hasLimitOfHasColimitOp
+#align category_theory.limits.has_limit_of_has_colimit_op CategoryTheory.Limits.hasLimit_of_hasColimit_op
 
 /-- If `C` has colimits of shape `Jᵒᵖ`, we can construct limits in `Cᵒᵖ` of shape `J`.
 -/
-theorem hasLimitsOfShapeOpOfHasColimitsOfShape [HasColimitsOfShape Jᵒᵖ C] :
+theorem hasLimitsOfShape_op_of_hasColimitsOfShape [HasColimitsOfShape Jᵒᵖ C] :
     HasLimitsOfShape J Cᵒᵖ :=
-  { HasLimit := fun F => hasLimitOfHasColimitLeftOp F }
-#align category_theory.limits.has_limits_of_shape_op_of_has_colimits_of_shape CategoryTheory.Limits.hasLimitsOfShapeOpOfHasColimitsOfShape
+  { HasLimit := fun F => hasLimit_of_hasColimit_leftOp F }
+#align category_theory.limits.has_limits_of_shape_op_of_has_colimits_of_shape CategoryTheory.Limits.hasLimitsOfShape_op_of_hasColimitsOfShape
 
-theorem hasLimitsOfShapeOfHasColimitsOfShapeOp [HasColimitsOfShape Jᵒᵖ Cᵒᵖ] :
+theorem hasLimitsOfShape_of_hasColimitsOfShape_op [HasColimitsOfShape Jᵒᵖ Cᵒᵖ] :
     HasLimitsOfShape J C :=
-  { HasLimit := fun F => hasLimitOfHasColimitOp F }
-#align category_theory.limits.has_limits_of_shape_of_has_colimits_of_shape_op CategoryTheory.Limits.hasLimitsOfShapeOfHasColimitsOfShapeOp
+  { HasLimit := fun F => hasLimit_of_hasColimit_op F }
+#align category_theory.limits.has_limits_of_shape_of_has_colimits_of_shape_op CategoryTheory.Limits.hasLimitsOfShape_of_hasColimitsOfShape_op
 
 attribute [local instance] has_limits_of_shape_op_of_has_colimits_of_shape
 
@@ -292,40 +276,40 @@ theorem hasLimits_of_hasColimits_op [HasColimits Cᵒᵖ] : HasLimits C :=
   { HasLimitsOfShape := fun J hJ => has_limits_of_shape_of_has_colimits_of_shape_op }
 #align category_theory.limits.has_limits_of_has_colimits_op CategoryTheory.Limits.hasLimits_of_hasColimits_op
 
-instance hasCofilteredLimitsOpOfHasFilteredColimits [HasFilteredColimitsOfSize.{v₂, u₂} C] :
+instance has_cofiltered_limits_op_of_has_filtered_colimits [HasFilteredColimitsOfSize.{v₂, u₂} C] :
     HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ
     where HasLimitsOfShape I hI₁ hI₂ := has_limits_of_shape_op_of_has_colimits_of_shape
-#align category_theory.limits.has_cofiltered_limits_op_of_has_filtered_colimits CategoryTheory.Limits.hasCofilteredLimitsOpOfHasFilteredColimits
+#align category_theory.limits.has_cofiltered_limits_op_of_has_filtered_colimits CategoryTheory.Limits.has_cofiltered_limits_op_of_has_filtered_colimits
 
-theorem hasCofilteredLimitsOfHasFilteredColimitsOp [HasFilteredColimitsOfSize.{v₂, u₂} Cᵒᵖ] :
+theorem has_cofiltered_limits_of_has_filtered_colimits_op [HasFilteredColimitsOfSize.{v₂, u₂} Cᵒᵖ] :
     HasCofilteredLimitsOfSize.{v₂, u₂} C :=
   { HasLimitsOfShape := fun I hI₂ hI₂ => has_limits_of_shape_of_has_colimits_of_shape_op }
-#align category_theory.limits.has_cofiltered_limits_of_has_filtered_colimits_op CategoryTheory.Limits.hasCofilteredLimitsOfHasFilteredColimitsOp
+#align category_theory.limits.has_cofiltered_limits_of_has_filtered_colimits_op CategoryTheory.Limits.has_cofiltered_limits_of_has_filtered_colimits_op
 
 /-- If `F.left_op : Jᵒᵖ ⥤ C` has a limit, we can construct a colimit for `F : J ⥤ Cᵒᵖ`.
 -/
-theorem hasColimitOfHasLimitLeftOp (F : J ⥤ Cᵒᵖ) [HasLimit F.leftOp] : HasColimit F :=
+theorem hasColimit_of_hasLimit_leftOp (F : J ⥤ Cᵒᵖ) [HasLimit F.leftOp] : HasColimit F :=
   HasColimit.mk
     { Cocone := coconeOfConeLeftOp (Limit.cone F.leftOp)
       IsColimit := isColimitCoconeOfConeLeftOp _ (limit.isLimit _) }
-#align category_theory.limits.has_colimit_of_has_limit_left_op CategoryTheory.Limits.hasColimitOfHasLimitLeftOp
+#align category_theory.limits.has_colimit_of_has_limit_left_op CategoryTheory.Limits.hasColimit_of_hasLimit_leftOp
 
-theorem hasColimitOfHasLimitOp (F : J ⥤ C) [HasLimit F.op] : HasColimit F :=
+theorem hasColimit_of_hasLimit_op (F : J ⥤ C) [HasLimit F.op] : HasColimit F :=
   HasColimit.mk
     { Cocone := (Limit.cone F.op).unop
       IsColimit := isColimitConeUnop _ (limit.isLimit _) }
-#align category_theory.limits.has_colimit_of_has_limit_op CategoryTheory.Limits.hasColimitOfHasLimitOp
+#align category_theory.limits.has_colimit_of_has_limit_op CategoryTheory.Limits.hasColimit_of_hasLimit_op
 
 /-- If `C` has colimits of shape `Jᵒᵖ`, we can construct limits in `Cᵒᵖ` of shape `J`.
 -/
-instance hasColimitsOfShapeOpOfHasLimitsOfShape [HasLimitsOfShape Jᵒᵖ C] : HasColimitsOfShape J Cᵒᵖ
-    where HasColimit F := hasColimitOfHasLimitLeftOp F
-#align category_theory.limits.has_colimits_of_shape_op_of_has_limits_of_shape CategoryTheory.Limits.hasColimitsOfShapeOpOfHasLimitsOfShape
+instance hasColimitsOfShape_op_of_hasLimitsOfShape [HasLimitsOfShape Jᵒᵖ C] :
+    HasColimitsOfShape J Cᵒᵖ where HasColimit F := hasColimit_of_hasLimit_leftOp F
+#align category_theory.limits.has_colimits_of_shape_op_of_has_limits_of_shape CategoryTheory.Limits.hasColimitsOfShape_op_of_hasLimitsOfShape
 
-theorem hasColimitsOfShapeOfHasLimitsOfShapeOp [HasLimitsOfShape Jᵒᵖ Cᵒᵖ] :
+theorem hasColimitsOfShape_of_hasLimitsOfShape_op [HasLimitsOfShape Jᵒᵖ Cᵒᵖ] :
     HasColimitsOfShape J C :=
-  { HasColimit := fun F => hasColimitOfHasLimitOp F }
-#align category_theory.limits.has_colimits_of_shape_of_has_limits_of_shape_op CategoryTheory.Limits.hasColimitsOfShapeOfHasLimitsOfShapeOp
+  { HasColimit := fun F => hasColimit_of_hasLimit_op F }
+#align category_theory.limits.has_colimits_of_shape_of_has_limits_of_shape_op CategoryTheory.Limits.hasColimitsOfShape_of_hasLimitsOfShape_op
 
 /-- If `C` has limits, we can construct colimits for `Cᵒᵖ`.
 -/
@@ -337,14 +321,14 @@ theorem hasColimits_of_hasLimits_op [HasLimits Cᵒᵖ] : HasColimits C :=
   { HasColimitsOfShape := fun J hJ => has_colimits_of_shape_of_has_limits_of_shape_op }
 #align category_theory.limits.has_colimits_of_has_limits_op CategoryTheory.Limits.hasColimits_of_hasLimits_op
 
-instance hasFilteredColimitsOpOfHasCofilteredLimits [HasCofilteredLimitsOfSize.{v₂, u₂} C] :
+instance has_filtered_colimits_op_of_has_cofiltered_limits [HasCofilteredLimitsOfSize.{v₂, u₂} C] :
     HasFilteredColimitsOfSize.{v₂, u₂} Cᵒᵖ where HasColimitsOfShape I hI₁ hI₂ := inferInstance
-#align category_theory.limits.has_filtered_colimits_op_of_has_cofiltered_limits CategoryTheory.Limits.hasFilteredColimitsOpOfHasCofilteredLimits
+#align category_theory.limits.has_filtered_colimits_op_of_has_cofiltered_limits CategoryTheory.Limits.has_filtered_colimits_op_of_has_cofiltered_limits
 
-theorem hasFilteredColimitsOfHasCofilteredLimitsOp [HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ] :
+theorem has_filtered_colimits_of_has_cofiltered_limits_op [HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ] :
     HasFilteredColimitsOfSize.{v₂, u₂} C :=
   { HasColimitsOfShape := fun I hI₁ hI₂ => has_colimits_of_shape_of_has_limits_of_shape_op }
-#align category_theory.limits.has_filtered_colimits_of_has_cofiltered_limits_op CategoryTheory.Limits.hasFilteredColimitsOfHasCofilteredLimitsOp
+#align category_theory.limits.has_filtered_colimits_of_has_cofiltered_limits_op CategoryTheory.Limits.has_filtered_colimits_of_has_cofiltered_limits_op
 
 variable (X : Type v₂)
 
@@ -394,21 +378,21 @@ theorem hasCoproducts_of_opposite [HasProducts.{v₂} Cᵒᵖ] : HasCoproducts.{
   hasCoproductsOfShape_of_opposite X
 #align category_theory.limits.has_coproducts_of_opposite CategoryTheory.Limits.hasCoproducts_of_opposite
 
-instance hasFiniteCoproductsOpposite [HasFiniteProducts C] : HasFiniteCoproducts Cᵒᵖ
+instance hasFiniteCoproducts_opposite [HasFiniteProducts C] : HasFiniteCoproducts Cᵒᵖ
     where out n := Limits.hasCoproductsOfShape_opposite _
-#align category_theory.limits.has_finite_coproducts_opposite CategoryTheory.Limits.hasFiniteCoproductsOpposite
+#align category_theory.limits.has_finite_coproducts_opposite CategoryTheory.Limits.hasFiniteCoproducts_opposite
 
-theorem hasFiniteCoproductsOfOpposite [HasFiniteProducts Cᵒᵖ] : HasFiniteCoproducts C :=
+theorem hasFiniteCoproducts_of_opposite [HasFiniteProducts Cᵒᵖ] : HasFiniteCoproducts C :=
   { out := fun n => hasCoproductsOfShape_of_opposite _ }
-#align category_theory.limits.has_finite_coproducts_of_opposite CategoryTheory.Limits.hasFiniteCoproductsOfOpposite
+#align category_theory.limits.has_finite_coproducts_of_opposite CategoryTheory.Limits.hasFiniteCoproducts_of_opposite
 
-instance hasFiniteProductsOpposite [HasFiniteCoproducts C] : HasFiniteProducts Cᵒᵖ
+instance hasFiniteProducts_opposite [HasFiniteCoproducts C] : HasFiniteProducts Cᵒᵖ
     where out n := inferInstance
-#align category_theory.limits.has_finite_products_opposite CategoryTheory.Limits.hasFiniteProductsOpposite
+#align category_theory.limits.has_finite_products_opposite CategoryTheory.Limits.hasFiniteProducts_opposite
 
-theorem hasFiniteProductsOfOpposite [HasFiniteCoproducts Cᵒᵖ] : HasFiniteProducts C :=
+theorem hasFiniteProducts_of_opposite [HasFiniteCoproducts Cᵒᵖ] : HasFiniteProducts C :=
   { out := fun n => hasProductsOfShape_of_opposite _ }
-#align category_theory.limits.has_finite_products_of_opposite CategoryTheory.Limits.hasFiniteProductsOfOpposite
+#align category_theory.limits.has_finite_products_of_opposite CategoryTheory.Limits.hasFiniteProducts_of_opposite
 
 instance hasEqualizers_opposite [HasCoequalizers C] : HasEqualizers Cᵒᵖ :=
   by
@@ -424,17 +408,17 @@ instance hasCoequalizers_opposite [HasEqualizers C] : HasCoequalizers Cᵒᵖ :=
   infer_instance
 #align category_theory.limits.has_coequalizers_opposite CategoryTheory.Limits.hasCoequalizers_opposite
 
-instance hasFiniteColimitsOpposite [HasFiniteLimits C] : HasFiniteColimits Cᵒᵖ
+instance hasFiniteColimits_opposite [HasFiniteLimits C] : HasFiniteColimits Cᵒᵖ
     where out J 𝒟 𝒥 := by
     skip
     infer_instance
-#align category_theory.limits.has_finite_colimits_opposite CategoryTheory.Limits.hasFiniteColimitsOpposite
+#align category_theory.limits.has_finite_colimits_opposite CategoryTheory.Limits.hasFiniteColimits_opposite
 
-instance hasFiniteLimitsOpposite [HasFiniteColimits C] : HasFiniteLimits Cᵒᵖ
+instance hasFiniteLimits_opposite [HasFiniteColimits C] : HasFiniteLimits Cᵒᵖ
     where out J 𝒟 𝒥 := by
     skip
     infer_instance
-#align category_theory.limits.has_finite_limits_opposite CategoryTheory.Limits.hasFiniteLimitsOpposite
+#align category_theory.limits.has_finite_limits_opposite CategoryTheory.Limits.hasFiniteLimits_opposite
 
 instance hasPullbacks_opposite [HasPushouts C] : HasPullbacks Cᵒᵖ :=
   by

ac3ae212

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

ac3ae212

feat(CategoryTheory): a lemma about composing different isomorphisms from opposite coproducts to products (#12155)

423f5783

Diff

@@ -416,6 +416,23 @@ theorem opCoproductIsoProduct'_inv_comp_inj {c : Cofan Z} {f : Fan (op <| Z ·)}
     (opCoproductIsoProduct' hc hf).inv ≫ (c.inj b).op = f.proj b :=
   IsLimit.conePointUniqueUpToIso_inv_comp (Cofan.IsColimit.op hc) hf ⟨b⟩
 
+theorem opCoproductIsoProduct'_comp_self {c c' : Cofan Z} {f : Fan (op <| Z ·)}
+    (hc : IsColimit c) (hc' : IsColimit c') (hf : IsLimit f) :
+    (opCoproductIsoProduct' hc hf).hom ≫ (opCoproductIsoProduct' hc' hf).inv =
+    (hc.coconePointUniqueUpToIso hc').op.inv := by
+  apply Quiver.Hom.unop_inj
+  apply hc'.hom_ext
+  intro ⟨j⟩
+  change c'.inj _ ≫ _ = _
+  simp only [unop_op, unop_comp, Discrete.functor_obj, const_obj_obj, Iso.op_inv,
+    Quiver.Hom.unop_op, IsColimit.comp_coconePointUniqueUpToIso_inv]
+  apply Quiver.Hom.op_inj
+  simp only [op_comp, op_unop, Quiver.Hom.op_unop, Category.assoc,
+    opCoproductIsoProduct'_inv_comp_inj]
+  rw [← opCoproductIsoProduct'_inv_comp_inj hc hf]
+  simp only [Iso.hom_inv_id_assoc]
+  rfl
+
 variable (Z) in
 theorem opCoproductIsoProduct_inv_comp_ι (b : α) :
     (opCoproductIsoProduct Z).inv ≫ (Sigma.ι Z b).op = Pi.π (op <| Z ·) b :=
@@ -490,8 +507,24 @@ theorem proj_comp_opProductIsoCoproduct'_hom {f : Fan Z} {c : Cofan (op <| Z ·)
     (f.proj b).op ≫ (opProductIsoCoproduct' hf hc).hom = c.inj b :=
   IsColimit.comp_coconePointUniqueUpToIso_hom (Fan.IsLimit.op hf) hc ⟨b⟩
 
+theorem opProductIsoCoproduct'_comp_self {f f' : Fan Z} {c : Cofan (op <| Z ·)}
+    (hf : IsLimit f) (hf' : IsLimit f') (hc : IsColimit c) :
+    (opProductIsoCoproduct' hf hc).hom ≫ (opProductIsoCoproduct' hf' hc).inv =
+    (hf.conePointUniqueUpToIso hf').op.inv := by
+  apply Quiver.Hom.unop_inj
+  apply hf.hom_ext
+  intro ⟨j⟩
+  change _ ≫ f.proj _ = _
+  simp only [unop_op, unop_comp, Category.assoc, Discrete.functor_obj, Iso.op_inv,
+    Quiver.Hom.unop_op, IsLimit.conePointUniqueUpToIso_inv_comp]
+  apply Quiver.Hom.op_inj
+  simp only [op_comp, op_unop, Quiver.Hom.op_unop, proj_comp_opProductIsoCoproduct'_hom]
+  rw [← proj_comp_opProductIsoCoproduct'_hom hf' hc]
+  simp only [Category.assoc, Iso.hom_inv_id, Category.comp_id]
+  rfl
+
 variable (Z) in
-theorem proj_comp_opProductIsoCoproduct_hom (b : α) :
+theorem π_comp_opProductIsoCoproduct_hom (b : α) :
     (Pi.π Z b).op ≫ (opProductIsoCoproduct Z).hom = Sigma.ι (op <| Z ·) b :=
   proj_comp_opProductIsoCoproduct'_hom _ _ b

ac3ae212

chore: remove duplicates of IsLimit.op and variants (#11683)

d5876416

Diff

@@ -34,27 +34,16 @@ namespace CategoryTheory.Limits
 variable {C : Type u₁} [Category.{v₁} C]
 variable {J : Type u₂} [Category.{v₂} J]
 
-/-- Turn a colimit for `F : J ⥤ C` into a limit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ`. -/
-@[simps]
-def isLimitCoconeOp (F : J ⥤ C) {c : Cocone F} (hc : IsColimit c) : IsLimit c.op
-    where
-  lift s := (hc.desc s.unop).op
-  fac s j := Quiver.Hom.unop_inj (by simp)
-  uniq s m w := by
-    refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
-    simpa only [Quiver.Hom.unop_op, IsColimit.fac] using w (op j)
-#align category_theory.limits.is_limit_cocone_op CategoryTheory.Limits.isLimitCoconeOp
+#align category_theory.limits.is_limit_cocone_op CategoryTheory.Limits.IsColimit.op
+#align category_theory.limits.is_colimit_cone_op CategoryTheory.Limits.IsLimit.op
+#align category_theory.limits.is_limit_cocone_unop CategoryTheory.Limits.IsColimit.unop
+#align category_theory.limits.is_colimit_cone_unop CategoryTheory.Limits.IsLimit.unop
 
-/-- Turn a limit for `F : J ⥤ C` into a colimit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ`. -/
-@[simps]
-def isColimitConeOp (F : J ⥤ C) {c : Cone F} (hc : IsLimit c) : IsColimit c.op
-    where
-  desc s := (hc.lift s.unop).op
-  fac s j := Quiver.Hom.unop_inj (by simp)
-  uniq s m w := by
-    refine' Quiver.Hom.unop_inj (hc.hom_ext fun j => Quiver.Hom.op_inj _)
-    simpa only [Quiver.Hom.unop_op, IsLimit.fac] using w (op j)
-#align category_theory.limits.is_colimit_cone_op CategoryTheory.Limits.isColimitConeOp
+-- 2024-03-26
+@[deprecated] alias isLimitCoconeOp := IsColimit.op
+@[deprecated] alias isColimitConeOp := IsLimit.op
+@[deprecated] alias isLimitCoconeUnop := IsColimit.unop
+@[deprecated] alias isColimitConeUnop := IsLimit.unop
 
 /-- Turn a colimit for `F : J ⥤ Cᵒᵖ` into a limit for `F.leftOp : Jᵒᵖ ⥤ C`. -/
 @[simps]
@@ -134,28 +123,6 @@ def isColimitCoconeUnopOfCone (F : Jᵒᵖ ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLim
     simpa only [Quiver.Hom.op_unop, IsLimit.fac] using w (unop j)
 #align category_theory.limits.is_colimit_cocone_unop_of_cone CategoryTheory.Limits.isColimitCoconeUnopOfCone
 
-/-- Turn a colimit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ` into a limit for `F : J ⥤ C`. -/
-@[simps]
-def isLimitCoconeUnop (F : J ⥤ C) {c : Cocone F.op} (hc : IsColimit c) : IsLimit c.unop
-    where
-  lift s := (hc.desc s.op).unop
-  fac s j := Quiver.Hom.op_inj (by simp)
-  uniq s m w := by
-    refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
-    simpa only [Quiver.Hom.op_unop, IsColimit.fac] using w (unop j)
-#align category_theory.limits.is_limit_cocone_unop CategoryTheory.Limits.isLimitCoconeUnop
-
-/-- Turn a limit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ` into a colimit for `F : J ⥤ C`. -/
-@[simps]
-def isColimitConeUnop (F : J ⥤ C) {c : Cone F.op} (hc : IsLimit c) : IsColimit c.unop
-    where
-  desc s := (hc.lift s.op).unop
-  fac s j := Quiver.Hom.op_inj (by simp)
-  uniq s m w := by
-    refine' Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj _)
-    simpa only [Quiver.Hom.op_unop, IsLimit.fac] using w (unop j)
-#align category_theory.limits.is_colimit_cone_unop CategoryTheory.Limits.isColimitConeUnop
-
 /-- Turn a colimit for `F.leftOp : Jᵒᵖ ⥤ C` into a limit for `F : J ⥤ Cᵒᵖ`. -/
 @[simps]
 def isLimitConeOfCoconeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cocone F.leftOp} (hc : IsColimit c) :
@@ -245,12 +212,12 @@ theorem hasLimit_of_hasColimit_leftOp (F : J ⥤ Cᵒᵖ) [HasColimit F.leftOp]
 theorem hasLimit_of_hasColimit_op (F : J ⥤ C) [HasColimit F.op] : HasLimit F :=
   HasLimit.mk
     { cone := (colimit.cocone F.op).unop
-      isLimit := isLimitCoconeUnop _ (colimit.isColimit _) }
+      isLimit := (colimit.isColimit _).unop }
 
 theorem hasLimit_op_of_hasColimit (F : J ⥤ C) [HasColimit F] : HasLimit F.op :=
   HasLimit.mk
     { cone := (colimit.cocone F).op
-      isLimit := isLimitCoconeOp _ (colimit.isColimit _) }
+      isLimit := (colimit.isColimit _).op }
 #align category_theory.limits.has_limit_of_has_colimit_op CategoryTheory.Limits.hasLimit_of_hasColimit_op
 
 /-- If `C` has colimits of shape `Jᵒᵖ`, we can construct limits in `Cᵒᵖ` of shape `J`.
@@ -298,13 +265,13 @@ theorem hasColimit_of_hasLimit_leftOp (F : J ⥤ Cᵒᵖ) [HasLimit F.leftOp] :
 theorem hasColimit_of_hasLimit_op (F : J ⥤ C) [HasLimit F.op] : HasColimit F :=
   HasColimit.mk
     { cocone := (limit.cone F.op).unop
-      isColimit := isColimitConeUnop _ (limit.isLimit _) }
+      isColimit := (limit.isLimit _).unop }
 #align category_theory.limits.has_colimit_of_has_limit_op CategoryTheory.Limits.hasColimit_of_hasLimit_op
 
 theorem hasColimit_op_of_hasLimit (F : J ⥤ C) [HasLimit F] : HasColimit F.op :=
   HasColimit.mk
     { cocone := (limit.cone F).op
-      isColimit := isColimitConeOp _ (limit.isLimit _) }
+      isColimit := (limit.isLimit _).op }
 
 /-- If `C` has colimits of shape `Jᵒᵖ`, we can construct limits in `Cᵒᵖ` of shape `J`.
 -/
@@ -732,11 +699,11 @@ def isColimitEquivIsLimitOp {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : Pushout
   apply equivOfSubsingletonOfSubsingleton
   · intro h
     exact (IsLimit.postcomposeHomEquiv _ _).invFun
-      ((IsLimit.whiskerEquivalenceEquiv walkingSpanOpEquiv.symm).toFun (isLimitCoconeOp _ h))
+      ((IsLimit.whiskerEquivalenceEquiv walkingSpanOpEquiv.symm).toFun h.op)
   · intro h
     exact (IsColimit.equivIsoColimit c.opUnop).toFun
-      (isColimitConeUnop _ ((IsLimit.postcomposeHomEquiv _ _).invFun
-        ((IsLimit.whiskerEquivalenceEquiv _).toFun h)))
+      (((IsLimit.postcomposeHomEquiv _ _).invFun
+        ((IsLimit.whiskerEquivalenceEquiv _).toFun h)).unop)
 #align category_theory.limits.pushout_cocone.is_colimit_equiv_is_limit_op CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitOp
 
 /-- A pushout cone is a colimit cocone in `Cᵒᵖ` if and only if the corresponding pullback cone
@@ -745,12 +712,12 @@ def isColimitEquivIsLimitUnop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c :
     IsColimit c ≃ IsLimit c.unop := by
   apply equivOfSubsingletonOfSubsingleton
   · intro h
-    exact isLimitCoconeUnop _ ((IsColimit.precomposeHomEquiv _ _).invFun
-      ((IsColimit.whiskerEquivalenceEquiv _).toFun h))
+    exact ((IsColimit.precomposeHomEquiv _ _).invFun
+      ((IsColimit.whiskerEquivalenceEquiv _).toFun h)).unop
   · intro h
     exact (IsColimit.equivIsoColimit c.unopOp).toFun
       ((IsColimit.precomposeHomEquiv _ _).invFun
-      ((IsColimit.whiskerEquivalenceEquiv walkingCospanOpEquiv.symm).toFun (isColimitConeOp _ h)))
+      ((IsColimit.whiskerEquivalenceEquiv walkingCospanOpEquiv.symm).toFun h.op))
 #align category_theory.limits.pushout_cocone.is_colimit_equiv_is_limit_unop CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitUnop
 
 end PushoutCocone

ac3ae212

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

Empty lines were removed by executing the following Python script twice

import os
import re


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

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

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

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

75c86f04

Diff

@@ -32,7 +32,6 @@ open Opposite
 namespace CategoryTheory.Limits
 
 variable {C : Type u₁} [Category.{v₁} C]
-
 variable {J : Type u₂} [Category.{v₂} J]
 
 /-- Turn a colimit for `F : J ⥤ C` into a limit for `F.op : Jᵒᵖ ⥤ Cᵒᵖ`. -/

ac3ae212

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

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

8be0b69c

Diff

@@ -623,7 +623,7 @@ def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
 
 namespace PushoutCocone
 
--- porting note: it was originally @[simps (config := lemmasOnly)]
+-- Porting note: it was originally @[simps (config := lemmasOnly)]
 /-- The obvious map `PushoutCocone f g → PullbackCone f.unop g.unop` -/
 @[simps!]
 def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
@@ -643,7 +643,7 @@ theorem unop_snd {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocon
     c.unop.snd = c.inr.unop := by aesop_cat
 #align category_theory.limits.pushout_cocone.unop_snd CategoryTheory.Limits.PushoutCocone.unop_snd
 
--- porting note: it was originally @[simps (config := lemmasOnly)]
+-- Porting note: it was originally @[simps (config := lemmasOnly)]
 /-- The obvious map `PushoutCocone f.op g.op → PullbackCone f g` -/
 @[simps!]
 def op {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : PullbackCone f.op g.op :=
@@ -665,7 +665,7 @@ end PushoutCocone
 
 namespace PullbackCone
 
--- porting note: it was originally @[simps (config := lemmasOnly)]
+-- Porting note: it was originally @[simps (config := lemmasOnly)]
 /-- The obvious map `PullbackCone f g → PushoutCocone f.unop g.unop` -/
 @[simps!]
 def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :

ac3ae212

chore: classify simp can prove porting notes (#10930)

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to

"simp can prove this"
"simp can simplify this`"
"was @[simp], now can be proved by simp"
"was @[simp], but simp can prove it"
"removed simp attribute as the equality can already be obtained by simp"
"simp can already prove this"
"simp already proves this"
"simp can prove these"

d8fa853a

Diff

@@ -633,12 +633,12 @@ def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
       (Cocone.whisker walkingCospanOpEquiv.functor c))
 #align category_theory.limits.pushout_cocone.unop CategoryTheory.Limits.PushoutCocone.unop
 
--- porting note: removed simp attribute as the equality can already be obtained by simp
+-- Porting note (#10618): removed simp attribute as the equality can already be obtained by simp
 theorem unop_fst {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
     c.unop.fst = c.inl.unop := by simp
 #align category_theory.limits.pushout_cocone.unop_fst CategoryTheory.Limits.PushoutCocone.unop_fst
 
--- porting note: removed simp attribute as the equality can already be obtained by simp
+-- Porting note (#10618): removed simp attribute as the equality can already be obtained by simp
 theorem unop_snd {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
     c.unop.snd = c.inr.unop := by aesop_cat
 #align category_theory.limits.pushout_cocone.unop_snd CategoryTheory.Limits.PushoutCocone.unop_snd
@@ -651,12 +651,12 @@ def op {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : Pullbac
     (Cone.whisker walkingSpanOpEquiv.inverse (Cocone.op c))
 #align category_theory.limits.pushout_cocone.op CategoryTheory.Limits.PushoutCocone.op
 
--- porting note: removed simp attribute as the equality can already be obtained by simp
+-- Porting note (#10618): removed simp attribute as the equality can already be obtained by simp
 theorem op_fst {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : c.op.fst = c.inl.op :=
   by aesop_cat
 #align category_theory.limits.pushout_cocone.op_fst CategoryTheory.Limits.PushoutCocone.op_fst
 
--- porting note: removed simp attribute as the equality can already be obtained by simp
+-- Porting note (#10618): removed simp attribute as the equality can already be obtained by simp
 theorem op_snd {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) : c.op.snd = c.inr.op :=
   by aesop_cat
 #align category_theory.limits.pushout_cocone.op_snd CategoryTheory.Limits.PushoutCocone.op_snd
@@ -675,12 +675,12 @@ def unop {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
       (Cone.whisker walkingSpanOpEquiv.functor c))
 #align category_theory.limits.pullback_cone.unop CategoryTheory.Limits.PullbackCone.unop
 
--- porting note: removed simp attribute as the equality can already be obtained by simp
+-- Porting note (#10618): removed simp attribute as the equality can already be obtained by simp
 theorem unop_inl {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
     c.unop.inl = c.fst.unop := by aesop_cat
 #align category_theory.limits.pullback_cone.unop_inl CategoryTheory.Limits.PullbackCone.unop_inl
 
--- porting note: removed simp attribute as the equality can already be obtained by simp
+-- Porting note (#10618): removed simp attribute as the equality can already be obtained by simp
 theorem unop_inr {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
     c.unop.inr = c.snd.unop := by aesop_cat
 #align category_theory.limits.pullback_cone.unop_inr CategoryTheory.Limits.PullbackCone.unop_inr
@@ -692,12 +692,12 @@ def op {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : PushoutC
     (Cocone.whisker walkingCospanOpEquiv.inverse (Cone.op c))
 #align category_theory.limits.pullback_cone.op CategoryTheory.Limits.PullbackCone.op
 
--- porting note: removed simp attribute as the equality can already be obtained by simp
+-- Porting note (#10618): removed simp attribute as the equality can already be obtained by simp
 theorem op_inl {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : c.op.inl = c.fst.op :=
   by aesop_cat
 #align category_theory.limits.pullback_cone.op_inl CategoryTheory.Limits.PullbackCone.op_inl
 
--- porting note: removed simp attribute as the equality can already be obtained by simp
+-- Porting note (#10618): removed simp attribute as the equality can already be obtained by simp
 theorem op_inr {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : c.op.inr = c.snd.op :=
   by aesop_cat
 #align category_theory.limits.pullback_cone.op_inr CategoryTheory.Limits.PullbackCone.op_inr

ac3ae212

chore: cleanup simp calls (#9539)

Remove some unnecessary arguments in simp calls, which will become problematic when the simp algorithm changes in leanprover/lean4#3124.

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

320fe23c

Diff

@@ -468,8 +468,8 @@ theorem desc_op_comp_opCoproductIsoProduct_hom {X : C} (π : (a : α) → Z a 
     (Sigma.desc π).op ≫ (opCoproductIsoProduct Z).hom = Pi.lift (fun a ↦ (π a).op) := by
   convert desc_op_comp_opCoproductIsoProduct'_hom (coproductIsCoproduct Z)
     (productIsProduct (op <| Z ·)) (Cofan.mk _ π)
-  · ext; simp [Sigma.desc, colimit.desc, coproductIsCoproduct]
-  · ext; simp [Pi.lift, limit.lift, productIsProduct]
+  · ext; simp [Sigma.desc, coproductIsCoproduct]
+  · ext; simp [Pi.lift, productIsProduct]
 
 end OppositeCoproducts
 
@@ -542,8 +542,8 @@ theorem opProductIsoCoproduct_inv_comp_lift {X : C} (π : (a : α) → X ⟶ Z a
     (opProductIsoCoproduct Z).inv ≫ (Pi.lift π).op  = Sigma.desc (fun a ↦ (π a).op) := by
   convert opProductIsoCoproduct'_inv_comp_lift (productIsProduct Z)
     (coproductIsCoproduct (op <| Z ·)) (Fan.mk _ π)
-  · ext; simp [Pi.lift, limit.lift, productIsProduct]
-  · ext; simp [Sigma.desc, colimit.desc, coproductIsCoproduct]
+  · ext; simp [Pi.lift, productIsProduct]
+  · ext; simp [Sigma.desc, coproductIsCoproduct]
 
 end OppositeProducts

ac3ae212

perf(FunLike.Basic): beta reduce CoeFun.coe (#7905)

This eliminates (fun a ↦ β) α in the type when applying a FunLike.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

e194c756

Diff

@@ -790,14 +790,14 @@ noncomputable def pullbackIsoUnopPushout {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
 theorem pullbackIsoUnopPushout_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] :
     (pullbackIsoUnopPushout f g).inv ≫ pullback.fst = (pushout.inl : _ ⟶ pushout f.op g.op).unop :=
-  (IsLimit.conePointUniqueUpToIso_inv_comp _ _ _).trans (by simp)
+  (IsLimit.conePointUniqueUpToIso_inv_comp _ _ _).trans (by simp [unop_id (X := { unop := X })])
 #align category_theory.limits.pullback_iso_unop_pushout_inv_fst CategoryTheory.Limits.pullbackIsoUnopPushout_inv_fst
 
 @[reassoc (attr := simp)]
 theorem pullbackIsoUnopPushout_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
     [HasPushout f.op g.op] :
     (pullbackIsoUnopPushout f g).inv ≫ pullback.snd = (pushout.inr : _ ⟶ pushout f.op g.op).unop :=
-  (IsLimit.conePointUniqueUpToIso_inv_comp _ _ _).trans (by simp)
+  (IsLimit.conePointUniqueUpToIso_inv_comp _ _ _).trans (by simp [unop_id (X := { unop := Y })])
 #align category_theory.limits.pullback_iso_unop_pushout_inv_snd CategoryTheory.Limits.pullbackIsoUnopPushout_inv_snd
 
 @[reassoc (attr := simp)]

ac3ae212

refactor(CategoryTheory): change the API for opposite (co)products to accept general (co)fans (#8302)

63c34b16

Diff

@@ -401,112 +401,149 @@ theorem hasFiniteProducts_of_opposite [HasFiniteCoproducts Cᵒᵖ] : HasFiniteP
 
 section OppositeCoproducts
 
-variable {α : Type*} (Z : α → C) [HasCoproduct Z]
+variable {α : Type*} {Z : α → C} [HasCoproduct Z]
 
 instance : HasLimit (Discrete.functor Z).op := hasLimit_op_of_hasColimit (Discrete.functor Z)
 
-instance : HasLimit ((Discrete.opposite α).inverse ⋙ (Discrete.functor fun i ↦ Z i).op) :=
+instance : HasLimit ((Discrete.opposite α).inverse ⋙ (Discrete.functor Z).op) :=
   hasLimitEquivalenceComp (Discrete.opposite α).symm
 
-instance : HasProduct (fun z ↦ op (Z z)) := hasLimitOfIso
+instance : HasProduct (op <| Z ·) := hasLimitOfIso
   ((Discrete.natIsoFunctor ≪≫ Discrete.natIso (fun _ ↦ by rfl)) :
-    (Discrete.opposite α).inverse ⋙ (Discrete.functor fun i ↦ Z i).op ≅
-    Discrete.functor (fun z ↦ op (Z z)))
+    (Discrete.opposite α).inverse ⋙ (Discrete.functor Z).op ≅
+    Discrete.functor (op <| Z ·))
 
-/-- The isomorphism from the opposite of the coproduct to the product. -/
+/-- A `Cofan` gives a `Fan` in the opposite category.  -/
 @[simp]
-noncomputable
-def opCoproductIsoProduct : op (∐ Z) ≅ ∏ (fun z => op (Z z)) :=
-  IsLimit.conePointUniqueUpToIso (isLimitCoconeOp _ (coproductIsCoproduct fun b ↦ Z b))
-    (limit.isLimit _) ≪≫ (IsLimit.conePointsIsoOfEquivalence
-    (productIsProduct (fun z ↦ op (Z z))) (limit.isLimit _) (Discrete.opposite α).symm
-    (Discrete.natIsoFunctor ≪≫ Discrete.natIso (fun _ ↦ by rfl))).symm
-
-lemma opCoproductIsoProduct_inv_comp_ι (b : α) :
-    (opCoproductIsoProduct Z).inv ≫ (Sigma.ι (fun a => Z a) b).op =
-    Pi.π (fun a => op (Z a)) b := by
-  dsimp only [opCoproductIsoProduct]
-  simp only [Iso.trans_inv]
-  have := IsLimit.conePointUniqueUpToIso_inv_comp
-    (isLimitCoconeOp _ (coproductIsCoproduct fun b ↦ Z b)) (limit.isLimit _) (op ⟨b⟩)
-  dsimp at this
-  rw [Category.assoc, this]
-  simp only [limit.cone_x, Fan.mk_pt, Equivalence.symm_functor, Discrete.natIsoFunctor,
-    Functor.comp_obj, Functor.op_obj, Iso.symm_inv, IsLimit.conePointsIsoOfEquivalence_hom,
-    Equivalence.symm_inverse, Cones.equivalenceOfReindexing_functor, Iso.trans_hom, Iso.symm_hom,
-    isoWhiskerLeft_inv, Iso.trans_inv, whiskerLeft_comp, Cones.whiskering_obj, limit.isLimit_lift,
-    limit.lift_π, Cones.postcompose_obj_pt, Cone.whisker_pt, Cones.postcompose_obj_π,
-    Cone.whisker_π, Category.assoc, NatTrans.comp_app, Functor.const_obj_obj, unop_op,
-    Discrete.functor_obj, whiskerLeft_app, Fan.mk_π_app, Discrete.opposite_functor_obj_as,
-    Discrete.natIso_inv_app, Iso.refl_inv, Equivalence.invFunIdAssoc_hom_app, Functor.id_obj,
-    Functor.op_map, Discrete.functor_map_id, op_id]
-  simp only [Discrete.functor, Function.comp_apply, id_eq, Discrete.opposite, Equivalence.mk,
-    id_obj, comp_obj, leftOp_obj, unop_op, op_obj, Category.comp_id]
-
-lemma desc_op_comp_opCoproductIsoProduct_hom {X : C} (π : (a : α) → Z a ⟶ X) :
-    (Sigma.desc π).op ≫ (opCoproductIsoProduct Z).hom = Pi.lift (fun a => Quiver.Hom.op (π a)) := by
-  rw [← Iso.eq_comp_inv (opCoproductIsoProduct Z)]
-  congr
-  refine' Sigma.hom_ext (f := Z) _ _ (fun a => _)
-  rw [← Category.assoc, colimit.ι_desc, ← Quiver.Hom.unop_op (Sigma.ι Z a), ← unop_comp,
-    opCoproductIsoProduct_inv_comp_ι, ← unop_comp]
-  simp only [Cofan.mk_pt, Cofan.mk_ι_app, Pi.lift, Pi.π, limit.lift_π, Fan.mk_pt, Fan.mk_π_app,
-    Quiver.Hom.unop_op]
+def Cofan.op (c : Cofan Z) : Fan (op <| Z ·) := Fan.mk _ (fun a ↦ (c.inj a).op)
+
+/-- If a `Cofan` is colimit, then its opposite is limit. -/
+def Cofan.IsColimit.op {c : Cofan Z} (hc : IsColimit c) : IsLimit c.op := by
+  let e : Discrete.functor (Opposite.op <| Z ·) ≅ (Discrete.opposite α).inverse ⋙
+    (Discrete.functor Z).op := Discrete.natIso (fun _ ↦ Iso.refl _)
+  refine IsLimit.ofIsoLimit ((IsLimit.postcomposeInvEquiv e _).2
+    (IsLimit.whiskerEquivalence hc.op (Discrete.opposite α).symm))
+    (Cones.ext (Iso.refl _) (fun ⟨a⟩ ↦ ?_))
+  dsimp
+  erw [Category.id_comp, Category.comp_id]
+  rfl
+
+/--
+The canonical isomorphism from the opposite of an abstract coproduct to the corresponding product
+in the opposite category.
+-/
+def opCoproductIsoProduct' {c : Cofan Z} {f : Fan (op <| Z ·)}
+    (hc : IsColimit c) (hf : IsLimit f) : op c.pt ≅ f.pt :=
+  IsLimit.conePointUniqueUpToIso (Cofan.IsColimit.op hc) hf
+
+variable (Z) in
+/--
+The canonical isomorphism from the opposite of the coproduct to the product in the opposite
+category.
+-/
+def opCoproductIsoProduct :
+    op (∐ Z) ≅ ∏ (op <| Z ·) :=
+  opCoproductIsoProduct' (coproductIsCoproduct Z) (productIsProduct (op <| Z ·))
+
+theorem opCoproductIsoProduct'_inv_comp_inj {c : Cofan Z} {f : Fan (op <| Z ·)}
+    (hc : IsColimit c) (hf : IsLimit f) (b : α) :
+    (opCoproductIsoProduct' hc hf).inv ≫ (c.inj b).op = f.proj b :=
+  IsLimit.conePointUniqueUpToIso_inv_comp (Cofan.IsColimit.op hc) hf ⟨b⟩
+
+variable (Z) in
+theorem opCoproductIsoProduct_inv_comp_ι (b : α) :
+    (opCoproductIsoProduct Z).inv ≫ (Sigma.ι Z b).op = Pi.π (op <| Z ·) b :=
+  opCoproductIsoProduct'_inv_comp_inj _ _ b
+
+theorem desc_op_comp_opCoproductIsoProduct'_hom {c : Cofan Z} {f : Fan (op <| Z ·)}
+    (hc : IsColimit c) (hf : IsLimit f) (c' : Cofan Z) :
+    (hc.desc c').op ≫ (opCoproductIsoProduct' hc hf).hom = hf.lift c'.op := by
+  refine (Iso.eq_comp_inv _).mp (Quiver.Hom.unop_inj (hc.hom_ext (fun ⟨j⟩ ↦ Quiver.Hom.op_inj ?_)))
+  simp only [unop_op, Discrete.functor_obj, const_obj_obj, Quiver.Hom.unop_op, IsColimit.fac,
+    Cofan.op, unop_comp, op_comp, op_unop, Quiver.Hom.op_unop, Category.assoc]
+  erw [opCoproductIsoProduct'_inv_comp_inj, IsLimit.fac]
+  rfl
+
+theorem desc_op_comp_opCoproductIsoProduct_hom {X : C} (π : (a : α) → Z a ⟶ X) :
+    (Sigma.desc π).op ≫ (opCoproductIsoProduct Z).hom = Pi.lift (fun a ↦ (π a).op) := by
+  convert desc_op_comp_opCoproductIsoProduct'_hom (coproductIsCoproduct Z)
+    (productIsProduct (op <| Z ·)) (Cofan.mk _ π)
+  · ext; simp [Sigma.desc, colimit.desc, coproductIsCoproduct]
+  · ext; simp [Pi.lift, limit.lift, productIsProduct]
 
 end OppositeCoproducts
 
 section OppositeProducts
 
-variable {α : Type*} (Z : α → C) [HasProduct Z]
+variable {α : Type*} {Z : α → C} [HasProduct Z]
 
 instance : HasColimit (Discrete.functor Z).op := hasColimit_op_of_hasLimit (Discrete.functor Z)
 
-instance : HasColimit ((Discrete.opposite α).inverse ⋙ (Discrete.functor fun i ↦ Z i).op) :=
+instance : HasColimit ((Discrete.opposite α).inverse ⋙ (Discrete.functor Z).op) :=
   hasColimit_equivalence_comp (Discrete.opposite α).symm
 
-instance : HasCoproduct (fun z ↦ op (Z z)) := hasColimitOfIso
+instance : HasCoproduct (op <| Z ·) := hasColimitOfIso
   ((Discrete.natIsoFunctor ≪≫ Discrete.natIso (fun _ ↦ by rfl)) :
-    (Discrete.opposite α).inverse ⋙ (Discrete.functor fun i ↦ Z i).op ≅
-    Discrete.functor (fun z ↦ op (Z z))).symm
+    (Discrete.opposite α).inverse ⋙ (Discrete.functor Z).op ≅
+    Discrete.functor (op <| Z ·)).symm
 
-/-- The isomorphism from the opposite of the product to the coproduct. -/
+/-- A `Fan` gives a `Cofan` in the opposite category. -/
 @[simp]
-noncomputable
-def opProductIsoCoproduct : op (∏ Z) ≅ ∐  (fun z => op (Z z)) :=
-  IsColimit.coconePointUniqueUpToIso (isColimitConeOp _ (productIsProduct fun b ↦ Z b))
-    (colimit.isColimit _) ≪≫ (IsColimit.coconePointsIsoOfEquivalence
-    (coproductIsCoproduct (fun z ↦ op (Z z))) (colimit.isColimit _) (Discrete.opposite α).symm
-    (Discrete.natIsoFunctor ≪≫ Discrete.natIso (fun _ ↦ by rfl))).symm
-
-lemma π_comp_opProductIsoCoproduct (b : α) : (Pi.π Z b).op ≫ (opProductIsoCoproduct Z).hom =
-    Sigma.ι (fun a => op (Z a)) b := by
-  dsimp only [opProductIsoCoproduct]
-  simp only [Iso.trans_hom]
-  have := IsColimit.comp_coconePointUniqueUpToIso_hom
-    (isColimitConeOp _ (productIsProduct Z)) (colimit.isColimit _) (op ⟨b⟩)
-  dsimp at this
-  rw [← Category.assoc, this]
-  simp only [colimit.cocone_x, Cofan.mk_pt, Equivalence.symm_functor, Discrete.natIsoFunctor,
-    comp_obj, op_obj, Iso.symm_hom, IsColimit.coconePointsIsoOfEquivalence_inv,
-    Equivalence.symm_inverse, Cocones.equivalenceOfReindexing_functor_obj, Iso.trans_inv,
-    Iso.symm_inv, isoWhiskerLeft_hom, Iso.trans_hom, whiskerLeft_comp, colimit.isColimit_desc,
-    colimit.ι_desc, Cocones.precompose_obj_pt, Cocone.whisker_pt, Cocones.precompose_obj_ι,
-    Cocone.whisker_ι, Category.assoc, NatTrans.comp_app, unop_op, Discrete.functor_obj,
-    const_obj_obj, Equivalence.invFunIdAssoc_inv_app, id_obj, op_map, Discrete.functor_map_id,
-    op_id, whiskerLeft_app, Discrete.natIso_hom_app, Iso.refl_hom, Cofan.mk_ι_app,
-    Discrete.opposite_functor_obj_as, Category.id_comp]
-  simp only [Discrete.functor, Function.comp_apply, id_eq, Discrete.opposite, Equivalence.mk,
-    id_obj, comp_obj, leftOp_obj, unop_op, Category.id_comp]
-
-lemma opProductIsoCoproduct_inv_comp_π_op {X : C} (π : (a : α) → X ⟶ Z a) :
-    (opProductIsoCoproduct Z).inv ≫ (Pi.lift π).op = Sigma.desc (fun a => Quiver.Hom.op (π a)) := by
-  rw [Iso.inv_comp_eq (opProductIsoCoproduct Z)]
-  congr
-  refine' Pi.hom_ext (f := Z) _ _ (fun a => _)
-  rw [Category.assoc, limit.lift_π, ← Quiver.Hom.unop_op (Pi.π Z a), ← unop_comp,
-    π_comp_opProductIsoCoproduct, ← unop_comp]
-  simp only [Fan.mk_pt, Fan.mk_π_app, colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app,
-    Quiver.Hom.unop_op]
+def Fan.op (f : Fan Z) : Cofan (op <| Z ·) := Cofan.mk _ (fun a ↦ (f.proj a).op)
+
+/-- If a `Fan` is limit, then its opposite is colimit. -/
+def Fan.IsLimit.op {f : Fan Z} (hf : IsLimit f) : IsColimit f.op := by
+  let e : Discrete.functor (Opposite.op <| Z ·) ≅ (Discrete.opposite α).inverse ⋙
+    (Discrete.functor Z).op := Discrete.natIso (fun _ ↦ Iso.refl _)
+  refine IsColimit.ofIsoColimit ((IsColimit.precomposeHomEquiv e _).2
+    (IsColimit.whiskerEquivalence hf.op (Discrete.opposite α).symm))
+    (Cocones.ext (Iso.refl _) (fun ⟨a⟩ ↦ ?_))
+  dsimp
+  erw [Category.id_comp, Category.comp_id]
+  rfl
+
+/--
+The canonical isomorphism from the opposite of an abstract product to the corresponding coproduct
+in the opposite category.
+-/
+def opProductIsoCoproduct' {f : Fan Z} {c : Cofan (op <| Z ·)}
+    (hf : IsLimit f) (hc : IsColimit c) : op f.pt ≅ c.pt :=
+  IsColimit.coconePointUniqueUpToIso (Fan.IsLimit.op hf) hc
+
+variable (Z) in
+/--
+The canonical isomorphism from the opposite of the product to the coproduct in the opposite
+category.
+-/
+def opProductIsoCoproduct :
+    op (∏ Z) ≅ ∐ (op <| Z ·) :=
+  opProductIsoCoproduct' (productIsProduct Z) (coproductIsCoproduct (op <| Z ·))
+
+theorem proj_comp_opProductIsoCoproduct'_hom {f : Fan Z} {c : Cofan (op <| Z ·)}
+    (hf : IsLimit f) (hc : IsColimit c) (b : α) :
+    (f.proj b).op ≫ (opProductIsoCoproduct' hf hc).hom = c.inj b :=
+  IsColimit.comp_coconePointUniqueUpToIso_hom (Fan.IsLimit.op hf) hc ⟨b⟩
+
+variable (Z) in
+theorem proj_comp_opProductIsoCoproduct_hom (b : α) :
+    (Pi.π Z b).op ≫ (opProductIsoCoproduct Z).hom = Sigma.ι (op <| Z ·) b :=
+  proj_comp_opProductIsoCoproduct'_hom _ _ b
+
+theorem opProductIsoCoproduct'_inv_comp_lift {f : Fan Z} {c : Cofan (op <| Z ·)}
+    (hf : IsLimit f) (hc : IsColimit c) (f' : Fan Z) :
+    (opProductIsoCoproduct' hf hc).inv ≫ (hf.lift f').op = hc.desc f'.op := by
+  refine (Iso.inv_comp_eq _).mpr (Quiver.Hom.unop_inj (hf.hom_ext (fun ⟨j⟩ ↦ Quiver.Hom.op_inj ?_)))
+  simp only [Discrete.functor_obj, unop_op, Quiver.Hom.unop_op, IsLimit.fac, Fan.op, unop_comp,
+    Category.assoc, op_comp, op_unop, Quiver.Hom.op_unop]
+  erw [← Category.assoc, proj_comp_opProductIsoCoproduct'_hom, IsColimit.fac]
+  rfl
+
+theorem opProductIsoCoproduct_inv_comp_lift {X : C} (π : (a : α) → X ⟶ Z a) :
+    (opProductIsoCoproduct Z).inv ≫ (Pi.lift π).op  = Sigma.desc (fun a ↦ (π a).op) := by
+  convert opProductIsoCoproduct'_inv_comp_lift (productIsProduct Z)
+    (coproductIsCoproduct (op <| Z ·)) (Fan.mk _ π)
+  · ext; simp [Pi.lift, limit.lift, productIsProduct]
+  · ext; simp [Sigma.desc, colimit.desc, coproductIsCoproduct]
 
 end OppositeProducts

ac3ae212

style: fix wrapping of where (#7149)

084cfb35

Diff

@@ -279,8 +279,8 @@ theorem hasLimits_of_hasColimits_op [HasColimits Cᵒᵖ] : HasLimits C :=
 #align category_theory.limits.has_limits_of_has_colimits_op CategoryTheory.Limits.hasLimits_of_hasColimits_op
 
 instance has_cofiltered_limits_op_of_has_filtered_colimits [HasFilteredColimitsOfSize.{v₂, u₂} C] :
-    HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ
-    where HasLimitsOfShape _ _ _ := hasLimitsOfShape_op_of_hasColimitsOfShape
+    HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ where
+  HasLimitsOfShape _ _ _ := hasLimitsOfShape_op_of_hasColimitsOfShape
 #align category_theory.limits.has_cofiltered_limits_op_of_has_filtered_colimits CategoryTheory.Limits.has_cofiltered_limits_op_of_has_filtered_colimits
 
 theorem has_cofiltered_limits_of_has_filtered_colimits_op [HasFilteredColimitsOfSize.{v₂, u₂} Cᵒᵖ] :
@@ -383,16 +383,16 @@ theorem hasCoproducts_of_opposite [HasProducts.{v₂} Cᵒᵖ] : HasCoproducts.{
   hasCoproductsOfShape_of_opposite X
 #align category_theory.limits.has_coproducts_of_opposite CategoryTheory.Limits.hasCoproducts_of_opposite
 
-instance hasFiniteCoproducts_opposite [HasFiniteProducts C] : HasFiniteCoproducts Cᵒᵖ
-    where out _ := Limits.hasCoproductsOfShape_opposite _
+instance hasFiniteCoproducts_opposite [HasFiniteProducts C] : HasFiniteCoproducts Cᵒᵖ where
+  out _ := Limits.hasCoproductsOfShape_opposite _
 #align category_theory.limits.has_finite_coproducts_opposite CategoryTheory.Limits.hasFiniteCoproducts_opposite
 
 theorem hasFiniteCoproducts_of_opposite [HasFiniteProducts Cᵒᵖ] : HasFiniteCoproducts C :=
   { out := fun _ => hasCoproductsOfShape_of_opposite _ }
 #align category_theory.limits.has_finite_coproducts_of_opposite CategoryTheory.Limits.hasFiniteCoproducts_of_opposite
 
-instance hasFiniteProducts_opposite [HasFiniteCoproducts C] : HasFiniteProducts Cᵒᵖ
-    where out _ := inferInstance
+instance hasFiniteProducts_opposite [HasFiniteCoproducts C] : HasFiniteProducts Cᵒᵖ where
+  out _ := inferInstance
 #align category_theory.limits.has_finite_products_opposite CategoryTheory.Limits.hasFiniteProducts_opposite
 
 theorem hasFiniteProducts_of_opposite [HasFiniteCoproducts Cᵒᵖ] : HasFiniteProducts C :=

ac3ae212

feat: some lemmas about products and coproducts in opposite categories (#6758)

Adds missing theorem hasColimit_op_of_hasLimit and its dual.
Adds instance [HasCoproduct Z] : HasProduct (fun z ↦ op (Z z)) and its dual
Defines the isomorphism op (∐ Z) ≅ ∏ (fun z => op (Z z)) and its dual and proves some naturality lemmas about them.

Co-authored-by: Riccardo Brasca @riccardobrasca [riccardo.brasca@gmail.com](mailto:riccardo.brasca@gmail.com) Co-authored-by: Filippo A E Nuccio @faenuccio [filippo.nuccio@univ-st-etienne.fr](mailto:filippo.nuccio@univ-st-etienne.fr)

75e30432

Diff

@@ -247,6 +247,11 @@ theorem hasLimit_of_hasColimit_op (F : J ⥤ C) [HasColimit F.op] : HasLimit F :
   HasLimit.mk
     { cone := (colimit.cocone F.op).unop
       isLimit := isLimitCoconeUnop _ (colimit.isColimit _) }
+
+theorem hasLimit_op_of_hasColimit (F : J ⥤ C) [HasColimit F] : HasLimit F.op :=
+  HasLimit.mk
+    { cone := (colimit.cocone F).op
+      isLimit := isLimitCoconeOp _ (colimit.isColimit _) }
 #align category_theory.limits.has_limit_of_has_colimit_op CategoryTheory.Limits.hasLimit_of_hasColimit_op
 
 /-- If `C` has colimits of shape `Jᵒᵖ`, we can construct limits in `Cᵒᵖ` of shape `J`.
@@ -297,6 +302,11 @@ theorem hasColimit_of_hasLimit_op (F : J ⥤ C) [HasLimit F.op] : HasColimit F :
       isColimit := isColimitConeUnop _ (limit.isLimit _) }
 #align category_theory.limits.has_colimit_of_has_limit_op CategoryTheory.Limits.hasColimit_of_hasLimit_op
 
+theorem hasColimit_op_of_hasLimit (F : J ⥤ C) [HasLimit F] : HasColimit F.op :=
+  HasColimit.mk
+    { cocone := (limit.cone F).op
+      isColimit := isColimitConeOp _ (limit.isLimit _) }
+
 /-- If `C` has colimits of shape `Jᵒᵖ`, we can construct limits in `Cᵒᵖ` of shape `J`.
 -/
 instance hasColimitsOfShape_op_of_hasLimitsOfShape [HasLimitsOfShape Jᵒᵖ C] :
@@ -389,6 +399,117 @@ theorem hasFiniteProducts_of_opposite [HasFiniteCoproducts Cᵒᵖ] : HasFiniteP
   { out := fun _ => hasProductsOfShape_of_opposite _ }
 #align category_theory.limits.has_finite_products_of_opposite CategoryTheory.Limits.hasFiniteProducts_of_opposite
 
+section OppositeCoproducts
+
+variable {α : Type*} (Z : α → C) [HasCoproduct Z]
+
+instance : HasLimit (Discrete.functor Z).op := hasLimit_op_of_hasColimit (Discrete.functor Z)
+
+instance : HasLimit ((Discrete.opposite α).inverse ⋙ (Discrete.functor fun i ↦ Z i).op) :=
+  hasLimitEquivalenceComp (Discrete.opposite α).symm
+
+instance : HasProduct (fun z ↦ op (Z z)) := hasLimitOfIso
+  ((Discrete.natIsoFunctor ≪≫ Discrete.natIso (fun _ ↦ by rfl)) :
+    (Discrete.opposite α).inverse ⋙ (Discrete.functor fun i ↦ Z i).op ≅
+    Discrete.functor (fun z ↦ op (Z z)))
+
+/-- The isomorphism from the opposite of the coproduct to the product. -/
+@[simp]
+noncomputable
+def opCoproductIsoProduct : op (∐ Z) ≅ ∏ (fun z => op (Z z)) :=
+  IsLimit.conePointUniqueUpToIso (isLimitCoconeOp _ (coproductIsCoproduct fun b ↦ Z b))
+    (limit.isLimit _) ≪≫ (IsLimit.conePointsIsoOfEquivalence
+    (productIsProduct (fun z ↦ op (Z z))) (limit.isLimit _) (Discrete.opposite α).symm
+    (Discrete.natIsoFunctor ≪≫ Discrete.natIso (fun _ ↦ by rfl))).symm
+
+lemma opCoproductIsoProduct_inv_comp_ι (b : α) :
+    (opCoproductIsoProduct Z).inv ≫ (Sigma.ι (fun a => Z a) b).op =
+    Pi.π (fun a => op (Z a)) b := by
+  dsimp only [opCoproductIsoProduct]
+  simp only [Iso.trans_inv]
+  have := IsLimit.conePointUniqueUpToIso_inv_comp
+    (isLimitCoconeOp _ (coproductIsCoproduct fun b ↦ Z b)) (limit.isLimit _) (op ⟨b⟩)
+  dsimp at this
+  rw [Category.assoc, this]
+  simp only [limit.cone_x, Fan.mk_pt, Equivalence.symm_functor, Discrete.natIsoFunctor,
+    Functor.comp_obj, Functor.op_obj, Iso.symm_inv, IsLimit.conePointsIsoOfEquivalence_hom,
+    Equivalence.symm_inverse, Cones.equivalenceOfReindexing_functor, Iso.trans_hom, Iso.symm_hom,
+    isoWhiskerLeft_inv, Iso.trans_inv, whiskerLeft_comp, Cones.whiskering_obj, limit.isLimit_lift,
+    limit.lift_π, Cones.postcompose_obj_pt, Cone.whisker_pt, Cones.postcompose_obj_π,
+    Cone.whisker_π, Category.assoc, NatTrans.comp_app, Functor.const_obj_obj, unop_op,
+    Discrete.functor_obj, whiskerLeft_app, Fan.mk_π_app, Discrete.opposite_functor_obj_as,
+    Discrete.natIso_inv_app, Iso.refl_inv, Equivalence.invFunIdAssoc_hom_app, Functor.id_obj,
+    Functor.op_map, Discrete.functor_map_id, op_id]
+  simp only [Discrete.functor, Function.comp_apply, id_eq, Discrete.opposite, Equivalence.mk,
+    id_obj, comp_obj, leftOp_obj, unop_op, op_obj, Category.comp_id]
+
+lemma desc_op_comp_opCoproductIsoProduct_hom {X : C} (π : (a : α) → Z a ⟶ X) :
+    (Sigma.desc π).op ≫ (opCoproductIsoProduct Z).hom = Pi.lift (fun a => Quiver.Hom.op (π a)) := by
+  rw [← Iso.eq_comp_inv (opCoproductIsoProduct Z)]
+  congr
+  refine' Sigma.hom_ext (f := Z) _ _ (fun a => _)
+  rw [← Category.assoc, colimit.ι_desc, ← Quiver.Hom.unop_op (Sigma.ι Z a), ← unop_comp,
+    opCoproductIsoProduct_inv_comp_ι, ← unop_comp]
+  simp only [Cofan.mk_pt, Cofan.mk_ι_app, Pi.lift, Pi.π, limit.lift_π, Fan.mk_pt, Fan.mk_π_app,
+    Quiver.Hom.unop_op]
+
+end OppositeCoproducts
+
+section OppositeProducts
+
+variable {α : Type*} (Z : α → C) [HasProduct Z]
+
+instance : HasColimit (Discrete.functor Z).op := hasColimit_op_of_hasLimit (Discrete.functor Z)
+
+instance : HasColimit ((Discrete.opposite α).inverse ⋙ (Discrete.functor fun i ↦ Z i).op) :=
+  hasColimit_equivalence_comp (Discrete.opposite α).symm
+
+instance : HasCoproduct (fun z ↦ op (Z z)) := hasColimitOfIso
+  ((Discrete.natIsoFunctor ≪≫ Discrete.natIso (fun _ ↦ by rfl)) :
+    (Discrete.opposite α).inverse ⋙ (Discrete.functor fun i ↦ Z i).op ≅
+    Discrete.functor (fun z ↦ op (Z z))).symm
+
+/-- The isomorphism from the opposite of the product to the coproduct. -/
+@[simp]
+noncomputable
+def opProductIsoCoproduct : op (∏ Z) ≅ ∐  (fun z => op (Z z)) :=
+  IsColimit.coconePointUniqueUpToIso (isColimitConeOp _ (productIsProduct fun b ↦ Z b))
+    (colimit.isColimit _) ≪≫ (IsColimit.coconePointsIsoOfEquivalence
+    (coproductIsCoproduct (fun z ↦ op (Z z))) (colimit.isColimit _) (Discrete.opposite α).symm
+    (Discrete.natIsoFunctor ≪≫ Discrete.natIso (fun _ ↦ by rfl))).symm
+
+lemma π_comp_opProductIsoCoproduct (b : α) : (Pi.π Z b).op ≫ (opProductIsoCoproduct Z).hom =
+    Sigma.ι (fun a => op (Z a)) b := by
+  dsimp only [opProductIsoCoproduct]
+  simp only [Iso.trans_hom]
+  have := IsColimit.comp_coconePointUniqueUpToIso_hom
+    (isColimitConeOp _ (productIsProduct Z)) (colimit.isColimit _) (op ⟨b⟩)
+  dsimp at this
+  rw [← Category.assoc, this]
+  simp only [colimit.cocone_x, Cofan.mk_pt, Equivalence.symm_functor, Discrete.natIsoFunctor,
+    comp_obj, op_obj, Iso.symm_hom, IsColimit.coconePointsIsoOfEquivalence_inv,
+    Equivalence.symm_inverse, Cocones.equivalenceOfReindexing_functor_obj, Iso.trans_inv,
+    Iso.symm_inv, isoWhiskerLeft_hom, Iso.trans_hom, whiskerLeft_comp, colimit.isColimit_desc,
+    colimit.ι_desc, Cocones.precompose_obj_pt, Cocone.whisker_pt, Cocones.precompose_obj_ι,
+    Cocone.whisker_ι, Category.assoc, NatTrans.comp_app, unop_op, Discrete.functor_obj,
+    const_obj_obj, Equivalence.invFunIdAssoc_inv_app, id_obj, op_map, Discrete.functor_map_id,
+    op_id, whiskerLeft_app, Discrete.natIso_hom_app, Iso.refl_hom, Cofan.mk_ι_app,
+    Discrete.opposite_functor_obj_as, Category.id_comp]
+  simp only [Discrete.functor, Function.comp_apply, id_eq, Discrete.opposite, Equivalence.mk,
+    id_obj, comp_obj, leftOp_obj, unop_op, Category.id_comp]
+
+lemma opProductIsoCoproduct_inv_comp_π_op {X : C} (π : (a : α) → X ⟶ Z a) :
+    (opProductIsoCoproduct Z).inv ≫ (Pi.lift π).op = Sigma.desc (fun a => Quiver.Hom.op (π a)) := by
+  rw [Iso.inv_comp_eq (opProductIsoCoproduct Z)]
+  congr
+  refine' Pi.hom_ext (f := Z) _ _ (fun a => _)
+  rw [Category.assoc, limit.lift_π, ← Quiver.Hom.unop_op (Pi.π Z a), ← unop_comp,
+    π_comp_opProductIsoCoproduct, ← unop_comp]
+  simp only [Fan.mk_pt, Fan.mk_π_app, colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app,
+    Quiver.Hom.unop_op]
+
+end OppositeProducts
+
 instance hasEqualizers_opposite [HasCoequalizers C] : HasEqualizers Cᵒᵖ := by
   haveI : HasColimitsOfShape WalkingParallelPairᵒᵖ C :=
     hasColimitsOfShape_of_equivalence walkingParallelPairOpEquiv

ac3ae212

feat: left and right homology data are dual notions (#5674)

This PR shows that left and right homology data of short complexes are dual notions.

cf06ef75

Diff

@@ -5,6 +5,7 @@ Authors: Scott Morrison, Floris van Doorn
 -/
 import Mathlib.CategoryTheory.Limits.Filtered
 import Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts
+import Mathlib.CategoryTheory.Limits.Shapes.Kernels
 import Mathlib.CategoryTheory.DiscreteCategory
 
 #align_import category_theory.limits.opposites from "leanprover-community/mathlib"@"ac3ae212f394f508df43e37aa093722fa9b65d31"
@@ -707,4 +708,54 @@ theorem pushoutIsoUnopPullback_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [
 
 end Pushout
 
+section HasZeroMorphisms
+
+variable [HasZeroMorphisms C]
+
+/-- A colimit cokernel cofork gives a limit kernel fork in the opposite category -/
+def CokernelCofork.IsColimit.ofπOp {X Y Q : C} (p : Y ⟶ Q) {f : X ⟶ Y}
+    (w : f ≫ p = 0) (h : IsColimit (CokernelCofork.ofπ p w)) :
+    IsLimit (KernelFork.ofι p.op (show p.op ≫ f.op = 0 by rw [← op_comp, w, op_zero])) :=
+  KernelFork.IsLimit.ofι _ _
+    (fun x hx => (h.desc (CokernelCofork.ofπ x.unop (Quiver.Hom.op_inj hx))).op)
+    (fun x hx => Quiver.Hom.unop_inj (Cofork.IsColimit.π_desc h))
+    (fun x hx b hb => Quiver.Hom.unop_inj (Cofork.IsColimit.hom_ext h
+      (by simpa only [Quiver.Hom.unop_op, Cofork.IsColimit.π_desc] using Quiver.Hom.op_inj hb)))
+
+/-- A colimit cokernel cofork in the opposite category gives a limit kernel fork
+in the original category -/
+def CokernelCofork.IsColimit.ofπUnop {X Y Q : Cᵒᵖ} (p : Y ⟶ Q) {f : X ⟶ Y}
+    (w : f ≫ p = 0) (h : IsColimit (CokernelCofork.ofπ p w)) :
+    IsLimit (KernelFork.ofι p.unop (show p.unop ≫ f.unop = 0 by rw [← unop_comp, w, unop_zero])) :=
+  KernelFork.IsLimit.ofι _ _
+    (fun x hx => (h.desc (CokernelCofork.ofπ x.op (Quiver.Hom.unop_inj hx))).unop)
+    (fun x hx => Quiver.Hom.op_inj (Cofork.IsColimit.π_desc h))
+    (fun x hx b hb => Quiver.Hom.op_inj (Cofork.IsColimit.hom_ext h
+      (by simpa only [Quiver.Hom.op_unop, Cofork.IsColimit.π_desc] using Quiver.Hom.unop_inj hb)))
+
+/-- A limit kernel fork gives a colimit cokernel cofork in the opposite category -/
+def KernelFork.IsLimit.ofιOp {K X Y : C} (i : K ⟶ X) {f : X ⟶ Y}
+    (w : i ≫ f = 0) (h : IsLimit (KernelFork.ofι i w)) :
+    IsColimit (CokernelCofork.ofπ i.op
+      (show f.op ≫ i.op = 0 by rw [← op_comp, w, op_zero])) :=
+  CokernelCofork.IsColimit.ofπ _ _
+    (fun x hx => (h.lift (KernelFork.ofι x.unop (Quiver.Hom.op_inj hx))).op)
+    (fun x hx => Quiver.Hom.unop_inj (Fork.IsLimit.lift_ι h))
+    (fun x hx b hb => Quiver.Hom.unop_inj (Fork.IsLimit.hom_ext h (by
+      simpa only [Quiver.Hom.unop_op, Fork.IsLimit.lift_ι] using Quiver.Hom.op_inj hb)))
+
+/-- A limit kernel fork in the opposite category gives a colimit cokernel cofork
+in the original category -/
+def KernelFork.IsLimit.ofιUnop {K X Y : Cᵒᵖ} (i : K ⟶ X) {f : X ⟶ Y}
+    (w : i ≫ f = 0) (h : IsLimit (KernelFork.ofι i w)) :
+    IsColimit (CokernelCofork.ofπ i.unop
+      (show f.unop ≫ i.unop = 0 by rw [← unop_comp, w, unop_zero])) :=
+  CokernelCofork.IsColimit.ofπ _ _
+    (fun x hx => (h.lift (KernelFork.ofι x.op (Quiver.Hom.unop_inj hx))).unop)
+    (fun x hx => Quiver.Hom.op_inj (Fork.IsLimit.lift_ι h))
+    (fun x hx b hb => Quiver.Hom.op_inj (Fork.IsLimit.hom_ext h (by
+      simpa only [Quiver.Hom.op_unop, Fork.IsLimit.lift_ι] using Quiver.Hom.unop_inj hb)))
+
+end HasZeroMorphisms
+
 end CategoryTheory.Limits

ac3ae212

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Floris van Doorn
-
-! This file was ported from Lean 3 source module category_theory.limits.opposites
-! leanprover-community/mathlib commit ac3ae212f394f508df43e37aa093722fa9b65d31
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.CategoryTheory.Limits.Filtered
 import Mathlib.CategoryTheory.Limits.Shapes.FiniteProducts
 import Mathlib.CategoryTheory.DiscreteCategory
 
+#align_import category_theory.limits.opposites from "leanprover-community/mathlib"@"ac3ae212f394f508df43e37aa093722fa9b65d31"
+
 /-!
 # Limits in `C` give colimits in `Cᵒᵖ`.

ac3ae212

chore: fix focusing dots (#5708)

This PR is the result of running

find . -type f -name "*.lean" -exec sed -i -E 's/^( +)\. /\1· /' {} \;
find . -type f -name "*.lean" -exec sed -i -E 'N;s/^( +·)\n +(.*)$/\1 \2/;P;D' {} \;

which firstly replaces . focusing dots with · and secondly removes isolated instances of such dots, unifying them with the following line. A new rule is placed in the style linter to verify this.

cb02d09e

Diff

@@ -575,10 +575,10 @@ in the opposite category is a limit cone. -/
 def isColimitEquivIsLimitOp {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
     IsColimit c ≃ IsLimit c.op := by
   apply equivOfSubsingletonOfSubsingleton
-  . intro h
+  · intro h
     exact (IsLimit.postcomposeHomEquiv _ _).invFun
       ((IsLimit.whiskerEquivalenceEquiv walkingSpanOpEquiv.symm).toFun (isLimitCoconeOp _ h))
-  . intro h
+  · intro h
     exact (IsColimit.equivIsoColimit c.opUnop).toFun
       (isColimitConeUnop _ ((IsLimit.postcomposeHomEquiv _ _).invFun
         ((IsLimit.whiskerEquivalenceEquiv _).toFun h)))
@@ -589,10 +589,10 @@ in `C` is a limit cone. -/
 def isColimitEquivIsLimitUnop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
     IsColimit c ≃ IsLimit c.unop := by
   apply equivOfSubsingletonOfSubsingleton
-  . intro h
+  · intro h
     exact isLimitCoconeUnop _ ((IsColimit.precomposeHomEquiv _ _).invFun
       ((IsColimit.whiskerEquivalenceEquiv _).toFun h))
-  . intro h
+  · intro h
     exact (IsColimit.equivIsoColimit c.unopOp).toFun
       ((IsColimit.precomposeHomEquiv _ _).invFun
       ((IsColimit.whiskerEquivalenceEquiv walkingCospanOpEquiv.symm).toFun (isColimitConeOp _ h)))

ac3ae212

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

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

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

14167e48

Diff

@@ -646,8 +646,8 @@ theorem pullbackIsoUnopPushout_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [
 
 @[reassoc (attr := simp)]
 theorem pullbackIsoUnopPushout_hom_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
-    [HasPushout f.op g.op] : pushout.inl ≫ (pullbackIsoUnopPushout f g).hom.op = pullback.fst.op :=
-  by
+    [HasPushout f.op g.op] :
+    pushout.inl ≫ (pullbackIsoUnopPushout f g).hom.op = pullback.fst.op := by
   apply Quiver.Hom.unop_inj
   dsimp
   rw [← pullbackIsoUnopPushout_inv_fst, Iso.hom_inv_id_assoc]
@@ -655,8 +655,8 @@ theorem pullbackIsoUnopPushout_hom_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [
 
 @[reassoc (attr := simp)]
 theorem pullbackIsoUnopPushout_hom_inr {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
-    [HasPushout f.op g.op] : pushout.inr ≫ (pullbackIsoUnopPushout f g).hom.op = pullback.snd.op :=
-  by
+    [HasPushout f.op g.op] : pushout.inr ≫ (pullbackIsoUnopPushout f g).hom.op =
+    pullback.snd.op := by
   apply Quiver.Hom.unop_inj
   dsimp
   rw [← pullbackIsoUnopPushout_inv_snd, Iso.hom_inv_id_assoc]
@@ -693,8 +693,7 @@ theorem pushoutIsoUnopPullback_inr_hom {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [
 @[simp]
 theorem pushoutIsoUnopPullback_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
     [HasPullback f.op g.op] :
-      (pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst = pushout.inl.op :=
-  by
+    (pushoutIsoUnopPullback f g).inv.op ≫ pullback.fst = pushout.inl.op := by
   apply Quiver.Hom.unop_inj
   dsimp
   rw [← pushoutIsoUnopPullback_inl_hom, Category.assoc, Iso.hom_inv_id, Category.comp_id]
@@ -703,8 +702,7 @@ theorem pushoutIsoUnopPullback_inv_fst {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [
 @[simp]
 theorem pushoutIsoUnopPullback_inv_snd {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y) [HasPushout f g]
     [HasPullback f.op g.op] :
-      (pushoutIsoUnopPullback f g).inv.op ≫ pullback.snd = pushout.inr.op :=
-  by
+    (pushoutIsoUnopPullback f g).inv.op ≫ pullback.snd = pushout.inr.op := by
   apply Quiver.Hom.unop_inj
   dsimp
   rw [← pushoutIsoUnopPullback_inr_hom, Category.assoc, Iso.hom_inv_id, Category.comp_id]

ac3ae212

chore: fix #align lines (#3640)

This PR fixes two things:

Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

2b42dc7c

Diff

@@ -463,7 +463,6 @@ def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
     _ ≅ walkingSpanOpEquiv.functor ⋙ walkingSpanOpEquiv.inverse ⋙ (span f g).op :=
       (Functor.associator _ _ _)
     _ ≅ walkingSpanOpEquiv.functor ⋙ cospan f.op g.op := isoWhiskerLeft _ (cospanOp f g).symm
-
 #align category_theory.limits.op_span CategoryTheory.Limits.opSpan
 
 namespace PushoutCocone

ac3ae212

chore: made Opposite a structure (#3193)

The opposite category is no longer a type synonym, but a structure.

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

d090d0a8

Diff

@@ -591,7 +591,7 @@ def isColimitEquivIsLimitUnop {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c :
     IsColimit c ≃ IsLimit c.unop := by
   apply equivOfSubsingletonOfSubsingleton
   . intro h
-    exact isLimitCoconeOp _ ((IsColimit.precomposeHomEquiv _ _).invFun
+    exact isLimitCoconeUnop _ ((IsColimit.precomposeHomEquiv _ _).invFun
       ((IsColimit.whiskerEquivalenceEquiv _).toFun h))
   . intro h
     exact (IsColimit.equivIsoColimit c.unopOp).toFun

ac3ae212

feat: port CategoryTheory.Limits.Opposites (#2805)

Co-authored-by: Johan Commelin <johan@commelin.net>

3fcb15f5

`category_theory.limits.opposites` ⟷ `Mathlib.CategoryTheory.Limits.Opposites`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 238

category_theory.limits.opposites ⟷ Mathlib.CategoryTheory.Limits.Opposites

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 2 + 238

`category_theory.limits.opposites` ⟷ `Mathlib.CategoryTheory.Limits.Opposites`