Theorem: CategoryTheory.WithInitial.pseudofunctor_mapId
File: Mathlib/CategoryTheory/WithTerminal.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ ∀ {a b c : Cat} (f : a ⟶ b) {g h : b ⟶ c} (η : g ⟶ h),
    prelaxfunctor.map₂ (Bicategory.whiskerLeft f η) =
      ((fun {a b c} => mapComp) f g).hom ≫
        Bicategory.whiskerLeft (prelaxfunctor.map f) (prelaxfunctor.map₂ η) ≫ ((fun {a b c} => mapComp) f h).inv
state_after: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ h✝
⊢ prelaxfunctor.map₂ (Bicategory.whiskerLeft f✝ η✝) =
    ((fun {a b c} => mapComp) f✝ g✝).hom ≫
      Bicategory.whiskerLeft (prelaxfunctor.map f✝) (prelaxfunctor.map₂ η✝) ≫ ((fun {a b c} => mapComp) f✝ h✝).inv
tactic: intros
state_before: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ h✝
⊢ prelaxfunctor.map₂ (Bicategory.whiskerLeft f✝ η✝) =
    ((fun {a b c} => mapComp) f✝ g✝).hom ≫
      Bicategory.whiskerLeft (prelaxfunctor.map f✝) (prelaxfunctor.map₂ η✝) ≫ ((fun {a b c} => mapComp) f✝ h✝).inv
state_after: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ h✝
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerLeft f✝ η✝)).app =
    (((fun {a b c} => mapComp) f✝ g✝).hom ≫
        Bicategory.whiskerLeft (prelaxfunctor.map f✝) (prelaxfunctor.map₂ η✝) ≫
          ((fun {a b c} => mapComp) f✝ h✝).inv).app
tactic: apply NatTrans.ext
state_before: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ h✝
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerLeft f✝ η✝)).app =
    (((fun {a b c} => mapComp) f✝ g✝).hom ≫
        Bicategory.whiskerLeft (prelaxfunctor.map f✝) (prelaxfunctor.map₂ η✝) ≫
          ((fun {a b c} => mapComp) f✝ h✝).inv).app
state_after: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ h✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerLeft f✝ η✝)).app X =
    (((fun {a b c} => mapComp) f✝ g✝).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) (prelaxfunctor.map₂ η✝) ≫
            ((fun {a b c} => mapComp) f✝ h✝).inv).app
      X
tactic: funext X
state_before: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ h✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerLeft f✝ η✝)).app X =
    (((fun {a b c} => mapComp) f✝ g✝).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) (prelaxfunctor.map₂ η✝) ≫
            ((fun {a b c} => mapComp) f✝ h✝).inv).app
      X
state_after: case app.h.of
C : Type u
inst✝ : Category.{v, u} C
a✝¹ b✝ c✝ : Cat
f✝ : a✝¹ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ h✝
a✝ : ↑a✝¹
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerLeft f✝ η✝)).app (of a✝) =
    (((fun {a b c} => mapComp) f✝ g✝).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) (prelaxfunctor.map₂ η✝) ≫
            ((fun {a b c} => mapComp) f✝ h✝).inv).app
      (of a✝)

case app.h.star
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : g✝ ⟶ h✝
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerLeft f✝ η✝)).app star =
    (((fun {a b c} => mapComp) f✝ g✝).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) (prelaxfunctor.map₂ η✝) ≫
            ((fun {a b c} => mapComp) f✝ h✝).inv).app
      star
tactic: cases X
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ ∀ {a b c : Cat} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
    prelaxfunctor.map₂ (Bicategory.whiskerRight η h) =
      ((fun {a b c} => mapComp) f h).hom ≫
        Bicategory.whiskerRight (prelaxfunctor.map₂ η) (prelaxfunctor.map h) ≫ ((fun {a b c} => mapComp) g h).inv
state_after: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ g✝ : a✝ ⟶ b✝
η✝ : f✝ ⟶ g✝
h✝ : b✝ ⟶ c✝
⊢ prelaxfunctor.map₂ (Bicategory.whiskerRight η✝ h✝) =
    ((fun {a b c} => mapComp) f✝ h✝).hom ≫
      Bicategory.whiskerRight (prelaxfunctor.map₂ η✝) (prelaxfunctor.map h✝) ≫ ((fun {a b c} => mapComp) g✝ h✝).inv
tactic: intros
state_before: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ g✝ : a✝ ⟶ b✝
η✝ : f✝ ⟶ g✝
h✝ : b✝ ⟶ c✝
⊢ prelaxfunctor.map₂ (Bicategory.whiskerRight η✝ h✝) =
    ((fun {a b c} => mapComp) f✝ h✝).hom ≫
      Bicategory.whiskerRight (prelaxfunctor.map₂ η✝) (prelaxfunctor.map h✝) ≫ ((fun {a b c} => mapComp) g✝ h✝).inv
