File: Mathlib/CategoryTheory/Limits/Opposites.lean

full_name: CategoryTheory.Limits.isLimitConeLeftOpOfCocone_lift
code: /-- Turn a colimit for `F : J ⥤ Cᵒᵖ` into a limit for `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps]
def isLimitConeLeftOpOfCocone (F : J ⥤ Cᵒᵖ) {c : Cocone F} (hc : IsColimit c) :
    IsLimit (coneLeftOpOfCocone c) 
goal: (CategoryTheory.Limits.isLimitConeLeftOpOfCocone F hc).lift s =
  (hc.desc (CategoryTheory.Limits.coconeOfConeLeftOp s)).unop

full_name: CategoryTheory.Limits.isLimitConeLeftOpOfCocone
code: /-- Turn a colimit for `F : J ⥤ Cᵒᵖ` into a limit for `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps]
def isLimitConeLeftOpOfCocone (F : J ⥤ Cᵒᵖ) {c : Cocone F} (hc : IsColimit c) :
    IsLimit (coneLeftOpOfCocone c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneLeftOpOfCocone c)

full_name: CategoryTheory.Limits.isColimitCoconeLeftOpOfCone
code: /-- Turn a limit of `F : J ⥤ Cᵒᵖ` into a colimit of `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps]
def isColimitCoconeLeftOpOfCone (F : J ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLimit c) :
    IsColimit (coconeLeftOpOfCone c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeLeftOpOfCone c)

full_name: CategoryTheory.Limits.isColimitCoconeLeftOpOfCone_desc
code: /-- Turn a limit of `F : J ⥤ Cᵒᵖ` into a colimit of `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps]
def isColimitCoconeLeftOpOfCone (F : J ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLimit c) :
    IsColimit (coconeLeftOpOfCone c) 
goal: (CategoryTheory.Limits.isColimitCoconeLeftOpOfCone F hc).desc s =
  (hc.lift (CategoryTheory.Limits.coneOfCoconeLeftOp s)).unop

full_name: CategoryTheory.Limits.isLimitConeRightOpOfCocone
code: /-- Turn a colimit for `F : Jᵒᵖ ⥤ C` into a limit for `F.rightOp : J ⥤ Cᵒᵖ`. -/
@[simps]
def isLimitConeRightOpOfCocone (F : Jᵒᵖ ⥤ C) {c : Cocone F} (hc : IsColimit c) :
    IsLimit (coneRightOpOfCocone c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneRightOpOfCocone c)

full_name: CategoryTheory.Limits.isLimitConeRightOpOfCocone_lift
code: /-- Turn a colimit for `F : Jᵒᵖ ⥤ C` into a limit for `F.rightOp : J ⥤ Cᵒᵖ`. -/
@[simps]
def isLimitConeRightOpOfCocone (F : Jᵒᵖ ⥤ C) {c : Cocone F} (hc : IsColimit c) :
    IsLimit (coneRightOpOfCocone c) 
goal: (CategoryTheory.Limits.isLimitConeRightOpOfCocone F hc).lift s =
  (hc.desc (CategoryTheory.Limits.coconeOfConeRightOp s)).op

full_name: CategoryTheory.Limits.isColimitCoconeRightOpOfCone
code: /-- Turn a limit for `F : Jᵒᵖ ⥤ C` into a colimit for `F.rightOp : J ⥤ Cᵒᵖ`. -/
@[simps]
def isColimitCoconeRightOpOfCone (F : Jᵒᵖ ⥤ C) {c : Cone F} (hc : IsLimit c) :
    IsColimit (coconeRightOpOfCone c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeRightOpOfCone c)

full_name: CategoryTheory.Limits.isColimitCoconeRightOpOfCone_desc
code: /-- Turn a limit for `F : Jᵒᵖ ⥤ C` into a colimit for `F.rightOp : J ⥤ Cᵒᵖ`. -/
@[simps]
def isColimitCoconeRightOpOfCone (F : Jᵒᵖ ⥤ C) {c : Cone F} (hc : IsLimit c) :
    IsColimit (coconeRightOpOfCone c) 
goal: (CategoryTheory.Limits.isColimitCoconeRightOpOfCone F hc).desc s =
  (hc.lift (CategoryTheory.Limits.coneOfCoconeRightOp s)).op

full_name: CategoryTheory.Limits.isLimitConeUnopOfCocone
code: /-- 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) :
    IsLimit (coneUnopOfCocone c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneUnopOfCocone c)

full_name: CategoryTheory.Limits.isLimitConeUnopOfCocone_lift
code: /-- 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) :
    IsLimit (coneUnopOfCocone c) 
goal: (CategoryTheory.Limits.isLimitConeUnopOfCocone F hc).lift s = (hc.desc (CategoryTheory.Limits.coconeOfConeUnop s)).unop

full_name: CategoryTheory.Limits.isColimitCoconeUnopOfCone
code: /-- 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) :
    IsColimit (coconeUnopOfCone c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeUnopOfCone c)

full_name: CategoryTheory.Limits.isColimitCoconeUnopOfCone_desc
code: /-- 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) :
    IsColimit (coconeUnopOfCone c) 
goal: (CategoryTheory.Limits.isColimitCoconeUnopOfCone F hc).desc s =
  (hc.lift (CategoryTheory.Limits.coneOfCoconeUnop s)).unop

full_name: CategoryTheory.Limits.isLimitConeOfCoconeLeftOp
code: /-- 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) :
    IsLimit (coneOfCoconeLeftOp c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfCoconeLeftOp c)

