File: Mathlib/CategoryTheory/Limits/Cones.lean

full_name: CategoryTheory.Functor.cones
code: /-- If `F : J ⥤ C` then `F.cones` is the functor assigning to an object `X : C` the
type of natural transformations from the constant functor with value `X` to `F`.
An object representing this functor is a limit of `F`.
-/
@[simps!]
def cones : Cᵒᵖ ⥤ Type max u₁ v₃ 
goal: Cᵒᵖ ⥤ Type (max u₁ v₃)

full_name: CategoryTheory.Functor.cones_map_app
code: /-- If `F : J ⥤ C` then `F.cones` is the functor assigning to an object `X : C` the
type of natural transformations from the constant functor with value `X` to `F`.
An object representing this functor is a limit of `F`.
-/
@[simps!]
def cones : Cᵒᵖ ⥤ Type max u₁ v₃ 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (a : (CategoryTheory.yoneda.obj F).obj ((CategoryTheory.Functor.const J).op.obj X)) (X_1 : J),
  (F.cones.map f a).app X_1 = f.unop ≫ a.app X_1

full_name: CategoryTheory.Functor.cones_obj
code: /-- If `F : J ⥤ C` then `F.cones` is the functor assigning to an object `X : C` the
type of natural transformations from the constant functor with value `X` to `F`.
An object representing this functor is a limit of `F`.
-/
@[simps!]
def cones : Cᵒᵖ ⥤ Type max u₁ v₃ 
goal: F.cones.obj X = ((CategoryTheory.Functor.const J).obj (Opposite.unop X) ⟶ F)

full_name: CategoryTheory.Functor.cocones_map_app
code: /-- If `F : J ⥤ C` then `F.cocones` is the functor assigning to an object `(X : C)`
the type of natural transformations from `F` to the constant functor with value `X`.
An object corepresenting this functor is a colimit of `F`.
-/
@[simps!]
def cocones : C ⥤ Type max u₁ v₃ 
goal: ∀ {X Y : C} (f : X ⟶ Y) (a : (CategoryTheory.coyoneda.obj (Opposite.op F)).obj ((CategoryTheory.Functor.const J).obj X))
  (X_1 : J), (F.cocones.map f a).app X_1 = a.app X_1 ≫ f

full_name: CategoryTheory.Functor.cocones_obj
code: /-- If `F : J ⥤ C` then `F.cocones` is the functor assigning to an object `(X : C)`
the type of natural transformations from `F` to the constant functor with value `X`.
An object corepresenting this functor is a colimit of `F`.
-/
@[simps!]
def cocones : C ⥤ Type max u₁ v₃ 
goal: F.cocones.obj X = (F ⟶ (CategoryTheory.Functor.const J).obj X)

full_name: CategoryTheory.Functor.cocones
code: /-- If `F : J ⥤ C` then `F.cocones` is the functor assigning to an object `(X : C)`
the type of natural transformations from `F` to the constant functor with value `X`.
An object corepresenting this functor is a colimit of `F`.
-/
@[simps!]
def cocones : C ⥤ Type max u₁ v₃ 
goal: C ⥤ Type (max u₁ v₃)

full_name: CategoryTheory.cones_map_app_app
code: /-- Functorially associated to each functor `J ⥤ C`, we have the `C`-presheaf consisting of
cones with a given cone point.
-/
@[simps!]
def cones : (J ⥤ C) ⥤ Cᵒᵖ ⥤ Type max u₁ v₃ 
goal: ∀ {X Y : J ⥤ C} (f : X ⟶ Y) (X_1 : Cᵒᵖ)
  (a : (CategoryTheory.yoneda.obj X).obj ((CategoryTheory.Functor.const J).op.obj X_1)) (X_2 : J),
  (((CategoryTheory.cones J C).map f).app X_1 a).app X_2 = a.app X_2 ≫ f.app X_2

full_name: CategoryTheory.cones_obj_map_app
code: /-- Functorially associated to each functor `J ⥤ C`, we have the `C`-presheaf consisting of
cones with a given cone point.
-/
@[simps!]
def cones : (J ⥤ C) ⥤ Cᵒᵖ ⥤ Type max u₁ v₃ 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (a : (CategoryTheory.yoneda.obj F).obj ((CategoryTheory.Functor.const J).op.obj X)) (X_1 : J),
  (((CategoryTheory.cones J C).obj F).map f a).app X_1 = f.unop ≫ a.app X_1

full_name: CategoryTheory.cones
code: /-- Functorially associated to each functor `J ⥤ C`, we have the `C`-presheaf consisting of
cones with a given cone point.
-/
@[simps!]
def cones : (J ⥤ C) ⥤ Cᵒᵖ ⥤ Type max u₁ v₃ 
goal: (J ⥤ C) ⥤ Cᵒᵖ ⥤ Type (max u₁ v₃)

full_name: CategoryTheory.cones_obj_obj
code: /-- Functorially associated to each functor `J ⥤ C`, we have the `C`-presheaf consisting of
cones with a given cone point.
-/
@[simps!]
def cones : (J ⥤ C) ⥤ Cᵒᵖ ⥤ Type max u₁ v₃ 
goal: ((CategoryTheory.cones J C).obj F).obj X = ((CategoryTheory.Functor.const J).obj (Opposite.unop X) ⟶ F)

full_name: CategoryTheory.cocones_map_app_app
code: /-- Contravariantly associated to each functor `J ⥤ C`, we have the `C`-copresheaf consisting of
cocones with a given cocone point.
-/
@[simps!]
def cocones : (J ⥤ C)ᵒᵖ ⥤ C ⥤ Type max u₁ v₃ 
goal: ∀ {X Y : (J ⥤ C)ᵒᵖ} (f : X ⟶ Y) (X_1 : C)
  (a : (CategoryTheory.coyoneda.obj X).obj ((CategoryTheory.Functor.const J).obj X_1)) (X_2 : J),
  (((CategoryTheory.cocones J C).map f).app X_1 a).app X_2 = f.unop.app X_2 ≫ a.app X_2

full_name: CategoryTheory.cocones
code: /-- Contravariantly associated to each functor `J ⥤ C`, we have the `C`-copresheaf consisting of
cocones with a given cocone point.
-/
@[simps!]
def cocones : (J ⥤ C)ᵒᵖ ⥤ C ⥤ Type max u₁ v₃ 
goal: (J ⥤ C)ᵒᵖ ⥤ C ⥤ Type (max u₁ v₃)

full_name: CategoryTheory.cocones_obj_map_app
code: /-- Contravariantly associated to each functor `J ⥤ C`, we have the `C`-copresheaf consisting of
cocones with a given cocone point.
-/
@[simps!]
def cocones : (J ⥤ C)ᵒᵖ ⥤ C ⥤ Type max u₁ v₃ 
goal: ∀ {X Y : C} (f : X ⟶ Y)
  (a : (CategoryTheory.coyoneda.obj (Opposite.op (Opposite.unop F))).obj ((CategoryTheory.Functor.const J).obj X))
  (X_1 : J), (((CategoryTheory.cocones J C).obj F).map f a).app X_1 = a.app X_1 ≫ f

full_name: CategoryTheory.cocones_obj_obj
code: /-- Contravariantly associated to each functor `J ⥤ C`, we have the `C`-copresheaf consisting of
cocones with a given cocone point.
-/
@[simps!]
def cocones : (J ⥤ C)ᵒᵖ ⥤ C ⥤ Type max u₁ v₃ 
goal: ((CategoryTheory.cocones J C).obj F).obj X = (Opposite.unop F ⟶ (CategoryTheory.Functor.const J).obj X)

full_name: CategoryTheory.Limits.Cone.π
code: /-- A `c : Cone F` is:
* an object `c.pt` and
* a natural transformation `c.π : c.pt ⟶ F` from the constant `c.pt` functor to `F`.

Example: if `J` is a category coming from a poset then the data required to make
a term of type `Cone F` is morphisms `πⱼ : c.pt ⟶ F j` for all `j : J` and,
for all `i ≤ j` in `J`, morphisms `πᵢⱼ : F i ⟶ F j` such that `πᵢ ≫ πᵢⱼ = πᵢ`.

`Cone F` is equivalent, via `cone.equiv` below, to `Σ X, F.cones.obj X`.
-/
structure Cone (F : J ⥤ C) where
  /-- An object of `C` -/
  pt : C
  /-- A natural transformation from the constant functor at `X` to `F` -/
  π : (const J).obj pt ⟶ F
goal: (CategoryTheory.Functor.const J).obj self.pt ⟶ F

full_name: CategoryTheory.Limits.Cone
code: /-- A `c : Cone F` is:
* an object `c.pt` and
* a natural transformation `c.π : c.pt ⟶ F` from the constant `c.pt` functor to `F`.

Example: if `J` is a category coming from a poset then the data required to make
a term of type `Cone F` is morphisms `πⱼ : c.pt ⟶ F j` for all `j : J` and,
for all `i ≤ j` in `J`, morphisms `πᵢⱼ : F i ⟶ F j` such that `πᵢ ≫ πᵢⱼ = πᵢ`.

`Cone F` is equivalent, via `cone.equiv` below, to `Σ X, F.cones.obj X`.
-/
structure Cone (F : J ⥤ C) where
  /-- An object of `C` -/
  pt : C
  /-- A natural transformation from the constant functor at `X` to `F` -/
  π : (const J).obj pt ⟶ F
goal: Type (max (max u₁ u₃) v₃)

full_name: CategoryTheory.Limits.Cone.pt
code: /-- A `c : Cone F` is:
* an object `c.pt` and
* a natural transformation `c.π : c.pt ⟶ F` from the constant `c.pt` functor to `F`.

Example: if `J` is a category coming from a poset then the data required to make
a term of type `Cone F` is morphisms `πⱼ : c.pt ⟶ F j` for all `j : J` and,
for all `i ≤ j` in `J`, morphisms `πᵢⱼ : F i ⟶ F j` such that `πᵢ ≫ πᵢⱼ = πᵢ`.

`Cone F` is equivalent, via `cone.equiv` below, to `Σ X, F.cones.obj X`.
-/
structure Cone (F : J ⥤ C) where
  /-- An object of `C` -/
  pt : C
  /-- A natural transformation from the constant functor at `X` to `F` -/
  π : (const J).obj pt ⟶ F
goal: C

full_name: CategoryTheory.Limits.inhabitedCone
code: instance inhabitedCone (F : Discrete PUnit ⥤ C) : Inhabited (Cone F) 
goal: Inhabited (CategoryTheory.Limits.Cone F)

full_name: CategoryTheory.Limits.Cone.w
code: @[reassoc (attr := simp)]
theorem Cone.w {F : J ⥤ C} (c : Cone F) {j j' : J} (f : j ⟶ j') :
    c.π.app j ≫ F.map f = c.π.app j' 
goal: c.π.app j ≫ F.map f = c.π.app j'

full_name: CategoryTheory.Limits.Cocone
code: /-- A `c : Cocone F` is
* an object `c.pt` and
* a natural transformation `c.ι : F ⟶ c.pt` from `F` to the constant `c.pt` functor.

For example, if the source `J` of `F` is a partially ordered set, then to give
`c : Cocone F` is to give a collection of morphisms `ιⱼ : F j ⟶ c.pt` and, for
all `j ≤ k` in `J`, morphisms `ιⱼₖ : F j ⟶ F k` such that `Fⱼₖ ≫ Fₖ = Fⱼ` for all `j ≤ k`.

`Cocone F` is equivalent, via `Cone.equiv` below, to `Σ X, F.cocones.obj X`.
-/
structure Cocone (F : J ⥤ C) where
  /-- An object of `C` -/
  pt : C
  /-- A natural transformation from `F` to the constant functor at `pt` -/
  ι : F ⟶ (const J).obj pt
goal: Type (max (max u₁ u₃) v₃)

full_name: CategoryTheory.Limits.Cocone.pt
code: /-- A `c : Cocone F` is
* an object `c.pt` and
* a natural transformation `c.ι : F ⟶ c.pt` from `F` to the constant `c.pt` functor.

For example, if the source `J` of `F` is a partially ordered set, then to give
`c : Cocone F` is to give a collection of morphisms `ιⱼ : F j ⟶ c.pt` and, for
all `j ≤ k` in `J`, morphisms `ιⱼₖ : F j ⟶ F k` such that `Fⱼₖ ≫ Fₖ = Fⱼ` for all `j ≤ k`.

`Cocone F` is equivalent, via `Cone.equiv` below, to `Σ X, F.cocones.obj X`.
-/
structure Cocone (F : J ⥤ C) where
  /-- An object of `C` -/
  pt : C
  /-- A natural transformation from `F` to the constant functor at `pt` -/
  ι : F ⟶ (const J).obj pt
goal: C

full_name: CategoryTheory.Limits.Cocone.ι
code: /-- A `c : Cocone F` is
* an object `c.pt` and
* a natural transformation `c.ι : F ⟶ c.pt` from `F` to the constant `c.pt` functor.

For example, if the source `J` of `F` is a partially ordered set, then to give
`c : Cocone F` is to give a collection of morphisms `ιⱼ : F j ⟶ c.pt` and, for
all `j ≤ k` in `J`, morphisms `ιⱼₖ : F j ⟶ F k` such that `Fⱼₖ ≫ Fₖ = Fⱼ` for all `j ≤ k`.

`Cocone F` is equivalent, via `Cone.equiv` below, to `Σ X, F.cocones.obj X`.
-/
structure Cocone (F : J ⥤ C) where
  /-- An object of `C` -/
  pt : C
  /-- A natural transformation from `F` to the constant functor at `pt` -/
  ι : F ⟶ (const J).obj pt
goal: F ⟶ (CategoryTheory.Functor.const J).obj self.pt

full_name: CategoryTheory.Limits.inhabitedCocone
code: instance inhabitedCocone (F : Discrete PUnit ⥤ C) : Inhabited (Cocone F) 
goal: Inhabited (CategoryTheory.Limits.Cocone F)

