File: Mathlib/CategoryTheory/Bicategory/Kan/HasKan.lean

full_name: CategoryTheory.Bicategory.HasLeftKanExtension
code: /-- The existence of a left Kan extension of `g` along `f`. -/
class HasLeftKanExtension (f : a ⟶ b) (g : a ⟶ c) : Prop where
  hasInitial : HasInitial <| LeftExtension f g
goal: Prop

full_name: CategoryTheory.Bicategory.HasLeftKanExtension.hasInitial
code: /-- The existence of a left Kan extension of `g` along `f`. -/
class HasLeftKanExtension (f : a ⟶ b) (g : a ⟶ c) : Prop where
  hasInitial : HasInitial <| LeftExtension f g
goal: CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftExtension f g)

full_name: CategoryTheory.Bicategory.LeftExtension.IsKan.hasLeftKanExtension
code: theorem LeftExtension.IsKan.hasLeftKanExtension {t : LeftExtension f g} (H : IsKan t) :
    HasLeftKanExtension f g 
goal: CategoryTheory.Bicategory.HasLeftKanExtension f g

full_name: CategoryTheory.Bicategory.instHasInitialLeftExtensionOfHasLeftKanExtension
code: instance [HasLeftKanExtension f g] : HasInitial <| LeftExtension f g 
goal: CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftExtension f g)

full_name: CategoryTheory.Bicategory.lanLeftExtension
code: /-- The left Kan extension of `g` along `f` at the level of structured arrows. -/
def lanLeftExtension (f : a ⟶ b) (g : a ⟶ c) [HasLeftKanExtension f g] : LeftExtension f g 
goal: CategoryTheory.Bicategory.LeftExtension f g

full_name: CategoryTheory.Bicategory.lan
code: /-- The left Kan extension of `g` along `f`. -/
def lan (f : a ⟶ b) (g : a ⟶ c) [HasLeftKanExtension f g] : b ⟶ c 
goal: b ⟶ c

full_name: CategoryTheory.Bicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Kan_HasKan___macroRules_CategoryTheory_Bicategory_term_⁺__1»
code: /-- `f⁺ g` is the left Kan extension of `g` along `f`.
```
  b
  △ \
  |   \ f⁺ g
f |     \
  |       ◿
  a - - - ▷ c
      g
```
-/
scoped infixr:90 "⁺ " => lan
goal: Lean.Macro

full_name: CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Kan_HasKan___unexpand_CategoryTheory_Bicategory_lan_1
code: /-- `f⁺ g` is the left Kan extension of `g` along `f`.
```
  b
  △ \
  |   \ f⁺ g
f |     \
  |       ◿
  a - - - ▷ c
      g
```
-/
scoped infixr:90 "⁺ " => lan
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Bicategory.lanLeftExtension_extension
code: @[simp]
theorem lanLeftExtension_extension (f : a ⟶ b) (g : a ⟶ c) [HasLeftKanExtension f g] :
    (lanLeftExtension f g).extension = f⁺ g 
goal: (CategoryTheory.Bicategory.lanLeftExtension f g).extension = CategoryTheory.Bicategory.lan f g

full_name: CategoryTheory.Bicategory.lanUnit
code: /-- The unit for the left Kan extension `f⁺ g`. -/
def lanUnit (f : a ⟶ b) (g : a ⟶ c) [HasLeftKanExtension f g] : g ⟶ f ≫ f⁺ g 
goal: g ⟶ CategoryTheory.CategoryStruct.comp f (CategoryTheory.Bicategory.lan f g)

full_name: CategoryTheory.Bicategory.lanLeftExtension_unit
code: @[simp]
theorem lanLeftExtension_unit (f : a ⟶ b) (g : a ⟶ c) [HasLeftKanExtension f g] :
    (lanLeftExtension f g).unit = lanUnit f g 
goal: (CategoryTheory.Bicategory.lanLeftExtension f g).unit = CategoryTheory.Bicategory.lanUnit f g

full_name: CategoryTheory.Bicategory.lanIsKan
code: /-- Evidence that the `Lan.extension f g` is a Kan extension. -/
def lanIsKan (f : a ⟶ b) (g : a ⟶ c) [HasLeftKanExtension f g] : (lanLeftExtension f g).IsKan 
goal: (CategoryTheory.Bicategory.lanLeftExtension f g).IsKan

full_name: CategoryTheory.Bicategory.lanDesc
code: /-- The family of 2-morphisms out of the left Kan extension `f⁺ g`. -/
def lanDesc [HasLeftKanExtension f g] (s : LeftExtension f g) :
    f⁺ g ⟶ s.extension 