full_name: CategoryTheory.Limits.isLimitConeOfCoconeLeftOp_lift
code: /-- 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) :
    IsLimit (coneOfCoconeLeftOp c) 
goal: (CategoryTheory.Limits.isLimitConeOfCoconeLeftOp F hc).lift s =
  (hc.desc (CategoryTheory.Limits.coconeLeftOpOfCone s)).op

full_name: CategoryTheory.Limits.isColimitCoconeOfConeLeftOp_desc
code: /-- Turn a limit of `F.leftOp : Jᵒᵖ ⥤ C` into a colimit of `F : J ⥤ Cᵒᵖ`. -/
@[simps]
def isColimitCoconeOfConeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cone F.leftOp} (hc : IsLimit c) :
    IsColimit (coconeOfConeLeftOp c) 
goal: (CategoryTheory.Limits.isColimitCoconeOfConeLeftOp F hc).desc s =
  (hc.lift (CategoryTheory.Limits.coneLeftOpOfCocone s)).op

full_name: CategoryTheory.Limits.isColimitCoconeOfConeLeftOp
code: /-- Turn a limit of `F.leftOp : Jᵒᵖ ⥤ C` into a colimit of `F : J ⥤ Cᵒᵖ`. -/
@[simps]
def isColimitCoconeOfConeLeftOp (F : J ⥤ Cᵒᵖ) {c : Cone F.leftOp} (hc : IsLimit c) :
    IsColimit (coconeOfConeLeftOp c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeOfConeLeftOp c)

full_name: CategoryTheory.Limits.isLimitConeOfCoconeRightOp_lift
code: /-- Turn a colimit for `F.rightOp : J ⥤ Cᵒᵖ` into a limit for `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def isLimitConeOfCoconeRightOp (F : Jᵒᵖ ⥤ C) {c : Cocone F.rightOp} (hc : IsColimit c) :
    IsLimit (coneOfCoconeRightOp c) 
goal: (CategoryTheory.Limits.isLimitConeOfCoconeRightOp F hc).lift s =
  (hc.desc (CategoryTheory.Limits.coconeRightOpOfCone s)).unop

full_name: CategoryTheory.Limits.isLimitConeOfCoconeRightOp
code: /-- Turn a colimit for `F.rightOp : J ⥤ Cᵒᵖ` into a limit for `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def isLimitConeOfCoconeRightOp (F : Jᵒᵖ ⥤ C) {c : Cocone F.rightOp} (hc : IsColimit c) :
    IsLimit (coneOfCoconeRightOp c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfCoconeRightOp c)

full_name: CategoryTheory.Limits.isColimitCoconeOfConeRightOp
code: /-- Turn a limit for `F.rightOp : J ⥤ Cᵒᵖ` into a limit for `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def isColimitCoconeOfConeRightOp (F : Jᵒᵖ ⥤ C) {c : Cone F.rightOp} (hc : IsLimit c) :
    IsColimit (coconeOfConeRightOp c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeOfConeRightOp c)

full_name: CategoryTheory.Limits.isColimitCoconeOfConeRightOp_desc
code: /-- Turn a limit for `F.rightOp : J ⥤ Cᵒᵖ` into a limit for `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def isColimitCoconeOfConeRightOp (F : Jᵒᵖ ⥤ C) {c : Cone F.rightOp} (hc : IsLimit c) :
    IsColimit (coconeOfConeRightOp c) 
goal: (CategoryTheory.Limits.isColimitCoconeOfConeRightOp F hc).desc s =
  (hc.lift (CategoryTheory.Limits.coneRightOpOfCocone s)).unop

full_name: CategoryTheory.Limits.isLimitConeOfCoconeUnop_lift
code: /-- 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) :
    IsLimit (coneOfCoconeUnop c) 
goal: (CategoryTheory.Limits.isLimitConeOfCoconeUnop F hc).lift s = (hc.desc (CategoryTheory.Limits.coconeUnopOfCone s)).op

full_name: CategoryTheory.Limits.isLimitConeOfCoconeUnop
code: /-- 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) :
    IsLimit (coneOfCoconeUnop c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfCoconeUnop c)

full_name: CategoryTheory.Limits.isColimitConeOfCoconeUnop_desc
code: /-- 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) :
    IsColimit (coconeOfConeUnop c) 
goal: (CategoryTheory.Limits.isColimitConeOfCoconeUnop F hc).desc s = (hc.lift (CategoryTheory.Limits.coneUnopOfCocone s)).op

full_name: CategoryTheory.Limits.isColimitConeOfCoconeUnop
code: /-- 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) :
    IsColimit (coconeOfConeUnop c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeOfConeUnop c)

