File: Mathlib/CategoryTheory/Adjunction/Limits.lean

full_name: CategoryTheory.Adjunction.functorialityRightAdjoint
code: /-- The right adjoint of `Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F)`.

Auxiliary definition for `functorialityIsLeftAdjoint`.
-/
def functorialityRightAdjoint : Cocone (K ⋙ F) ⥤ Cocone K 
goal: CategoryTheory.Functor (CategoryTheory.Limits.Cocone (K.comp F)) (CategoryTheory.Limits.Cocone K)

full_name: CategoryTheory.Adjunction.functorialityUnit_app_hom
code: /-- The unit for the adjunction for `Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F)`.

Auxiliary definition for `functorialityIsLeftAdjoint`.
-/
@[simps]
def functorialityUnit :
    𝟭 (Cocone K) ⟶ Cocones.functoriality _ F ⋙ functorialityRightAdjoint adj K 
goal: ((adj.functorialityUnit K).app c).hom = adj.unit.app c.pt

full_name: CategoryTheory.Adjunction.functorialityUnit
code: /-- The unit for the adjunction for `Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F)`.

Auxiliary definition for `functorialityIsLeftAdjoint`.
-/
@[simps]
def functorialityUnit :
    𝟭 (Cocone K) ⟶ Cocones.functoriality _ F ⋙ functorialityRightAdjoint adj K 
goal: CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone K) ⟶
  (CategoryTheory.Limits.Cocones.functoriality K F).comp (adj.functorialityRightAdjoint K)

full_name: CategoryTheory.Adjunction.functorialityCounit
code: /-- The counit for the adjunction for `Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F)`.

Auxiliary definition for `functorialityIsLeftAdjoint`.
-/
@[simps]
def functorialityCounit :
    functorialityRightAdjoint adj K ⋙ Cocones.functoriality _ F ⟶ 𝟭 (Cocone (K ⋙ F)) 
goal: (adj.functorialityRightAdjoint K).comp (CategoryTheory.Limits.Cocones.functoriality K F) ⟶
  CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (K.comp F))

full_name: CategoryTheory.Adjunction.functorialityCounit_app_hom
code: /-- The counit for the adjunction for `Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F)`.

Auxiliary definition for `functorialityIsLeftAdjoint`.
-/
@[simps]
def functorialityCounit :
    functorialityRightAdjoint adj K ⋙ Cocones.functoriality _ F ⟶ 𝟭 (Cocone (K ⋙ F)) 
goal: ((adj.functorialityCounit K).app c).hom = adj.counit.app c.pt

full_name: CategoryTheory.Adjunction.functorialityAdjunction
code: /-- The functor `Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F)` is a left adjoint. -/
def functorialityAdjunction : Cocones.functoriality K F ⊣ functorialityRightAdjoint adj K 
goal: CategoryTheory.Limits.Cocones.functoriality K F ⊣ adj.functorialityRightAdjoint K

full_name: CategoryTheory.Adjunction.leftAdjointPreservesColimits
code: /-- A left adjoint preserves colimits.

See <https://stacks.math.columbia.edu/tag/0038>.
-/
def leftAdjointPreservesColimits : PreservesColimitsOfSize.{v, u} F 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Adjunction.isEquivalencePreservesColimits
code: noncomputable instance (priority := 100) isEquivalencePreservesColimits
    (E : C ⥤ D) [E.IsEquivalence] :
    PreservesColimitsOfSize.{v, u} E 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, v₁, v₂, u₁, u₂} E

full_name: CategoryTheory.Adjunction.isEquivalenceReflectsColimits
code: noncomputable instance (priority := 100) isEquivalenceReflectsColimits
    (E : D ⥤ C) [E.IsEquivalence] :
    ReflectsColimitsOfSize.{v, u} E 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{v, u, v₂, v₁, u₂, u₁} E

full_name: CategoryTheory.Adjunction.isEquivalenceCreatesColimits
code: noncomputable instance (priority := 100) isEquivalenceCreatesColimits (H : D ⥤ C)
    [H.IsEquivalence] :
    CreatesColimitsOfSize.{v, u} H 
goal: CategoryTheory.CreatesColimitsOfSize.{v, u, v₂, v₁, u₂, u₁} H

full_name: CategoryTheory.Adjunction.hasColimit_comp_equivalence
code: theorem hasColimit_comp_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimit K] :
    HasColimit (K ⋙ E) 
goal: CategoryTheory.Limits.HasColimit (K.comp E)

full_name: CategoryTheory.Adjunction.hasColimit_of_comp_equivalence
code: theorem hasColimit_of_comp_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimit (K ⋙ E)] :
    HasColimit K 
goal: CategoryTheory.Limits.HasColimit K

