Adjunctions and limits

A left adjoint preserves colimits (CategoryTheory.Adjunction.leftAdjointPreservesColimits), and a right adjoint preserves limits (CategoryTheory.Adjunction.rightAdjointPreservesLimits).

Equivalences create and reflect (co)limits. (CategoryTheory.Adjunction.isEquivalenceCreatesLimits, CategoryTheory.Adjunction.isEquivalenceCreatesColimits, CategoryTheory.Adjunction.isEquivalenceReflectsLimits, CategoryTheory.Adjunction.isEquivalenceReflectsColimits,)

In CategoryTheory.Adjunction.coconesIso we show that 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 CategoryTheory.Adjunction.functorialityRightAdjoint {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) : CategoryTheory.Functor (CategoryTheory.Limits.Cocone (K.comp F)) (CategoryTheory.Limits.Cocone K)

The right adjoint of Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F).

Auxiliary definition for functorialityIsLeftAdjoint.

Equations

• One or more equations did not get rendered due to their size.

def CategoryTheory.Adjunction.functorialityUnit {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) : CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone K) ⟶ (CategoryTheory.Limits.Cocones.functoriality K F).comp (adj.functorialityRightAdjoint K)

The unit for the adjunction for Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F).

Auxiliary definition for functorialityIsLeftAdjoint.

Equations

• adj.functorialityUnit K = { app := fun (c : CategoryTheory.Limits.Cocone K) => { hom := adj.unit.app c.pt, w := ⋯ }, naturality := ⋯ }

@[simp]

theorem CategoryTheory.Adjunction.functorialityUnit_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) (c : CategoryTheory.Limits.Cocone K) : ((adj.functorialityUnit K).app c).hom = adj.unit.app c.pt

def CategoryTheory.Adjunction.functorialityCounit {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) : (adj.functorialityRightAdjoint K).comp (CategoryTheory.Limits.Cocones.functoriality K F) ⟶ CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (K.comp F))

The counit for the adjunction for Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F).

Auxiliary definition for functorialityIsLeftAdjoint.

Equations

• adj.functorialityCounit K = { app := fun (c : CategoryTheory.Limits.Cocone (K.comp F)) => { hom := adj.counit.app c.pt, w := ⋯ }, naturality := ⋯ }

@[simp]

theorem CategoryTheory.Adjunction.functorialityCounit_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) (c : CategoryTheory.Limits.Cocone (K.comp F)) : ((adj.functorialityCounit K).app c).hom = adj.counit.app c.pt

def CategoryTheory.Adjunction.functorialityAdjunction {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) : CategoryTheory.Limits.Cocones.functoriality K F ⊣ adj.functorialityRightAdjoint K

The functor Cocones.functoriality K F : Cocone K ⥤ Cocone (K ⋙ F) is a left adjoint.

Equations

• adj.functorialityAdjunction K = { unit := adj.functorialityUnit K, counit := adj.functorialityCounit K, left_triangle_components := ⋯, right_triangle_components := ⋯ }

def CategoryTheory.Adjunction.leftAdjointPreservesColimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) : CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, v₁, v₂, u₁, u₂} F

A left adjoint preserves colimits.

See https://stacks.math.columbia.edu/tag/0038.

Equations

• One or more equations did not get rendered due to their size.

noncomputable instance CategoryTheory.Adjunction.colimPreservesColimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] [CategoryTheory.Limits.HasColimitsOfShape J C] : CategoryTheory.Limits.PreservesColimits CategoryTheory.Limits.colim

Equations

• CategoryTheory.Adjunction.colimPreservesColimits = CategoryTheory.Limits.colimConstAdj.leftAdjointPreservesColimits

@[instance 100]

noncomputable instance CategoryTheory.Adjunction.isEquivalencePreservesColimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor C D) [E.IsEquivalence] : CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, v₁, v₂, u₁, u₂} E

Equations

• CategoryTheory.Adjunction.isEquivalencePreservesColimits E = E.adjunction.leftAdjointPreservesColimits

@[instance 100]

noncomputable instance CategoryTheory.Adjunction.isEquivalenceReflectsColimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor D C) [E.IsEquivalence] : CategoryTheory.Limits.ReflectsColimitsOfSize.{v, u, v₂, v₁, u₂, u₁} E

Equations

• One or more equations did not get rendered due to their size.