full_name: CategoryTheory.Limits.Cocone.w
code: @[reassoc] -- @[simp] -- Porting note (#10618): simp can prove this
theorem Cocone.w {F : J ⥤ C} (c : Cocone F) {j j' : J} (f : j ⟶ j') :
    F.map f ≫ c.ι.app j' = c.ι.app j 
goal: F.map f ≫ c.ι.app j' = c.ι.app j

full_name: CategoryTheory.Limits.Cone.equiv_hom_snd
code: /-- The isomorphism between a cone on `F` and an element of the functor `F.cones`. -/
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
goal: ((CategoryTheory.Limits.Cone.equiv F).hom c).snd = c.π

full_name: CategoryTheory.Limits.Cone.equiv_inv_π
code: /-- The isomorphism between a cone on `F` and an element of the functor `F.cones`. -/
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
goal: ((CategoryTheory.Limits.Cone.equiv F).inv c).π = c.snd

full_name: CategoryTheory.Limits.Cone.equiv
code: /-- The isomorphism between a cone on `F` and an element of the functor `F.cones`. -/
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
goal: CategoryTheory.Limits.Cone F ≅ (X : Cᵒᵖ) × F.cones.obj X

full_name: CategoryTheory.Limits.Cone.equiv_inv_pt
code: /-- The isomorphism between a cone on `F` and an element of the functor `F.cones`. -/
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
goal: ((CategoryTheory.Limits.Cone.equiv F).inv c).pt = Opposite.unop c.fst

full_name: CategoryTheory.Limits.Cone.equiv_hom_fst
code: /-- The isomorphism between a cone on `F` and an element of the functor `F.cones`. -/
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
goal: ((CategoryTheory.Limits.Cone.equiv F).hom c).fst = Opposite.op c.pt

full_name: CategoryTheory.Limits.Cone.extensions
code: /-- A map to the vertex of a cone naturally induces a cone by composition. -/
@[simps]
def extensions (c : Cone F) : yoneda.obj c.pt ⋙ uliftFunctor.{u₁} ⟶ F.cones 
goal: CategoryTheory.yoneda.obj c.pt ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ⟶ F.cones

full_name: CategoryTheory.Limits.Cone.extensions_app
code: /-- A map to the vertex of a cone naturally induces a cone by composition. -/
@[simps]
def extensions (c : Cone F) : yoneda.obj c.pt ⋙ uliftFunctor.{u₁} ⟶ F.cones 
goal: c.extensions.app X f = (CategoryTheory.Functor.const J).map f.down ≫ c.π

full_name: CategoryTheory.Limits.Cone.extend_π
code: /-- A map to the vertex of a cone induces a cone by composition. -/
@[simps]
def extend (c : Cone F) {X : C} (f : X ⟶ c.pt) : Cone F 
goal: (c.extend f).π = c.extensions.app (Opposite.op X) { down := f }

full_name: CategoryTheory.Limits.Cone.extend
code: /-- A map to the vertex of a cone induces a cone by composition. -/
@[simps]
def extend (c : Cone F) {X : C} (f : X ⟶ c.pt) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.Cone.extend_pt
code: /-- A map to the vertex of a cone induces a cone by composition. -/
@[simps]
def extend (c : Cone F) {X : C} (f : X ⟶ c.pt) : Cone F 
goal: (c.extend f).pt = X

full_name: CategoryTheory.Limits.Cone.whisker_π
code: /-- Whisker a cone by precomposition of a functor. -/
@[simps]
def whisker (E : K ⥤ J) (c : Cone F) : Cone (E ⋙ F) 
goal: (CategoryTheory.Limits.Cone.whisker E c).π = CategoryTheory.whiskerLeft E c.π

full_name: CategoryTheory.Limits.Cone.whisker
code: /-- Whisker a cone by precomposition of a functor. -/
@[simps]
def whisker (E : K ⥤ J) (c : Cone F) : Cone (E ⋙ F) 
goal: CategoryTheory.Limits.Cone (E ⋙ F)

full_name: CategoryTheory.Limits.Cone.whisker_pt
code: /-- Whisker a cone by precomposition of a functor. -/
@[simps]
def whisker (E : K ⥤ J) (c : Cone F) : Cone (E ⋙ F) 
goal: (CategoryTheory.Limits.Cone.whisker E c).pt = c.pt

full_name: CategoryTheory.Limits.Cocone.equiv
code: /-- The isomorphism between a cocone on `F` and an element of the functor `F.cocones`. -/
def equiv (F : J ⥤ C) : Cocone F ≅ ΣX, F.cocones.obj X 
goal: CategoryTheory.Limits.Cocone F ≅ (X : C) × F.cocones.obj X

full_name: CategoryTheory.Limits.Cocone.extensions
code: /-- A map from the vertex of a cocone naturally induces a cocone by composition. -/
@[simps]
def extensions (c : Cocone F) : coyoneda.obj (op c.pt) ⋙ uliftFunctor.{u₁} ⟶ F.cocones 
goal: CategoryTheory.coyoneda.obj (Opposite.op c.pt) ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ⟶ F.cocones

full_name: CategoryTheory.Limits.Cocone.extensions_app
code: /-- A map from the vertex of a cocone naturally induces a cocone by composition. -/
@[simps]
def extensions (c : Cocone F) : coyoneda.obj (op c.pt) ⋙ uliftFunctor.{u₁} ⟶ F.cocones 
goal: c.extensions.app X f = c.ι ≫ (CategoryTheory.Functor.const J).map f.down

full_name: CategoryTheory.Limits.Cocone.extend_ι
code: /-- A map from the vertex of a cocone induces a cocone by composition. -/
@[simps]
def extend (c : Cocone F) {Y : C} (f : c.pt ⟶ Y) : Cocone F 
goal: (c.extend f).ι = c.extensions.app Y { down := f }

full_name: CategoryTheory.Limits.Cocone.extend
code: /-- A map from the vertex of a cocone induces a cocone by composition. -/
@[simps]
def extend (c : Cocone F) {Y : C} (f : c.pt ⟶ Y) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.Cocone.extend_pt
code: /-- A map from the vertex of a cocone induces a cocone by composition. -/
@[simps]
def extend (c : Cocone F) {Y : C} (f : c.pt ⟶ Y) : Cocone F 
goal: (c.extend f).pt = Y

full_name: CategoryTheory.Limits.Cocone.whisker_ι
code: /-- Whisker a cocone by precomposition of a functor. See `whiskering` for a functorial
version.
-/
@[simps]
def whisker (E : K ⥤ J) (c : Cocone F) : Cocone (E ⋙ F) 
goal: (CategoryTheory.Limits.Cocone.whisker E c).ι = CategoryTheory.whiskerLeft E c.ι

full_name: CategoryTheory.Limits.Cocone.whisker
code: /-- Whisker a cocone by precomposition of a functor. See `whiskering` for a functorial
version.
-/
@[simps]
def whisker (E : K ⥤ J) (c : Cocone F) : Cocone (E ⋙ F) 
goal: CategoryTheory.Limits.Cocone (E ⋙ F)

full_name: CategoryTheory.Limits.Cocone.whisker_pt
code: /-- Whisker a cocone by precomposition of a functor. See `whiskering` for a functorial
version.
-/
@[simps]
def whisker (E : K ⥤ J) (c : Cocone F) : Cocone (E ⋙ F) 
goal: (CategoryTheory.Limits.Cocone.whisker E c).pt = c.pt

full_name: CategoryTheory.Limits.ConeMorphism.w
code: /-- A cone morphism between two cones for the same diagram is a morphism of the cone points which
commutes with the cone legs. -/
structure ConeMorphism (A B : Cone F) where
  /-- A morphism between the two vertex objects of the cones -/
  hom : A.pt ⟶ B.pt
  /-- The triangle consisting of the two natural transformations and `hom` commutes -/
  w : ∀ j : J, hom ≫ B.π.app j = A.π.app j := by aesop_cat
goal: self.hom ≫ B.π.app j = A.π.app j

full_name: CategoryTheory.Limits.ConeMorphism
code: /-- A cone morphism between two cones for the same diagram is a morphism of the cone points which
commutes with the cone legs. -/
structure ConeMorphism (A B : Cone F) where
  /-- A morphism between the two vertex objects of the cones -/
  hom : A.pt ⟶ B.pt
  /-- The triangle consisting of the two natural transformations and `hom` commutes -/
  w : ∀ j : J, hom ≫ B.π.app j = A.π.app j := by aesop_cat
goal: Type v₃

full_name: CategoryTheory.Limits.ConeMorphism.hom
code: /-- A cone morphism between two cones for the same diagram is a morphism of the cone points which
commutes with the cone legs. -/
structure ConeMorphism (A B : Cone F) where
  /-- A morphism between the two vertex objects of the cones -/
  hom : A.pt ⟶ B.pt
  /-- The triangle consisting of the two natural transformations and `hom` commutes -/
  w : ∀ j : J, hom ≫ B.π.app j = A.π.app j := by aesop_cat
goal: A.pt ⟶ B.pt

full_name: CategoryTheory.Limits.inhabitedConeMorphism
code: instance inhabitedConeMorphism (A : Cone F) : Inhabited (ConeMorphism A A) 
goal: Inhabited (CategoryTheory.Limits.ConeMorphism A A)

full_name: CategoryTheory.Limits.Cone.category
code: /-- The category of cones on a given diagram. -/
@[simps]
instance Cone.category : Category (Cone F) 
goal: CategoryTheory.Category.{v₃, max (max u₃ u₁) v₃} (CategoryTheory.Limits.Cone F)

full_name: CategoryTheory.Limits.Cone.category_id_hom
code: /-- The category of cones on a given diagram. -/
@[simps]
instance Cone.category : Category (Cone F) 
goal: (𝟙 B).hom = 𝟙 B.pt

full_name: CategoryTheory.Limits.Cone.category_comp_hom
code: /-- The category of cones on a given diagram. -/
@[simps]
instance Cone.category : Category (Cone F) 
goal: ∀ {X Y Z : CategoryTheory.Limits.Cone F} (f : X ⟶ Y) (g : Y ⟶ Z), (f ≫ g).hom = f.hom ≫ g.hom

full_name: CategoryTheory.Limits.ConeMorphism.ext
code: @[ext]
theorem ConeMorphism.ext {c c' : Cone F} (f g : c ⟶ c') (w : f.hom = g.hom) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.Cones.ext
code: /-- To give an isomorphism between cones, it suffices to give an
  isomorphism between their vertices which commutes with the cone
  maps. -/
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.π.app j = φ.hom ≫ c'.π.app j := by aesop_cat) : c ≅ c' 
goal: c ≅ c'

full_name: CategoryTheory.Limits.Cones.ext_hom_hom
code: /-- To give an isomorphism between cones, it suffices to give an
  isomorphism between their vertices which commutes with the cone
  maps. -/
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.π.app j = φ.hom ≫ c'.π.app j := by aesop_cat) : c ≅ c' 
goal: (CategoryTheory.Limits.Cones.ext φ w).hom.hom = φ.hom

full_name: CategoryTheory.Limits.Cones.ext_inv_hom
code: /-- To give an isomorphism between cones, it suffices to give an
  isomorphism between their vertices which commutes with the cone
  maps. -/
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.π.app j = φ.hom ≫ c'.π.app j := by aesop_cat) : c ≅ c' 
goal: (CategoryTheory.Limits.Cones.ext φ w).inv.hom = φ.inv

full_name: CategoryTheory.Limits.Cones.eta_inv_hom
code: /-- Eta rule for cones. -/
@[simps!]
def eta (c : Cone F) : c ≅ ⟨c.pt, c.π⟩ 
goal: (CategoryTheory.Limits.Cones.eta c).inv.hom = 𝟙 c.pt

full_name: CategoryTheory.Limits.Cones.eta
code: /-- Eta rule for cones. -/
@[simps!]
def eta (c : Cone F) : c ≅ ⟨c.pt, c.π⟩ 
goal: c ≅ { pt := c.pt, π := c.π }

full_name: CategoryTheory.Limits.Cones.eta_hom_hom
code: /-- Eta rule for cones. -/
@[simps!]
def eta (c : Cone F) : c ≅ ⟨c.pt, c.π⟩ 
goal: (CategoryTheory.Limits.Cones.eta c).hom.hom = 𝟙 c.pt

full_name: CategoryTheory.Limits.Cones.cone_iso_of_hom_iso
code: /-- Given a cone morphism whose object part is an isomorphism, produce an
isomorphism of cones.
-/
theorem cone_iso_of_hom_iso {K : J ⥤ C} {c d : Cone K} (f : c ⟶ d) [i : IsIso f.hom] : IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.Limits.Cones.extend_hom
code: /-- There is a morphism from an extended cone to the original cone. -/
@[simps]
def extend (s : Cone F) {X : C} (f : X ⟶ s.pt) : s.extend f ⟶ s 
goal: (CategoryTheory.Limits.Cones.extend s f).hom = f

full_name: CategoryTheory.Limits.Cones.extend
code: /-- There is a morphism from an extended cone to the original cone. -/
@[simps]
def extend (s : Cone F) {X : C} (f : X ⟶ s.pt) : s.extend f ⟶ s 
goal: s.extend f ⟶ s

full_name: CategoryTheory.Limits.Cones.extendId
code: /-- Extending a cone by the identity does nothing. -/
@[simps!]
def extendId (s : Cone F) : s.extend (𝟙 s.pt) ≅ s 
goal: s.extend (𝟙 s.pt) ≅ s

full_name: CategoryTheory.Limits.Cones.extendId_hom_hom
code: /-- Extending a cone by the identity does nothing. -/
@[simps!]
def extendId (s : Cone F) : s.extend (𝟙 s.pt) ≅ s 
goal: (CategoryTheory.Limits.Cones.extendId s).hom.hom = 𝟙 s.pt

full_name: CategoryTheory.Limits.Cones.extendId_inv_hom
code: /-- Extending a cone by the identity does nothing. -/
@[simps!]
def extendId (s : Cone F) : s.extend (𝟙 s.pt) ≅ s 
goal: (CategoryTheory.Limits.Cones.extendId s).inv.hom = 𝟙 s.pt

full_name: CategoryTheory.Limits.Cones.extendComp
code: /-- Extending a cone by a composition is the same as extending the cone twice. -/
@[simps!]
def extendComp (s : Cone F) {X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt) :
    s.extend (f ≫ g) ≅ (s.extend g).extend f 
goal: s.extend (f ≫ g) ≅ (s.extend g).extend f

full_name: CategoryTheory.Limits.Cones.extendComp_inv_hom
code: /-- Extending a cone by a composition is the same as extending the cone twice. -/
@[simps!]
def extendComp (s : Cone F) {X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt) :
    s.extend (f ≫ g) ≅ (s.extend g).extend f 
goal: (CategoryTheory.Limits.Cones.extendComp s f g).inv.hom = 𝟙 X

full_name: CategoryTheory.Limits.Cones.extendComp_hom_hom
code: /-- Extending a cone by a composition is the same as extending the cone twice. -/
@[simps!]
def extendComp (s : Cone F) {X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt) :
    s.extend (f ≫ g) ≅ (s.extend g).extend f 
goal: (CategoryTheory.Limits.Cones.extendComp s f g).hom.hom = 𝟙 X

full_name: CategoryTheory.Limits.Cones.extendIso_hom_hom
code: /-- A cone extended by an isomorphism is isomorphic to the original cone. -/
@[simps]
def extendIso (s : Cone F) {X : C} (f : X ≅ s.pt) : s.extend f.hom ≅ s 
goal: (CategoryTheory.Limits.Cones.extendIso s f).hom.hom = f.hom

full_name: CategoryTheory.Limits.Cones.extendIso
code: /-- A cone extended by an isomorphism is isomorphic to the original cone. -/
@[simps]
def extendIso (s : Cone F) {X : C} (f : X ≅ s.pt) : s.extend f.hom ≅ s 
goal: s.extend f.hom ≅ s

full_name: CategoryTheory.Limits.Cones.extendIso_inv_hom
code: /-- A cone extended by an isomorphism is isomorphic to the original cone. -/
@[simps]
def extendIso (s : Cone F) {X : C} (f : X ≅ s.pt) : s.extend f.hom ≅ s 
goal: (CategoryTheory.Limits.Cones.extendIso s f).inv.hom = f.inv

full_name: CategoryTheory.Limits.Cones.instIsIsoConeExtend
code: instance {s : Cone F} {X : C} (f : X ⟶ s.pt) [IsIso f] : IsIso (Cones.extend s f) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.Cones.extend s f)