full_name: CategoryTheory.Limits.hasLimit_of_hasColimit_leftOp
code: /-- If `F.leftOp : 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 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.hasLimit_of_hasColimit_op
code: theorem hasLimit_of_hasColimit_op (F : J ⥤ C) [HasColimit F.op] : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.hasLimit_op_of_hasColimit
code: theorem hasLimit_op_of_hasColimit (F : J ⥤ C) [HasColimit F] : HasLimit F.op 
goal: CategoryTheory.Limits.HasLimit F.op

full_name: CategoryTheory.Limits.hasLimitsOfShape_op_of_hasColimitsOfShape
code: /-- 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ᵒᵖ 
goal: CategoryTheory.Limits.HasLimitsOfShape J Cᵒᵖ

full_name: CategoryTheory.Limits.hasLimitsOfShape_of_hasColimitsOfShape_op
code: theorem hasLimitsOfShape_of_hasColimitsOfShape_op [HasColimitsOfShape Jᵒᵖ Cᵒᵖ] :
    HasLimitsOfShape J C 
goal: CategoryTheory.Limits.HasLimitsOfShape J C

full_name: CategoryTheory.Limits.hasLimits_op_of_hasColimits
code: /-- If `C` has colimits, we can construct limits for `Cᵒᵖ`.
-/
instance hasLimits_op_of_hasColimits [HasColimits C] : HasLimits Cᵒᵖ 
goal: CategoryTheory.Limits.HasLimits Cᵒᵖ

full_name: CategoryTheory.Limits.hasLimits_of_hasColimits_op
code: theorem hasLimits_of_hasColimits_op [HasColimits Cᵒᵖ] : HasLimits C 
goal: CategoryTheory.Limits.HasLimits C

full_name: CategoryTheory.Limits.has_cofiltered_limits_op_of_has_filtered_colimits
code: instance has_cofiltered_limits_op_of_has_filtered_colimits [HasFilteredColimitsOfSize.{v₂, u₂} C] :
    HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ 
goal: CategoryTheory.Limits.HasCofilteredLimitsOfSize.{v₂, u₂, v₁, u₁} Cᵒᵖ

full_name: CategoryTheory.Limits.has_cofiltered_limits_of_has_filtered_colimits_op
code: theorem has_cofiltered_limits_of_has_filtered_colimits_op [HasFilteredColimitsOfSize.{v₂, u₂} Cᵒᵖ] :
    HasCofilteredLimitsOfSize.{v₂, u₂} C 
goal: CategoryTheory.Limits.HasCofilteredLimitsOfSize.{v₂, u₂, v₁, u₁} C

full_name: CategoryTheory.Limits.hasColimit_of_hasLimit_leftOp
code: /-- If `F.leftOp : 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 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.hasColimit_of_hasLimit_op
code: theorem hasColimit_of_hasLimit_op (F : J ⥤ C) [HasLimit F.op] : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.hasColimit_op_of_hasLimit
code: theorem hasColimit_op_of_hasLimit (F : J ⥤ C) [HasLimit F] : HasColimit F.op 
goal: CategoryTheory.Limits.HasColimit F.op

full_name: CategoryTheory.Limits.hasColimitsOfShape_op_of_hasLimitsOfShape
code: /-- 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ᵒᵖ 
goal: CategoryTheory.Limits.HasColimitsOfShape J Cᵒᵖ

full_name: CategoryTheory.Limits.hasColimitsOfShape_of_hasLimitsOfShape_op
code: theorem hasColimitsOfShape_of_hasLimitsOfShape_op [HasLimitsOfShape Jᵒᵖ Cᵒᵖ] :
    HasColimitsOfShape J C 
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Limits.hasColimits_op_of_hasLimits
code: /-- If `C` has limits, we can construct colimits for `Cᵒᵖ`.
-/
instance hasColimits_op_of_hasLimits [HasLimits C] : HasColimits Cᵒᵖ 
goal: CategoryTheory.Limits.HasColimits Cᵒᵖ

full_name: CategoryTheory.Limits.hasColimits_of_hasLimits_op
code: theorem hasColimits_of_hasLimits_op [HasLimits Cᵒᵖ] : HasColimits C 
goal: CategoryTheory.Limits.HasColimits C

full_name: CategoryTheory.Limits.has_filtered_colimits_op_of_has_cofiltered_limits
code: instance has_filtered_colimits_op_of_has_cofiltered_limits [HasCofilteredLimitsOfSize.{v₂, u₂} C] :
    HasFilteredColimitsOfSize.{v₂, u₂} Cᵒᵖ 
goal: CategoryTheory.Limits.HasFilteredColimitsOfSize.{v₂, u₂, v₁, u₁} Cᵒᵖ

full_name: CategoryTheory.Limits.has_filtered_colimits_of_has_cofiltered_limits_op
code: theorem has_filtered_colimits_of_has_cofiltered_limits_op [HasCofilteredLimitsOfSize.{v₂, u₂} Cᵒᵖ] :
    HasFilteredColimitsOfSize.{v₂, u₂} C 
goal: CategoryTheory.Limits.HasFilteredColimitsOfSize.{v₂, u₂, v₁, u₁} C

full_name: CategoryTheory.Limits.hasCoproductsOfShape_opposite
code: /-- If `C` has products indexed by `X`, then `Cᵒᵖ` has coproducts indexed by `X`.
-/
instance hasCoproductsOfShape_opposite [HasProductsOfShape X C] : HasCoproductsOfShape X Cᵒᵖ 
goal: CategoryTheory.Limits.HasCoproductsOfShape X Cᵒᵖ

full_name: CategoryTheory.Limits.hasCoproductsOfShape_of_opposite
code: theorem hasCoproductsOfShape_of_opposite [HasProductsOfShape X Cᵒᵖ] : HasCoproductsOfShape X C 
goal: CategoryTheory.Limits.HasCoproductsOfShape X C

full_name: CategoryTheory.Limits.hasProductsOfShape_opposite
code: /-- If `C` has coproducts indexed by `X`, then `Cᵒᵖ` has products indexed by `X`.
-/
instance hasProductsOfShape_opposite [HasCoproductsOfShape X C] : HasProductsOfShape X Cᵒᵖ 
goal: CategoryTheory.Limits.HasProductsOfShape X Cᵒᵖ