goal: CategoryTheory.Bicategory.lan f g ⟶ s.extension

full_name: CategoryTheory.Bicategory.lanUnit_desc
code: @[reassoc (attr := simp)]
theorem lanUnit_desc [HasLeftKanExtension f g] (s : LeftExtension f g) :
    lanUnit f g ≫ f ◁ lanDesc s = s.unit 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.lanUnit f g)
    (CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.lanDesc s)) =
  s.unit

full_name: CategoryTheory.Bicategory.lanIsKan_desc
code: @[simp]
theorem lanIsKan_desc [HasLeftKanExtension f g] (s : LeftExtension f g) :
    (lanIsKan f g).desc s = lanDesc s 
goal: (CategoryTheory.Bicategory.lanIsKan f g).desc s = CategoryTheory.Bicategory.lanDesc s

full_name: CategoryTheory.Bicategory.Lan.existsUnique
code: theorem Lan.existsUnique [HasLeftKanExtension f g] (s : LeftExtension f g) :
    ∃! τ, lanUnit f g ≫ f ◁ τ = s.unit 
goal: ∃! τ,
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.lanUnit f g)
      (CategoryTheory.Bicategory.whiskerLeft f τ) =
    s.unit

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.commute
code: /-- We say that a 1-morphism `h` commutes with the left Kan extension `f⁺ g` if the whiskered
left extension for `f⁺ g` by `h` is a Kan extension of `g ≫ h` along `f`. -/
class Lan.CommuteWith
    (f : a ⟶ b) (g : a ⟶ c) [HasLeftKanExtension f g] {x : B} (h : c ⟶ x) : Prop where
  commute : Nonempty <| IsKan <| (lanLeftExtension f g).whisker h
goal: Nonempty ((CategoryTheory.Bicategory.lanLeftExtension f g).whisker h).IsKan

full_name: CategoryTheory.Bicategory.Lan.CommuteWith
code: /-- We say that a 1-morphism `h` commutes with the left Kan extension `f⁺ g` if the whiskered
left extension for `f⁺ g` by `h` is a Kan extension of `g ≫ h` along `f`. -/
class Lan.CommuteWith
    (f : a ⟶ b) (g : a ⟶ c) [HasLeftKanExtension f g] {x : B} (h : c ⟶ x) : Prop where
  commute : Nonempty <| IsKan <| (lanLeftExtension f g).whisker h
goal: Prop

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.of_isKan_whisker
code: theorem of_isKan_whisker [HasLeftKanExtension f g] (t : LeftExtension f g) {x : B} (h : c ⟶ x)
    (H : IsKan (t.whisker h)) (i : t.whisker h ≅ (lanLeftExtension f g).whisker h) :
    Lan.CommuteWith f g h 
goal: CategoryTheory.Bicategory.Lan.CommuteWith f g h

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.of_lan_comp_iso
code: theorem of_lan_comp_iso [HasLeftKanExtension f g]
    {x : B} {h : c ⟶ x} [HasLeftKanExtension f (g ≫ h)]
    (i : f⁺ (g ≫ h) ≅ f⁺ g ≫ h)
    (w : lanUnit f (g ≫ h) ≫ f ◁ i.hom = lanUnit f g ▷ h ≫ (α_ _ _ _).hom) :
    Lan.CommuteWith f g h 
goal: CategoryTheory.Bicategory.Lan.CommuteWith f g h

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.isKan
code: /-- Evidence that `h` commutes with the left Kan extension `f⁺ g`. -/
def isKan : IsKan <| (lanLeftExtension f g).whisker h 
goal: ((CategoryTheory.Bicategory.lanLeftExtension f g).whisker h).IsKan

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.instHasLeftKanExtensionComp
code: instance : HasLeftKanExtension f (g ≫ h) 
goal: CategoryTheory.Bicategory.HasLeftKanExtension f (CategoryTheory.CategoryStruct.comp g h)

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.isKanWhisker
code: /-- If `h` commutes with `f⁺ g` and `t` is another left Kan extension of `g` along `f`, then
`t.whisker h` is a left Kan extension of `g ≫ h` along `f`. -/
def isKanWhisker
    (t : LeftExtension f g) (H : IsKan t) {x : B} (h : c ⟶ x) [Lan.CommuteWith f g h] :
    IsKan (t.whisker h) 