full_name: CategoryTheory.Limits.Cones.postcompose_obj_pt
code: /--
Functorially postcompose a cone for `F` by a natural transformation `F ⟶ G` to give a cone for `G`.
-/
@[simps]
def postcompose {G : J ⥤ C} (α : F ⟶ G) : Cone F ⥤ Cone G 
goal: ((CategoryTheory.Limits.Cones.postcompose α).obj c).pt = c.pt

full_name: CategoryTheory.Limits.Cones.postcompose_obj_π
code: /--
Functorially postcompose a cone for `F` by a natural transformation `F ⟶ G` to give a cone for `G`.
-/
@[simps]
def postcompose {G : J ⥤ C} (α : F ⟶ G) : Cone F ⥤ Cone G 
goal: ((CategoryTheory.Limits.Cones.postcompose α).obj c).π = c.π ≫ α

full_name: CategoryTheory.Limits.Cones.postcompose_map_hom
code: /--
Functorially postcompose a cone for `F` by a natural transformation `F ⟶ G` to give a cone for `G`.
-/
@[simps]
def postcompose {G : J ⥤ C} (α : F ⟶ G) : Cone F ⥤ Cone G 
goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y), ((CategoryTheory.Limits.Cones.postcompose α).map f).hom = f.hom

full_name: CategoryTheory.Limits.Cones.postcompose
code: /--
Functorially postcompose a cone for `F` by a natural transformation `F ⟶ G` to give a cone for `G`.
-/
@[simps]
def postcompose {G : J ⥤ C} (α : F ⟶ G) : Cone F ⥤ Cone G 
goal: CategoryTheory.Limits.Cone F ⥤ CategoryTheory.Limits.Cone G

full_name: CategoryTheory.Limits.Cones.postcomposeComp_inv_app_hom
code: /-- Postcomposing a cone by the composite natural transformation `α ≫ β` is the same as
postcomposing by `α` and then by `β`. -/
@[simps!]
def postcomposeComp {G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) :
    postcompose (α ≫ β) ≅ postcompose α ⋙ postcompose β 
goal: ((CategoryTheory.Limits.Cones.postcomposeComp α β).inv.app X).hom = 𝟙 X.pt

full_name: CategoryTheory.Limits.Cones.postcomposeComp_hom_app_hom
code: /-- Postcomposing a cone by the composite natural transformation `α ≫ β` is the same as
postcomposing by `α` and then by `β`. -/
@[simps!]
def postcomposeComp {G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) :
    postcompose (α ≫ β) ≅ postcompose α ⋙ postcompose β 
goal: ((CategoryTheory.Limits.Cones.postcomposeComp α β).hom.app X).hom = 𝟙 X.pt

full_name: CategoryTheory.Limits.Cones.postcomposeComp
code: /-- Postcomposing a cone by the composite natural transformation `α ≫ β` is the same as
postcomposing by `α` and then by `β`. -/
@[simps!]
def postcomposeComp {G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) :
    postcompose (α ≫ β) ≅ postcompose α ⋙ postcompose β 
goal: CategoryTheory.Limits.Cones.postcompose (α ≫ β) ≅
  CategoryTheory.Limits.Cones.postcompose α ⋙ CategoryTheory.Limits.Cones.postcompose β

full_name: CategoryTheory.Limits.Cones.postcomposeId_inv_app_hom
code: /-- Postcomposing by the identity does not change the cone up to isomorphism. -/
@[simps!]
def postcomposeId : postcompose (𝟙 F) ≅ 𝟭 (Cone F) 
goal: (CategoryTheory.Limits.Cones.postcomposeId.inv.app X).hom = 𝟙 X.pt

full_name: CategoryTheory.Limits.Cones.postcomposeId
code: /-- Postcomposing by the identity does not change the cone up to isomorphism. -/
@[simps!]
def postcomposeId : postcompose (𝟙 F) ≅ 𝟭 (Cone F) 
goal: CategoryTheory.Limits.Cones.postcompose (𝟙 F) ≅ 𝟭 (CategoryTheory.Limits.Cone F)

full_name: CategoryTheory.Limits.Cones.postcomposeId_hom_app_hom
code: /-- Postcomposing by the identity does not change the cone up to isomorphism. -/
@[simps!]
def postcomposeId : postcompose (𝟙 F) ≅ 𝟭 (Cone F) 
goal: (CategoryTheory.Limits.Cones.postcomposeId.hom.app X).hom = 𝟙 X.pt

full_name: CategoryTheory.Limits.Cones.postcomposeEquivalence_counitIso
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cones.
-/
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
goal: (CategoryTheory.Limits.Cones.postcomposeEquivalence α).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cones.ext
        (CategoryTheory.Iso.refl
          ((CategoryTheory.Limits.Cones.postcompose α.inv ⋙ CategoryTheory.Limits.Cones.postcompose α.hom).obj s).pt)
        ⋯)
    ⋯

full_name: CategoryTheory.Limits.Cones.postcomposeEquivalence_inverse
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cones.
-/
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
goal: (CategoryTheory.Limits.Cones.postcomposeEquivalence α).inverse = CategoryTheory.Limits.Cones.postcompose α.inv

full_name: CategoryTheory.Limits.Cones.postcomposeEquivalence
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cones.
-/
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
goal: CategoryTheory.Limits.Cone F ≌ CategoryTheory.Limits.Cone G

full_name: CategoryTheory.Limits.Cones.postcomposeEquivalence_unitIso
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cones.
-/
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
goal: (CategoryTheory.Limits.Cones.postcomposeEquivalence α).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl ((𝟭 (CategoryTheory.Limits.Cone F)).obj s).pt) ⋯)
    ⋯

full_name: CategoryTheory.Limits.Cones.postcomposeEquivalence_functor
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cones.
-/
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
goal: (CategoryTheory.Limits.Cones.postcomposeEquivalence α).functor = CategoryTheory.Limits.Cones.postcompose α.hom

full_name: CategoryTheory.Limits.Cones.whiskering_map_hom
code: /-- Whiskering on the left by `E : K ⥤ J` gives a functor from `Cone F` to `Cone (E ⋙ F)`.
-/
@[simps]
def whiskering (E : K ⥤ J) : Cone F ⥤ Cone (E ⋙ F) 
goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y), ((CategoryTheory.Limits.Cones.whiskering E).map f).hom = f.hom

full_name: CategoryTheory.Limits.Cones.whiskering_obj
code: /-- Whiskering on the left by `E : K ⥤ J` gives a functor from `Cone F` to `Cone (E ⋙ F)`.
-/
@[simps]
def whiskering (E : K ⥤ J) : Cone F ⥤ Cone (E ⋙ F) 
goal: (CategoryTheory.Limits.Cones.whiskering E).obj c = CategoryTheory.Limits.Cone.whisker E c

full_name: CategoryTheory.Limits.Cones.whiskering
code: /-- Whiskering on the left by `E : K ⥤ J` gives a functor from `Cone F` to `Cone (E ⋙ F)`.
-/
@[simps]
def whiskering (E : K ⥤ J) : Cone F ⥤ Cone (E ⋙ F) 
goal: CategoryTheory.Limits.Cone F ⥤ CategoryTheory.Limits.Cone (E ⋙ F)

full_name: CategoryTheory.Limits.Cones.whiskeringEquivalence_counitIso
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
goal: (CategoryTheory.Limits.Cones.whiskeringEquivalence e).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cones.ext
        (CategoryTheory.Iso.refl
          (((CategoryTheory.Limits.Cones.whiskering e.inverse ⋙
                    CategoryTheory.Limits.Cones.postcompose (e.invFunIdAssoc F).hom) ⋙
                  CategoryTheory.Limits.Cones.whiskering e.functor).obj
              s).pt)
        ⋯)
    ⋯

full_name: CategoryTheory.Limits.Cones.whiskeringEquivalence_inverse
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
goal: (CategoryTheory.Limits.Cones.whiskeringEquivalence e).inverse =
  CategoryTheory.Limits.Cones.whiskering e.inverse ⋙ CategoryTheory.Limits.Cones.postcompose (e.invFunIdAssoc F).hom

full_name: CategoryTheory.Limits.Cones.whiskeringEquivalence_functor
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
goal: (CategoryTheory.Limits.Cones.whiskeringEquivalence e).functor = CategoryTheory.Limits.Cones.whiskering e.functor

full_name: CategoryTheory.Limits.Cones.whiskeringEquivalence_unitIso
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
goal: (CategoryTheory.Limits.Cones.whiskeringEquivalence e).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl ((𝟭 (CategoryTheory.Limits.Cone F)).obj s).pt) ⋯)
    ⋯

full_name: CategoryTheory.Limits.Cones.whiskeringEquivalence
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
goal: CategoryTheory.Limits.Cone F ≌ CategoryTheory.Limits.Cone (e.functor ⋙ F)

full_name: CategoryTheory.Limits.Cones.equivalenceOfReindexing_functor
code: /-- The categories of cones over `F` and `G` are equivalent if `F` and `G` are naturally isomorphic
(possibly after changing the indexing category by an equivalence).
-/
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
goal: (CategoryTheory.Limits.Cones.equivalenceOfReindexing e α).functor =
  CategoryTheory.Limits.Cones.whiskering e.functor ⋙ CategoryTheory.Limits.Cones.postcompose α.hom

full_name: CategoryTheory.Limits.Cones.equivalenceOfReindexing_unitIso
code: /-- The categories of cones over `F` and `G` are equivalent if `F` and `G` are naturally isomorphic
(possibly after changing the indexing category by an equivalence).
-/
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
goal: (CategoryTheory.Limits.Cones.equivalenceOfReindexing e α).unitIso =
  CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl s.pt) ⋯) ⋯ ≪≫
    CategoryTheory.isoWhiskerLeft (CategoryTheory.Limits.Cones.whiskering e.functor)
      (CategoryTheory.isoWhiskerRight
        (CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl s.pt) ⋯)
          ⋯)
        (CategoryTheory.Limits.Cones.whiskering e.inverse ⋙
          CategoryTheory.Limits.Cones.postcompose (e.invFunIdAssoc F).hom))

full_name: CategoryTheory.Limits.Cones.equivalenceOfReindexing
code: /-- The categories of cones over `F` and `G` are equivalent if `F` and `G` are naturally isomorphic
(possibly after changing the indexing category by an equivalence).
-/
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
goal: CategoryTheory.Limits.Cone F ≌ CategoryTheory.Limits.Cone G

full_name: CategoryTheory.Limits.Cones.equivalenceOfReindexing_inverse
code: /-- The categories of cones over `F` and `G` are equivalent if `F` and `G` are naturally isomorphic
(possibly after changing the indexing category by an equivalence).
-/
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
goal: (CategoryTheory.Limits.Cones.equivalenceOfReindexing e α).inverse =
  CategoryTheory.Limits.Cones.postcompose α.inv ⋙
    CategoryTheory.Limits.Cones.whiskering e.inverse ⋙ CategoryTheory.Limits.Cones.postcompose (e.invFunIdAssoc F).hom