full_name: CategoryTheory.Adjunction.hasColimitsOfShape_of_equivalence
code: /-- Transport a `HasColimitsOfShape` instance across an equivalence. -/
theorem hasColimitsOfShape_of_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimitsOfShape J D] :
    HasColimitsOfShape J C 
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Adjunction.has_colimits_of_equivalence
code: /-- Transport a `HasColimitsOfSize` instance across an equivalence. -/
theorem has_colimits_of_equivalence (E : C ⥤ D) [E.IsEquivalence] [HasColimitsOfSize.{v, u} D] :
    HasColimitsOfSize.{v, u} C 
goal: CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₁, u₁} C

full_name: CategoryTheory.Adjunction.functorialityLeftAdjoint
code: /-- The left adjoint of `Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G)`.

Auxiliary definition for `functorialityIsRightAdjoint`.
-/
def functorialityLeftAdjoint : Cone (K ⋙ G) ⥤ Cone K 
goal: CategoryTheory.Functor (CategoryTheory.Limits.Cone (K.comp G)) (CategoryTheory.Limits.Cone K)

full_name: CategoryTheory.Adjunction.functorialityUnit'
code: /-- The unit for the adjunction for `Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G)`.

Auxiliary definition for `functorialityIsRightAdjoint`.
-/
@[simps]
def functorialityUnit' :
    𝟭 (Cone (K ⋙ G)) ⟶ functorialityLeftAdjoint adj K ⋙ Cones.functoriality _ G 
goal: CategoryTheory.Functor.id (CategoryTheory.Limits.Cone (K.comp G)) ⟶
  (adj.functorialityLeftAdjoint K).comp (CategoryTheory.Limits.Cones.functoriality K G)

full_name: CategoryTheory.Adjunction.functorialityUnit'_app_hom
code: /-- The unit for the adjunction for `Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G)`.

Auxiliary definition for `functorialityIsRightAdjoint`.
-/
@[simps]
def functorialityUnit' :
    𝟭 (Cone (K ⋙ G)) ⟶ functorialityLeftAdjoint adj K ⋙ Cones.functoriality _ G 
goal: ((adj.functorialityUnit' K).app c).hom = adj.unit.app c.pt

full_name: CategoryTheory.Adjunction.functorialityCounit'
code: /-- The counit for the adjunction for `Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G)`.

Auxiliary definition for `functorialityIsRightAdjoint`.
-/
@[simps]
def functorialityCounit' :
    Cones.functoriality _ G ⋙ functorialityLeftAdjoint adj K ⟶ 𝟭 (Cone K) 
goal: (CategoryTheory.Limits.Cones.functoriality K G).comp (adj.functorialityLeftAdjoint K) ⟶
  CategoryTheory.Functor.id (CategoryTheory.Limits.Cone K)

full_name: CategoryTheory.Adjunction.functorialityCounit'_app_hom
code: /-- The counit for the adjunction for `Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G)`.

Auxiliary definition for `functorialityIsRightAdjoint`.
-/
@[simps]
def functorialityCounit' :
    Cones.functoriality _ G ⋙ functorialityLeftAdjoint adj K ⟶ 𝟭 (Cone K) 
goal: ((adj.functorialityCounit' K).app c).hom = adj.counit.app c.pt

full_name: CategoryTheory.Adjunction.functorialityAdjunction'
code: /-- The functor `Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G)` is a right adjoint. -/
def functorialityAdjunction' : functorialityLeftAdjoint adj K ⊣ Cones.functoriality K G 
goal: adj.functorialityLeftAdjoint K ⊣ CategoryTheory.Limits.Cones.functoriality K G

full_name: CategoryTheory.Adjunction.rightAdjointPreservesLimits
code: /-- A right adjoint preserves limits.

See <https://stacks.math.columbia.edu/tag/0038>.
-/
def rightAdjointPreservesLimits : PreservesLimitsOfSize.{v, u} G 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} G

full_name: CategoryTheory.Adjunction.isEquivalencePreservesLimits
code: noncomputable instance (priority := 100) isEquivalencePreservesLimits
    (E : D ⥤ C) [E.IsEquivalence] :
    PreservesLimitsOfSize.{v, u} E 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} E

full_name: CategoryTheory.Adjunction.isEquivalenceReflectsLimits
code: noncomputable instance (priority := 100) isEquivalenceReflectsLimits
    (E : D ⥤ C) [E.IsEquivalence] :
    ReflectsLimitsOfSize.{v, u} E 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} E

full_name: CategoryTheory.Adjunction.isEquivalenceCreatesLimits
code: noncomputable instance (priority := 100) isEquivalenceCreatesLimits (H : D ⥤ C) [H.IsEquivalence] :
    CreatesLimitsOfSize.{v, u} H 
goal: CategoryTheory.CreatesLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} H

full_name: CategoryTheory.Adjunction.hasLimit_comp_equivalence
code: theorem hasLimit_comp_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimit K] : HasLimit (K ⋙ E) 
goal: CategoryTheory.Limits.HasLimit (K.comp E)

full_name: CategoryTheory.Adjunction.hasLimit_of_comp_equivalence
code: theorem hasLimit_of_comp_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimit (K ⋙ E)] :
    HasLimit K 
goal: CategoryTheory.Limits.HasLimit K