goal: (t.whisker h).IsKan

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIsoWhisker
code: /-- The isomorphism `f⁺ (g ≫ h) ≅ f⁺ g ≫ h` at the level of structured arrows. -/
def lanCompIsoWhisker : lanLeftExtension f (g ≫ h) ≅ (lanLeftExtension f g).whisker h 
goal: CategoryTheory.Bicategory.lanLeftExtension f (CategoryTheory.CategoryStruct.comp g h) ≅
  (CategoryTheory.Bicategory.lanLeftExtension f g).whisker h

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIsoWhisker_hom_right
code: @[simp]
theorem lanCompIsoWhisker_hom_right :
    (lanCompIsoWhisker f g h).hom.right = lanDesc ((lanLeftExtension f g).whisker h) 
goal: (CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIsoWhisker f g h).hom.right =
  CategoryTheory.Bicategory.lanDesc ((CategoryTheory.Bicategory.lanLeftExtension f g).whisker h)

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIsoWhisker_inv_right
code: @[simp]
theorem lanCompIsoWhisker_inv_right :
    (lanCompIsoWhisker f g h).inv.right = (isKan f g h).desc (lanLeftExtension f (g ≫ h)) 
goal: (CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIsoWhisker f g h).inv.right =
  (CategoryTheory.Bicategory.Lan.CommuteWith.isKan f g h).desc
    (CategoryTheory.Bicategory.lanLeftExtension f (CategoryTheory.CategoryStruct.comp g h))

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso
code: /-- The 1-morphism `h` commutes with the left Kan extension `f⁺ g`. -/
@[simps!]
def lanCompIso : f⁺ (g ≫ h) ≅ f⁺ g ≫ h 
goal: CategoryTheory.Bicategory.lan f (CategoryTheory.CategoryStruct.comp g h) ≅
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.lan f g) h

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso_inv
code: /-- The 1-morphism `h` commutes with the left Kan extension `f⁺ g`. -/
@[simps!]
def lanCompIso : f⁺ (g ≫ h) ≅ f⁺ g ≫ h 
goal: (CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso f g h).inv =
  (CategoryTheory.Bicategory.Lan.CommuteWith.isKan f g h).desc
    (CategoryTheory.Bicategory.lanLeftExtension f (CategoryTheory.CategoryStruct.comp g h))

full_name: CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso_hom
code: /-- The 1-morphism `h` commutes with the left Kan extension `f⁺ g`. -/
@[simps!]
def lanCompIso : f⁺ (g ≫ h) ≅ f⁺ g ≫ h 
goal: (CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIso f g h).hom =
  CategoryTheory.Bicategory.lanDesc ((CategoryTheory.Bicategory.lanLeftExtension f g).whisker h)

full_name: CategoryTheory.Bicategory.HasAbsLeftKanExtension
code: /-- We say that there exists an absolute left Kan extension of `g` along `f` if any 1-morphism `h`
commutes with the left Kan extension `f⁺ g`. -/
class HasAbsLeftKanExtension (f : a ⟶ b) (g : a ⟶ c) extends HasLeftKanExtension f g : Prop where
  commute {x : B} (h : c ⟶ x) : Lan.CommuteWith f g h
goal: Prop

full_name: CategoryTheory.Bicategory.HasAbsLeftKanExtension.commute
code: /-- We say that there exists an absolute left Kan extension of `g` along `f` if any 1-morphism `h`
commutes with the left Kan extension `f⁺ g`. -/
class HasAbsLeftKanExtension (f : a ⟶ b) (g : a ⟶ c) extends HasLeftKanExtension f g : Prop where
  commute {x : B} (h : c ⟶ x) : Lan.CommuteWith f g h
goal: CategoryTheory.Bicategory.Lan.CommuteWith f g h

full_name: CategoryTheory.Bicategory.instCommuteWith
code: instance [HasAbsLeftKanExtension f g] {x : B} (h : c ⟶ x) : Lan.CommuteWith f g h 
goal: CategoryTheory.Bicategory.Lan.CommuteWith f g h

full_name: CategoryTheory.Bicategory.LeftExtension.IsAbsKan.hasAbsLeftKanExtension
code: theorem LeftExtension.IsAbsKan.hasAbsLeftKanExtension {t : LeftExtension f g} (H : IsAbsKan t) :
    HasAbsLeftKanExtension f g 
goal: CategoryTheory.Bicategory.HasAbsLeftKanExtension f g