full_name: CategoryTheory.Limits.Cones.equivalenceOfReindexing_counitIso
code: /-- The categories of cones over `F` and `G` are equivalent if `F` and `G` are naturally isomorphic
(possibly after changing the indexing category by an equivalence).
-/
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
goal: (CategoryTheory.Limits.Cones.equivalenceOfReindexing e α).counitIso =
  CategoryTheory.isoWhiskerLeft (CategoryTheory.Limits.Cones.postcompose α.inv)
      (CategoryTheory.isoWhiskerRight
        (CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl s.pt) ⋯)
          ⋯)
        (CategoryTheory.Limits.Cones.postcompose α.hom)) ≪≫
    CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl s.pt) ⋯) ⋯

full_name: CategoryTheory.Limits.Cones.forget_map
code: /-- Forget the cone structure and obtain just the cone point. -/
@[simps]
def forget : Cone F ⥤ C 
goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y), (CategoryTheory.Limits.Cones.forget F).map f = f.hom

full_name: CategoryTheory.Limits.Cones.forget
code: /-- Forget the cone structure and obtain just the cone point. -/
@[simps]
def forget : Cone F ⥤ C 
goal: CategoryTheory.Limits.Cone F ⥤ C

full_name: CategoryTheory.Limits.Cones.forget_obj
code: /-- Forget the cone structure and obtain just the cone point. -/
@[simps]
def forget : Cone F ⥤ C 
goal: (CategoryTheory.Limits.Cones.forget F).obj t = t.pt

full_name: CategoryTheory.Limits.Cones.functoriality
code: /-- A functor `G : C ⥤ D` sends cones over `F` to cones over `F ⋙ G` functorially. -/
@[simps]
def functoriality : Cone F ⥤ Cone (F ⋙ G) 
goal: CategoryTheory.Limits.Cone F ⥤ CategoryTheory.Limits.Cone (F ⋙ G)

full_name: CategoryTheory.Limits.Cones.functoriality_obj_pt
code: /-- A functor `G : C ⥤ D` sends cones over `F` to cones over `F ⋙ G` functorially. -/
@[simps]
def functoriality : Cone F ⥤ Cone (F ⋙ G) 
goal: ((CategoryTheory.Limits.Cones.functoriality F G).obj A).pt = G.obj A.pt

full_name: CategoryTheory.Limits.Cones.functoriality_obj_π_app
code: /-- A functor `G : C ⥤ D` sends cones over `F` to cones over `F ⋙ G` functorially. -/
@[simps]
def functoriality : Cone F ⥤ Cone (F ⋙ G) 
goal: ((CategoryTheory.Limits.Cones.functoriality F G).obj A).π.app j = G.map (A.π.app j)

full_name: CategoryTheory.Limits.Cones.functoriality_map_hom
code: /-- A functor `G : C ⥤ D` sends cones over `F` to cones over `F ⋙ G` functorially. -/
@[simps]
def functoriality : Cone F ⥤ Cone (F ⋙ G) 
goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cones.functoriality F G).map f).hom = G.map f.hom

full_name: CategoryTheory.Limits.Cones.functoriality_full
code: instance functoriality_full [G.Full] [G.Faithful] : (functoriality F G).Full 
goal: (CategoryTheory.Limits.Cones.functoriality F G).Full

full_name: CategoryTheory.Limits.Cones.functoriality_faithful
code: instance functoriality_faithful [G.Faithful] : (Cones.functoriality F G).Faithful 
goal: (CategoryTheory.Limits.Cones.functoriality F G).Faithful

full_name: CategoryTheory.Limits.Cones.functorialityEquivalence_unitIso
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cones over `F` and cones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
goal: (CategoryTheory.Limits.Cones.functorialityEquivalence F e).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun c => CategoryTheory.Limits.Cones.ext (e.unitIso.app ((𝟭 (CategoryTheory.Limits.Cone F)).obj c).1) ⋯) ⋯

full_name: CategoryTheory.Limits.Cones.functorialityEquivalence_counitIso
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cones over `F` and cones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
goal: (CategoryTheory.Limits.Cones.functorialityEquivalence F e).counitIso =
  CategoryTheory.NatIso.ofComponents (fun c => CategoryTheory.Limits.Cones.ext (e.counitIso.app c.pt) ⋯) ⋯

full_name: CategoryTheory.Limits.Cones.functorialityEquivalence_inverse
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cones over `F` and cones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
goal: (CategoryTheory.Limits.Cones.functorialityEquivalence F e).inverse =
  CategoryTheory.Limits.Cones.functoriality (F ⋙ e.functor) e.inverse ⋙
    (CategoryTheory.Limits.Cones.postcomposeEquivalence
        (F.associator e.functor e.inverse ≪≫ CategoryTheory.isoWhiskerLeft F e.unitIso.symm ≪≫ F.rightUnitor)).functor

full_name: CategoryTheory.Limits.Cones.functorialityEquivalence
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cones over `F` and cones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
goal: CategoryTheory.Limits.Cone F ≌ CategoryTheory.Limits.Cone (F ⋙ e.functor)

full_name: CategoryTheory.Limits.Cones.functorialityEquivalence_functor
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cones over `F` and cones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
goal: (CategoryTheory.Limits.Cones.functorialityEquivalence F e).functor =
  CategoryTheory.Limits.Cones.functoriality F e.functor

full_name: CategoryTheory.Limits.Cones.reflects_cone_isomorphism
code: /-- If `F` reflects isomorphisms, then `Cones.functoriality F` reflects isomorphisms
as well.
-/
instance reflects_cone_isomorphism (F : C ⥤ D) [F.ReflectsIsomorphisms] (K : J ⥤ C) :
    (Cones.functoriality K F).ReflectsIsomorphisms 
goal: (CategoryTheory.Limits.Cones.functoriality K F).ReflectsIsomorphisms

full_name: CategoryTheory.Limits.CoconeMorphism
code: /-- A cocone morphism between two cocones for the same diagram is a morphism of the cocone points
which commutes with the cocone legs. -/
structure CoconeMorphism (A B : Cocone F) where
  /-- A morphism between the (co)vertex objects in `C` -/
  hom : A.pt ⟶ B.pt
  /-- The triangle made from the two natural transformations and `hom` commutes -/
  w : ∀ j : J, A.ι.app j ≫ hom = B.ι.app j := by aesop_cat
goal: Type v₃

full_name: CategoryTheory.Limits.CoconeMorphism.hom
code: /-- A cocone morphism between two cocones for the same diagram is a morphism of the cocone points
which commutes with the cocone legs. -/
structure CoconeMorphism (A B : Cocone F) where
  /-- A morphism between the (co)vertex objects in `C` -/
  hom : A.pt ⟶ B.pt
  /-- The triangle made from the two natural transformations and `hom` commutes -/
  w : ∀ j : J, A.ι.app j ≫ hom = B.ι.app j := by aesop_cat
goal: A.pt ⟶ B.pt

full_name: CategoryTheory.Limits.CoconeMorphism.w
code: /-- A cocone morphism between two cocones for the same diagram is a morphism of the cocone points
which commutes with the cocone legs. -/
structure CoconeMorphism (A B : Cocone F) where
  /-- A morphism between the (co)vertex objects in `C` -/
  hom : A.pt ⟶ B.pt
  /-- The triangle made from the two natural transformations and `hom` commutes -/
  w : ∀ j : J, A.ι.app j ≫ hom = B.ι.app j := by aesop_cat
goal: A.ι.app j ≫ self.hom = B.ι.app j

full_name: CategoryTheory.Limits.inhabitedCoconeMorphism
code: instance inhabitedCoconeMorphism (A : Cocone F) : Inhabited (CoconeMorphism A A) 
goal: Inhabited (CategoryTheory.Limits.CoconeMorphism A A)

full_name: CategoryTheory.Limits.Cocone.category
code: @[simps]
instance Cocone.category : Category (Cocone F) 
goal: CategoryTheory.Category.{v₃, max (max u₃ u₁) v₃} (CategoryTheory.Limits.Cocone F)

full_name: CategoryTheory.Limits.Cocone.category_comp_hom
code: @[simps]
instance Cocone.category : Category (Cocone F) 
goal: ∀ {X Y Z : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y) (g : Y ⟶ Z), (f ≫ g).hom = f.hom ≫ g.hom

full_name: CategoryTheory.Limits.Cocone.category_id_hom
code: @[simps]
instance Cocone.category : Category (Cocone F) 
goal: (𝟙 B).hom = 𝟙 B.pt

full_name: CategoryTheory.Limits.CoconeMorphism.ext
code: @[ext]
theorem CoconeMorphism.ext {c c' : Cocone F} (f g : c ⟶ c') (w : f.hom = g.hom) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.Cocones.ext_inv_hom
code: /-- To give an isomorphism between cocones, it suffices to give an
  isomorphism between their vertices which commutes with the cocone
  maps. -/
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cocone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.ι.app j ≫ φ.hom = c'.ι.app j := by aesop_cat) : c ≅ c' 
goal: (CategoryTheory.Limits.Cocones.ext φ w).inv.hom = φ.inv

full_name: CategoryTheory.Limits.Cocones.ext
code: /-- To give an isomorphism between cocones, it suffices to give an
  isomorphism between their vertices which commutes with the cocone
  maps. -/
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cocone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.ι.app j ≫ φ.hom = c'.ι.app j := by aesop_cat) : c ≅ c' 
goal: c ≅ c'

full_name: CategoryTheory.Limits.Cocones.ext_hom_hom
code: /-- To give an isomorphism between cocones, it suffices to give an
  isomorphism between their vertices which commutes with the cocone
  maps. -/
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cocone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.ι.app j ≫ φ.hom = c'.ι.app j := by aesop_cat) : c ≅ c' 
goal: (CategoryTheory.Limits.Cocones.ext φ w).hom.hom = φ.hom

full_name: CategoryTheory.Limits.Cocones.eta_inv_hom
code: /-- Eta rule for cocones. -/
@[simps!]
def eta (c : Cocone F) : c ≅ ⟨c.pt, c.ι⟩ 
goal: (CategoryTheory.Limits.Cocones.eta c).inv.hom = 𝟙 c.pt

full_name: CategoryTheory.Limits.Cocones.eta_hom_hom
code: /-- Eta rule for cocones. -/
@[simps!]
def eta (c : Cocone F) : c ≅ ⟨c.pt, c.ι⟩ 
goal: (CategoryTheory.Limits.Cocones.eta c).hom.hom = 𝟙 c.pt

full_name: CategoryTheory.Limits.Cocones.eta
code: /-- Eta rule for cocones. -/
@[simps!]
def eta (c : Cocone F) : c ≅ ⟨c.pt, c.ι⟩ 
goal: c ≅ { pt := c.pt, ι := c.ι }

full_name: CategoryTheory.Limits.Cocones.cocone_iso_of_hom_iso
code: /-- Given a cocone morphism whose object part is an isomorphism, produce an
isomorphism of cocones.
-/
theorem cocone_iso_of_hom_iso {K : J ⥤ C} {c d : Cocone K} (f : c ⟶ d) [i : IsIso f.hom] :
    IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.Limits.Cocones.extend_hom
code: /-- There is a morphism from a cocone to its extension. -/
@[simps]
def extend (s : Cocone F) {X : C} (f : s.pt ⟶ X) : s ⟶ s.extend f 
goal: (CategoryTheory.Limits.Cocones.extend s f).hom = f

full_name: CategoryTheory.Limits.Cocones.extend
code: /-- There is a morphism from a cocone to its extension. -/
@[simps]
def extend (s : Cocone F) {X : C} (f : s.pt ⟶ X) : s ⟶ s.extend f 
goal: s ⟶ s.extend f

full_name: CategoryTheory.Limits.Cocones.extendId_inv_hom
code: /-- Extending a cocone by the identity does nothing. -/
@[simps!]
def extendId (s : Cocone F) : s ≅ s.extend (𝟙 s.pt) 
goal: (CategoryTheory.Limits.Cocones.extendId s).inv.hom = 𝟙 s.pt

full_name: CategoryTheory.Limits.Cocones.extendId_hom_hom
code: /-- Extending a cocone by the identity does nothing. -/
@[simps!]
def extendId (s : Cocone F) : s ≅ s.extend (𝟙 s.pt) 
goal: (CategoryTheory.Limits.Cocones.extendId s).hom.hom = 𝟙 s.pt

full_name: CategoryTheory.Limits.Cocones.extendId
code: /-- Extending a cocone by the identity does nothing. -/
@[simps!]
def extendId (s : Cocone F) : s ≅ s.extend (𝟙 s.pt) 
goal: s ≅ s.extend (𝟙 s.pt)

full_name: CategoryTheory.Limits.Cocones.extendComp
code: /-- Extending a cocone by a composition is the same as extending the cone twice. -/
@[simps!]
def extendComp (s : Cocone F) {X Y : C} (f : s.pt ⟶ X) (g : X ⟶ Y) :
    s.extend (f ≫ g) ≅ (s.extend f).extend g 
goal: s.extend (f ≫ g) ≅ (s.extend f).extend g

full_name: CategoryTheory.Limits.Cocones.extendComp_inv_hom
code: /-- Extending a cocone by a composition is the same as extending the cone twice. -/
@[simps!]
def extendComp (s : Cocone F) {X Y : C} (f : s.pt ⟶ X) (g : X ⟶ Y) :
    s.extend (f ≫ g) ≅ (s.extend f).extend g 
goal: (CategoryTheory.Limits.Cocones.extendComp s f g).inv.hom = 𝟙 Y

full_name: CategoryTheory.Limits.Cocones.extendComp_hom_hom
code: /-- Extending a cocone by a composition is the same as extending the cone twice. -/
@[simps!]
def extendComp (s : Cocone F) {X Y : C} (f : s.pt ⟶ X) (g : X ⟶ Y) :
    s.extend (f ≫ g) ≅ (s.extend f).extend g 
goal: (CategoryTheory.Limits.Cocones.extendComp s f g).hom.hom = 𝟙 Y

full_name: CategoryTheory.Limits.Cocones.extendIso_inv_hom
code: /-- A cocone extended by an isomorphism is isomorphic to the original cone. -/
@[simps]
def extendIso (s : Cocone F) {X : C} (f : s.pt ≅ X) : s ≅ s.extend f.hom 
goal: (CategoryTheory.Limits.Cocones.extendIso s f).inv.hom = f.inv