full_name: CategoryTheory.Limits.hasProductsOfShape_of_opposite
code: theorem hasProductsOfShape_of_opposite [HasCoproductsOfShape X Cᵒᵖ] : HasProductsOfShape X C 
goal: CategoryTheory.Limits.HasProductsOfShape X C

full_name: CategoryTheory.Limits.hasProducts_opposite
code: instance hasProducts_opposite [HasCoproducts.{v₂} C] : HasProducts.{v₂} Cᵒᵖ 
goal: CategoryTheory.Limits.HasProducts Cᵒᵖ

full_name: CategoryTheory.Limits.hasProducts_of_opposite
code: theorem hasProducts_of_opposite [HasCoproducts.{v₂} Cᵒᵖ] : HasProducts.{v₂} C 
goal: CategoryTheory.Limits.HasProducts C

full_name: CategoryTheory.Limits.hasCoproducts_opposite
code: instance hasCoproducts_opposite [HasProducts.{v₂} C] : HasCoproducts.{v₂} Cᵒᵖ 
goal: CategoryTheory.Limits.HasCoproducts Cᵒᵖ

full_name: CategoryTheory.Limits.hasCoproducts_of_opposite
code: theorem hasCoproducts_of_opposite [HasProducts.{v₂} Cᵒᵖ] : HasCoproducts.{v₂} C 
goal: CategoryTheory.Limits.HasCoproducts C

full_name: CategoryTheory.Limits.hasFiniteCoproducts_opposite
code: instance hasFiniteCoproducts_opposite [HasFiniteProducts C] : HasFiniteCoproducts Cᵒᵖ 
goal: CategoryTheory.Limits.HasFiniteCoproducts Cᵒᵖ

full_name: CategoryTheory.Limits.hasFiniteCoproducts_of_opposite
code: theorem hasFiniteCoproducts_of_opposite [HasFiniteProducts Cᵒᵖ] : HasFiniteCoproducts C 
goal: CategoryTheory.Limits.HasFiniteCoproducts C

full_name: CategoryTheory.Limits.hasFiniteProducts_opposite
code: instance hasFiniteProducts_opposite [HasFiniteCoproducts C] : HasFiniteProducts Cᵒᵖ 
goal: CategoryTheory.Limits.HasFiniteProducts Cᵒᵖ

full_name: CategoryTheory.Limits.hasFiniteProducts_of_opposite
code: theorem hasFiniteProducts_of_opposite [HasFiniteCoproducts Cᵒᵖ] : HasFiniteProducts C 
goal: CategoryTheory.Limits.HasFiniteProducts C

full_name: CategoryTheory.Limits.instHasLimitOppositeDiscreteOpFunctor
code: instance : HasLimit (Discrete.functor Z).op 
goal: CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor Z).op

full_name: CategoryTheory.Limits.instHasLimitDiscreteOppositeCompInverseOppositeOpFunctor
code: instance : HasLimit ((Discrete.opposite α).inverse ⋙ (Discrete.functor Z).op) 
goal: CategoryTheory.Limits.HasLimit ((CategoryTheory.Discrete.opposite α).inverse ⋙ (CategoryTheory.Discrete.functor Z).op)

full_name: CategoryTheory.Limits.instHasProductOppositeOp
code: instance : HasProduct (op <| Z ·) 
goal: CategoryTheory.Limits.HasProduct fun x => Opposite.op (Z x)

full_name: CategoryTheory.Limits.Cofan.op
code: /-- A `Cofan` gives a `Fan` in the opposite category.  -/
@[simp]
def Cofan.op (c : Cofan Z) : Fan (op <| Z ·) 
goal: CategoryTheory.Limits.Fan fun x => Opposite.op (Z x)

full_name: CategoryTheory.Limits.Cofan.IsColimit.op
code: /-- If a `Cofan` is colimit, then its opposite is limit. -/
def Cofan.IsColimit.op {c : Cofan Z} (hc : IsColimit c) : IsLimit c.op 
goal: CategoryTheory.Limits.IsLimit c.op

full_name: CategoryTheory.Limits.opCoproductIsoProduct'
code: /--
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 
goal: Opposite.op c.pt ≅ f.pt

full_name: CategoryTheory.Limits.opCoproductIsoProduct
code: /--
The canonical isomorphism from the opposite of the coproduct to the product in the opposite
category.
-/
def opCoproductIsoProduct :
    op (∐ Z) ≅ ∏ᶜ (op <| Z ·) 
goal: Opposite.op (∐ Z) ≅ ∏ᶜ fun x => Opposite.op (Z x)