state_after: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ g✝ : a✝ ⟶ b✝
η✝ : f✝ ⟶ g✝
h✝ : b✝ ⟶ c✝
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerRight η✝ h✝)).app =
    (((fun {a b c} => mapComp) f✝ h✝).hom ≫
        Bicategory.whiskerRight (prelaxfunctor.map₂ η✝) (prelaxfunctor.map h✝) ≫
          ((fun {a b c} => mapComp) g✝ h✝).inv).app
tactic: apply NatTrans.ext
state_before: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ g✝ : a✝ ⟶ b✝
η✝ : f✝ ⟶ g✝
h✝ : b✝ ⟶ c✝
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerRight η✝ h✝)).app =
    (((fun {a b c} => mapComp) f✝ h✝).hom ≫
        Bicategory.whiskerRight (prelaxfunctor.map₂ η✝) (prelaxfunctor.map h✝) ≫
          ((fun {a b c} => mapComp) g✝ h✝).inv).app
state_after: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ g✝ : a✝ ⟶ b✝
η✝ : f✝ ⟶ g✝
h✝ : b✝ ⟶ c✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerRight η✝ h✝)).app X =
    (((fun {a b c} => mapComp) f✝ h✝).hom ≫
          Bicategory.whiskerRight (prelaxfunctor.map₂ η✝) (prelaxfunctor.map h✝) ≫
            ((fun {a b c} => mapComp) g✝ h✝).inv).app
      X
tactic: funext X
state_before: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ g✝ : a✝ ⟶ b✝
η✝ : f✝ ⟶ g✝
h✝ : b✝ ⟶ c✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerRight η✝ h✝)).app X =
    (((fun {a b c} => mapComp) f✝ h✝).hom ≫
          Bicategory.whiskerRight (prelaxfunctor.map₂ η✝) (prelaxfunctor.map h✝) ≫
            ((fun {a b c} => mapComp) g✝ h✝).inv).app
      X
state_after: case app.h.of
C : Type u
inst✝ : Category.{v, u} C
a✝¹ b✝ c✝ : Cat
f✝ g✝ : a✝¹ ⟶ b✝
η✝ : f✝ ⟶ g✝
h✝ : b✝ ⟶ c✝
a✝ : ↑a✝¹
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerRight η✝ h✝)).app (of a✝) =
    (((fun {a b c} => mapComp) f✝ h✝).hom ≫
          Bicategory.whiskerRight (prelaxfunctor.map₂ η✝) (prelaxfunctor.map h✝) ≫
            ((fun {a b c} => mapComp) g✝ h✝).inv).app
      (of a✝)

case app.h.star
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ : Cat
f✝ g✝ : a✝ ⟶ b✝
η✝ : f✝ ⟶ g✝
h✝ : b✝ ⟶ c✝
⊢ (prelaxfunctor.map₂ (Bicategory.whiskerRight η✝ h✝)).app star =
    (((fun {a b c} => mapComp) f✝ h✝).hom ≫
          Bicategory.whiskerRight (prelaxfunctor.map₂ η✝) (prelaxfunctor.map h✝) ≫
            ((fun {a b c} => mapComp) g✝ h✝).inv).app
      star
tactic: cases X
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ ∀ {a b c d : Cat} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
    prelaxfunctor.map₂ (Bicategory.associator f g h).hom =
      ((fun {a b c} => mapComp) (f ≫ g) h).hom ≫
        Bicategory.whiskerRight ((fun {a b c} => mapComp) f g).hom (prelaxfunctor.map h) ≫
          (Bicategory.associator (prelaxfunctor.map f) (prelaxfunctor.map g) (prelaxfunctor.map h)).hom ≫
            Bicategory.whiskerLeft (prelaxfunctor.map f) ((fun {a b c} => mapComp) g h).inv ≫
              ((fun {a b c} => mapComp) f (g ≫ h)).inv
state_after: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ d✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ : b✝ ⟶ c✝
h✝ : c✝ ⟶ d✝
⊢ prelaxfunctor.map₂ (Bicategory.associator f✝ g✝ h✝).hom =
    ((fun {a b c} => mapComp) (f✝ ≫ g✝) h✝).hom ≫
      Bicategory.whiskerRight ((fun {a b c} => mapComp) f✝ g✝).hom (prelaxfunctor.map h✝) ≫
        (Bicategory.associator (prelaxfunctor.map f✝) (prelaxfunctor.map g✝) (prelaxfunctor.map h✝)).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun {a b c} => mapComp) g✝ h✝).inv ≫
            ((fun {a b c} => mapComp) f✝ (g✝ ≫ h✝)).inv