full_name: CategoryTheory.Bicategory.HasLeftKanLift.hasInitial
code: /-- The existence of a left kan lift of `g` along `f`. -/
class HasLeftKanLift (f : b ⟶ a) (g : c ⟶ a) : Prop where mk' ::
  hasInitial : HasInitial <| LeftLift f g
goal: CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftLift f g)

full_name: CategoryTheory.Bicategory.HasLeftKanLift.mk'
code: /-- The existence of a left kan lift of `g` along `f`. -/
class HasLeftKanLift (f : b ⟶ a) (g : c ⟶ a) : Prop where mk' ::
  hasInitial : HasInitial <| LeftLift f g
goal: CategoryTheory.Bicategory.HasLeftKanLift f g

full_name: CategoryTheory.Bicategory.HasLeftKanLift
code: /-- The existence of a left kan lift of `g` along `f`. -/
class HasLeftKanLift (f : b ⟶ a) (g : c ⟶ a) : Prop where mk' ::
  hasInitial : HasInitial <| LeftLift f g
goal: Prop

full_name: CategoryTheory.Bicategory.LeftLift.IsKan.hasLeftKanLift
code: theorem LeftLift.IsKan.hasLeftKanLift {t : LeftLift f g} (H : IsKan t) : HasLeftKanLift f g 
goal: CategoryTheory.Bicategory.HasLeftKanLift f g

full_name: CategoryTheory.Bicategory.instHasInitialLeftLiftOfHasLeftKanLift
code: instance [HasLeftKanLift f g] : HasInitial <| LeftLift f g 
goal: CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftLift f g)

full_name: CategoryTheory.Bicategory.lanLiftLeftLift
code: /-- The left Kan lift of `g` along `f` at the level of structured arrows. -/
def lanLiftLeftLift (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] : LeftLift f g 
goal: CategoryTheory.Bicategory.LeftLift f g

full_name: CategoryTheory.Bicategory.lanLift
code: /-- The left Kan lift of `g` along `f`. -/
def lanLift (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] : c ⟶ b 
goal: c ⟶ b

full_name: CategoryTheory.Bicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Kan_HasKan___macroRules_CategoryTheory_Bicategory_term_₊__1»
code: /-- `f₊ g` is the left Kan lift of `g` along `f`.
```
            b
          ◹ |
   f₊ g /   |
      /     | f
    /       ▽
  c - - - ▷ a
       g
```
-/
scoped infixr:90 "₊ " => lanLift
goal: Lean.Macro

full_name: CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Kan_HasKan___unexpand_CategoryTheory_Bicategory_lanLift_1
code: /-- `f₊ g` is the left Kan lift of `g` along `f`.
```
            b
          ◹ |
   f₊ g /   |
      /     | f
    /       ▽
  c - - - ▷ a
       g
```
-/
scoped infixr:90 "₊ " => lanLift
goal: Lean.PrettyPrinter.Unexpander

full_name: CategoryTheory.Bicategory.lanLiftLeftLift_lift
code: @[simp]
theorem lanLiftLeftLift_lift (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] :
    (lanLiftLeftLift f g).lift = f₊ g 
goal: (CategoryTheory.Bicategory.lanLiftLeftLift f g).lift = CategoryTheory.Bicategory.lanLift f g

full_name: CategoryTheory.Bicategory.lanLiftUnit
code: /-- The unit for the left Kan lift `f₊ g`. -/
def lanLiftUnit (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] : g ⟶ f₊ g ≫ f 
goal: g ⟶ CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.lanLift f g) f

full_name: CategoryTheory.Bicategory.lanLiftLeftLift_unit
code: @[simp]
theorem lanLiftLeftLift_unit (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] :
    (lanLiftLeftLift f g).unit = lanLiftUnit f g 
goal: (CategoryTheory.Bicategory.lanLiftLeftLift f g).unit = CategoryTheory.Bicategory.lanLiftUnit f g

full_name: CategoryTheory.Bicategory.lanLiftIsKan
code: /-- Evidence that the `LanLift.lift f g` is a Kan lift. -/
def lanLiftIsKan (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] : (lanLiftLeftLift f g).IsKan 
goal: (CategoryTheory.Bicategory.lanLiftLeftLift f g).IsKan

full_name: CategoryTheory.Bicategory.lanLiftDesc
code: /-- The family of 2-morphisms out of the left Kan lift `f₊ g`. -/
def lanLiftDesc [HasLeftKanLift f g] (s : LeftLift f g) :
    f ₊ g ⟶ s.lift 
goal: CategoryTheory.Bicategory.lanLift f g ⟶ s.lift