@[instance 100]

noncomputable instance CategoryTheory.Adjunction.isEquivalenceCreatesColimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (H : CategoryTheory.Functor D C) [H.IsEquivalence] : CategoryTheory.CreatesColimitsOfSize.{v, u, v₂, v₁, u₂, u₁} H

Equations

• One or more equations did not get rendered due to their size.

theorem CategoryTheory.Adjunction.hasColimit_comp_equivalence {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) (E : CategoryTheory.Functor C D) [E.IsEquivalence] [CategoryTheory.Limits.HasColimit K] : CategoryTheory.Limits.HasColimit (K.comp E)

theorem CategoryTheory.Adjunction.hasColimit_of_comp_equivalence {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J C) (E : CategoryTheory.Functor C D) [E.IsEquivalence] [CategoryTheory.Limits.HasColimit (K.comp E)] : CategoryTheory.Limits.HasColimit K

theorem CategoryTheory.Adjunction.hasColimitsOfShape_of_equivalence {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (E : CategoryTheory.Functor C D) [E.IsEquivalence] [CategoryTheory.Limits.HasColimitsOfShape J D] : CategoryTheory.Limits.HasColimitsOfShape J C

Transport a HasColimitsOfShape instance across an equivalence.

theorem CategoryTheory.Adjunction.has_colimits_of_equivalence {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor C D) [E.IsEquivalence] [CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₂, u₂} D] : CategoryTheory.Limits.HasColimitsOfSize.{v, u, v₁, u₁} C

Transport a HasColimitsOfSize instance across an equivalence.

def CategoryTheory.Adjunction.functorialityLeftAdjoint {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) : CategoryTheory.Functor (CategoryTheory.Limits.Cone (K.comp G)) (CategoryTheory.Limits.Cone K)

The left adjoint of Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G).

Auxiliary definition for functorialityIsRightAdjoint.

Equations

• One or more equations did not get rendered due to their size.

def CategoryTheory.Adjunction.functorialityUnit' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) : CategoryTheory.Functor.id (CategoryTheory.Limits.Cone (K.comp G)) ⟶ (adj.functorialityLeftAdjoint K).comp (CategoryTheory.Limits.Cones.functoriality K G)

The unit for the adjunction for Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G).

Auxiliary definition for functorialityIsRightAdjoint.

Equations

• adj.functorialityUnit' K = { app := fun (c : CategoryTheory.Limits.Cone (K.comp G)) => { hom := adj.unit.app c.pt, w := ⋯ }, naturality := ⋯ }

@[simp]

theorem CategoryTheory.Adjunction.functorialityUnit'_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) (c : CategoryTheory.Limits.Cone (K.comp G)) : ((adj.functorialityUnit' K).app c).hom = adj.unit.app c.pt

def CategoryTheory.Adjunction.functorialityCounit' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) : (CategoryTheory.Limits.Cones.functoriality K G).comp (adj.functorialityLeftAdjoint K) ⟶ CategoryTheory.Functor.id (CategoryTheory.Limits.Cone K)

The counit for the adjunction for Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G).

Auxiliary definition for functorialityIsRightAdjoint.

Equations

• adj.functorialityCounit' K = { app := fun (c : CategoryTheory.Limits.Cone K) => { hom := adj.counit.app c.pt, w := ⋯ }, naturality := ⋯ }

@[simp]

theorem CategoryTheory.Adjunction.functorialityCounit'_app_hom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) (c : CategoryTheory.Limits.Cone K) : ((adj.functorialityCounit' K).app c).hom = adj.counit.app c.pt

def CategoryTheory.Adjunction.functorialityAdjunction' {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) : adj.functorialityLeftAdjoint K ⊣ CategoryTheory.Limits.Cones.functoriality K G

The functor Cones.functoriality K G : Cone K ⥤ Cone (K ⋙ G) is a right adjoint.

Equations

• adj.functorialityAdjunction' K = { unit := adj.functorialityUnit' K, counit := adj.functorialityCounit' K, left_triangle_components := ⋯, right_triangle_components := ⋯ }

def CategoryTheory.Adjunction.rightAdjointPreservesLimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) : CategoryTheory.Limits.PreservesLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} G

A right adjoint preserves limits.

See https://stacks.math.columbia.edu/tag/0038.

Equations

• One or more equations did not get rendered due to their size.