full_name: CategoryTheory.Limits.Cocones.extendIso_hom_hom
code: /-- A cocone extended by an isomorphism is isomorphic to the original cone. -/
@[simps]
def extendIso (s : Cocone F) {X : C} (f : s.pt ≅ X) : s ≅ s.extend f.hom 
goal: (CategoryTheory.Limits.Cocones.extendIso s f).hom.hom = f.hom

full_name: CategoryTheory.Limits.Cocones.extendIso
code: /-- A cocone extended by an isomorphism is isomorphic to the original cone. -/
@[simps]
def extendIso (s : Cocone F) {X : C} (f : s.pt ≅ X) : s ≅ s.extend f.hom 
goal: s ≅ s.extend f.hom

full_name: CategoryTheory.Limits.Cocones.instIsIsoCoconeExtend
code: instance {s : Cocone F} {X : C} (f : s.pt ⟶ X) [IsIso f] : IsIso (Cocones.extend s f) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.Cocones.extend s f)

full_name: CategoryTheory.Limits.Cocones.precompose_map_hom
code: /-- Functorially precompose a cocone for `F` by a natural transformation `G ⟶ F` to give a cocone
for `G`. -/
@[simps]
def precompose {G : J ⥤ C} (α : G ⟶ F) : Cocone F ⥤ Cocone G 
goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y), ((CategoryTheory.Limits.Cocones.precompose α).map f).hom = f.hom

full_name: CategoryTheory.Limits.Cocones.precompose_obj_pt
code: /-- Functorially precompose a cocone for `F` by a natural transformation `G ⟶ F` to give a cocone
for `G`. -/
@[simps]
def precompose {G : J ⥤ C} (α : G ⟶ F) : Cocone F ⥤ Cocone G 
goal: ((CategoryTheory.Limits.Cocones.precompose α).obj c).pt = c.pt

full_name: CategoryTheory.Limits.Cocones.precompose
code: /-- Functorially precompose a cocone for `F` by a natural transformation `G ⟶ F` to give a cocone
for `G`. -/
@[simps]
def precompose {G : J ⥤ C} (α : G ⟶ F) : Cocone F ⥤ Cocone G 
goal: CategoryTheory.Limits.Cocone F ⥤ CategoryTheory.Limits.Cocone G

full_name: CategoryTheory.Limits.Cocones.precompose_obj_ι
code: /-- Functorially precompose a cocone for `F` by a natural transformation `G ⟶ F` to give a cocone
for `G`. -/
@[simps]
def precompose {G : J ⥤ C} (α : G ⟶ F) : Cocone F ⥤ Cocone G 
goal: ((CategoryTheory.Limits.Cocones.precompose α).obj c).ι = α ≫ c.ι

full_name: CategoryTheory.Limits.Cocones.precomposeComp
code: /-- Precomposing a cocone by the composite natural transformation `α ≫ β` is the same as
precomposing by `β` and then by `α`. -/
def precomposeComp {G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) :
    precompose (α ≫ β) ≅ precompose β ⋙ precompose α 
goal: CategoryTheory.Limits.Cocones.precompose (α ≫ β) ≅
  CategoryTheory.Limits.Cocones.precompose β ⋙ CategoryTheory.Limits.Cocones.precompose α

full_name: CategoryTheory.Limits.Cocones.precomposeId
code: /-- Precomposing by the identity does not change the cocone up to isomorphism. -/
def precomposeId : precompose (𝟙 F) ≅ 𝟭 (Cocone F) 
goal: CategoryTheory.Limits.Cocones.precompose (𝟙 F) ≅ 𝟭 (CategoryTheory.Limits.Cocone F)

full_name: CategoryTheory.Limits.Cocones.precomposeEquivalence_functor
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cocones.
-/
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
goal: (CategoryTheory.Limits.Cocones.precomposeEquivalence α).functor = CategoryTheory.Limits.Cocones.precompose α.hom

full_name: CategoryTheory.Limits.Cocones.precomposeEquivalence_unitIso
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cocones.
-/
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
goal: (CategoryTheory.Limits.Cocones.precomposeEquivalence α).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cocones.ext (CategoryTheory.Iso.refl ((𝟭 (CategoryTheory.Limits.Cocone F)).obj s).pt) ⋯)
    ⋯

full_name: CategoryTheory.Limits.Cocones.precomposeEquivalence
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cocones.
-/
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
goal: CategoryTheory.Limits.Cocone F ≌ CategoryTheory.Limits.Cocone G

full_name: CategoryTheory.Limits.Cocones.precomposeEquivalence_counitIso
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cocones.
-/
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
goal: (CategoryTheory.Limits.Cocones.precomposeEquivalence α).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cocones.ext
        (CategoryTheory.Iso.refl
          ((CategoryTheory.Limits.Cocones.precompose α.inv ⋙ CategoryTheory.Limits.Cocones.precompose α.hom).obj s).pt)
        ⋯)
    ⋯

full_name: CategoryTheory.Limits.Cocones.precomposeEquivalence_inverse
code: /-- If `F` and `G` are naturally isomorphic functors, then they have equivalent categories of
cocones.
-/
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
goal: (CategoryTheory.Limits.Cocones.precomposeEquivalence α).inverse = CategoryTheory.Limits.Cocones.precompose α.inv

full_name: CategoryTheory.Limits.Cocones.whiskering
code: /-- Whiskering on the left by `E : K ⥤ J` gives a functor from `Cocone F` to `Cocone (E ⋙ F)`.
-/
@[simps]
def whiskering (E : K ⥤ J) : Cocone F ⥤ Cocone (E ⋙ F) 
goal: CategoryTheory.Limits.Cocone F ⥤ CategoryTheory.Limits.Cocone (E ⋙ F)

full_name: CategoryTheory.Limits.Cocones.whiskering_map_hom
code: /-- Whiskering on the left by `E : K ⥤ J` gives a functor from `Cocone F` to `Cocone (E ⋙ F)`.
-/
@[simps]
def whiskering (E : K ⥤ J) : Cocone F ⥤ Cocone (E ⋙ F) 
goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y), ((CategoryTheory.Limits.Cocones.whiskering E).map f).hom = f.hom

full_name: CategoryTheory.Limits.Cocones.whiskering_obj
code: /-- Whiskering on the left by `E : K ⥤ J` gives a functor from `Cocone F` to `Cocone (E ⋙ F)`.
-/
@[simps]
def whiskering (E : K ⥤ J) : Cocone F ⥤ Cocone (E ⋙ F) 
goal: (CategoryTheory.Limits.Cocones.whiskering E).obj c = CategoryTheory.Limits.Cocone.whisker E c

full_name: CategoryTheory.Limits.Cocones.whiskeringEquivalence_inverse
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (e.functor ⋙ F) 
goal: (CategoryTheory.Limits.Cocones.whiskeringEquivalence e).inverse =
  CategoryTheory.Limits.Cocones.whiskering e.inverse ⋙
    CategoryTheory.Limits.Cocones.precompose
      (F.leftUnitor.inv ≫ CategoryTheory.whiskerRight e.counitIso.inv F ≫ (e.inverse.associator e.functor F).inv)

full_name: CategoryTheory.Limits.Cocones.whiskeringEquivalence
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (e.functor ⋙ F) 
goal: CategoryTheory.Limits.Cocone F ≌ CategoryTheory.Limits.Cocone (e.functor ⋙ F)

full_name: CategoryTheory.Limits.Cocones.whiskeringEquivalence_counitIso
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (e.functor ⋙ F) 
goal: (CategoryTheory.Limits.Cocones.whiskeringEquivalence e).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cocones.ext
        (CategoryTheory.Iso.refl
          (((CategoryTheory.Limits.Cocones.whiskering e.inverse ⋙
                    CategoryTheory.Limits.Cocones.precompose
                      (F.leftUnitor.inv ≫
                        CategoryTheory.whiskerRight e.counitIso.inv F ≫ (e.inverse.associator e.functor F).inv)) ⋙
                  CategoryTheory.Limits.Cocones.whiskering e.functor).obj
              s).pt)
        ⋯)
    ⋯

full_name: CategoryTheory.Limits.Cocones.whiskeringEquivalence_functor
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (e.functor ⋙ F) 
goal: (CategoryTheory.Limits.Cocones.whiskeringEquivalence e).functor = CategoryTheory.Limits.Cocones.whiskering e.functor

full_name: CategoryTheory.Limits.Cocones.whiskeringEquivalence_unitIso
code: /-- Whiskering by an equivalence gives an equivalence between categories of cones.
-/
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (e.functor ⋙ F) 
goal: (CategoryTheory.Limits.Cocones.whiskeringEquivalence e).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cocones.ext (CategoryTheory.Iso.refl ((𝟭 (CategoryTheory.Limits.Cocone F)).obj s).pt) ⋯)
    ⋯

full_name: CategoryTheory.Limits.Cocones.equivalenceOfReindexing_functor_obj
code: /--
The categories of cocones over `F` and `G` are equivalent if `F` and `G` are naturally isomorphic
(possibly after changing the indexing category by an equivalence).
-/
@[simps! functor_obj]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cocone F ≌ Cocone G 
goal: (CategoryTheory.Limits.Cocones.equivalenceOfReindexing e α).functor.obj X =
  (CategoryTheory.Limits.Cocones.precompose α.inv).obj (CategoryTheory.Limits.Cocone.whisker e.functor X)

full_name: CategoryTheory.Limits.Cocones.equivalenceOfReindexing
code: /--
The categories of cocones over `F` and `G` are equivalent if `F` and `G` are naturally isomorphic
(possibly after changing the indexing category by an equivalence).
-/
@[simps! functor_obj]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cocone F ≌ Cocone G 
goal: CategoryTheory.Limits.Cocone F ≌ CategoryTheory.Limits.Cocone G

full_name: CategoryTheory.Limits.Cocones.forget_obj
code: /-- Forget the cocone structure and obtain just the cocone point. -/
@[simps]
def forget : Cocone F ⥤ C 
goal: (CategoryTheory.Limits.Cocones.forget F).obj t = t.pt

full_name: CategoryTheory.Limits.Cocones.forget_map
code: /-- Forget the cocone structure and obtain just the cocone point. -/
@[simps]
def forget : Cocone F ⥤ C 
goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y), (CategoryTheory.Limits.Cocones.forget F).map f = f.hom

full_name: CategoryTheory.Limits.Cocones.forget
code: /-- Forget the cocone structure and obtain just the cocone point. -/
@[simps]
def forget : Cocone F ⥤ C 
goal: CategoryTheory.Limits.Cocone F ⥤ C

full_name: CategoryTheory.Limits.Cocones.functoriality_obj_pt
code: /-- A functor `G : C ⥤ D` sends cocones over `F` to cocones over `F ⋙ G` functorially. -/
@[simps]
def functoriality : Cocone F ⥤ Cocone (F ⋙ G) 
goal: ((CategoryTheory.Limits.Cocones.functoriality F G).obj A).pt = G.obj A.pt

full_name: CategoryTheory.Limits.Cocones.functoriality_map_hom
code: /-- A functor `G : C ⥤ D` sends cocones over `F` to cocones over `F ⋙ G` functorially. -/
@[simps]
def functoriality : Cocone F ⥤ Cocone (F ⋙ G) 
goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocones.functoriality F G).map f).hom = G.map f.hom

full_name: CategoryTheory.Limits.Cocones.functoriality
code: /-- A functor `G : C ⥤ D` sends cocones over `F` to cocones over `F ⋙ G` functorially. -/
@[simps]
def functoriality : Cocone F ⥤ Cocone (F ⋙ G) 
goal: CategoryTheory.Limits.Cocone F ⥤ CategoryTheory.Limits.Cocone (F ⋙ G)

full_name: CategoryTheory.Limits.Cocones.functoriality_obj_ι_app
code: /-- A functor `G : C ⥤ D` sends cocones over `F` to cocones over `F ⋙ G` functorially. -/
@[simps]
def functoriality : Cocone F ⥤ Cocone (F ⋙ G) 
goal: ((CategoryTheory.Limits.Cocones.functoriality F G).obj A).ι.app j = G.map (A.ι.app j)

full_name: CategoryTheory.Limits.Cocones.functoriality_full
code: instance functoriality_full [G.Full] [G.Faithful] : (functoriality F G).Full 
goal: (CategoryTheory.Limits.Cocones.functoriality F G).Full

full_name: CategoryTheory.Limits.Cocones.functoriality_faithful
code: instance functoriality_faithful [G.Faithful] : (functoriality F G).Faithful 
goal: (CategoryTheory.Limits.Cocones.functoriality F G).Faithful

full_name: CategoryTheory.Limits.Cocones.functorialityEquivalence_counitIso
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cocones over `F` and cocones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (F ⋙ e.functor) 
goal: (CategoryTheory.Limits.Cocones.functorialityEquivalence F e).counitIso =
  CategoryTheory.NatIso.ofComponents (fun c => CategoryTheory.Limits.Cocones.ext (e.counitIso.app c.pt) ⋯) ⋯

full_name: CategoryTheory.Limits.Cocones.functorialityEquivalence_unitIso
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cocones over `F` and cocones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (F ⋙ e.functor) 
goal: (CategoryTheory.Limits.Cocones.functorialityEquivalence F e).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun c => CategoryTheory.Limits.Cocones.ext (e.unitIso.app ((𝟭 (CategoryTheory.Limits.Cocone F)).obj c).1) ⋯) ⋯

full_name: CategoryTheory.Limits.Cocones.functorialityEquivalence_functor
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cocones over `F` and cocones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (F ⋙ e.functor) 
goal: (CategoryTheory.Limits.Cocones.functorialityEquivalence F e).functor =
  CategoryTheory.Limits.Cocones.functoriality F e.functor

