File: Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean

full_name: CategoryTheory.Functor.RightExtension
code: /-- Given two functors `L : C ⥤ D` and `F : C ⥤ H`, this is the category of functors
`F' : H ⥤ D` equipped with a natural transformation `L ⋙ F' ⟶ F`. -/
abbrev RightExtension (L : C ⥤ D) (F : C ⥤ H) 
goal: Type (max (max (max (max u_3 u_5) u_8) u_9) u_1 u_8)

full_name: CategoryTheory.Functor.LeftExtension
code: /-- Given two functors `L : C ⥤ D` and `F : C ⥤ H`, this is the category of functors
`F' : H ⥤ D` equipped with a natural transformation `F ⟶ L ⋙ F'`. -/
abbrev LeftExtension (L : C ⥤ D) (F : C ⥤ H) 
goal: Type (max (max (max (max u_3 u_5) u_8) u_9) u_1 u_8)

full_name: CategoryTheory.Functor.RightExtension.mk_hom
code: /-- Constructor for objects of the category `Functor.RightExtension L F`. -/
@[simps!]
def RightExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : L ⋙ F' ⟶ F) :
    RightExtension L F 
goal: (CategoryTheory.Functor.RightExtension.mk F' α).hom = α

full_name: CategoryTheory.Functor.RightExtension.mk
code: /-- Constructor for objects of the category `Functor.RightExtension L F`. -/
@[simps!]
def RightExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : L ⋙ F' ⟶ F) :
    RightExtension L F 
goal: L.RightExtension F

full_name: CategoryTheory.Functor.RightExtension.mk_right_as
code: /-- Constructor for objects of the category `Functor.RightExtension L F`. -/
@[simps!]
def RightExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : L ⋙ F' ⟶ F) :
    RightExtension L F 
goal: (CategoryTheory.Functor.RightExtension.mk F' α).right.as = PUnit.unit

full_name: CategoryTheory.Functor.RightExtension.mk_left
code: /-- Constructor for objects of the category `Functor.RightExtension L F`. -/
@[simps!]
def RightExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : L ⋙ F' ⟶ F) :
    RightExtension L F 
goal: (CategoryTheory.Functor.RightExtension.mk F' α).left = F'

full_name: CategoryTheory.Functor.LeftExtension.mk_left_as
code: /-- Constructor for objects of the category `Functor.LeftExtension L F`. -/
@[simps!]
def LeftExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') :
    LeftExtension L F 
goal: (CategoryTheory.Functor.LeftExtension.mk F' α).left.as = PUnit.unit

full_name: CategoryTheory.Functor.LeftExtension.mk_right
code: /-- Constructor for objects of the category `Functor.LeftExtension L F`. -/
@[simps!]
def LeftExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') :
    LeftExtension L F 
goal: (CategoryTheory.Functor.LeftExtension.mk F' α).right = F'

full_name: CategoryTheory.Functor.LeftExtension.mk
code: /-- Constructor for objects of the category `Functor.LeftExtension L F`. -/
@[simps!]
def LeftExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') :
    LeftExtension L F 
goal: L.LeftExtension F

full_name: CategoryTheory.Functor.LeftExtension.mk_hom
code: /-- Constructor for objects of the category `Functor.LeftExtension L F`. -/
@[simps!]
def LeftExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') :
    LeftExtension L F 
goal: (CategoryTheory.Functor.LeftExtension.mk F' α).hom = α

full_name: CategoryTheory.Functor.IsRightKanExtension
code: /-- Given `α : L ⋙ F' ⟶ F`, the property `F'.IsRightKanExtension α` asserts that
`(F', α)` is a terminal object in the category `RightExtension L F`, i.e. that `(F', α)`
is a right Kan extension of `F` along `L`. -/
class IsRightKanExtension : Prop where
  nonempty_isUniversal : Nonempty (RightExtension.mk F' α).IsUniversal
goal: Prop

full_name: CategoryTheory.Functor.IsRightKanExtension.nonempty_isUniversal
code: /-- Given `α : L ⋙ F' ⟶ F`, the property `F'.IsRightKanExtension α` asserts that
`(F', α)` is a terminal object in the category `RightExtension L F`, i.e. that `(F', α)`
is a right Kan extension of `F` along `L`. -/
class IsRightKanExtension : Prop where
  nonempty_isUniversal : Nonempty (RightExtension.mk F' α).IsUniversal
goal: Nonempty (CategoryTheory.CostructuredArrow.IsUniversal (CategoryTheory.Functor.RightExtension.mk F' α))

full_name: CategoryTheory.Functor.isUniversalOfIsRightKanExtension
code: /-- If `(F', α)` is a right Kan extension of `F` along `L`, then `(F', α)` is a terminal object
in the category `RightExtension L F`. -/
noncomputable def isUniversalOfIsRightKanExtension : (RightExtension.mk F' α).IsUniversal 
goal: CategoryTheory.CostructuredArrow.IsUniversal (CategoryTheory.Functor.RightExtension.mk F' α)

full_name: CategoryTheory.Functor.liftOfIsRightKanExtension
code: /-- If `(F', α)` is a right Kan extension of `F` along `L` and `β : L ⋙ G ⟶ F` is
a natural transformation, this is the induced morphism `G ⟶ F'`. -/
noncomputable def liftOfIsRightKanExtension (G : D ⥤ H) (β : L ⋙ G ⟶ F) : G ⟶ F' 
goal: G ⟶ F'

full_name: CategoryTheory.Functor.liftOfIsRightKanExtension_fac
code: @[reassoc (attr := simp)]
lemma liftOfIsRightKanExtension_fac (G : D ⥤ H) (β : L ⋙ G ⟶ F) :
    whiskerLeft L (F'.liftOfIsRightKanExtension α G β) ≫ α = β 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft L (F'.liftOfIsRightKanExtension α G β)) α = β

full_name: CategoryTheory.Functor.liftOfIsRightKanExtension_fac_app
code: @[reassoc (attr := simp)]
lemma liftOfIsRightKanExtension_fac_app (G : D ⥤ H) (β : L ⋙ G ⟶ F) (X : C) :
    (F'.liftOfIsRightKanExtension α G β).app (L.obj X) ≫ α.app X = β.app X 
goal: CategoryTheory.CategoryStruct.comp ((F'.liftOfIsRightKanExtension α G β).app (L.obj X)) (α.app X) = β.app X

full_name: CategoryTheory.Functor.hom_ext_of_isRightKanExtension
code: lemma hom_ext_of_isRightKanExtension {G : D ⥤ H} (γ₁ γ₂ : G ⟶ F')
    (hγ : whiskerLeft L γ₁ ≫ α = whiskerLeft L γ₂ ≫ α) : γ₁ = γ₂ 
goal: γ₁ = γ₂

full_name: CategoryTheory.Functor.homEquivOfIsRightKanExtension
code: /-- If `(F', α)` is a right Kan extension of `F` along `L`, then this
is the induced bijection `(G ⟶ F') ≃ (L ⋙ G ⟶ F)` for all `G`. -/
noncomputable def homEquivOfIsRightKanExtension (G : D ⥤ H) :
    (G ⟶ F') ≃ (L ⋙ G ⟶ F) 
goal: (G ⟶ F') ≃ (L.comp G ⟶ F)

full_name: CategoryTheory.Functor.isRightKanExtension_of_iso
code: lemma isRightKanExtension_of_iso {F' F'' : D ⥤ H} (e : F' ≅ F'') {L : C ⥤ D} {F : C ⥤ H}
    (α : L ⋙ F' ⟶ F) (α' : L ⋙ F'' ⟶ F) (comm : whiskerLeft L e.hom ≫ α' = α)
    [F'.IsRightKanExtension α] : F''.IsRightKanExtension α' 
goal: F''.IsRightKanExtension α'

full_name: CategoryTheory.Functor.isRightKanExtension_iff_of_iso
code: lemma isRightKanExtension_iff_of_iso {F' F'' : D ⥤ H} (e : F' ≅ F'') {L : C ⥤ D} {F : C ⥤ H}
    (α : L ⋙ F' ⟶ F) (α' : L ⋙ F'' ⟶ F) (comm : whiskerLeft L e.hom ≫ α' = α) :
    F'.IsRightKanExtension α ↔ F''.IsRightKanExtension α' 
goal: F'.IsRightKanExtension α ↔ F''.IsRightKanExtension α'

full_name: CategoryTheory.Functor.rightKanExtensionUniqueOfIso_inv
code: /-- Right Kan extensions of isomorphic functors are isomorphic. -/
@[simps]
noncomputable def rightKanExtensionUniqueOfIso {G : C ⥤ H} (i : F ≅ G) (G' : D ⥤ H)
    (β : L ⋙ G' ⟶ G) [G'.IsRightKanExtension β] : F' ≅ G' 
goal: (F'.rightKanExtensionUniqueOfIso α i G' β).inv =
  F'.liftOfIsRightKanExtension α G' (CategoryTheory.CategoryStruct.comp β i.inv)

full_name: CategoryTheory.Functor.rightKanExtensionUniqueOfIso_hom
code: /-- Right Kan extensions of isomorphic functors are isomorphic. -/
@[simps]
noncomputable def rightKanExtensionUniqueOfIso {G : C ⥤ H} (i : F ≅ G) (G' : D ⥤ H)
    (β : L ⋙ G' ⟶ G) [G'.IsRightKanExtension β] : F' ≅ G' 
goal: (F'.rightKanExtensionUniqueOfIso α i G' β).hom =
  G'.liftOfIsRightKanExtension β F' (CategoryTheory.CategoryStruct.comp α i.hom)

full_name: CategoryTheory.Functor.rightKanExtensionUniqueOfIso
code: /-- Right Kan extensions of isomorphic functors are isomorphic. -/
@[simps]
noncomputable def rightKanExtensionUniqueOfIso {G : C ⥤ H} (i : F ≅ G) (G' : D ⥤ H)
    (β : L ⋙ G' ⟶ G) [G'.IsRightKanExtension β] : F' ≅ G' 
goal: F' ≅ G'

full_name: CategoryTheory.Functor.rightKanExtensionUnique_hom
code: /-- Two right Kan extensions are (canonically) isomorphic. -/
@[simps!]
noncomputable def rightKanExtensionUnique
    (F'' : D ⥤ H) (α' : L ⋙ F'' ⟶ F) [F''.IsRightKanExtension α'] : F' ≅ F'' 
goal: (F'.rightKanExtensionUnique α F'' α').hom = F''.liftOfIsRightKanExtension α' F' α

full_name: CategoryTheory.Functor.rightKanExtensionUnique_inv
code: /-- Two right Kan extensions are (canonically) isomorphic. -/
@[simps!]
noncomputable def rightKanExtensionUnique
    (F'' : D ⥤ H) (α' : L ⋙ F'' ⟶ F) [F''.IsRightKanExtension α'] : F' ≅ F'' 
goal: (F'.rightKanExtensionUnique α F'' α').inv = F'.liftOfIsRightKanExtension α F'' α'

full_name: CategoryTheory.Functor.rightKanExtensionUnique
code: /-- Two right Kan extensions are (canonically) isomorphic. -/
@[simps!]
noncomputable def rightKanExtensionUnique
    (F'' : D ⥤ H) (α' : L ⋙ F'' ⟶ F) [F''.IsRightKanExtension α'] : F' ≅ F'' 
goal: F' ≅ F''

full_name: CategoryTheory.Functor.isRightKanExtension_iff_isIso
code: lemma isRightKanExtension_iff_isIso {F' : D ⥤ H} {F'' : D ⥤ H} (φ : F'' ⟶ F')
    {L : C ⥤ D} {F : C ⥤ H} (α : L ⋙ F' ⟶ F) (α' : L ⋙ F'' ⟶ F)
    (comm : whiskerLeft L φ ≫ α = α') [F'.IsRightKanExtension α] :
    F''.IsRightKanExtension α' ↔ IsIso φ 
goal: F''.IsRightKanExtension α' ↔ CategoryTheory.IsIso φ

full_name: CategoryTheory.Functor.IsLeftKanExtension.nonempty_isUniversal
code: /-- Given `α : F ⟶ L ⋙ F'`, the property `F'.IsLeftKanExtension α` asserts that
`(F', α)` is an initial object in the category `LeftExtension L F`, i.e. that `(F', α)`
is a left Kan extension of `F` along `L`. -/
class IsLeftKanExtension : Prop where
  nonempty_isUniversal : Nonempty (LeftExtension.mk F' α).IsUniversal
goal: Nonempty (CategoryTheory.StructuredArrow.IsUniversal (CategoryTheory.Functor.LeftExtension.mk F' α))

full_name: CategoryTheory.Functor.IsLeftKanExtension
code: /-- Given `α : F ⟶ L ⋙ F'`, the property `F'.IsLeftKanExtension α` asserts that
`(F', α)` is an initial object in the category `LeftExtension L F`, i.e. that `(F', α)`
is a left Kan extension of `F` along `L`. -/
class IsLeftKanExtension : Prop where
  nonempty_isUniversal : Nonempty (LeftExtension.mk F' α).IsUniversal
goal: Prop

full_name: CategoryTheory.Functor.isUniversalOfIsLeftKanExtension
code: /-- If `(F', α)` is a left Kan extension of `F` along `L`, then `(F', α)` is an initial object
in the category `LeftExtension L F`. -/
noncomputable def isUniversalOfIsLeftKanExtension : (LeftExtension.mk F' α).IsUniversal 
goal: CategoryTheory.StructuredArrow.IsUniversal (CategoryTheory.Functor.LeftExtension.mk F' α)

full_name: CategoryTheory.Functor.descOfIsLeftKanExtension
code: /-- If `(F', α)` is a left Kan extension of `F` along `L` and `β : F ⟶ L ⋙ G` is
a natural transformation, this is the induced morphism `F' ⟶ G`. -/
noncomputable def descOfIsLeftKanExtension (G : D ⥤ H) (β : F ⟶ L ⋙ G) : F' ⟶ G 
goal: F' ⟶ G

full_name: CategoryTheory.Functor.descOfIsLeftKanExtension_fac
code: @[reassoc (attr := simp)]
lemma descOfIsLeftKanExtension_fac (G : D ⥤ H) (β : F ⟶ L ⋙ G) :
    α ≫ whiskerLeft L (F'.descOfIsLeftKanExtension α G β) = β 
goal: CategoryTheory.CategoryStruct.comp α (CategoryTheory.whiskerLeft L (F'.descOfIsLeftKanExtension α G β)) = β

full_name: CategoryTheory.Functor.descOfIsLeftKanExtension_fac_app
code: @[reassoc (attr := simp)]
lemma descOfIsLeftKanExtension_fac_app (G : D ⥤ H) (β : F ⟶ L ⋙ G) (X : C) :
    α.app X ≫ (F'.descOfIsLeftKanExtension α G β).app (L.obj X) = β.app X 
goal: CategoryTheory.CategoryStruct.comp (α.app X) ((F'.descOfIsLeftKanExtension α G β).app (L.obj X)) = β.app X

full_name: CategoryTheory.Functor.hom_ext_of_isLeftKanExtension
code: lemma hom_ext_of_isLeftKanExtension {G : D ⥤ H} (γ₁ γ₂ : F' ⟶ G)
    (hγ : α ≫ whiskerLeft L γ₁ = α ≫ whiskerLeft L γ₂) : γ₁ = γ₂ 
goal: γ₁ = γ₂

full_name: CategoryTheory.Functor.homEquivOfIsLeftKanExtension
code: /-- If `(F', α)` is a left Kan extension of `F` along `L`, then this
is the induced bijection `(F' ⟶ G) ≃ (F ⟶ L ⋙ G)` for all `G`. -/
noncomputable def homEquivOfIsLeftKanExtension (G : D ⥤ H) :
    (F' ⟶ G) ≃ (F ⟶ L ⋙ G) 
goal: (F' ⟶ G) ≃ (F ⟶ L.comp G)

full_name: CategoryTheory.Functor.isLeftKanExtension_of_iso
code: lemma isLeftKanExtension_of_iso {F' : D ⥤ H} {F'' : D ⥤ H} (e : F' ≅ F'')
    {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') (α' : F ⟶ L ⋙ F'')
    (comm : α ≫ whiskerLeft L e.hom = α') [F'.IsLeftKanExtension α] :
    F''.IsLeftKanExtension α' 
goal: F''.IsLeftKanExtension α'

full_name: CategoryTheory.Functor.isLeftKanExtension_iff_of_iso
code: lemma isLeftKanExtension_iff_of_iso {F' F'' : D ⥤ H} (e : F' ≅ F'')
    {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') (α' : F ⟶ L ⋙ F'')
    (comm : α ≫ whiskerLeft L e.hom = α') :
    F'.IsLeftKanExtension α ↔ F''.IsLeftKanExtension α' 
goal: F'.IsLeftKanExtension α ↔ F''.IsLeftKanExtension α'

full_name: CategoryTheory.Functor.leftKanExtensionUniqueOfIso_inv
code: /-- Left Kan extensions of isomorphic functors are isomorphic. -/
@[simps]
noncomputable def leftKanExtensionUniqueOfIso {G : C ⥤ H} (i : F ≅ G) (G' : D ⥤ H)
    (β : G ⟶ L ⋙ G') [G'.IsLeftKanExtension β] : F' ≅ G' 
goal: (F'.leftKanExtensionUniqueOfIso α i G' β).inv =
  G'.descOfIsLeftKanExtension β F' (CategoryTheory.CategoryStruct.comp i.inv α)

full_name: CategoryTheory.Functor.leftKanExtensionUniqueOfIso
code: /-- Left Kan extensions of isomorphic functors are isomorphic. -/
@[simps]
noncomputable def leftKanExtensionUniqueOfIso {G : C ⥤ H} (i : F ≅ G) (G' : D ⥤ H)
    (β : G ⟶ L ⋙ G') [G'.IsLeftKanExtension β] : F' ≅ G' 
goal: F' ≅ G'

full_name: CategoryTheory.Functor.leftKanExtensionUniqueOfIso_hom
code: /-- Left Kan extensions of isomorphic functors are isomorphic. -/
@[simps]
noncomputable def leftKanExtensionUniqueOfIso {G : C ⥤ H} (i : F ≅ G) (G' : D ⥤ H)
    (β : G ⟶ L ⋙ G') [G'.IsLeftKanExtension β] : F' ≅ G' 
goal: (F'.leftKanExtensionUniqueOfIso α i G' β).hom =
  F'.descOfIsLeftKanExtension α G' (CategoryTheory.CategoryStruct.comp i.hom β)

full_name: CategoryTheory.Functor.leftKanExtensionUnique_hom
code: /-- Two left Kan extensions are (canonically) isomorphic. -/
@[simps!]
noncomputable def leftKanExtensionUnique
    (F'' : D ⥤ H) (α' : F ⟶ L ⋙ F'') [F''.IsLeftKanExtension α'] : F' ≅ F'' 
goal: (F'.leftKanExtensionUnique α F'' α').hom = F'.descOfIsLeftKanExtension α F'' α'

full_name: CategoryTheory.Functor.leftKanExtensionUnique
code: /-- Two left Kan extensions are (canonically) isomorphic. -/
@[simps!]
noncomputable def leftKanExtensionUnique
    (F'' : D ⥤ H) (α' : F ⟶ L ⋙ F'') [F''.IsLeftKanExtension α'] : F' ≅ F'' 
goal: F' ≅ F''

full_name: CategoryTheory.Functor.leftKanExtensionUnique_inv
code: /-- Two left Kan extensions are (canonically) isomorphic. -/
@[simps!]
noncomputable def leftKanExtensionUnique
    (F'' : D ⥤ H) (α' : F ⟶ L ⋙ F'') [F''.IsLeftKanExtension α'] : F' ≅ F'' 
goal: (F'.leftKanExtensionUnique α F'' α').inv = F''.descOfIsLeftKanExtension α' F' α

full_name: CategoryTheory.Functor.isLeftKanExtension_iff_isIso
code: lemma isLeftKanExtension_iff_isIso {F' : D ⥤ H} {F'' : D ⥤ H} (φ : F' ⟶ F'')
    {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F') (α' : F ⟶ L ⋙ F'')
    (comm : α ≫ whiskerLeft L φ = α') [F'.IsLeftKanExtension α] :
    F''.IsLeftKanExtension α' ↔ IsIso φ 
goal: F''.IsLeftKanExtension α' ↔ CategoryTheory.IsIso φ

full_name: CategoryTheory.Functor.HasRightKanExtension
code: /-- This property `HasRightKanExtension L F` holds when the functor `F` has a right
Kan extension along `L`. -/
abbrev HasRightKanExtension (L : C ⥤ D) (F : C ⥤ H) 
goal: Prop

full_name: CategoryTheory.Functor.HasRightKanExtension.mk
code: lemma HasRightKanExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : L ⋙ F' ⟶ F)
    [F'.IsRightKanExtension α] : HasRightKanExtension L F 
goal: L.HasRightKanExtension F

full_name: CategoryTheory.Functor.HasLeftKanExtension
code: /-- This property `HasLeftKanExtension L F` holds when the functor `F` has a left
Kan extension along `L`. -/
abbrev HasLeftKanExtension (L : C ⥤ D) (F : C ⥤ H) 
goal: Prop

full_name: CategoryTheory.Functor.HasLeftKanExtension.mk
code: lemma HasLeftKanExtension.mk (F' : D ⥤ H) {L : C ⥤ D} {F : C ⥤ H} (α : F ⟶ L ⋙ F')
    [F'.IsLeftKanExtension α] : HasLeftKanExtension L F 
goal: L.HasLeftKanExtension F

full_name: CategoryTheory.Functor.rightKanExtension
code: /-- A chosen right Kan extension when `[HasRightKanExtension L F]` holds. -/
noncomputable def rightKanExtension : D ⥤ H 
goal: CategoryTheory.Functor D H

full_name: CategoryTheory.Functor.rightKanExtensionCounit
code: /-- The counit of the chosen right Kan extension `rightKanExtension L F`. -/
noncomputable def rightKanExtensionCounit : L ⋙ rightKanExtension L F ⟶ F 
goal: L.comp (L.rightKanExtension F) ⟶ F

full_name: CategoryTheory.Functor.instIsRightKanExtensionRightKanExtensionRightKanExtensionCounit
code: instance : (L.rightKanExtension F).IsRightKanExtension (L.rightKanExtensionCounit F) 
goal: (L.rightKanExtension F).IsRightKanExtension (L.rightKanExtensionCounit F)

full_name: CategoryTheory.Functor.rightKanExtension_hom_ext
code: @[ext]
lemma rightKanExtension_hom_ext {G : D ⥤ H} (γ₁ γ₂ : G ⟶ rightKanExtension L F)
    (hγ : whiskerLeft L γ₁ ≫ rightKanExtensionCounit L F =
      whiskerLeft L γ₂ ≫ rightKanExtensionCounit L F) :
    γ₁ = γ₂ 
goal: γ₁ = γ₂

full_name: CategoryTheory.Functor.leftKanExtension
code: /-- A chosen left Kan extension when `[HasLeftKanExtension L F]` holds. -/
noncomputable def leftKanExtension : D ⥤ H 
goal: CategoryTheory.Functor D H

full_name: CategoryTheory.Functor.leftKanExtensionUnit
code: /-- The unit of the chosen left Kan extension `leftKanExtension L F`. -/
noncomputable def leftKanExtensionUnit : F ⟶ L ⋙ leftKanExtension L F 
goal: F ⟶ L.comp (L.leftKanExtension F)

full_name: CategoryTheory.Functor.instIsLeftKanExtensionLeftKanExtensionLeftKanExtensionUnit
code: instance : (L.leftKanExtension F).IsLeftKanExtension (L.leftKanExtensionUnit F) 
goal: (L.leftKanExtension F).IsLeftKanExtension (L.leftKanExtensionUnit F)

full_name: CategoryTheory.Functor.leftKanExtension_hom_ext
code: @[ext]
lemma leftKanExtension_hom_ext {G : D ⥤ H} (γ₁ γ₂ : leftKanExtension L F ⟶ G)
    (hγ : leftKanExtensionUnit L F ≫ whiskerLeft L γ₁ =
      leftKanExtensionUnit L F ≫ whiskerLeft L γ₂) : γ₁ = γ₂ 
goal: γ₁ = γ₂

full_name: CategoryTheory.Functor.LeftExtension.postcomp₁_obj_hom_app
code: /-- The functor `LeftExtension L' F ⥤ LeftExtension L F`
induced by a natural transformation `L' ⟶ L ⋙ G'`. -/
@[simps!]
def LeftExtension.postcomp₁ (f : L' ⟶ L ⋙ G) (F : C ⥤ H) :
    LeftExtension L' F ⥤ LeftExtension L F 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Functor.LeftExtension.postcomp₁ G f F).obj X).hom.app X_1 =
    CategoryTheory.CategoryStruct.comp (X.hom.app X_1) (X.right.map (f.app X_1))

full_name: CategoryTheory.Functor.LeftExtension.postcomp₁_map_left
code: /-- The functor `LeftExtension L' F ⥤ LeftExtension L F`
induced by a natural transformation `L' ⟶ L ⋙ G'`. -/
@[simps!]
def LeftExtension.postcomp₁ (f : L' ⟶ L ⋙ G) (F : C ⥤ H) :
    LeftExtension L' F ⥤ LeftExtension L F 
goal: ((CategoryTheory.Functor.LeftExtension.postcomp₁ G f F).map φ).left = CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.Functor.LeftExtension.postcomp₁_obj_left
code: /-- The functor `LeftExtension L' F ⥤ LeftExtension L F`
induced by a natural transformation `L' ⟶ L ⋙ G'`. -/
@[simps!]
def LeftExtension.postcomp₁ (f : L' ⟶ L ⋙ G) (F : C ⥤ H) :
    LeftExtension L' F ⥤ LeftExtension L F 
goal: ((CategoryTheory.Functor.LeftExtension.postcomp₁ G f F).obj X).left = X.left

full_name: CategoryTheory.Functor.LeftExtension.postcomp₁_obj_right_map
code: /-- The functor `LeftExtension L' F ⥤ LeftExtension L F`
induced by a natural transformation `L' ⟶ L ⋙ G'`. -/
@[simps!]
def LeftExtension.postcomp₁ (f : L' ⟶ L ⋙ G) (F : C ⥤ H) :
    LeftExtension L' F ⥤ LeftExtension L F 
goal: ∀ {X_1 Y : D} (f_1 : X_1 ⟶ Y),
  ((CategoryTheory.Functor.LeftExtension.postcomp₁ G f F).obj X).right.map f_1 = X.right.map (G.map f_1)

full_name: CategoryTheory.Functor.LeftExtension.postcomp₁
code: /-- The functor `LeftExtension L' F ⥤ LeftExtension L F`
induced by a natural transformation `L' ⟶ L ⋙ G'`. -/
@[simps!]
def LeftExtension.postcomp₁ (f : L' ⟶ L ⋙ G) (F : C ⥤ H) :
    LeftExtension L' F ⥤ LeftExtension L F 
goal: CategoryTheory.Functor (L'.LeftExtension F) (L.LeftExtension F)

full_name: CategoryTheory.Functor.LeftExtension.postcomp₁_map_right_app
code: /-- The functor `LeftExtension L' F ⥤ LeftExtension L F`
induced by a natural transformation `L' ⟶ L ⋙ G'`. -/
@[simps!]
def LeftExtension.postcomp₁ (f : L' ⟶ L ⋙ G) (F : C ⥤ H) :
    LeftExtension L' F ⥤ LeftExtension L F 
goal: ∀ (X_1 : D), ((CategoryTheory.Functor.LeftExtension.postcomp₁ G f F).map φ).right.app X_1 = φ.right.app (G.obj X_1)

full_name: CategoryTheory.Functor.LeftExtension.postcomp₁_obj_right_obj
code: /-- The functor `LeftExtension L' F ⥤ LeftExtension L F`
induced by a natural transformation `L' ⟶ L ⋙ G'`. -/
@[simps!]
def LeftExtension.postcomp₁ (f : L' ⟶ L ⋙ G) (F : C ⥤ H) :
    LeftExtension L' F ⥤ LeftExtension L F 
goal: ∀ (X_1 : D), ((CategoryTheory.Functor.LeftExtension.postcomp₁ G f F).obj X).right.obj X_1 = X.right.obj (G.obj X_1)

full_name: CategoryTheory.Functor.RightExtension.postcomp₁_obj_right
code: /-- The functor `RightExtension L' F ⥤ RightExtension L F`
induced by a natural transformation `L ⋙ G ⟶ L'`. -/
@[simps!]
def RightExtension.postcomp₁ (f : L ⋙ G ⟶ L') (F : C ⥤ H) :
    RightExtension L' F ⥤ RightExtension L F 
goal: ((CategoryTheory.Functor.RightExtension.postcomp₁ G f F).obj X).right = X.right

full_name: CategoryTheory.Functor.RightExtension.postcomp₁_map_left_app
code: /-- The functor `RightExtension L' F ⥤ RightExtension L F`
induced by a natural transformation `L ⋙ G ⟶ L'`. -/
@[simps!]
def RightExtension.postcomp₁ (f : L ⋙ G ⟶ L') (F : C ⥤ H) :
    RightExtension L' F ⥤ RightExtension L F 
goal: ∀ (X_1 : D), ((CategoryTheory.Functor.RightExtension.postcomp₁ G f F).map φ).left.app X_1 = φ.left.app (G.obj X_1)

full_name: CategoryTheory.Functor.RightExtension.postcomp₁_obj_left_obj
code: /-- The functor `RightExtension L' F ⥤ RightExtension L F`
induced by a natural transformation `L ⋙ G ⟶ L'`. -/
@[simps!]
def RightExtension.postcomp₁ (f : L ⋙ G ⟶ L') (F : C ⥤ H) :
    RightExtension L' F ⥤ RightExtension L F 
goal: ∀ (X_1 : D), ((CategoryTheory.Functor.RightExtension.postcomp₁ G f F).obj X).left.obj X_1 = X.left.obj (G.obj X_1)

full_name: CategoryTheory.Functor.RightExtension.postcomp₁_obj_hom_app
code: /-- The functor `RightExtension L' F ⥤ RightExtension L F`
induced by a natural transformation `L ⋙ G ⟶ L'`. -/
@[simps!]
def RightExtension.postcomp₁ (f : L ⋙ G ⟶ L') (F : C ⥤ H) :
    RightExtension L' F ⥤ RightExtension L F 
goal: ∀ (X_1 : C),
  ((CategoryTheory.Functor.RightExtension.postcomp₁ G f F).obj X).hom.app X_1 =
    CategoryTheory.CategoryStruct.comp (X.left.map (f.app X_1)) (X.hom.app X_1)

full_name: CategoryTheory.Functor.RightExtension.postcomp₁_map_right
code: /-- The functor `RightExtension L' F ⥤ RightExtension L F`
induced by a natural transformation `L ⋙ G ⟶ L'`. -/
@[simps!]
def RightExtension.postcomp₁ (f : L ⋙ G ⟶ L') (F : C ⥤ H) :
    RightExtension L' F ⥤ RightExtension L F 
goal: ((CategoryTheory.Functor.RightExtension.postcomp₁ G f F).map φ).right = CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.Functor.RightExtension.postcomp₁
code: /-- The functor `RightExtension L' F ⥤ RightExtension L F`
induced by a natural transformation `L ⋙ G ⟶ L'`. -/
@[simps!]
def RightExtension.postcomp₁ (f : L ⋙ G ⟶ L') (F : C ⥤ H) :
    RightExtension L' F ⥤ RightExtension L F 
goal: CategoryTheory.Functor (L'.RightExtension F) (L.RightExtension F)

full_name: CategoryTheory.Functor.RightExtension.postcomp₁_obj_left_map
code: /-- The functor `RightExtension L' F ⥤ RightExtension L F`
induced by a natural transformation `L ⋙ G ⟶ L'`. -/
@[simps!]
def RightExtension.postcomp₁ (f : L ⋙ G ⟶ L') (F : C ⥤ H) :
    RightExtension L' F ⥤ RightExtension L F 
goal: ∀ {X_1 Y : D} (f_1 : X_1 ⟶ Y),
  ((CategoryTheory.Functor.RightExtension.postcomp₁ G f F).obj X).left.map f_1 = X.left.map (G.map f_1)

full_name: CategoryTheory.Functor.instIsEquivalenceLeftExtensionPostcomp₁OfIsIso
code: noncomputable instance (f : L' ⟶ L ⋙ G) [IsIso f] (F : C ⥤ H) :
    IsEquivalence (LeftExtension.postcomp₁ G f F) 
goal: (CategoryTheory.Functor.LeftExtension.postcomp₁ G f F).IsEquivalence

full_name: CategoryTheory.Functor.instIsEquivalenceRightExtensionPostcomp₁OfIsIso
code: noncomputable instance (f : L ⋙ G ⟶ L') [IsIso f] (F : C ⥤ H) :
    IsEquivalence (RightExtension.postcomp₁ G f F) 
goal: (CategoryTheory.Functor.RightExtension.postcomp₁ G f F).IsEquivalence

full_name: CategoryTheory.Functor.hasLeftExtension_iff_postcomp₁
code: lemma hasLeftExtension_iff_postcomp₁ :
    HasLeftKanExtension L' F ↔ HasLeftKanExtension L F 
goal: L'.HasLeftKanExtension F ↔ L.HasLeftKanExtension F

full_name: CategoryTheory.Functor.hasRightExtension_iff_postcomp₁
code: lemma hasRightExtension_iff_postcomp₁ :
    HasRightKanExtension L' F ↔ HasRightKanExtension L F 
goal: L'.HasRightKanExtension F ↔ L.HasRightKanExtension F

full_name: CategoryTheory.Functor.LeftExtension.isUniversalPostcomp₁Equiv
code: /-- Given an isomorphism `e : L ⋙ G ≅ L'`, a left extension of `F` along `L'` is universal
iff the corresponding left extension of `L` along `L` is. -/
noncomputable def LeftExtension.isUniversalPostcomp₁Equiv (ex : LeftExtension L' F) :
    ex.IsUniversal ≃ ((LeftExtension.postcomp₁ G e.inv F).obj ex).IsUniversal 
goal: CategoryTheory.StructuredArrow.IsUniversal ex ≃
  CategoryTheory.StructuredArrow.IsUniversal ((CategoryTheory.Functor.LeftExtension.postcomp₁ G e.inv F).obj ex)

full_name: CategoryTheory.Functor.RightExtension.isUniversalPostcomp₁Equiv
code: /-- Given an isomorphism `e : L ⋙ G ≅ L'`, a right extension of `F` along `L'` is universal
iff the corresponding right extension of `L` along `L` is. -/
noncomputable def RightExtension.isUniversalPostcomp₁Equiv (ex : RightExtension L' F) :
    ex.IsUniversal ≃ ((RightExtension.postcomp₁ G e.hom F).obj ex).IsUniversal 
goal: CategoryTheory.CostructuredArrow.IsUniversal ex ≃
  CategoryTheory.CostructuredArrow.IsUniversal ((CategoryTheory.Functor.RightExtension.postcomp₁ G e.hom F).obj ex)

full_name: CategoryTheory.Functor.isLeftKanExtension_iff_postcomp₁
code: lemma isLeftKanExtension_iff_postcomp₁ (α : F ⟶ L' ⋙ F') :
    F'.IsLeftKanExtension α ↔ (G ⋙ F').IsLeftKanExtension
      (α ≫ whiskerRight e.inv _ ≫ (Functor.associator _ _ _).hom) 
goal: F'.IsLeftKanExtension α ↔
  (G.comp F').IsLeftKanExtension
    (CategoryTheory.CategoryStruct.comp α
      (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight e.inv F') (L.associator G F').hom))

full_name: CategoryTheory.Functor.isRightKanExtension_iff_postcomp₁
code: lemma isRightKanExtension_iff_postcomp₁ (α : L' ⋙ F' ⟶ F) :
    F'.IsRightKanExtension α ↔ (G ⋙ F').IsRightKanExtension
      ((Functor.associator _ _ _).inv ≫ whiskerRight e.hom F' ≫ α) 
goal: F'.IsRightKanExtension α ↔
  (G.comp F').IsRightKanExtension
    (CategoryTheory.CategoryStruct.comp (L.associator G F').inv
      (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight e.hom F') α))

full_name: CategoryTheory.Functor.LeftExtension.precomp_map_left
code: /-- The functor `LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def LeftExtension.precomp : LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F) 
goal: ((CategoryTheory.Functor.LeftExtension.precomp L F G).map φ).left = CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.Functor.LeftExtension.precomp_obj_left
code: /-- The functor `LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def LeftExtension.precomp : LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F) 
goal: ((CategoryTheory.Functor.LeftExtension.precomp L F G).obj X).left = X.left

full_name: CategoryTheory.Functor.LeftExtension.precomp_obj_right
code: /-- The functor `LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def LeftExtension.precomp : LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F) 
goal: ((CategoryTheory.Functor.LeftExtension.precomp L F G).obj X).right = X.right

full_name: CategoryTheory.Functor.LeftExtension.precomp_obj_hom_app
code: /-- The functor `LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def LeftExtension.precomp : LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F) 
goal: ∀ (X_1 : C'), ((CategoryTheory.Functor.LeftExtension.precomp L F G).obj X).hom.app X_1 = X.hom.app (G.obj X_1)

full_name: CategoryTheory.Functor.LeftExtension.precomp
code: /-- The functor `LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def LeftExtension.precomp : LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F) 
goal: CategoryTheory.Functor (L.LeftExtension F) ((G.comp L).LeftExtension (G.comp F))

full_name: CategoryTheory.Functor.LeftExtension.precomp_map_right
code: /-- The functor `LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def LeftExtension.precomp : LeftExtension L F ⥤ LeftExtension (G ⋙ L) (G ⋙ F) 
goal: ((CategoryTheory.Functor.LeftExtension.precomp L F G).map φ).right = φ.right

full_name: CategoryTheory.Functor.RightExtension.precomp_obj_left
code: /-- The functor `RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def RightExtension.precomp : RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F) 
goal: ((CategoryTheory.Functor.RightExtension.precomp L F G).obj X).left = X.left

full_name: CategoryTheory.Functor.RightExtension.precomp
code: /-- The functor `RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def RightExtension.precomp : RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F) 
goal: CategoryTheory.Functor (L.RightExtension F) ((G.comp L).RightExtension (G.comp F))

full_name: CategoryTheory.Functor.RightExtension.precomp_map_left
code: /-- The functor `RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def RightExtension.precomp : RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F) 
goal: ((CategoryTheory.Functor.RightExtension.precomp L F G).map φ).left = φ.left

full_name: CategoryTheory.Functor.RightExtension.precomp_obj_hom_app
code: /-- The functor `RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def RightExtension.precomp : RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F) 
goal: ∀ (X_1 : C'), ((CategoryTheory.Functor.RightExtension.precomp L F G).obj X).hom.app X_1 = X.hom.app (G.obj X_1)

full_name: CategoryTheory.Functor.RightExtension.precomp_map_right
code: /-- The functor `RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def RightExtension.precomp : RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F) 
goal: ((CategoryTheory.Functor.RightExtension.precomp L F G).map φ).right = CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.Functor.RightExtension.precomp_obj_right
code: /-- The functor `RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F)`
obtained by precomposition. -/
@[simps!]
def RightExtension.precomp : RightExtension L F ⥤ RightExtension (G ⋙ L) (G ⋙ F) 
goal: ((CategoryTheory.Functor.RightExtension.precomp L F G).obj X).right = X.right

full_name: CategoryTheory.Functor.instIsEquivalenceLeftExtensionCompPrecomp
code: noncomputable instance : IsEquivalence (LeftExtension.precomp L F G) 
goal: (CategoryTheory.Functor.LeftExtension.precomp L F G).IsEquivalence

full_name: CategoryTheory.Functor.instIsEquivalenceRightExtensionCompPrecomp
code: noncomputable instance : IsEquivalence (RightExtension.precomp L F G) 
goal: (CategoryTheory.Functor.RightExtension.precomp L F G).IsEquivalence

full_name: CategoryTheory.Functor.LeftExtension.isUniversalPrecompEquiv
code: /-- If `G` is an equivalence, then a left extension of `F` along `L` is universal iff
the corresponding left extension of `G ⋙ F` along `G ⋙ L` is. -/
noncomputable def LeftExtension.isUniversalPrecompEquiv (e : LeftExtension L F) :
    e.IsUniversal ≃ ((LeftExtension.precomp L F G).obj e).IsUniversal 
goal: CategoryTheory.StructuredArrow.IsUniversal e ≃
  CategoryTheory.StructuredArrow.IsUniversal ((CategoryTheory.Functor.LeftExtension.precomp L F G).obj e)

full_name: CategoryTheory.Functor.RightExtension.isUniversalPrecompEquiv
code: /-- If `G` is an equivalence, then a right extension of `F` along `L` is universal iff
the corresponding left extension of `G ⋙ F` along `G ⋙ L` is. -/
noncomputable def RightExtension.isUniversalPrecompEquiv (e : RightExtension L F) :
    e.IsUniversal ≃ ((RightExtension.precomp L F G).obj e).IsUniversal 
goal: CategoryTheory.CostructuredArrow.IsUniversal e ≃
  CategoryTheory.CostructuredArrow.IsUniversal ((CategoryTheory.Functor.RightExtension.precomp L F G).obj e)

full_name: CategoryTheory.Functor.isLeftKanExtension_iff_precomp
code: lemma isLeftKanExtension_iff_precomp (α : F ⟶ L ⋙ F') :
    F'.IsLeftKanExtension α ↔ F'.IsLeftKanExtension
      (whiskerLeft G α ≫ (Functor.associator _ _ _).inv) 
goal: F'.IsLeftKanExtension α ↔
  F'.IsLeftKanExtension (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft G α) (G.associator L F').inv)

full_name: CategoryTheory.Functor.isRightKanExtension_iff_precomp
code: lemma isRightKanExtension_iff_precomp (α : L ⋙ F' ⟶ F) :
    F'.IsRightKanExtension α ↔
      F'.IsRightKanExtension ((Functor.associator _ _ _).hom ≫ whiskerLeft G α) 
goal: F'.IsRightKanExtension α ↔
  F'.IsRightKanExtension (CategoryTheory.CategoryStruct.comp (G.associator L F').hom (CategoryTheory.whiskerLeft G α))

full_name: CategoryTheory.Functor.rightExtensionEquivalenceOfIso₁
code: /-- The equivalence `RightExtension L F ≌ RightExtension L' F` induced by
a natural isomorphism `L ≅ L'`. -/
def rightExtensionEquivalenceOfIso₁ : RightExtension L F ≌ RightExtension L' F 
goal: L.RightExtension F ≌ L'.RightExtension F

full_name: CategoryTheory.Functor.hasRightExtension_iff_of_iso₁
code: lemma hasRightExtension_iff_of_iso₁ : HasRightKanExtension L F ↔ HasRightKanExtension L' F 
goal: L.HasRightKanExtension F ↔ L'.HasRightKanExtension F

full_name: CategoryTheory.Functor.leftExtensionEquivalenceOfIso₁
code: /-- The equivalence `LeftExtension L F ≌ LeftExtension L' F` induced by
a natural isomorphism `L ≅ L'`. -/
def leftExtensionEquivalenceOfIso₁ : LeftExtension L F ≌ LeftExtension L' F 
goal: L.LeftExtension F ≌ L'.LeftExtension F

full_name: CategoryTheory.Functor.hasLeftExtension_iff_of_iso₁
code: lemma hasLeftExtension_iff_of_iso₁ : HasLeftKanExtension L F ↔ HasLeftKanExtension L' F 
goal: L.HasLeftKanExtension F ↔ L'.HasLeftKanExtension F

full_name: CategoryTheory.Functor.rightExtensionEquivalenceOfIso₂
code: /-- The equivalence `RightExtension L F ≌ RightExtension L F'` induced by
a natural isomorphism `F ≅ F'`. -/
def rightExtensionEquivalenceOfIso₂ : RightExtension L F ≌ RightExtension L F' 
goal: L.RightExtension F ≌ L.RightExtension F'

full_name: CategoryTheory.Functor.hasRightExtension_iff_of_iso₂
code: lemma hasRightExtension_iff_of_iso₂ : HasRightKanExtension L F ↔ HasRightKanExtension L F' 
goal: L.HasRightKanExtension F ↔ L.HasRightKanExtension F'

full_name: CategoryTheory.Functor.leftExtensionEquivalenceOfIso₂
code: /-- The equivalence `LeftExtension L F ≌ LeftExtension L F'` induced by
a natural isomorphism `F ≅ F'`. -/
def leftExtensionEquivalenceOfIso₂ : LeftExtension L F ≌ LeftExtension L F' 
goal: L.LeftExtension F ≌ L.LeftExtension F'

full_name: CategoryTheory.Functor.hasLeftExtension_iff_of_iso₂
code: lemma hasLeftExtension_iff_of_iso₂ : HasLeftKanExtension L F ↔ HasLeftKanExtension L F' 
goal: L.HasLeftKanExtension F ↔ L.HasLeftKanExtension F'

full_name: CategoryTheory.Functor.LeftExtension.isUniversalEquivOfIso₂
code: /-- When two left extensions `α₁ : LeftExtension L F₁` and `α₂ : LeftExtension L F₂`
are essentially the same via an isomorphism of functors `F₁ ≅ F₂`,
then `α₁` is universal iff `α₂` is. -/
noncomputable def LeftExtension.isUniversalEquivOfIso₂
    (α₁ : LeftExtension L F₁) (α₂ : LeftExtension L F₂) (e : F₁ ≅ F₂)
    (e' : α₁.right ≅ α₂.right)
    (h : α₁.hom ≫ whiskerLeft L e'.hom = e.hom ≫ α₂.hom) :
    α₁.IsUniversal ≃ α₂.IsUniversal 
goal: CategoryTheory.StructuredArrow.IsUniversal α₁ ≃ CategoryTheory.StructuredArrow.IsUniversal α₂

full_name: CategoryTheory.Functor.isLeftKanExtension_iff_of_iso₂
code: lemma isLeftKanExtension_iff_of_iso₂ {F₁' F₂' : D ⥤ H} (α₁ : F₁ ⟶ L ⋙ F₁') (α₂ : F₂ ⟶ L ⋙ F₂')
    (e : F₁ ≅ F₂) (e' : F₁' ≅ F₂') (h : α₁ ≫ whiskerLeft L e'.hom = e.hom ≫ α₂) :
    F₁'.IsLeftKanExtension α₁ ↔ F₂'.IsLeftKanExtension α₂ 
goal: F₁'.IsLeftKanExtension α₁ ↔ F₂'.IsLeftKanExtension α₂

full_name: CategoryTheory.Functor.RightExtension.isUniversalEquivOfIso₂
code: /-- When two right extensions `α₁ : RightExtension L F₁` and `α₂ : RightExtension L F₂`
are essentially the same via an isomorphism of functors `F₁ ≅ F₂`,
then `α₁` is universal iff `α₂` is. -/
noncomputable def RightExtension.isUniversalEquivOfIso₂
    (α₁ : RightExtension L F₁) (α₂ : RightExtension L F₂) (e : F₁ ≅ F₂)
    (e' : α₁.left ≅ α₂.left)
    (h : whiskerLeft L e'.hom ≫ α₂.hom = α₁.hom ≫ e.hom) :
    α₁.IsUniversal ≃ α₂.IsUniversal 
goal: CategoryTheory.CostructuredArrow.IsUniversal α₁ ≃ CategoryTheory.CostructuredArrow.IsUniversal α₂

full_name: CategoryTheory.Functor.isRightKanExtension_iff_of_iso₂
code: lemma isRightKanExtension_iff_of_iso₂ {F₁' F₂' : D ⥤ H} (α₁ : L ⋙ F₁' ⟶ F₁) (α₂ : L ⋙ F₂' ⟶ F₂)
    (e : F₁ ≅ F₂) (e' : F₁' ≅ F₂') (h : whiskerLeft L e'.hom ≫ α₂ = α₁ ≫ e.hom) :
    F₁'.IsRightKanExtension α₁ ↔ F₂'.IsRightKanExtension α₂ 
goal: F₁'.IsRightKanExtension α₁ ↔ F₂'.IsRightKanExtension α₂