noncomputable instance CategoryTheory.Adjunction.limPreservesLimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [CategoryTheory.Category.{v, u} J] [CategoryTheory.Limits.HasLimitsOfShape J C] : CategoryTheory.Limits.PreservesLimits CategoryTheory.Limits.lim

Equations

• CategoryTheory.Adjunction.limPreservesLimits = CategoryTheory.Limits.constLimAdj.rightAdjointPreservesLimits

@[instance 100]

noncomputable instance CategoryTheory.Adjunction.isEquivalencePreservesLimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor D C) [E.IsEquivalence] : CategoryTheory.Limits.PreservesLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} E

Equations

• CategoryTheory.Adjunction.isEquivalencePreservesLimits E = E.asEquivalence.symm.toAdjunction.rightAdjointPreservesLimits

@[instance 100]

noncomputable instance CategoryTheory.Adjunction.isEquivalenceReflectsLimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor D C) [E.IsEquivalence] : CategoryTheory.Limits.ReflectsLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} E

Equations

• One or more equations did not get rendered due to their size.

@[instance 100]

noncomputable instance CategoryTheory.Adjunction.isEquivalenceCreatesLimits {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (H : CategoryTheory.Functor D C) [H.IsEquivalence] : CategoryTheory.CreatesLimitsOfSize.{v, u, v₂, v₁, u₂, u₁} H

Equations

• One or more equations did not get rendered due to their size.

theorem CategoryTheory.Adjunction.hasLimit_comp_equivalence {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) (E : CategoryTheory.Functor D C) [E.IsEquivalence] [CategoryTheory.Limits.HasLimit K] : CategoryTheory.Limits.HasLimit (K.comp E)

theorem CategoryTheory.Adjunction.hasLimit_of_comp_equivalence {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (K : CategoryTheory.Functor J D) (E : CategoryTheory.Functor D C) [E.IsEquivalence] [CategoryTheory.Limits.HasLimit (K.comp E)] : CategoryTheory.Limits.HasLimit K

theorem CategoryTheory.Adjunction.hasLimitsOfShape_of_equivalence {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : Type u} [CategoryTheory.Category.{v, u} J] (E : CategoryTheory.Functor D C) [E.IsEquivalence] [CategoryTheory.Limits.HasLimitsOfShape J C] : CategoryTheory.Limits.HasLimitsOfShape J D

Transport a HasLimitsOfShape instance across an equivalence.

theorem CategoryTheory.Adjunction.has_limits_of_equivalence {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (E : CategoryTheory.Functor D C) [E.IsEquivalence] [CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₁, u₁} C] : CategoryTheory.Limits.HasLimitsOfSize.{v, u, v₂, u₂} D

Transport a HasLimitsOfSize instance across an equivalence.

def CategoryTheory.Adjunction.coconesIsoComponentHom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] {K : CategoryTheory.Functor J C} (Y : D) (t : ((CategoryTheory.cocones J D).obj (Opposite.op (K.comp F))).obj Y) : (G.comp ((CategoryTheory.cocones J C).obj (Opposite.op K))).obj Y

auxiliary construction for coconesIso

Equations

• adj.coconesIsoComponentHom Y t = { app := fun (j : J) => (adj.homEquiv (K.obj j) Y) (t.app j), naturality := ⋯ }

def CategoryTheory.Adjunction.coconesIsoComponentInv {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] {K : CategoryTheory.Functor J C} (Y : D) (t : (G.comp ((CategoryTheory.cocones J C).obj (Opposite.op K))).obj Y) : ((CategoryTheory.cocones J D).obj (Opposite.op (K.comp F))).obj Y

auxiliary construction for coconesIso

Equations

• adj.coconesIsoComponentInv Y t = { app := fun (j : J) => (adj.homEquiv (K.obj j) Y).symm (t.app j), naturality := ⋯ }

def CategoryTheory.Adjunction.conesIsoComponentHom {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] {K : CategoryTheory.Functor J D} (X : Cᵒᵖ) (t : (F.op.comp ((CategoryTheory.cones J D).obj K)).obj X) : ((CategoryTheory.cones J C).obj (K.comp G)).obj X

auxiliary construction for conesIso

Equations

• adj.conesIsoComponentHom X t = { app := fun (j : J) => (adj.homEquiv (Opposite.unop X) (K.obj j)) (t.app j), naturality := ⋯ }

def CategoryTheory.Adjunction.conesIsoComponentInv {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] {K : CategoryTheory.Functor J D} (X : Cᵒᵖ) (t : ((CategoryTheory.cones J C).obj (K.comp G)).obj X) : (F.op.comp ((CategoryTheory.cones J D).obj K)).obj X

auxiliary construction for conesIso

Equations

• adj.conesIsoComponentInv X t = { app := fun (j : J) => (adj.homEquiv (Opposite.unop X) (K.obj j)).symm (t.app j), naturality := ⋯ }

def CategoryTheory.Adjunction.coconesIso {C : Type u₁} [CategoryTheory.Category.{v₀, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₀, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] {K : CategoryTheory.Functor J C} : (CategoryTheory.cocones J D).obj (Opposite.op (K.comp F)) ≅ G.comp ((CategoryTheory.cocones J C).obj (Opposite.op K))

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.

Equations

• adj.coconesIso = CategoryTheory.NatIso.ofComponents (fun (Y : D) => { hom := adj.coconesIsoComponentHom Y, inv := adj.coconesIsoComponentInv Y, hom_inv_id := ⋯, inv_hom_id := ⋯ }) ⋯

def CategoryTheory.Adjunction.conesIso {C : Type u₁} [CategoryTheory.Category.{v₀, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₀, u₂} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) {J : Type u} [CategoryTheory.Category.{v, u} J] {K : CategoryTheory.Functor J D} : F.op.comp ((CategoryTheory.cones J D).obj K) ≅ (CategoryTheory.cones J C).obj (K.comp G)

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.

Equations

• adj.conesIso = CategoryTheory.NatIso.ofComponents (fun (X : Cᵒᵖ) => { hom := adj.conesIsoComponentHom X, inv := adj.conesIsoComponentInv X, hom_inv_id := ⋯, inv_hom_id := ⋯ }) ⋯

noncomputable instance CategoryTheory.Functor.instPreservesColimitsOfShapeOfIsLeftAdjoint {J : Type u_1} {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_1} J] [CategoryTheory.Category.{u_5, u_2} C] [CategoryTheory.Category.{u_6, u_3} D] (F : CategoryTheory.Functor C D) [F.IsLeftAdjoint] : CategoryTheory.Limits.PreservesColimitsOfShape J F

Equations

• F.instPreservesColimitsOfShapeOfIsLeftAdjoint = CategoryTheory.Limits.PreservesColimitsOfSize.preservesColimitsOfShape

noncomputable instance CategoryTheory.Functor.instPreservesColimitsOfSizeOfIsLeftAdjoint {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Category.{u_5, u_3} D] (F : CategoryTheory.Functor C D) [F.IsLeftAdjoint] : CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, u_4, u_5, u_2, u_3} F