full_name: CategoryTheory.Limits.Cocones.functorialityEquivalence_inverse
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cocones over `F` and cocones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (F ⋙ e.functor) 
goal: (CategoryTheory.Limits.Cocones.functorialityEquivalence F e).inverse =
  CategoryTheory.Limits.Cocones.functoriality (F ⋙ e.functor) e.inverse ⋙
    (CategoryTheory.Limits.Cocones.precomposeEquivalence
        (F.associator e.functor e.inverse ≪≫
            CategoryTheory.isoWhiskerLeft F e.unitIso.symm ≪≫ F.rightUnitor).symm).functor

full_name: CategoryTheory.Limits.Cocones.functorialityEquivalence
code: /-- If `e : C ≌ D` is an equivalence of categories, then `functoriality F e.functor` induces an
equivalence between cocones over `F` and cocones over `F ⋙ e.functor`.
-/
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (F ⋙ e.functor) 
goal: CategoryTheory.Limits.Cocone F ≌ CategoryTheory.Limits.Cocone (F ⋙ e.functor)

full_name: CategoryTheory.Limits.Cocones.reflects_cocone_isomorphism
code: /-- If `F` reflects isomorphisms, then `Cocones.functoriality F` reflects isomorphisms
as well.
-/
instance reflects_cocone_isomorphism (F : C ⥤ D) [F.ReflectsIsomorphisms] (K : J ⥤ C) :
    (Cocones.functoriality K F).ReflectsIsomorphisms 
goal: (CategoryTheory.Limits.Cocones.functoriality K F).ReflectsIsomorphisms

full_name: CategoryTheory.Functor.mapCone
code: /-- The image of a cone in C under a functor G : C ⥤ D is a cone in D. -/
@[simps!]
def mapCone (c : Cone F) : Cone (F ⋙ H) 
goal: CategoryTheory.Limits.Cone (F ⋙ H)

full_name: CategoryTheory.Functor.mapCone_pt
code: /-- The image of a cone in C under a functor G : C ⥤ D is a cone in D. -/
@[simps!]
def mapCone (c : Cone F) : Cone (F ⋙ H) 
goal: (H.mapCone c).pt = H.obj c.pt

full_name: CategoryTheory.Functor.mapCone_π_app
code: /-- The image of a cone in C under a functor G : C ⥤ D is a cone in D. -/
@[simps!]
def mapCone (c : Cone F) : Cone (F ⋙ H) 
goal: (H.mapCone c).π.app j = H.map (c.π.app j)

full_name: CategoryTheory.Functor.mapCocone_pt
code: /-- The image of a cocone in C under a functor G : C ⥤ D is a cocone in D. -/
@[simps!]
def mapCocone (c : Cocone F) : Cocone (F ⋙ H) 
goal: (H.mapCocone c).pt = H.obj c.pt

full_name: CategoryTheory.Functor.mapCocone
code: /-- The image of a cocone in C under a functor G : C ⥤ D is a cocone in D. -/
@[simps!]
def mapCocone (c : Cocone F) : Cocone (F ⋙ H) 
goal: CategoryTheory.Limits.Cocone (F ⋙ H)

full_name: CategoryTheory.Functor.mapCocone_ι_app
code: /-- The image of a cocone in C under a functor G : C ⥤ D is a cocone in D. -/
@[simps!]
def mapCocone (c : Cocone F) : Cocone (F ⋙ H) 
goal: (H.mapCocone c).ι.app j = H.map (c.ι.app j)

full_name: CategoryTheory.Functor.mapConeMorphism
code: /-- Given a cone morphism `c ⟶ c'`, construct a cone morphism on the mapped cones functorially.  -/
def mapConeMorphism {c c' : Cone F} (f : c ⟶ c') : H.mapCone c ⟶ H.mapCone c' 
goal: H.mapCone c ⟶ H.mapCone c'

full_name: CategoryTheory.Functor.mapCoconeMorphism
code: /-- Given a cocone morphism `c ⟶ c'`, construct a cocone morphism on the mapped cocones
functorially. -/
def mapCoconeMorphism {c c' : Cocone F} (f : c ⟶ c') : H.mapCocone c ⟶ H.mapCocone c' 
goal: H.mapCocone c ⟶ H.mapCocone c'

full_name: CategoryTheory.Functor.mapConeInv
code: /-- If `H` is an equivalence, we invert `H.mapCone` and get a cone for `F` from a cone
for `F ⋙ H`. -/
noncomputable def mapConeInv [IsEquivalence H] (c : Cone (F ⋙ H)) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Functor.mapConeMapConeInv
code: /-- `mapCone` is the left inverse to `mapConeInv`. -/
noncomputable def mapConeMapConeInv {F : J ⥤ D} (H : D ⥤ C) [IsEquivalence H]
    (c : Cone (F ⋙ H)) :
    mapCone H (mapConeInv H c) ≅ c 
goal: H.mapCone (H.mapConeInv c) ≅ c

full_name: CategoryTheory.Functor.mapConeInvMapCone
code: /-- `MapCone` is the right inverse to `mapConeInv`. -/
noncomputable def mapConeInvMapCone {F : J ⥤ D} (H : D ⥤ C) [IsEquivalence H] (c : Cone F) :
    mapConeInv H (mapCone H c) ≅ c 
goal: H.mapConeInv (H.mapCone c) ≅ c

full_name: CategoryTheory.Functor.mapCoconeInv
code: /-- If `H` is an equivalence, we invert `H.mapCone` and get a cone for `F` from a cone
for `F ⋙ H`. -/
noncomputable def mapCoconeInv [IsEquivalence H] (c : Cocone (F ⋙ H)) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Functor.mapCoconeMapCoconeInv
code: /-- `mapCocone` is the left inverse to `mapCoconeInv`. -/
noncomputable def mapCoconeMapCoconeInv {F : J ⥤ D} (H : D ⥤ C) [IsEquivalence H]
    (c : Cocone (F ⋙ H)) :
    mapCocone H (mapCoconeInv H c) ≅ c 
goal: H.mapCocone (H.mapCoconeInv c) ≅ c

full_name: CategoryTheory.Functor.mapCoconeInvMapCocone
code: /-- `mapCocone` is the right inverse to `mapCoconeInv`. -/
noncomputable def mapCoconeInvMapCocone {F : J ⥤ D} (H : D ⥤ C) [IsEquivalence H] (c : Cocone F) :
    mapCoconeInv H (mapCocone H c) ≅ c 
goal: H.mapCoconeInv (H.mapCocone c) ≅ c

full_name: CategoryTheory.Functor.functorialityCompPostcompose_inv_app_hom
code: /-- `functoriality F _ ⋙ postcompose (whisker_left F _)` simplifies to `functoriality F _`. -/
@[simps!]
def functorialityCompPostcompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cones.functoriality F H ⋙ Cones.postcompose (whiskerLeft F α.hom) ≅ Cones.functoriality F H' 
goal: ((CategoryTheory.Functor.functorialityCompPostcompose α).inv.app X).hom = α.inv.app X.pt

full_name: CategoryTheory.Functor.functorialityCompPostcompose
code: /-- `functoriality F _ ⋙ postcompose (whisker_left F _)` simplifies to `functoriality F _`. -/
@[simps!]
def functorialityCompPostcompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cones.functoriality F H ⋙ Cones.postcompose (whiskerLeft F α.hom) ≅ Cones.functoriality F H' 
goal: CategoryTheory.Limits.Cones.functoriality F H ⋙
    CategoryTheory.Limits.Cones.postcompose (CategoryTheory.whiskerLeft F α.hom) ≅
  CategoryTheory.Limits.Cones.functoriality F H'

full_name: CategoryTheory.Functor.functorialityCompPostcompose_hom_app_hom
code: /-- `functoriality F _ ⋙ postcompose (whisker_left F _)` simplifies to `functoriality F _`. -/
@[simps!]
def functorialityCompPostcompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cones.functoriality F H ⋙ Cones.postcompose (whiskerLeft F α.hom) ≅ Cones.functoriality F H' 
goal: ((CategoryTheory.Functor.functorialityCompPostcompose α).hom.app X).hom = α.hom.app X.pt

full_name: CategoryTheory.Functor.postcomposeWhiskerLeftMapCone
code: /-- For `F : J ⥤ C`, given a cone `c : Cone F`, and a natural isomorphism `α : H ≅ H'` for functors
`H H' : C ⥤ D`, the postcomposition of the cone `H.mapCone` using the isomorphism `α` is
isomorphic to the cone `H'.mapCone`.
-/
@[simps!]
def postcomposeWhiskerLeftMapCone {H H' : C ⥤ D} (α : H ≅ H') (c : Cone F) :
    (Cones.postcompose (whiskerLeft F α.hom : _)).obj (mapCone H c) ≅ mapCone H' c 
goal: (CategoryTheory.Limits.Cones.postcompose (CategoryTheory.whiskerLeft F α.hom)).obj (H.mapCone c) ≅ H'.mapCone c

full_name: CategoryTheory.Functor.postcomposeWhiskerLeftMapCone_hom_hom
code: /-- For `F : J ⥤ C`, given a cone `c : Cone F`, and a natural isomorphism `α : H ≅ H'` for functors
`H H' : C ⥤ D`, the postcomposition of the cone `H.mapCone` using the isomorphism `α` is
isomorphic to the cone `H'.mapCone`.
-/
@[simps!]
def postcomposeWhiskerLeftMapCone {H H' : C ⥤ D} (α : H ≅ H') (c : Cone F) :
    (Cones.postcompose (whiskerLeft F α.hom : _)).obj (mapCone H c) ≅ mapCone H' c 
goal: (CategoryTheory.Functor.postcomposeWhiskerLeftMapCone α c).hom.hom = α.hom.app c.pt

full_name: CategoryTheory.Functor.postcomposeWhiskerLeftMapCone_inv_hom
code: /-- For `F : J ⥤ C`, given a cone `c : Cone F`, and a natural isomorphism `α : H ≅ H'` for functors
`H H' : C ⥤ D`, the postcomposition of the cone `H.mapCone` using the isomorphism `α` is
isomorphic to the cone `H'.mapCone`.
-/
@[simps!]
def postcomposeWhiskerLeftMapCone {H H' : C ⥤ D} (α : H ≅ H') (c : Cone F) :
    (Cones.postcompose (whiskerLeft F α.hom : _)).obj (mapCone H c) ≅ mapCone H' c 
goal: (CategoryTheory.Functor.postcomposeWhiskerLeftMapCone α c).inv.hom = α.inv.app c.pt

full_name: CategoryTheory.Functor.mapConePostcompose_hom_hom
code: /--
`mapCone` commutes with `postcompose`. In particular, for `F : J ⥤ C`, given a cone `c : Cone F`, a
natural transformation `α : F ⟶ G` and a functor `H : C ⥤ D`, we have two obvious ways of producing
a cone over `G ⋙ H`, and they are both isomorphic.
-/
@[simps!]
def mapConePostcompose {α : F ⟶ G} {c} :
    mapCone H ((Cones.postcompose α).obj c) ≅
      (Cones.postcompose (whiskerRight α H : _)).obj (mapCone H c) 
goal: H.mapConePostcompose.hom.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapConePostcompose
code: /--
`mapCone` commutes with `postcompose`. In particular, for `F : J ⥤ C`, given a cone `c : Cone F`, a
natural transformation `α : F ⟶ G` and a functor `H : C ⥤ D`, we have two obvious ways of producing
a cone over `G ⋙ H`, and they are both isomorphic.
-/
@[simps!]
def mapConePostcompose {α : F ⟶ G} {c} :
    mapCone H ((Cones.postcompose α).obj c) ≅
      (Cones.postcompose (whiskerRight α H : _)).obj (mapCone H c) 
goal: H.mapCone ((CategoryTheory.Limits.Cones.postcompose α).obj c) ≅
  (CategoryTheory.Limits.Cones.postcompose (CategoryTheory.whiskerRight α H)).obj (H.mapCone c)

full_name: CategoryTheory.Functor.mapConePostcompose_inv_hom
code: /--
`mapCone` commutes with `postcompose`. In particular, for `F : J ⥤ C`, given a cone `c : Cone F`, a
natural transformation `α : F ⟶ G` and a functor `H : C ⥤ D`, we have two obvious ways of producing
a cone over `G ⋙ H`, and they are both isomorphic.
-/
@[simps!]
def mapConePostcompose {α : F ⟶ G} {c} :
    mapCone H ((Cones.postcompose α).obj c) ≅
      (Cones.postcompose (whiskerRight α H : _)).obj (mapCone H c) 
goal: H.mapConePostcompose.inv.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapConePostcomposeEquivalenceFunctor_hom_hom
code: /-- `mapCone` commutes with `postcomposeEquivalence`
-/
@[simps!]
def mapConePostcomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCone H ((Cones.postcomposeEquivalence α).functor.obj c) ≅
      (Cones.postcomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCone H c) 
goal: H.mapConePostcomposeEquivalenceFunctor.hom.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapConePostcomposeEquivalenceFunctor
code: /-- `mapCone` commutes with `postcomposeEquivalence`
-/
@[simps!]
def mapConePostcomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCone H ((Cones.postcomposeEquivalence α).functor.obj c) ≅
      (Cones.postcomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCone H c) 
goal: H.mapCone ((CategoryTheory.Limits.Cones.postcomposeEquivalence α).functor.obj c) ≅
  (CategoryTheory.Limits.Cones.postcomposeEquivalence (CategoryTheory.isoWhiskerRight α H)).functor.obj (H.mapCone c)

full_name: CategoryTheory.Functor.mapConePostcomposeEquivalenceFunctor_inv_hom
code: /-- `mapCone` commutes with `postcomposeEquivalence`
-/
@[simps!]
def mapConePostcomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCone H ((Cones.postcomposeEquivalence α).functor.obj c) ≅
      (Cones.postcomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCone H c) 
goal: H.mapConePostcomposeEquivalenceFunctor.inv.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.functorialityCompPrecompose
code: /-- `functoriality F _ ⋙ precompose (whiskerLeft F _)` simplifies to `functoriality F _`. -/
@[simps!]
def functorialityCompPrecompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cocones.functoriality F H ⋙ Cocones.precompose (whiskerLeft F α.inv) ≅
      Cocones.functoriality F H' 