full_name: CategoryTheory.Limits.opCoproductIsoProduct'_inv_comp_inj
code: 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 
goal: (CategoryTheory.Limits.opCoproductIsoProduct' hc hf).inv ≫ (c.inj b).op = f.proj b

full_name: CategoryTheory.Limits.opCoproductIsoProduct'_comp_self
code: 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 
goal: (CategoryTheory.Limits.opCoproductIsoProduct' hc hf).hom ≫ (CategoryTheory.Limits.opCoproductIsoProduct' hc' hf).inv =
  (hc.coconePointUniqueUpToIso hc').op.inv

full_name: CategoryTheory.Limits.opCoproductIsoProduct_inv_comp_ι
code: theorem opCoproductIsoProduct_inv_comp_ι [HasCoproduct Z] (b : α) :
    (opCoproductIsoProduct Z).inv ≫ (Sigma.ι Z b).op = Pi.π (op <| Z ·) b 
goal: (CategoryTheory.Limits.opCoproductIsoProduct Z).inv ≫ (CategoryTheory.Limits.Sigma.ι Z b).op =
  CategoryTheory.Limits.Pi.π (fun x => Opposite.op (Z x)) b

full_name: CategoryTheory.Limits.desc_op_comp_opCoproductIsoProduct'_hom
code: 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 
goal: (hc.desc c').op ≫ (CategoryTheory.Limits.opCoproductIsoProduct' hc hf).hom = hf.lift c'.op

full_name: CategoryTheory.Limits.desc_op_comp_opCoproductIsoProduct_hom
code: theorem desc_op_comp_opCoproductIsoProduct_hom [HasCoproduct Z] {X : C} (π : (a : α) → Z a ⟶ X) :
    (Sigma.desc π).op ≫ (opCoproductIsoProduct Z).hom = Pi.lift (fun a ↦ (π a).op) 
goal: (CategoryTheory.Limits.Sigma.desc π).op ≫ (CategoryTheory.Limits.opCoproductIsoProduct Z).hom =
  CategoryTheory.Limits.Pi.lift fun a => (π a).op

full_name: CategoryTheory.Limits.instHasColimitOppositeDiscreteOpFunctor
code: instance : HasColimit (Discrete.functor Z).op 
goal: CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor Z).op

full_name: CategoryTheory.Limits.instHasColimitDiscreteOppositeCompInverseOppositeOpFunctor
code: instance : HasColimit ((Discrete.opposite α).inverse ⋙ (Discrete.functor Z).op) 
goal: CategoryTheory.Limits.HasColimit ((CategoryTheory.Discrete.opposite α).inverse ⋙ (CategoryTheory.Discrete.functor Z).op)

full_name: CategoryTheory.Limits.instHasCoproductOppositeOp
code: instance : HasCoproduct (op <| Z ·) 
goal: CategoryTheory.Limits.HasCoproduct fun x => Opposite.op (Z x)

full_name: CategoryTheory.Limits.Fan.op
code: /-- A `Fan` gives a `Cofan` in the opposite category. -/
@[simp]
def Fan.op (f : Fan Z) : Cofan (op <| Z ·) 
goal: CategoryTheory.Limits.Cofan fun x => Opposite.op (Z x)

full_name: CategoryTheory.Limits.Fan.IsLimit.op
code: /-- If a `Fan` is limit, then its opposite is colimit. -/
def Fan.IsLimit.op {f : Fan Z} (hf : IsLimit f) : IsColimit f.op 
goal: CategoryTheory.Limits.IsColimit f.op

full_name: CategoryTheory.Limits.opProductIsoCoproduct'
code: /--
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 
goal: Opposite.op f.pt ≅ c.pt

full_name: CategoryTheory.Limits.opProductIsoCoproduct
code: /--
The canonical isomorphism from the opposite of the product to the coproduct in the opposite
category.
-/
def opProductIsoCoproduct :
    op (∏ᶜ Z) ≅ ∐ (op <| Z ·) 
goal: Opposite.op (∏ᶜ Z) ≅ ∐ fun x => Opposite.op (Z x)

full_name: CategoryTheory.Limits.proj_comp_opProductIsoCoproduct'_hom
code: 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 
goal: (f.proj b).op ≫ (CategoryTheory.Limits.opProductIsoCoproduct' hf hc).hom = c.inj b

full_name: CategoryTheory.Limits.opProductIsoCoproduct'_comp_self
code: 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 
goal: (CategoryTheory.Limits.opProductIsoCoproduct' hf hc).hom ≫ (CategoryTheory.Limits.opProductIsoCoproduct' hf' hc).inv =
  (hf.conePointUniqueUpToIso hf').op.inv

full_name: CategoryTheory.Limits.π_comp_opProductIsoCoproduct_hom
code: theorem π_comp_opProductIsoCoproduct_hom [HasProduct Z] (b : α) :
    (Pi.π Z b).op ≫ (opProductIsoCoproduct Z).hom = Sigma.ι (op <| Z ·) b 
goal: (CategoryTheory.Limits.Pi.π Z b).op ≫ (CategoryTheory.Limits.opProductIsoCoproduct Z).hom =
  CategoryTheory.Limits.Sigma.ι (fun x => Opposite.op (Z x)) b

full_name: CategoryTheory.Limits.opProductIsoCoproduct'_inv_comp_lift
code: 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 
goal: (CategoryTheory.Limits.opProductIsoCoproduct' hf hc).inv ≫ (hf.lift f').op = hc.desc f'.op

full_name: CategoryTheory.Limits.opProductIsoCoproduct_inv_comp_lift
code: theorem opProductIsoCoproduct_inv_comp_lift [HasProduct Z] {X : C} (π : (a : α) → X ⟶ Z a) :
    (opProductIsoCoproduct Z).inv ≫ (Pi.lift π).op  = Sigma.desc (fun a ↦ (π a).op) 
goal: (CategoryTheory.Limits.opProductIsoCoproduct Z).inv ≫ (CategoryTheory.Limits.Pi.lift π).op =
  CategoryTheory.Limits.Sigma.desc fun a => (π a).op

full_name: CategoryTheory.Limits.hasEqualizers_opposite
code: instance hasEqualizers_opposite [HasCoequalizers C] : HasEqualizers Cᵒᵖ 
goal: CategoryTheory.Limits.HasEqualizers Cᵒᵖ

full_name: CategoryTheory.Limits.hasCoequalizers_opposite
code: instance hasCoequalizers_opposite [HasEqualizers C] : HasCoequalizers Cᵒᵖ 
goal: CategoryTheory.Limits.HasCoequalizers Cᵒᵖ

full_name: CategoryTheory.Limits.hasFiniteColimits_opposite
code: instance hasFiniteColimits_opposite [HasFiniteLimits C] : HasFiniteColimits Cᵒᵖ 
goal: CategoryTheory.Limits.HasFiniteColimits Cᵒᵖ

full_name: CategoryTheory.Limits.hasFiniteLimits_opposite
code: instance hasFiniteLimits_opposite [HasFiniteColimits C] : HasFiniteLimits Cᵒᵖ 
goal: CategoryTheory.Limits.HasFiniteLimits Cᵒᵖ

full_name: CategoryTheory.Limits.hasPullbacks_opposite
code: instance hasPullbacks_opposite [HasPushouts C] : HasPullbacks Cᵒᵖ 
goal: CategoryTheory.Limits.HasPullbacks Cᵒᵖ

full_name: CategoryTheory.Limits.hasPushouts_opposite
code: instance hasPushouts_opposite [HasPullbacks C] : HasPushouts Cᵒᵖ 
goal: CategoryTheory.Limits.HasPushouts Cᵒᵖ

full_name: CategoryTheory.Limits.spanOp_inv_app
code: /-- 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) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpan),
  (CategoryTheory.Limits.spanOp f g).inv.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
            (CategoryTheory.Iso.refl (Opposite.op Y)) val)
        X_1).inv

full_name: CategoryTheory.Limits.spanOp_hom_app
code: /-- 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) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpan),
  (CategoryTheory.Limits.spanOp f g).hom.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
            (CategoryTheory.Iso.refl (Opposite.op Y)) val)
        X_1).hom