full_name: CategoryTheory.Bicategory.lanLiftUnit_desc
code: @[reassoc (attr := simp)]
theorem lanLiftUnit_desc [HasLeftKanLift f g] (s : LeftLift f g) :
    lanLiftUnit f g ≫ lanLiftDesc s ▷ f = s.unit 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.lanLiftUnit f g)
    (CategoryTheory.Bicategory.whiskerRight (CategoryTheory.Bicategory.lanLiftDesc s) f) =
  s.unit

full_name: CategoryTheory.Bicategory.lanLiftIsKan_desc
code: @[simp]
theorem lanLiftIsKan_desc [HasLeftKanLift f g] (s : LeftLift f g) :
    (lanLiftIsKan f g).desc s = lanLiftDesc s 
goal: (CategoryTheory.Bicategory.lanLiftIsKan f g).desc s = CategoryTheory.Bicategory.lanLiftDesc s

full_name: CategoryTheory.Bicategory.LanLift.existsUnique
code: theorem LanLift.existsUnique [HasLeftKanLift f g] (s : LeftLift f g) :
    ∃! τ, lanLiftUnit f g ≫ τ ▷ f = s.unit 
goal: ∃! τ,
  CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.lanLiftUnit f g)
      (CategoryTheory.Bicategory.whiskerRight τ f) =
    s.unit

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.commute
code: /-- We say that a 1-morphism `h` commutes with the left Kan lift `f₊ g` if the whiskered left lift
for `f₊ g` by `h` is a Kan lift of `h ≫ g` along `f`. -/
class LanLift.CommuteWith
    (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] {x : B} (h : x ⟶ c) : Prop where
  commute : Nonempty <| IsKan <| (lanLiftLeftLift f g).whisker h
goal: Nonempty ((CategoryTheory.Bicategory.lanLiftLeftLift f g).whisker h).IsKan

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith
code: /-- We say that a 1-morphism `h` commutes with the left Kan lift `f₊ g` if the whiskered left lift
for `f₊ g` by `h` is a Kan lift of `h ≫ g` along `f`. -/
class LanLift.CommuteWith
    (f : b ⟶ a) (g : c ⟶ a) [HasLeftKanLift f g] {x : B} (h : x ⟶ c) : Prop where
  commute : Nonempty <| IsKan <| (lanLiftLeftLift f g).whisker h
goal: Prop

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.of_isKan_whisker
code: theorem of_isKan_whisker [HasLeftKanLift f g] (t : LeftLift f g) {x : B} (h : x ⟶ c)
    (H : IsKan (t.whisker h)) (i : t.whisker h ≅ (lanLiftLeftLift f g).whisker h) :
    LanLift.CommuteWith f g h 
goal: CategoryTheory.Bicategory.LanLift.CommuteWith f g h

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.of_lanLift_comp_iso
code: theorem of_lanLift_comp_iso [HasLeftKanLift f g]
    {x : B} {h : x ⟶ c} [HasLeftKanLift f (h ≫ g)]
    (i : f₊ (h ≫ g) ≅ h ≫ f₊ g)
    (w : lanLiftUnit f (h ≫ g) ≫ i.hom ▷ f = h ◁ lanLiftUnit f g ≫ (α_ _ _ _).inv) :
    LanLift.CommuteWith f g h 
goal: CategoryTheory.Bicategory.LanLift.CommuteWith f g h

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.isKan
code: /-- Evidence that `h` commutes with the left Kan lift `f₊ g`. -/
def isKan : IsKan <| (lanLiftLeftLift f g).whisker h 
goal: ((CategoryTheory.Bicategory.lanLiftLeftLift f g).whisker h).IsKan

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.instHasLeftKanLiftComp
code: instance : HasLeftKanLift f (h ≫ g) 
goal: CategoryTheory.Bicategory.HasLeftKanLift f (CategoryTheory.CategoryStruct.comp h g)

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.isKanWhisker
code: /-- If `h` commutes with `f₊ g` and `t` is another left Kan lift of `g` along `f`, then
`t.whisker h` is a left Kan lift of `h ≫ g` along `f`. -/
def isKanWhisker
    (t : LeftLift f g) (H : IsKan t) {x : B} (h : x ⟶ c) [LanLift.CommuteWith f g h] :
    IsKan (t.whisker h) 
goal: (t.whisker h).IsKan

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIsoWhisker
code: /-- The isomorphism `f₊ (h ≫ g) ≅ h ≫ f₊ g` at the level of structured arrows. -/
def lanLiftCompIsoWhisker :
    lanLiftLeftLift f (h ≫ g) ≅ (lanLiftLeftLift f g).whisker h 