Equations

• F.instPreservesColimitsOfSizeOfIsLeftAdjoint = { preservesColimitsOfShape := fun {J : Type ?u.50} [CategoryTheory.Category.{?u.51, ?u.50} J] => inferInstance }

noncomputable instance CategoryTheory.Functor.instPreservesLimitsOfShapeOfIsRightAdjoint {J : Type u_1} {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_1} J] [CategoryTheory.Category.{u_5, u_2} C] [CategoryTheory.Category.{u_6, u_3} D] (F : CategoryTheory.Functor C D) [F.IsRightAdjoint] : CategoryTheory.Limits.PreservesLimitsOfShape J F

Equations

• F.instPreservesLimitsOfShapeOfIsRightAdjoint = CategoryTheory.Limits.PreservesLimitsOfSize.preservesLimitsOfShape

noncomputable instance CategoryTheory.Functor.instPreservesLimitsOfSizeOfIsRightAdjoint {C : Type u_2} {D : Type u_3} [CategoryTheory.Category.{u_4, u_2} C] [CategoryTheory.Category.{u_5, u_3} D] (F : CategoryTheory.Functor C D) [F.IsRightAdjoint] : CategoryTheory.Limits.PreservesLimitsOfSize.{v, u, u_4, u_5, u_2, u_3} F

Equations

• F.instPreservesLimitsOfSizeOfIsRightAdjoint = { preservesLimitsOfShape := fun {J : Type ?u.50} [CategoryTheory.Category.{?u.51, ?u.50} J] => inferInstance }