full_name: CategoryTheory.Limits.spanOp
code: /-- 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) :
    span f.op g.op ≅ walkingCospanOpEquiv.inverse ⋙ (cospan f g).op 
goal: CategoryTheory.Limits.span f.op g.op ≅
  CategoryTheory.Limits.walkingCospanOpEquiv.inverse ⋙ (CategoryTheory.Limits.cospan f g).op

full_name: CategoryTheory.Limits.opCospan_hom_app
code: /-- 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) :
    (cospan f g).op ≅ walkingCospanOpEquiv.functor ⋙ span f.op g.op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospanᵒᵖ),
  (CategoryTheory.Limits.opCospan f g).hom.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
            (CategoryTheory.Iso.refl (Opposite.op Y)) val)
        (Opposite.unop X_1)).inv

full_name: CategoryTheory.Limits.opCospan
code: /-- 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) :
    (cospan f g).op ≅ walkingCospanOpEquiv.functor ⋙ span f.op g.op 
goal: (CategoryTheory.Limits.cospan f g).op ≅
  CategoryTheory.Limits.walkingCospanOpEquiv.functor ⋙ CategoryTheory.Limits.span f.op g.op

full_name: CategoryTheory.Limits.opCospan_inv_app
code: /-- 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) :
    (cospan f g).op ≅ walkingCospanOpEquiv.functor ⋙ span f.op g.op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospanᵒᵖ),
  (CategoryTheory.Limits.opCospan f g).inv.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
            (CategoryTheory.Iso.refl (Opposite.op Y)) val)
        (Opposite.unop X_1)).hom

full_name: CategoryTheory.Limits.cospanOp_hom_app
code: /-- 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) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospan),
  (CategoryTheory.Limits.cospanOp f g).hom.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
            (CategoryTheory.Iso.refl (Opposite.op Z)) val)
        X_1).hom

full_name: CategoryTheory.Limits.cospanOp_inv_app
code: /-- 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) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospan),
  (CategoryTheory.Limits.cospanOp f g).inv.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
            (CategoryTheory.Iso.refl (Opposite.op Z)) val)
        X_1).inv

full_name: CategoryTheory.Limits.cospanOp
code: /-- 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) :
    cospan f.op g.op ≅ walkingSpanOpEquiv.inverse ⋙ (span f g).op 
goal: CategoryTheory.Limits.cospan f.op g.op ≅
  CategoryTheory.Limits.walkingSpanOpEquiv.inverse ⋙ (CategoryTheory.Limits.span f g).op

full_name: CategoryTheory.Limits.opSpan_hom_app
code: /-- 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) :
    (span f g).op ≅ walkingSpanOpEquiv.functor ⋙ cospan f.op g.op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpanᵒᵖ),
  (CategoryTheory.Limits.opSpan f g).hom.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
            (CategoryTheory.Iso.refl (Opposite.op Z)) val)
        (Opposite.unop X_1)).inv

full_name: CategoryTheory.Limits.opSpan_inv_app
code: /-- 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) :
    (span f g).op ≅ walkingSpanOpEquiv.functor ⋙ cospan f.op g.op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpanᵒᵖ),
  (CategoryTheory.Limits.opSpan f g).inv.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
        (fun val =>
          CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
            (CategoryTheory.Iso.refl (Opposite.op Z)) val)
        (Opposite.unop X_1)).hom

full_name: CategoryTheory.Limits.opSpan
code: /-- 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) :
    (span f g).op ≅ walkingSpanOpEquiv.functor ⋙ cospan f.op g.op 