tactic: intros
state_before: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ d✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ : b✝ ⟶ c✝
h✝ : c✝ ⟶ d✝
⊢ prelaxfunctor.map₂ (Bicategory.associator f✝ g✝ h✝).hom =
    ((fun {a b c} => mapComp) (f✝ ≫ g✝) h✝).hom ≫
      Bicategory.whiskerRight ((fun {a b c} => mapComp) f✝ g✝).hom (prelaxfunctor.map h✝) ≫
        (Bicategory.associator (prelaxfunctor.map f✝) (prelaxfunctor.map g✝) (prelaxfunctor.map h✝)).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun {a b c} => mapComp) g✝ h✝).inv ≫
            ((fun {a b c} => mapComp) f✝ (g✝ ≫ h✝)).inv
state_after: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ d✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ : b✝ ⟶ c✝
h✝ : c✝ ⟶ d✝
⊢ (prelaxfunctor.map₂ (Bicategory.associator f✝ g✝ h✝).hom).app =
    (((fun {a b c} => mapComp) (f✝ ≫ g✝) h✝).hom ≫
        Bicategory.whiskerRight ((fun {a b c} => mapComp) f✝ g✝).hom (prelaxfunctor.map h✝) ≫
          (Bicategory.associator (prelaxfunctor.map f✝) (prelaxfunctor.map g✝) (prelaxfunctor.map h✝)).hom ≫
            Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun {a b c} => mapComp) g✝ h✝).inv ≫
              ((fun {a b c} => mapComp) f✝ (g✝ ≫ h✝)).inv).app
tactic: apply NatTrans.ext
state_before: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ d✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ : b✝ ⟶ c✝
h✝ : c✝ ⟶ d✝
⊢ (prelaxfunctor.map₂ (Bicategory.associator f✝ g✝ h✝).hom).app =
    (((fun {a b c} => mapComp) (f✝ ≫ g✝) h✝).hom ≫
        Bicategory.whiskerRight ((fun {a b c} => mapComp) f✝ g✝).hom (prelaxfunctor.map h✝) ≫
          (Bicategory.associator (prelaxfunctor.map f✝) (prelaxfunctor.map g✝) (prelaxfunctor.map h✝)).hom ≫
            Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun {a b c} => mapComp) g✝ h✝).inv ≫
              ((fun {a b c} => mapComp) f✝ (g✝ ≫ h✝)).inv).app
state_after: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ d✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ : b✝ ⟶ c✝
h✝ : c✝ ⟶ d✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.associator f✝ g✝ h✝).hom).app X =
    (((fun {a b c} => mapComp) (f✝ ≫ g✝) h✝).hom ≫
          Bicategory.whiskerRight ((fun {a b c} => mapComp) f✝ g✝).hom (prelaxfunctor.map h✝) ≫
            (Bicategory.associator (prelaxfunctor.map f✝) (prelaxfunctor.map g✝) (prelaxfunctor.map h✝)).hom ≫
              Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun {a b c} => mapComp) g✝ h✝).inv ≫
                ((fun {a b c} => mapComp) f✝ (g✝ ≫ h✝)).inv).app
      X
tactic: funext X
state_before: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ d✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ : b✝ ⟶ c✝
h✝ : c✝ ⟶ d✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.associator f✝ g✝ h✝).hom).app X =
    (((fun {a b c} => mapComp) (f✝ ≫ g✝) h✝).hom ≫
          Bicategory.whiskerRight ((fun {a b c} => mapComp) f✝ g✝).hom (prelaxfunctor.map h✝) ≫
            (Bicategory.associator (prelaxfunctor.map f✝) (prelaxfunctor.map g✝) (prelaxfunctor.map h✝)).hom ≫
              Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun {a b c} => mapComp) g✝ h✝).inv ≫
                ((fun {a b c} => mapComp) f✝ (g✝ ≫ h✝)).inv).app
      X