goal: CategoryTheory.Limits.Cocones.functoriality F H ⋙
    CategoryTheory.Limits.Cocones.precompose (CategoryTheory.whiskerLeft F α.inv) ≅
  CategoryTheory.Limits.Cocones.functoriality F H'

full_name: CategoryTheory.Functor.functorialityCompPrecompose_hom_app_hom
code: /-- `functoriality F _ ⋙ precompose (whiskerLeft F _)` simplifies to `functoriality F _`. -/
@[simps!]
def functorialityCompPrecompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cocones.functoriality F H ⋙ Cocones.precompose (whiskerLeft F α.inv) ≅
      Cocones.functoriality F H' 
goal: ((CategoryTheory.Functor.functorialityCompPrecompose α).hom.app X).hom = α.hom.app X.pt

full_name: CategoryTheory.Functor.functorialityCompPrecompose_inv_app_hom
code: /-- `functoriality F _ ⋙ precompose (whiskerLeft F _)` simplifies to `functoriality F _`. -/
@[simps!]
def functorialityCompPrecompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cocones.functoriality F H ⋙ Cocones.precompose (whiskerLeft F α.inv) ≅
      Cocones.functoriality F H' 
goal: ((CategoryTheory.Functor.functorialityCompPrecompose α).inv.app X).hom = α.inv.app X.pt

full_name: CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_inv_hom
code: /--
For `F : J ⥤ C`, given a cocone `c : Cocone F`, and a natural isomorphism `α : H ≅ H'` for functors
`H H' : C ⥤ D`, the precomposition of the cocone `H.mapCocone` using the isomorphism `α` is
isomorphic to the cocone `H'.mapCocone`.
-/
@[simps!]
def precomposeWhiskerLeftMapCocone {H H' : C ⥤ D} (α : H ≅ H') (c : Cocone F) :
    (Cocones.precompose (whiskerLeft F α.inv : _)).obj (mapCocone H c) ≅ mapCocone H' c 
goal: (CategoryTheory.Functor.precomposeWhiskerLeftMapCocone α c).inv.hom = α.inv.app c.pt

full_name: CategoryTheory.Functor.precomposeWhiskerLeftMapCocone
code: /--
For `F : J ⥤ C`, given a cocone `c : Cocone F`, and a natural isomorphism `α : H ≅ H'` for functors
`H H' : C ⥤ D`, the precomposition of the cocone `H.mapCocone` using the isomorphism `α` is
isomorphic to the cocone `H'.mapCocone`.
-/
@[simps!]
def precomposeWhiskerLeftMapCocone {H H' : C ⥤ D} (α : H ≅ H') (c : Cocone F) :
    (Cocones.precompose (whiskerLeft F α.inv : _)).obj (mapCocone H c) ≅ mapCocone H' c 
goal: (CategoryTheory.Limits.Cocones.precompose (CategoryTheory.whiskerLeft F α.inv)).obj (H.mapCocone c) ≅ H'.mapCocone c

full_name: CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_hom_hom
code: /--
For `F : J ⥤ C`, given a cocone `c : Cocone F`, and a natural isomorphism `α : H ≅ H'` for functors
`H H' : C ⥤ D`, the precomposition of the cocone `H.mapCocone` using the isomorphism `α` is
isomorphic to the cocone `H'.mapCocone`.
-/
@[simps!]
def precomposeWhiskerLeftMapCocone {H H' : C ⥤ D} (α : H ≅ H') (c : Cocone F) :
    (Cocones.precompose (whiskerLeft F α.inv : _)).obj (mapCocone H c) ≅ mapCocone H' c 
goal: (CategoryTheory.Functor.precomposeWhiskerLeftMapCocone α c).hom.hom = α.hom.app c.pt

full_name: CategoryTheory.Functor.mapCoconePrecompose
code: /-- `map_cocone` commutes with `precompose`. In particular, for `F : J ⥤ C`, given a cocone
`c : Cocone F`, a natural transformation `α : F ⟶ G` and a functor `H : C ⥤ D`, we have two obvious
ways of producing a cocone over `G ⋙ H`, and they are both isomorphic.
-/
@[simps!]
def mapCoconePrecompose {α : F ⟶ G} {c} :
    mapCocone H ((Cocones.precompose α).obj c) ≅
      (Cocones.precompose (whiskerRight α H : _)).obj (mapCocone H c) 
goal: H.mapCocone ((CategoryTheory.Limits.Cocones.precompose α).obj c) ≅
  (CategoryTheory.Limits.Cocones.precompose (CategoryTheory.whiskerRight α H)).obj (H.mapCocone c)

full_name: CategoryTheory.Functor.mapCoconePrecompose_inv_hom
code: /-- `map_cocone` commutes with `precompose`. In particular, for `F : J ⥤ C`, given a cocone
`c : Cocone F`, a natural transformation `α : F ⟶ G` and a functor `H : C ⥤ D`, we have two obvious
ways of producing a cocone over `G ⋙ H`, and they are both isomorphic.
-/
@[simps!]
def mapCoconePrecompose {α : F ⟶ G} {c} :
    mapCocone H ((Cocones.precompose α).obj c) ≅
      (Cocones.precompose (whiskerRight α H : _)).obj (mapCocone H c) 
goal: H.mapCoconePrecompose.inv.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapCoconePrecompose_hom_hom
code: /-- `map_cocone` commutes with `precompose`. In particular, for `F : J ⥤ C`, given a cocone
`c : Cocone F`, a natural transformation `α : F ⟶ G` and a functor `H : C ⥤ D`, we have two obvious
ways of producing a cocone over `G ⋙ H`, and they are both isomorphic.
-/
@[simps!]
def mapCoconePrecompose {α : F ⟶ G} {c} :
    mapCocone H ((Cocones.precompose α).obj c) ≅
      (Cocones.precompose (whiskerRight α H : _)).obj (mapCocone H c) 
goal: H.mapCoconePrecompose.hom.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapCoconePrecomposeEquivalenceFunctor_inv_hom
code: /-- `mapCocone` commutes with `precomposeEquivalence`
-/
@[simps!]
def mapCoconePrecomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCocone H ((Cocones.precomposeEquivalence α).functor.obj c) ≅
      (Cocones.precomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCocone H c) 
goal: H.mapCoconePrecomposeEquivalenceFunctor.inv.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapCoconePrecomposeEquivalenceFunctor
code: /-- `mapCocone` commutes with `precomposeEquivalence`
-/
@[simps!]
def mapCoconePrecomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCocone H ((Cocones.precomposeEquivalence α).functor.obj c) ≅
      (Cocones.precomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCocone H c) 
goal: H.mapCocone ((CategoryTheory.Limits.Cocones.precomposeEquivalence α).functor.obj c) ≅
  (CategoryTheory.Limits.Cocones.precomposeEquivalence (CategoryTheory.isoWhiskerRight α H)).functor.obj (H.mapCocone c)

full_name: CategoryTheory.Functor.mapCoconePrecomposeEquivalenceFunctor_hom_hom
code: /-- `mapCocone` commutes with `precomposeEquivalence`
-/
@[simps!]
def mapCoconePrecomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCocone H ((Cocones.precomposeEquivalence α).functor.obj c) ≅
      (Cocones.precomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCocone H c) 
goal: H.mapCoconePrecomposeEquivalenceFunctor.hom.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapConeWhisker_inv_hom
code: /-- `mapCone` commutes with `whisker`
-/
@[simps!]
def mapConeWhisker {E : K ⥤ J} {c : Cone F} : mapCone H (c.whisker E) ≅ (mapCone H c).whisker E 
goal: H.mapConeWhisker.inv.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapConeWhisker
code: /-- `mapCone` commutes with `whisker`
-/
@[simps!]
def mapConeWhisker {E : K ⥤ J} {c : Cone F} : mapCone H (c.whisker E) ≅ (mapCone H c).whisker E 
goal: H.mapCone (CategoryTheory.Limits.Cone.whisker E c) ≅ CategoryTheory.Limits.Cone.whisker E (H.mapCone c)

full_name: CategoryTheory.Functor.mapConeWhisker_hom_hom
code: /-- `mapCone` commutes with `whisker`
-/
@[simps!]
def mapConeWhisker {E : K ⥤ J} {c : Cone F} : mapCone H (c.whisker E) ≅ (mapCone H c).whisker E 
goal: H.mapConeWhisker.hom.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapCoconeWhisker
code: /-- `mapCocone` commutes with `whisker`
-/
@[simps!]
def mapCoconeWhisker {E : K ⥤ J} {c : Cocone F} :
    mapCocone H (c.whisker E) ≅ (mapCocone H c).whisker E 
goal: H.mapCocone (CategoryTheory.Limits.Cocone.whisker E c) ≅ CategoryTheory.Limits.Cocone.whisker E (H.mapCocone c)

full_name: CategoryTheory.Functor.mapCoconeWhisker_hom_hom
code: /-- `mapCocone` commutes with `whisker`
-/
@[simps!]
def mapCoconeWhisker {E : K ⥤ J} {c : Cocone F} :
    mapCocone H (c.whisker E) ≅ (mapCocone H c).whisker E 
goal: H.mapCoconeWhisker.hom.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Functor.mapCoconeWhisker_inv_hom
code: /-- `mapCocone` commutes with `whisker`
-/
@[simps!]
def mapCoconeWhisker {E : K ⥤ J} {c : Cocone F} :
    mapCocone H (c.whisker E) ≅ (mapCocone H c).whisker E 
goal: H.mapCoconeWhisker.inv.hom = 𝟙 (H.obj c.pt)

full_name: CategoryTheory.Limits.Cocone.op
code: /-- Change a `Cocone F` into a `Cone F.op`. -/
@[simps]
def Cocone.op (c : Cocone F) : Cone F.op 
goal: CategoryTheory.Limits.Cone F.op

full_name: CategoryTheory.Limits.Cocone.op_pt
code: /-- Change a `Cocone F` into a `Cone F.op`. -/
@[simps]
def Cocone.op (c : Cocone F) : Cone F.op 
goal: c.op.pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.Cocone.op_π
code: /-- Change a `Cocone F` into a `Cone F.op`. -/
@[simps]
def Cocone.op (c : Cocone F) : Cone F.op 
goal: c.op.π = CategoryTheory.NatTrans.op c.ι

full_name: CategoryTheory.Limits.Cone.op_ι
code: /-- Change a `Cone F` into a `Cocone F.op`. -/
@[simps]
def Cone.op (c : Cone F) : Cocone F.op 
goal: c.op.ι = CategoryTheory.NatTrans.op c.π

full_name: CategoryTheory.Limits.Cone.op
code: /-- Change a `Cone F` into a `Cocone F.op`. -/
@[simps]
def Cone.op (c : Cone F) : Cocone F.op 
goal: CategoryTheory.Limits.Cocone F.op

full_name: CategoryTheory.Limits.Cone.op_pt
code: /-- Change a `Cone F` into a `Cocone F.op`. -/
@[simps]
def Cone.op (c : Cone F) : Cocone F.op 
goal: c.op.pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.Cocone.unop_π
code: /-- Change a `Cocone F.op` into a `Cone F`. -/
@[simps]
def Cocone.unop (c : Cocone F.op) : Cone F 
goal: c.unop.π = CategoryTheory.NatTrans.removeOp c.ι

full_name: CategoryTheory.Limits.Cocone.unop
code: /-- Change a `Cocone F.op` into a `Cone F`. -/
@[simps]
def Cocone.unop (c : Cocone F.op) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.Cocone.unop_pt
code: /-- Change a `Cocone F.op` into a `Cone F`. -/
@[simps]
def Cocone.unop (c : Cocone F.op) : Cone F 
goal: c.unop.pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.Cone.unop_pt
code: /-- Change a `Cone F.op` into a `Cocone F`. -/
@[simps]
def Cone.unop (c : Cone F.op) : Cocone F 
goal: c.unop.pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.Cone.unop_ι
code: /-- Change a `Cone F.op` into a `Cocone F`. -/
@[simps]
def Cone.unop (c : Cone F.op) : Cocone F 
goal: c.unop.ι = CategoryTheory.NatTrans.removeOp c.π

full_name: CategoryTheory.Limits.Cone.unop
code: /-- Change a `Cone F.op` into a `Cocone F`. -/
@[simps]
def Cone.unop (c : Cone F.op) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.coconeEquivalenceOpConeOp
code: /-- The category of cocones on `F`
is equivalent to the opposite category of
the category of cones on the opposite of `F`.
-/
def coconeEquivalenceOpConeOp : Cocone F ≌ (Cone F.op)ᵒᵖ 
goal: CategoryTheory.Limits.Cocone F ≌ (CategoryTheory.Limits.Cone F.op)ᵒᵖ

full_name: CategoryTheory.Limits.coneOfCoconeLeftOp_pt
code: /-- Change a cocone on `F.leftOp : Jᵒᵖ ⥤ C` to a cocone on `F : J ⥤ Cᵒᵖ`. -/
@[simps!]
def coneOfCoconeLeftOp (c : Cocone F.leftOp) : Cone F 
goal: (CategoryTheory.Limits.coneOfCoconeLeftOp c).pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.coneOfCoconeLeftOp
code: /-- Change a cocone on `F.leftOp : Jᵒᵖ ⥤ C` to a cocone on `F : J ⥤ Cᵒᵖ`. -/
@[simps!]
def coneOfCoconeLeftOp (c : Cocone F.leftOp) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.coneOfCoconeLeftOp_π_app
code: /-- Change a cocone on `F.leftOp : Jᵒᵖ ⥤ C` to a cocone on `F : J ⥤ Cᵒᵖ`. -/
@[simps!]
def coneOfCoconeLeftOp (c : Cocone F.leftOp) : Cone F 
goal: (CategoryTheory.Limits.coneOfCoconeLeftOp c).π.app X = (c.ι.app (Opposite.op X)).op