goal: (CategoryTheory.Limits.span f g).op ≅
  CategoryTheory.Limits.walkingSpanOpEquiv.functor ⋙ CategoryTheory.Limits.cospan f.op g.op

full_name: CategoryTheory.Limits.PushoutCocone.unop
code: /-- 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) :
    PullbackCone f.unop g.unop 
goal: CategoryTheory.Limits.PullbackCone f.unop g.unop

full_name: CategoryTheory.Limits.PushoutCocone.unop_π_app
code: /-- 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) :
    PullbackCone f.unop g.unop 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospan),
  c.unop.π.app X_1 =
    (c.ι.app X_1).unop ≫
      (Option.rec (CategoryTheory.Iso.refl X)
            (fun val =>
              CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl Y) (CategoryTheory.Iso.refl Z) val)
            X_1).inv.unop

full_name: CategoryTheory.Limits.PushoutCocone.unop_pt
code: /-- 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) :
    PullbackCone f.unop g.unop 
goal: c.unop.pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.PushoutCocone.unop_fst
code: theorem unop_fst {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.unop.fst = c.inl.unop 
goal: c.unop.fst = c.inl.unop

full_name: CategoryTheory.Limits.PushoutCocone.unop_snd
code: theorem unop_snd {X Y Z : Cᵒᵖ} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.unop.snd = c.inr.unop 
goal: c.unop.snd = c.inr.unop

full_name: CategoryTheory.Limits.PushoutCocone.op_π_app
code: /-- 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 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingCospan),
  c.op.π.app X_1 =
    (c.ι.app X_1).op ≫
      (Option.rec (CategoryTheory.Iso.refl (Opposite.op X))
          (fun val =>
            CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op Y))
              (CategoryTheory.Iso.refl (Opposite.op Z)) val)
          X_1).inv

full_name: CategoryTheory.Limits.PushoutCocone.op
code: /-- 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 
goal: CategoryTheory.Limits.PullbackCone f.op g.op

full_name: CategoryTheory.Limits.PushoutCocone.op_pt
code: /-- 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 
goal: c.op.pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.PushoutCocone.op_fst
code: theorem op_fst {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.op.fst = c.inl.op 
goal: c.op.fst = c.inl.op

full_name: CategoryTheory.Limits.PushoutCocone.op_snd
code: theorem op_snd {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} (c : PushoutCocone f g) :
    c.op.snd = c.inr.op 
goal: c.op.snd = c.inr.op

full_name: CategoryTheory.Limits.PullbackCone.unop
code: /-- 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) :
    PushoutCocone f.unop g.unop 
goal: CategoryTheory.Limits.PushoutCocone f.unop g.unop

full_name: CategoryTheory.Limits.PullbackCone.unop_ι_app
code: /-- 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) :
    PushoutCocone f.unop g.unop 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpan),
  c.unop.ι.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl Z)
            (fun val =>
              CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl X) (CategoryTheory.Iso.refl Y) val)
            X_1).hom.unop ≫
      (c.π.app X_1).unop

full_name: CategoryTheory.Limits.PullbackCone.unop_pt
code: /-- 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) :
    PushoutCocone f.unop g.unop 
goal: c.unop.pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.PullbackCone.unop_inl
code: theorem unop_inl {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.unop.inl = c.fst.unop 
goal: c.unop.inl = c.fst.unop

full_name: CategoryTheory.Limits.PullbackCone.unop_inr
code: theorem unop_inr {X Y Z : Cᵒᵖ} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.unop.inr = c.snd.unop 
goal: c.unop.inr = c.snd.unop

full_name: CategoryTheory.Limits.PullbackCone.op_pt
code: /-- The obvious map `PullbackCone f g → PushoutCocone f.op g.op` -/
@[simps!]
def op {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : PushoutCocone f.op g.op 
goal: c.op.pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.PullbackCone.op
code: /-- The obvious map `PullbackCone f g → PushoutCocone f.op g.op` -/
@[simps!]
def op {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : PushoutCocone f.op g.op 
goal: CategoryTheory.Limits.PushoutCocone f.op g.op

full_name: CategoryTheory.Limits.PullbackCone.op_ι_app
code: /-- The obvious map `PullbackCone f g → PushoutCocone f.op g.op` -/
@[simps!]
def op {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) : PushoutCocone f.op g.op 
goal: ∀ (X_1 : CategoryTheory.Limits.WalkingSpan),
  c.op.ι.app X_1 =
    (Option.rec (CategoryTheory.Iso.refl (Opposite.op Z))
          (fun val =>
            CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Iso.refl (Opposite.op X))
              (CategoryTheory.Iso.refl (Opposite.op Y)) val)
          X_1).hom ≫
      (c.π.app X_1).op

full_name: CategoryTheory.Limits.PullbackCone.op_inl
code: theorem op_inl {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.op.inl = c.fst.op 
goal: c.op.inl = c.fst.op

full_name: CategoryTheory.Limits.PullbackCone.op_inr
code: theorem op_inr {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z} (c : PullbackCone f g) :
    c.op.inr = c.snd.op 
goal: c.op.inr = c.snd.op

full_name: CategoryTheory.Limits.PullbackCone.opUnop
code: /-- 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 
goal: c.op.unop ≅ c

full_name: CategoryTheory.Limits.PullbackCone.unopOp
code: /-- 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 
goal: c.unop.op ≅ c

full_name: CategoryTheory.Limits.PushoutCocone.opUnop
code: /-- 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 
goal: c.op.unop ≅ c

full_name: CategoryTheory.Limits.PushoutCocone.unopOp
code: /-- 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 
goal: c.unop.op ≅ c

full_name: CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitOp
code: /-- 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) :
    IsColimit c ≃ IsLimit c.op 
goal: CategoryTheory.Limits.IsColimit c ≃ CategoryTheory.Limits.IsLimit c.op

full_name: CategoryTheory.Limits.PushoutCocone.isColimitEquivIsLimitUnop
code: /-- 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) :
    IsColimit c ≃ IsLimit c.unop 
goal: CategoryTheory.Limits.IsColimit c ≃ CategoryTheory.Limits.IsLimit c.unop

full_name: CategoryTheory.Limits.PullbackCone.isLimitEquivIsColimitOp
code: /-- 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 
goal: CategoryTheory.Limits.IsLimit c ≃ CategoryTheory.Limits.IsColimit c.op

full_name: CategoryTheory.Limits.PullbackCone.isLimitEquivIsColimitUnop
code: /-- 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 
goal: CategoryTheory.Limits.IsLimit c ≃ CategoryTheory.Limits.IsColimit c.unop

full_name: CategoryTheory.Limits.pullbackIsoUnopPushout
code: /-- 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) [h : HasPullback f g]
    [HasPushout f.op g.op] : pullback f g ≅ unop (pushout f.op g.op) 