full_name: CategoryTheory.Adjunction.hasLimitsOfShape_of_equivalence
code: /-- Transport a `HasLimitsOfShape` instance across an equivalence. -/
theorem hasLimitsOfShape_of_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimitsOfShape J C] :
    HasLimitsOfShape J D 
goal: CategoryTheory.Limits.HasLimitsOfShape J D

full_name: CategoryTheory.Adjunction.has_limits_of_equivalence
code: /-- Transport a `HasLimitsOfSize` instance across an equivalence. -/
theorem has_limits_of_equivalence (E : D ⥤ C) [E.IsEquivalence] [HasLimitsOfSize.{v, u} C] :
    HasLimitsOfSize.{v, u} D 
goal: CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₂, u₂} D

full_name: CategoryTheory.Adjunction.coconesIsoComponentHom
code: /-- auxiliary construction for `coconesIso` -/
@[simp]
def coconesIsoComponentHom {J : Type u} [Category.{v} J] {K : J ⥤ C} (Y : D)
    (t : ((cocones J D).obj (op (K ⋙ F))).obj Y) : (G ⋙ (cocones J C).obj (op K)).obj Y 
goal: (G.comp ((CategoryTheory.cocones J C).obj (Opposite.op K))).obj Y

full_name: CategoryTheory.Adjunction.coconesIsoComponentInv
code: /-- auxiliary construction for `coconesIso` -/
@[simp]
def coconesIsoComponentInv {J : Type u} [Category.{v} J] {K : J ⥤ C} (Y : D)
    (t : (G ⋙ (cocones J C).obj (op K)).obj Y) : ((cocones J D).obj (op (K ⋙ F))).obj Y 
goal: ((CategoryTheory.cocones J D).obj (Opposite.op (K.comp F))).obj Y

full_name: CategoryTheory.Adjunction.conesIsoComponentHom
code: /-- auxiliary construction for `conesIso` -/
@[simp]
def conesIsoComponentHom {J : Type u} [Category.{v} J] {K : J ⥤ D} (X : Cᵒᵖ)
    (t : (Functor.op F ⋙ (cones J D).obj K).obj X) : ((cones J C).obj (K ⋙ G)).obj X 
goal: ((CategoryTheory.cones J C).obj (K.comp G)).obj X

full_name: CategoryTheory.Adjunction.conesIsoComponentInv
code: /-- auxiliary construction for `conesIso` -/
@[simp]
def conesIsoComponentInv {J : Type u} [Category.{v} J] {K : J ⥤ D} (X : Cᵒᵖ)
    (t : ((cones J C).obj (K ⋙ G)).obj X) : (Functor.op F ⋙ (cones J D).obj K).obj X 
goal: (F.op.comp ((CategoryTheory.cones J D).obj K)).obj X

full_name: CategoryTheory.Adjunction.coconesIso
code: /-- When `F ⊣ G`,
the functor associating to each `Y` the cocones over `K ⋙ F` with cone point `Y`
is naturally isomorphic to
the functor associating to each `Y` the cocones over `K` with cone point `G.obj Y`.
-/
def coconesIso {J : Type u} [Category.{v} J] {K : J ⥤ C} :
    (cocones J D).obj (op (K ⋙ F)) ≅ G ⋙ (cocones J C).obj (op K) 
goal: (CategoryTheory.cocones J D).obj (Opposite.op (K.comp F)) ≅ G.comp ((CategoryTheory.cocones J C).obj (Opposite.op K))

full_name: CategoryTheory.Adjunction.conesIso
code: /-- When `F ⊣ G`,
the functor associating to each `X` the cones over `K` with cone point `F.op.obj X`
is naturally isomorphic to
the functor associating to each `X` the cones over `K ⋙ G` with cone point `X`.
-/
def conesIso {J : Type u} [Category.{v} J] {K : J ⥤ D} :
    F.op ⋙ (cones J D).obj K ≅ (cones J C).obj (K ⋙ G) 
goal: F.op.comp ((CategoryTheory.cones J D).obj K) ≅ (CategoryTheory.cones J C).obj (K.comp G)

full_name: CategoryTheory.Functor.instPreservesColimitsOfShapeOfIsLeftAdjoint
code: noncomputable instance [IsLeftAdjoint F] : PreservesColimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J F

full_name: CategoryTheory.Functor.instPreservesColimitsOfSizeOfIsLeftAdjoint
code: noncomputable instance [IsLeftAdjoint F] : PreservesColimitsOfSize.{v, u} F 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, u_4, u_5, u_2, u_3} F

full_name: CategoryTheory.Functor.instPreservesLimitsOfShapeOfIsRightAdjoint
code: noncomputable instance [IsRightAdjoint F] : PreservesLimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Functor.instPreservesLimitsOfSizeOfIsRightAdjoint
code: noncomputable instance [IsRightAdjoint F] : PreservesLimitsOfSize.{v, u} F 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{v, u, u_4, u_5, u_2, u_3} F