goal: CategoryTheory.Bicategory.lanLiftLeftLift f (CategoryTheory.CategoryStruct.comp h g) ≅
  (CategoryTheory.Bicategory.lanLiftLeftLift f g).whisker h

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIsoWhisker_hom_right
code: @[simp]
theorem lanLiftCompIsoWhisker_hom_right :
    (lanLiftCompIsoWhisker f g h).hom.right = lanLiftDesc ((lanLiftLeftLift f g).whisker h) 
goal: (CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIsoWhisker f g h).hom.right =
  CategoryTheory.Bicategory.lanLiftDesc ((CategoryTheory.Bicategory.lanLiftLeftLift f g).whisker h)

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIsoWhisker_inv_right
code: @[simp]
theorem lanLiftCompIsoWhisker_inv_right :
    (lanLiftCompIsoWhisker f g h).inv.right = (isKan f g h).desc (lanLiftLeftLift f (h ≫ g)) 
goal: (CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIsoWhisker f g h).inv.right =
  (CategoryTheory.Bicategory.LanLift.CommuteWith.isKan f g h).desc
    (CategoryTheory.Bicategory.lanLiftLeftLift f (CategoryTheory.CategoryStruct.comp h g))

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIso
code: /-- The 1-morphism `h` commutes with the left Kan lift `f₊ g`. -/
@[simps!]
def lanLiftCompIso : f₊ (h ≫ g) ≅ h ≫ f₊ g 
goal: CategoryTheory.Bicategory.lanLift f (CategoryTheory.CategoryStruct.comp h g) ≅
  CategoryTheory.CategoryStruct.comp h (CategoryTheory.Bicategory.lanLift f g)

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIso_hom
code: /-- The 1-morphism `h` commutes with the left Kan lift `f₊ g`. -/
@[simps!]
def lanLiftCompIso : f₊ (h ≫ g) ≅ h ≫ f₊ g 
goal: (CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIso f g h).hom =
  CategoryTheory.Bicategory.lanLiftDesc ((CategoryTheory.Bicategory.lanLiftLeftLift f g).whisker h)

full_name: CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIso_inv
code: /-- The 1-morphism `h` commutes with the left Kan lift `f₊ g`. -/
@[simps!]
def lanLiftCompIso : f₊ (h ≫ g) ≅ h ≫ f₊ g 
goal: (CategoryTheory.Bicategory.LanLift.CommuteWith.lanLiftCompIso f g h).inv =
  (CategoryTheory.Bicategory.LanLift.CommuteWith.isKan f g h).desc
    (CategoryTheory.Bicategory.lanLiftLeftLift f (CategoryTheory.CategoryStruct.comp h g))

full_name: CategoryTheory.Bicategory.HasAbsLeftKanLift
code: /-- We say that there exists an absolute left Kan lift of `g` along `f` if any 1-morphism `h`
commutes with the left Kan lift `f₊ g`. -/
class HasAbsLeftKanLift (f : b ⟶ a) (g : c ⟶ a) extends HasLeftKanLift f g : Prop where
  commute : ∀ {x : B} (h : x ⟶ c), LanLift.CommuteWith f g h
goal: Prop

full_name: CategoryTheory.Bicategory.HasAbsLeftKanLift.commute
code: /-- We say that there exists an absolute left Kan lift of `g` along `f` if any 1-morphism `h`
commutes with the left Kan lift `f₊ g`. -/
class HasAbsLeftKanLift (f : b ⟶ a) (g : c ⟶ a) extends HasLeftKanLift f g : Prop where
  commute : ∀ {x : B} (h : x ⟶ c), LanLift.CommuteWith f g h
goal: CategoryTheory.Bicategory.LanLift.CommuteWith f g h

full_name: CategoryTheory.Bicategory.instCommuteWith_1
code: instance [HasAbsLeftKanLift f g] {x : B} (h : x ⟶ c) : LanLift.CommuteWith f g h 
goal: CategoryTheory.Bicategory.LanLift.CommuteWith f g h

full_name: CategoryTheory.Bicategory.LeftLift.IsAbsKan.hasAbsLeftKanLift
code: theorem LeftLift.IsAbsKan.hasAbsLeftKanLift {t : LeftLift f g} (H : IsAbsKan t) :
    HasAbsLeftKanLift f g 
goal: CategoryTheory.Bicategory.HasAbsLeftKanLift f g