goal: CategoryTheory.Limits.pullback f g ≅ Opposite.unop (CategoryTheory.Limits.pushout f.op g.op)

full_name: CategoryTheory.Limits.pullbackIsoUnopPushout_inv_fst
code: @[reassoc (attr := simp)]
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 f g =
      (pushout.inl _ _ : _ ⟶ pushout f.op g.op).unop 
goal: (CategoryTheory.Limits.pullbackIsoUnopPushout f g).inv ≫ CategoryTheory.Limits.pullback.fst f g =
  (CategoryTheory.Limits.pushout.inl f.op g.op).unop

full_name: CategoryTheory.Limits.pullbackIsoUnopPushout_inv_snd
code: @[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 f g =
      (pushout.inr _ _ : _ ⟶ pushout f.op g.op).unop 
goal: (CategoryTheory.Limits.pullbackIsoUnopPushout f g).inv ≫ CategoryTheory.Limits.pullback.snd f g =
  (CategoryTheory.Limits.pushout.inr f.op g.op).unop

full_name: CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inl
code: @[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 f g).op 
goal: CategoryTheory.Limits.pushout.inl f.op g.op ≫ (CategoryTheory.Limits.pullbackIsoUnopPushout f g).hom.op =
  (CategoryTheory.Limits.pullback.fst f g).op

full_name: CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inr
code: @[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 f g).op 
goal: CategoryTheory.Limits.pushout.inr f.op g.op ≫ (CategoryTheory.Limits.pullbackIsoUnopPushout f g).hom.op =
  (CategoryTheory.Limits.pullback.snd f g).op

full_name: CategoryTheory.Limits.pushoutIsoUnopPullback
code: /-- 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) [h : HasPushout f g]
    [HasPullback f.op g.op] : pushout f g ≅ unop (pullback f.op g.op) 
goal: CategoryTheory.Limits.pushout f g ≅ Opposite.unop (CategoryTheory.Limits.pullback f.op g.op)

full_name: CategoryTheory.Limits.pushoutIsoUnopPullback_inl_hom
code: @[reassoc (attr := simp)]
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 f.op g.op).unop 
goal: CategoryTheory.Limits.pushout.inl f g ≫ (CategoryTheory.Limits.pushoutIsoUnopPullback f g).hom =
  (CategoryTheory.Limits.pullback.fst f.op g.op).unop

full_name: CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom
code: @[reassoc (attr := simp)]
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 f.op g.op).unop 
goal: CategoryTheory.Limits.pushout.inr f g ≫ (CategoryTheory.Limits.pushoutIsoUnopPullback f g).hom =
  (CategoryTheory.Limits.pullback.snd f.op g.op).unop

full_name: CategoryTheory.Limits.pushoutIsoUnopPullback_inv_fst
code: @[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 f.op g.op = (pushout.inl f g).op 
goal: (CategoryTheory.Limits.pushoutIsoUnopPullback f g).inv.op ≫ CategoryTheory.Limits.pullback.fst f.op g.op =
  (CategoryTheory.Limits.pushout.inl f g).op

full_name: CategoryTheory.Limits.pushoutIsoUnopPullback_inv_snd
code: @[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 f.op g.op = (pushout.inr f g).op 
goal: (CategoryTheory.Limits.pushoutIsoUnopPullback f g).inv.op ≫ CategoryTheory.Limits.pullback.snd f.op g.op =
  (CategoryTheory.Limits.pushout.inr f g).op

full_name: CategoryTheory.Limits.CokernelCofork.IsColimit.ofπOp
code: /-- 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])) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι p.op ⋯)

full_name: CategoryTheory.Limits.CokernelCofork.IsColimit.ofπUnop
code: /-- 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])) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι p.unop ⋯)

full_name: CategoryTheory.Limits.KernelFork.IsLimit.ofιOp
code: /-- 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])) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ i.op ⋯)

full_name: CategoryTheory.Limits.KernelFork.IsLimit.ofιUnop
code: /-- 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])) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ i.unop ⋯)