state_after: case app.h.of
C : Type u
inst✝ : Category.{v, u} C
a✝¹ b✝ c✝ d✝ : Cat
f✝ : a✝¹ ⟶ b✝
g✝ : b✝ ⟶ c✝
h✝ : c✝ ⟶ d✝
a✝ : ↑a✝¹
⊢ (prelaxfunctor.map₂ (Bicategory.associator f✝ g✝ h✝).hom).app (of a✝) =
    (((fun {a b c} => mapComp) (f✝ ≫ g✝) h✝).hom ≫
          Bicategory.whiskerRight ((fun {a b c} => mapComp) f✝ g✝).hom (prelaxfunctor.map h✝) ≫
            (Bicategory.associator (prelaxfunctor.map f✝) (prelaxfunctor.map g✝) (prelaxfunctor.map h✝)).hom ≫
              Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun {a b c} => mapComp) g✝ h✝).inv ≫
                ((fun {a b c} => mapComp) f✝ (g✝ ≫ h✝)).inv).app
      (of a✝)

case app.h.star
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ c✝ d✝ : Cat
f✝ : a✝ ⟶ b✝
g✝ : b✝ ⟶ c✝
h✝ : c✝ ⟶ d✝
⊢ (prelaxfunctor.map₂ (Bicategory.associator f✝ g✝ h✝).hom).app star =
    (((fun {a b c} => mapComp) (f✝ ≫ g✝) h✝).hom ≫
          Bicategory.whiskerRight ((fun {a b c} => mapComp) f✝ g✝).hom (prelaxfunctor.map h✝) ≫
            (Bicategory.associator (prelaxfunctor.map f✝) (prelaxfunctor.map g✝) (prelaxfunctor.map h✝)).hom ≫
              Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun {a b c} => mapComp) g✝ h✝).inv ≫
                ((fun {a b c} => mapComp) f✝ (g✝ ≫ h✝)).inv).app
      star
tactic: cases X
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ ∀ {a b : Cat} (f : a ⟶ b),
    prelaxfunctor.map₂ (Bicategory.leftUnitor f).hom =
      ((fun {a b c} => mapComp) (𝟙 a) f).hom ≫
        Bicategory.whiskerRight ((fun C => mapId ↑C) a).hom (prelaxfunctor.map f) ≫
          (Bicategory.leftUnitor (prelaxfunctor.map f)).hom
state_after: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ prelaxfunctor.map₂ (Bicategory.leftUnitor f✝).hom =
    ((fun {a b c} => mapComp) (𝟙 a✝) f✝).hom ≫
      Bicategory.whiskerRight ((fun C => mapId ↑C) a✝).hom (prelaxfunctor.map f✝) ≫
        (Bicategory.leftUnitor (prelaxfunctor.map f✝)).hom
tactic: intros
state_before: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ prelaxfunctor.map₂ (Bicategory.leftUnitor f✝).hom =
    ((fun {a b c} => mapComp) (𝟙 a✝) f✝).hom ≫
      Bicategory.whiskerRight ((fun C => mapId ↑C) a✝).hom (prelaxfunctor.map f✝) ≫
        (Bicategory.leftUnitor (prelaxfunctor.map f✝)).hom
state_after: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ (prelaxfunctor.map₂ (Bicategory.leftUnitor f✝).hom).app =
    (((fun {a b c} => mapComp) (𝟙 a✝) f✝).hom ≫
        Bicategory.whiskerRight ((fun C => mapId ↑C) a✝).hom (prelaxfunctor.map f✝) ≫
          (Bicategory.leftUnitor (prelaxfunctor.map f✝)).hom).app
tactic: apply NatTrans.ext
state_before: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ (prelaxfunctor.map₂ (Bicategory.leftUnitor f✝).hom).app =
    (((fun {a b c} => mapComp) (𝟙 a✝) f✝).hom ≫
        Bicategory.whiskerRight ((fun C => mapId ↑C) a✝).hom (prelaxfunctor.map f✝) ≫
          (Bicategory.leftUnitor (prelaxfunctor.map f✝)).hom).app
state_after: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.leftUnitor f✝).hom).app X =
    (((fun {a b c} => mapComp) (𝟙 a✝) f✝).hom ≫
          Bicategory.whiskerRight ((fun C => mapId ↑C) a✝).hom (prelaxfunctor.map f✝) ≫
            (Bicategory.leftUnitor (prelaxfunctor.map f✝)).hom).app
      X
tactic: funext X
state_before: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.leftUnitor f✝).hom).app X =
    (((fun {a b c} => mapComp) (𝟙 a✝) f✝).hom ≫
          Bicategory.whiskerRight ((fun C => mapId ↑C) a✝).hom (prelaxfunctor.map f✝) ≫
            (Bicategory.leftUnitor (prelaxfunctor.map f✝)).hom).app
      X