full_name: CategoryTheory.Limits.coconeLeftOpOfCone_ι_app
code: /-- Change a cone on `F : J ⥤ Cᵒᵖ` to a cocone on `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps!]
def coconeLeftOpOfCone (c : Cone F) : Cocone F.leftOp 
goal: (CategoryTheory.Limits.coconeLeftOpOfCone c).ι.app X = (c.π.app (Opposite.unop X)).unop

full_name: CategoryTheory.Limits.coconeLeftOpOfCone_pt
code: /-- Change a cone on `F : J ⥤ Cᵒᵖ` to a cocone on `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps!]
def coconeLeftOpOfCone (c : Cone F) : Cocone F.leftOp 
goal: (CategoryTheory.Limits.coconeLeftOpOfCone c).pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.coconeLeftOpOfCone
code: /-- Change a cone on `F : J ⥤ Cᵒᵖ` to a cocone on `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps!]
def coconeLeftOpOfCone (c : Cone F) : Cocone F.leftOp 
goal: CategoryTheory.Limits.Cocone F.leftOp

full_name: CategoryTheory.Limits.coconeOfConeLeftOp_pt
code: /-- Change a cone on `F.leftOp : Jᵒᵖ ⥤ C` to a cocone on `F : J ⥤ Cᵒᵖ`. -/
@[simps pt]
def coconeOfConeLeftOp (c : Cone F.leftOp) : Cocone F 
goal: (CategoryTheory.Limits.coconeOfConeLeftOp c).pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.coconeOfConeLeftOp
code: /-- Change a cone on `F.leftOp : Jᵒᵖ ⥤ C` to a cocone on `F : J ⥤ Cᵒᵖ`. -/
@[simps pt]
def coconeOfConeLeftOp (c : Cone F.leftOp) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.coconeOfConeLeftOp_ι_app
code: @[simp]
theorem coconeOfConeLeftOp_ι_app (c : Cone F.leftOp) (j) :
    (coconeOfConeLeftOp c).ι.app j = (c.π.app (op j)).op 
goal: (CategoryTheory.Limits.coconeOfConeLeftOp c).ι.app j = (c.π.app (Opposite.op j)).op

full_name: CategoryTheory.Limits.coneLeftOpOfCocone_pt
code: /-- Change a cocone on `F : J ⥤ Cᵒᵖ` to a cone on `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps!]
def coneLeftOpOfCocone (c : Cocone F) : Cone F.leftOp 
goal: (CategoryTheory.Limits.coneLeftOpOfCocone c).pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.coneLeftOpOfCocone_π_app
code: /-- Change a cocone on `F : J ⥤ Cᵒᵖ` to a cone on `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps!]
def coneLeftOpOfCocone (c : Cocone F) : Cone F.leftOp 
goal: (CategoryTheory.Limits.coneLeftOpOfCocone c).π.app X = (c.ι.app (Opposite.unop X)).unop

full_name: CategoryTheory.Limits.coneLeftOpOfCocone
code: /-- Change a cocone on `F : J ⥤ Cᵒᵖ` to a cone on `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps!]
def coneLeftOpOfCocone (c : Cocone F) : Cone F.leftOp 
goal: CategoryTheory.Limits.Cone F.leftOp

full_name: CategoryTheory.Limits.coneOfCoconeRightOp
code: /-- Change a cocone on `F.rightOp : J ⥤ Cᵒᵖ` to a cone on `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def coneOfCoconeRightOp (c : Cocone F.rightOp) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.coneOfCoconeRightOp_pt
code: /-- Change a cocone on `F.rightOp : J ⥤ Cᵒᵖ` to a cone on `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def coneOfCoconeRightOp (c : Cocone F.rightOp) : Cone F 
goal: (CategoryTheory.Limits.coneOfCoconeRightOp c).pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.coneOfCoconeRightOp_π
code: /-- Change a cocone on `F.rightOp : J ⥤ Cᵒᵖ` to a cone on `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def coneOfCoconeRightOp (c : Cocone F.rightOp) : Cone F 
goal: (CategoryTheory.Limits.coneOfCoconeRightOp c).π = CategoryTheory.NatTrans.removeRightOp c.ι

full_name: CategoryTheory.Limits.coconeRightOpOfCone_pt
code: /-- Change a cone on `F : Jᵒᵖ ⥤ C` to a cocone on `F.rightOp : Jᵒᵖ ⥤ C`. -/
@[simps]
def coconeRightOpOfCone (c : Cone F) : Cocone F.rightOp 
goal: (CategoryTheory.Limits.coconeRightOpOfCone c).pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.coconeRightOpOfCone_ι
code: /-- Change a cone on `F : Jᵒᵖ ⥤ C` to a cocone on `F.rightOp : Jᵒᵖ ⥤ C`. -/
@[simps]
def coconeRightOpOfCone (c : Cone F) : Cocone F.rightOp 
goal: (CategoryTheory.Limits.coconeRightOpOfCone c).ι = CategoryTheory.NatTrans.rightOp c.π

full_name: CategoryTheory.Limits.coconeRightOpOfCone
code: /-- Change a cone on `F : Jᵒᵖ ⥤ C` to a cocone on `F.rightOp : Jᵒᵖ ⥤ C`. -/
@[simps]
def coconeRightOpOfCone (c : Cone F) : Cocone F.rightOp 
goal: CategoryTheory.Limits.Cocone F.rightOp

full_name: CategoryTheory.Limits.coconeOfConeRightOp_ι
code: /-- Change a cone on `F.rightOp : J ⥤ Cᵒᵖ` to a cocone on `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def coconeOfConeRightOp (c : Cone F.rightOp) : Cocone F 
goal: (CategoryTheory.Limits.coconeOfConeRightOp c).ι = CategoryTheory.NatTrans.removeRightOp c.π

full_name: CategoryTheory.Limits.coconeOfConeRightOp_pt
code: /-- Change a cone on `F.rightOp : J ⥤ Cᵒᵖ` to a cocone on `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def coconeOfConeRightOp (c : Cone F.rightOp) : Cocone F 
goal: (CategoryTheory.Limits.coconeOfConeRightOp c).pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.coconeOfConeRightOp
code: /-- Change a cone on `F.rightOp : J ⥤ Cᵒᵖ` to a cocone on `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def coconeOfConeRightOp (c : Cone F.rightOp) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.coneRightOpOfCocone_π
code: /-- Change a cocone on `F : Jᵒᵖ ⥤ C` to a cone on `F.rightOp : J ⥤ Cᵒᵖ`. -/
@[simps]
def coneRightOpOfCocone (c : Cocone F) : Cone F.rightOp 
goal: (CategoryTheory.Limits.coneRightOpOfCocone c).π = CategoryTheory.NatTrans.rightOp c.ι

full_name: CategoryTheory.Limits.coneRightOpOfCocone_pt
code: /-- Change a cocone on `F : Jᵒᵖ ⥤ C` to a cone on `F.rightOp : J ⥤ Cᵒᵖ`. -/
@[simps]
def coneRightOpOfCocone (c : Cocone F) : Cone F.rightOp 
goal: (CategoryTheory.Limits.coneRightOpOfCocone c).pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.coneRightOpOfCocone
code: /-- Change a cocone on `F : Jᵒᵖ ⥤ C` to a cone on `F.rightOp : J ⥤ Cᵒᵖ`. -/
@[simps]
def coneRightOpOfCocone (c : Cocone F) : Cone F.rightOp 
goal: CategoryTheory.Limits.Cone F.rightOp

full_name: CategoryTheory.Limits.coneOfCoconeUnop_pt
code: /-- Change a cocone on `F.unop : J ⥤ C` into a cone on `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
@[simps]
def coneOfCoconeUnop (c : Cocone F.unop) : Cone F 
goal: (CategoryTheory.Limits.coneOfCoconeUnop c).pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.coneOfCoconeUnop_π
code: /-- Change a cocone on `F.unop : J ⥤ C` into a cone on `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
@[simps]
def coneOfCoconeUnop (c : Cocone F.unop) : Cone F 
goal: (CategoryTheory.Limits.coneOfCoconeUnop c).π = CategoryTheory.NatTrans.removeUnop c.ι

full_name: CategoryTheory.Limits.coneOfCoconeUnop
code: /-- Change a cocone on `F.unop : J ⥤ C` into a cone on `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
@[simps]
def coneOfCoconeUnop (c : Cocone F.unop) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.coconeUnopOfCone_ι
code: /-- Change a cone on `F : Jᵒᵖ ⥤ Cᵒᵖ` into a cocone on `F.unop : J ⥤ C`. -/
@[simps]
def coconeUnopOfCone (c : Cone F) : Cocone F.unop 
goal: (CategoryTheory.Limits.coconeUnopOfCone c).ι = CategoryTheory.NatTrans.unop c.π

full_name: CategoryTheory.Limits.coconeUnopOfCone_pt
code: /-- Change a cone on `F : Jᵒᵖ ⥤ Cᵒᵖ` into a cocone on `F.unop : J ⥤ C`. -/
@[simps]
def coconeUnopOfCone (c : Cone F) : Cocone F.unop 
goal: (CategoryTheory.Limits.coconeUnopOfCone c).pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.coconeUnopOfCone
code: /-- Change a cone on `F : Jᵒᵖ ⥤ Cᵒᵖ` into a cocone on `F.unop : J ⥤ C`. -/
@[simps]
def coconeUnopOfCone (c : Cone F) : Cocone F.unop 
goal: CategoryTheory.Limits.Cocone F.unop

full_name: CategoryTheory.Limits.coconeOfConeUnop
code: /-- Change a cone on `F.unop : J ⥤ C` into a cocone on `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
@[simps]
def coconeOfConeUnop (c : Cone F.unop) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.coconeOfConeUnop_ι
code: /-- Change a cone on `F.unop : J ⥤ C` into a cocone on `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
@[simps]
def coconeOfConeUnop (c : Cone F.unop) : Cocone F 
goal: (CategoryTheory.Limits.coconeOfConeUnop c).ι = CategoryTheory.NatTrans.removeUnop c.π

full_name: CategoryTheory.Limits.coconeOfConeUnop_pt
code: /-- Change a cone on `F.unop : J ⥤ C` into a cocone on `F : Jᵒᵖ ⥤ Cᵒᵖ`. -/
@[simps]
def coconeOfConeUnop (c : Cone F.unop) : Cocone F 
goal: (CategoryTheory.Limits.coconeOfConeUnop c).pt = Opposite.op c.pt

full_name: CategoryTheory.Limits.coneUnopOfCocone_pt
code: /-- Change a cocone on `F : Jᵒᵖ ⥤ Cᵒᵖ` into a cone on `F.unop : J ⥤ C`. -/
@[simps]
def coneUnopOfCocone (c : Cocone F) : Cone F.unop 
goal: (CategoryTheory.Limits.coneUnopOfCocone c).pt = Opposite.unop c.pt

full_name: CategoryTheory.Limits.coneUnopOfCocone
code: /-- Change a cocone on `F : Jᵒᵖ ⥤ Cᵒᵖ` into a cone on `F.unop : J ⥤ C`. -/
@[simps]
def coneUnopOfCocone (c : Cocone F) : Cone F.unop 
goal: CategoryTheory.Limits.Cone F.unop

full_name: CategoryTheory.Limits.coneUnopOfCocone_π
code: /-- Change a cocone on `F : Jᵒᵖ ⥤ Cᵒᵖ` into a cone on `F.unop : J ⥤ C`. -/
@[simps]
def coneUnopOfCocone (c : Cocone F) : Cone F.unop 
goal: (CategoryTheory.Limits.coneUnopOfCocone c).π = CategoryTheory.NatTrans.unop c.ι

full_name: CategoryTheory.Functor.mapConeOp_hom_hom
code: /-- The opposite cocone of the image of a cone is the image of the opposite cocone. -/
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapConeOp (t : Cone F) : (mapCone G t).op ≅ mapCocone G.op t.op 
goal: (CategoryTheory.Functor.mapConeOp G t).hom.hom = 𝟙 (Opposite.op (G.obj t.pt))

full_name: CategoryTheory.Functor.mapConeOp_inv_hom
code: /-- The opposite cocone of the image of a cone is the image of the opposite cocone. -/
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapConeOp (t : Cone F) : (mapCone G t).op ≅ mapCocone G.op t.op 
goal: (CategoryTheory.Functor.mapConeOp G t).inv.hom = 𝟙 (Opposite.op (G.obj t.pt))

full_name: CategoryTheory.Functor.mapConeOp
code: /-- The opposite cocone of the image of a cone is the image of the opposite cocone. -/
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapConeOp (t : Cone F) : (mapCone G t).op ≅ mapCocone G.op t.op 
goal: (G.mapCone t).op ≅ G.op.mapCocone t.op

full_name: CategoryTheory.Functor.mapCoconeOp_hom_hom
code: /-- The opposite cone of the image of a cocone is the image of the opposite cone. -/
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapCoconeOp {t : Cocone F} : (mapCocone G t).op ≅ mapCone G.op t.op 
goal: (CategoryTheory.Functor.mapCoconeOp G).hom.hom = 𝟙 (Opposite.op (G.obj t.pt))

full_name: CategoryTheory.Functor.mapCoconeOp_inv_hom
code: /-- The opposite cone of the image of a cocone is the image of the opposite cone. -/
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapCoconeOp {t : Cocone F} : (mapCocone G t).op ≅ mapCone G.op t.op 
goal: (CategoryTheory.Functor.mapCoconeOp G).inv.hom = 𝟙 (Opposite.op (G.obj t.pt))

full_name: CategoryTheory.Functor.mapCoconeOp
code: /-- The opposite cone of the image of a cocone is the image of the opposite cone. -/
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapCoconeOp {t : Cocone F} : (mapCocone G t).op ≅ mapCone G.op t.op 
goal: (G.mapCocone t).op ≅ G.op.mapCone t.op