Documentation

Mathlib.CategoryTheory.Adjunction.Evaluation

Adjunctions involving evaluation #

We show that evaluation of functors has adjoints, given the existence of (co)products.

noncomputable def CategoryTheory.evaluationLeftAdjoint {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) :

The left adjoint of evaluation.

Instances For
    @[simp]
    theorem CategoryTheory.evaluationLeftAdjoint_obj_obj {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) (d : D) (t : C) :
    ((evaluationLeftAdjoint D c).obj d).obj t = ∐ fun (x : c ⟶ t) => d
    @[simp]
    theorem CategoryTheory.evaluationLeftAdjoint_obj_map {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) (d : D) {Xāœ Yāœ : C} (f : Xāœ ⟶ Yāœ) :
    ((evaluationLeftAdjoint D c).obj d).map f = Limits.Sigma.desc fun (g : c ⟶ Xāœ) => Limits.Sigma.ι (fun (x : c ⟶ Yāœ) => d) (CategoryStruct.comp g f)
    @[simp]
    theorem CategoryTheory.evaluationLeftAdjoint_map_app {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) {xāœ dā‚‚ : D} (f : xāœ ⟶ dā‚‚) (xāœĀ¹ : C) :
    ((evaluationLeftAdjoint D c).map f).app xāœĀ¹ = Limits.Sigma.desc fun (h : c ⟶ xāœĀ¹) => CategoryStruct.comp f (Limits.Sigma.ι (fun (x : c ⟶ xāœĀ¹) => dā‚‚) h)

    The adjunction showing that evaluation is a right adjoint.

    Instances For
      @[simp]
      theorem CategoryTheory.evaluationAdjunctionRight_counit_app_app {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) (Y : Functor C D) (xāœ : C) :
      ((evaluationAdjunctionRight D c).counit.app Y).app xāœ = Limits.Sigma.desc fun (h : c ⟶ xāœ) => Y.map h
      theorem CategoryTheory.NatTrans.mono_iff_mono_app' {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasCoproductsOfShape (a ⟶ b) D] {F G : Functor C D} (Ī· : F ⟶ G) :
      Mono Ī· ↔ āˆ€ (c : C), Mono (Ī·.app c)

      See also the file Mathlib/CategoryTheory/Limits/FunctorCategory/EpiMono.lean for a similar result under a HasPullbacks assumption.

      noncomputable def CategoryTheory.evaluationRightAdjoint {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasProductsOfShape (a ⟶ b) D] (c : C) :

      The right adjoint of evaluation.

      Instances For
        @[simp]
        theorem CategoryTheory.evaluationRightAdjoint_map_app {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasProductsOfShape (a ⟶ b) D] (c : C) {Xāœ Yāœ : D} (f : Xāœ ⟶ Yāœ) (xāœ : C) :
        ((evaluationRightAdjoint D c).map f).app xāœ = Limits.Pi.lift fun (g : xāœ ⟶ c) => CategoryStruct.comp (Limits.Pi.Ļ€ (fun (x : xāœ ⟶ c) => Xāœ) g) f
        @[simp]
        theorem CategoryTheory.evaluationRightAdjoint_obj_obj {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (d : D) (t : C) :
        ((evaluationRightAdjoint D c).obj d).obj t = āˆį¶œ fun (x : t ⟶ c) => d
        @[simp]
        theorem CategoryTheory.evaluationRightAdjoint_obj_map {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (d : D) {Xāœ Yāœ : C} (f : Xāœ ⟶ Yāœ) :
        ((evaluationRightAdjoint D c).obj d).map f = Limits.Pi.lift fun (g : Yāœ ⟶ c) => Limits.Pi.Ļ€ (fun (x : Xāœ ⟶ c) => d) (CategoryStruct.comp f g)

        The adjunction showing that evaluation is a left adjoint.

        Instances For
          @[simp]
          theorem CategoryTheory.evaluationAdjunctionLeft_unit_app_app {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (X : Functor C D) (xāœ : C) :
          ((evaluationAdjunctionLeft D c).unit.app X).app xāœ = Limits.Pi.lift fun (g : xāœ ⟶ c) => X.map g
          theorem CategoryTheory.NatTrans.epi_iff_epi_app' {C : Type u₁} [Category.{v₁, u₁} C] (D : Type uā‚‚) [Category.{vā‚‚, uā‚‚} D] [āˆ€ (a b : C), Limits.HasProductsOfShape (a ⟶ b) D] {F G : Functor C D} (Ī· : F ⟶ G) :
          Epi Ī· ↔ āˆ€ (c : C), Epi (Ī·.app c)

          See also the file Mathlib/CategoryTheory/Limits/FunctorCategory/EpiMono.lean for a similar result under a HasPushouts assumption.