state_after: case app.h.of
C : Type u
inst✝ : Category.{v, u} C
a✝¹ b✝ : Cat
f✝ : a✝¹ ⟶ b✝
a✝ : ↑a✝¹
⊢ (prelaxfunctor.map₂ (Bicategory.leftUnitor f✝).hom).app (of a✝) =
    (((fun {a b c} => mapComp) (𝟙 a✝¹) f✝).hom ≫
          Bicategory.whiskerRight ((fun C => mapId ↑C) a✝¹).hom (prelaxfunctor.map f✝) ≫
            (Bicategory.leftUnitor (prelaxfunctor.map f✝)).hom).app
      (of a✝)

case app.h.star
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ (prelaxfunctor.map₂ (Bicategory.leftUnitor f✝).hom).app star =
    (((fun {a b c} => mapComp) (𝟙 a✝) f✝).hom ≫
          Bicategory.whiskerRight ((fun C => mapId ↑C) a✝).hom (prelaxfunctor.map f✝) ≫
            (Bicategory.leftUnitor (prelaxfunctor.map f✝)).hom).app
      star
tactic: cases X
state_before: C : Type u
inst✝ : Category.{v, u} C
⊢ ∀ {a b : Cat} (f : a ⟶ b),
    prelaxfunctor.map₂ (Bicategory.rightUnitor f).hom =
      ((fun {a b c} => mapComp) f (𝟙 b)).hom ≫
        Bicategory.whiskerLeft (prelaxfunctor.map f) ((fun C => mapId ↑C) b).hom ≫
          (Bicategory.rightUnitor (prelaxfunctor.map f)).hom
state_after: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ prelaxfunctor.map₂ (Bicategory.rightUnitor f✝).hom =
    ((fun {a b c} => mapComp) f✝ (𝟙 b✝)).hom ≫
      Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun C => mapId ↑C) b✝).hom ≫
        (Bicategory.rightUnitor (prelaxfunctor.map f✝)).hom
tactic: intros
state_before: C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ prelaxfunctor.map₂ (Bicategory.rightUnitor f✝).hom =
    ((fun {a b c} => mapComp) f✝ (𝟙 b✝)).hom ≫
      Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun C => mapId ↑C) b✝).hom ≫
        (Bicategory.rightUnitor (prelaxfunctor.map f✝)).hom
state_after: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ (prelaxfunctor.map₂ (Bicategory.rightUnitor f✝).hom).app =
    (((fun {a b c} => mapComp) f✝ (𝟙 b✝)).hom ≫
        Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun C => mapId ↑C) b✝).hom ≫
          (Bicategory.rightUnitor (prelaxfunctor.map f✝)).hom).app
tactic: apply NatTrans.ext
state_before: case app
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ (prelaxfunctor.map₂ (Bicategory.rightUnitor f✝).hom).app =
    (((fun {a b c} => mapComp) f✝ (𝟙 b✝)).hom ≫
        Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun C => mapId ↑C) b✝).hom ≫
          (Bicategory.rightUnitor (prelaxfunctor.map f✝)).hom).app
state_after: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.rightUnitor f✝).hom).app X =
    (((fun {a b c} => mapComp) f✝ (𝟙 b✝)).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun C => mapId ↑C) b✝).hom ≫
            (Bicategory.rightUnitor (prelaxfunctor.map f✝)).hom).app
      X
tactic: funext X
state_before: case app.h
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
X : ↑(prelaxfunctor.obj a✝)
⊢ (prelaxfunctor.map₂ (Bicategory.rightUnitor f✝).hom).app X =
    (((fun {a b c} => mapComp) f✝ (𝟙 b✝)).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun C => mapId ↑C) b✝).hom ≫
            (Bicategory.rightUnitor (prelaxfunctor.map f✝)).hom).app
      X
state_after: case app.h.of
C : Type u
inst✝ : Category.{v, u} C
a✝¹ b✝ : Cat
f✝ : a✝¹ ⟶ b✝
a✝ : ↑a✝¹
⊢ (prelaxfunctor.map₂ (Bicategory.rightUnitor f✝).hom).app (of a✝) =
    (((fun {a b c} => mapComp) f✝ (𝟙 b✝)).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun C => mapId ↑C) b✝).hom ≫
            (Bicategory.rightUnitor (prelaxfunctor.map f✝)).hom).app
      (of a✝)

case app.h.star
C : Type u
inst✝ : Category.{v, u} C
a✝ b✝ : Cat
f✝ : a✝ ⟶ b✝
⊢ (prelaxfunctor.map₂ (Bicategory.rightUnitor f✝).hom).app star =
    (((fun {a b c} => mapComp) f✝ (𝟙 b✝)).hom ≫
          Bicategory.whiskerLeft (prelaxfunctor.map f✝) ((fun C => mapId ↑C) b✝).hom ≫
            (Bicategory.rightUnitor (prelaxfunctor.map f✝)).hom).app
      star
tactic: cases X