l3lab/ntp-mathlib huggingface dataset:
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.rightUnitor _).inv ≫ whiskerLeft X adj.unit ≫ (Functor.associator _ _ _).inv
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).hom ≫ whiskerLeft X adj.counit ≫ (Functor.rightUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by ext; 

Proof state:
case w.h.w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.63, u_1} C
inst✝¹ : Category.{?u.67, u_2} D
inst✝ : Category.{?u.71, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
x✝¹ : C ⥤ D
x✝ : C
⊢ ((whiskerRight
                (NatTrans.mk fun X =>
                  (Functor.rightUnitor ((𝟭 (C ⥤ D)).obj X)).inv ≫
                    whiskerLeft X adj.unit ≫ (Functor.associator X F G).inv)
                ((whiskeringRight C D E).obj F) ≫
              (Functor.associator ((whiskeringRight C D E).obj F) ((whiskeringRight C E D).obj G)
                    ((whiskeringRight C D E).obj F)).hom ≫
                whiskerLeft ((whiskeringRight C D E).obj F)
                  (NatTrans.mk fun X =>
                    (Functor.associator X G F).hom ≫ whiskerLeft X adj.counit ≫ (Functor.rightUnitor X).hom)).app
          x✝¹).app
      x✝ =
    ((NatTrans.id (𝟭 (C ⥤ D) ⋙ (whiskeringRight C D E).obj F)).app x✝¹).app x✝

Next tactic:
dsimp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.rightUnitor _).inv ≫ whiskerLeft X adj.unit ≫ (Functor.associator _ _ _).inv
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).hom ≫ whiskerLeft X adj.counit ≫ (Functor.rightUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by ext; dsimp; 

Proof state:
case w.h.w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.63, u_1} C
inst✝¹ : Category.{?u.67, u_2} D
inst✝ : Category.{?u.71, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
x✝¹ : C ⥤ D
x✝ : C
⊢ F.map (𝟙 (x✝¹.obj x✝) ≫ adj.unit.app (x✝¹.obj x✝) ≫ 𝟙 (G.obj (F.obj (x✝¹.obj x✝)))) ≫
      𝟙 (F.obj (G.obj (F.obj (x✝¹.obj x✝)))) ≫
        𝟙 (F.obj (G.obj (F.obj (x✝¹.obj x✝)))) ≫ adj.counit.app (F.obj (x✝¹.obj x✝)) ≫ 𝟙 (F.obj (x✝¹.obj x✝)) =
    𝟙 (F.obj (x✝¹.obj x✝))

Next tactic:
simp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.rightUnitor _).inv ≫ whiskerLeft X adj.unit ≫ (Functor.associator _ _ _).inv
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).hom ≫ whiskerLeft X adj.counit ≫ (Functor.rightUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by ext; dsimp; simp
      right_triangle := by 

Proof state:
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.63, u_1} C
inst✝¹ : Category.{?u.67, u_2} D
inst✝ : Category.{?u.71, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
⊢ whiskerLeft ((whiskeringRight C E D).obj G)
        (NatTrans.mk fun X =>
          (Functor.rightUnitor ((𝟭 (C ⥤ D)).obj X)).inv ≫ whiskerLeft X adj.unit ≫ (Functor.associator X F G).inv) ≫
      (Functor.associator ((whiskeringRight C E D).obj G) ((whiskeringRight C D E).obj F)
            ((whiskeringRight C E D).obj G)).inv ≫
        whiskerRight
          (NatTrans.mk fun X => (Functor.associator X G F).hom ≫ whiskerLeft X adj.counit ≫ (Functor.rightUnitor X).hom)
          ((whiskeringRight C E D).obj G) =
    NatTrans.id ((whiskeringRight C E D).obj G ⋙ 𝟭 (C ⥤ D))

Next tactic:
ext
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.rightUnitor _).inv ≫ whiskerLeft X adj.unit ≫ (Functor.associator _ _ _).inv
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).hom ≫ whiskerLeft X adj.counit ≫ (Functor.rightUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by ext; dsimp; simp
      right_triangle := by ext; 

Proof state:
case w.h.w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.63, u_1} C
inst✝¹ : Category.{?u.67, u_2} D
inst✝ : Category.{?u.71, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
x✝¹ : C ⥤ E
x✝ : C
⊢ ((whiskerLeft ((whiskeringRight C E D).obj G)
                (NatTrans.mk fun X =>
                  (Functor.rightUnitor ((𝟭 (C ⥤ D)).obj X)).inv ≫
                    whiskerLeft X adj.unit ≫ (Functor.associator X F G).inv) ≫
              (Functor.associator ((whiskeringRight C E D).obj G) ((whiskeringRight C D E).obj F)
                    ((whiskeringRight C E D).obj G)).inv ≫
                whiskerRight
                  (NatTrans.mk fun X =>
                    (Functor.associator X G F).hom ≫ whiskerLeft X adj.counit ≫ (Functor.rightUnitor X).hom)
                  ((whiskeringRight C E D).obj G)).app
          x✝¹).app
      x✝ =
    ((NatTrans.id ((whiskeringRight C E D).obj G ⋙ 𝟭 (C ⥤ D))).app x✝¹).app x✝

Next tactic:
dsimp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerRight (adj : F ⊣ G) :
    (whiskeringRight C D E).obj F ⊣ (whiskeringRight C E D).obj G :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.rightUnitor _).inv ≫ whiskerLeft X adj.unit ≫ (Functor.associator _ _ _).inv
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).hom ≫ whiskerLeft X adj.counit ≫ (Functor.rightUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by ext; dsimp; simp
      right_triangle := by ext; dsimp; 

Proof state:
case w.h.w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.63, u_1} C
inst✝¹ : Category.{?u.67, u_2} D
inst✝ : Category.{?u.71, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
x✝¹ : C ⥤ E
x✝ : C
⊢ (𝟙 (G.obj (x✝¹.obj x✝)) ≫ adj.unit.app (G.obj (x✝¹.obj x✝)) ≫ 𝟙 (G.obj (F.obj (G.obj (x✝¹.obj x✝))))) ≫
      𝟙 (G.obj (F.obj (G.obj (x✝¹.obj x✝)))) ≫
        G.map (𝟙 (F.obj (G.obj (x✝¹.obj x✝))) ≫ adj.counit.app (x✝¹.obj x✝) ≫ 𝟙 (x✝¹.obj x✝)) =
    𝟙 (G.obj (x✝¹.obj x✝))

Next tactic:
simp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by 

Proof state:
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
⊢ ∀ ⦃X Y : D ⥤ C⦄ (f : X ⟶ Y),
    (𝟭 (D ⥤ C)).map f ≫
        (fun X =>
            (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator F G X).hom)
          Y =
      (fun X => (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator F G X).hom)
          X ≫
        ((whiskeringLeft E D C).obj G ⋙ (whiskeringLeft D E C).obj F).map f

Next tactic:
intros
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; 

Proof state:
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
X✝ Y✝ : D ⥤ C
f✝ : X✝ ⟶ Y✝
⊢ (𝟭 (D ⥤ C)).map f✝ ≫
      (fun X => (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator F G X).hom)
        Y✝ =
    (fun X => (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator F G X).hom)
        X✝ ≫
      ((whiskeringLeft E D C).obj G ⋙ (whiskeringLeft D E C).obj F).map f✝

Next tactic:
ext
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; 

Proof state:
case w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
X✝ Y✝ : D ⥤ C
f✝ : X✝ ⟶ Y✝
x✝ : D
⊢ ((𝟭 (D ⥤ C)).map f✝ ≫
          (fun X =>
              (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator F G X).hom)
            Y✝).app
      x✝ =
    ((fun X => (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator F G X).hom)
            X✝ ≫
          ((whiskeringLeft E D C).obj G ⋙ (whiskeringLeft D E C).obj F).map f✝).app
      x✝

Next tactic:
dsimp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; 

Proof state:
case w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
X✝ Y✝ : D ⥤ C
f✝ : X✝ ⟶ Y✝
x✝ : D
⊢ f✝.app x✝ ≫ 𝟙 (Y✝.obj x✝) ≫ Y✝.map (adj.unit.app x✝) ≫ 𝟙 (Y✝.obj (G.obj (F.obj x✝))) =
    (𝟙 (X✝.obj x✝) ≫ X✝.map (adj.unit.app x✝) ≫ 𝟙 (X✝.obj (G.obj (F.obj x✝)))) ≫ f✝.app (G.obj (F.obj x✝))

Next tactic:
simp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor _).hom
          naturality := by 

Proof state:
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
⊢ ∀ ⦃X Y : E ⥤ C⦄ (f : X ⟶ Y),
    ((whiskeringLeft D E C).obj F ⋙ (whiskeringLeft E D C).obj G).map f ≫
        (fun X => (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom) Y =
      (fun X => (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom) X ≫
        (𝟭 (E ⥤ C)).map f

Next tactic:
intros
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor _).hom
          naturality := by intros; 

Proof state:
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
X✝ Y✝ : E ⥤ C
f✝ : X✝ ⟶ Y✝
⊢ ((whiskeringLeft D E C).obj F ⋙ (whiskeringLeft E D C).obj G).map f✝ ≫
      (fun X => (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom) Y✝ =
    (fun X => (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom) X✝ ≫
      (𝟭 (E ⥤ C)).map f✝

Next tactic:
ext
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor _).hom
          naturality := by intros; ext; 

Proof state:
case w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
X✝ Y✝ : E ⥤ C
f✝ : X✝ ⟶ Y✝
x✝ : E
⊢ (((whiskeringLeft D E C).obj F ⋙ (whiskeringLeft E D C).obj G).map f✝ ≫
          (fun X => (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom) Y✝).app
      x✝ =
    ((fun X => (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom) X✝ ≫
          (𝟭 (E ⥤ C)).map f✝).app
      x✝

Next tactic:
dsimp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor _).hom
          naturality := by intros; ext; dsimp; 

Proof state:
case w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
X✝ Y✝ : E ⥤ C
f✝ : X✝ ⟶ Y✝
x✝ : E
⊢ f✝.app (F.obj (G.obj x✝)) ≫ 𝟙 (Y✝.obj (F.obj (G.obj x✝))) ≫ Y✝.map (adj.counit.app x✝) ≫ 𝟙 (Y✝.obj x✝) =
    (𝟙 (X✝.obj (F.obj (G.obj x✝))) ≫ X✝.map (adj.counit.app x✝) ≫ 𝟙 (X✝.obj x✝)) ≫ f✝.app x✝

Next tactic:
simp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by 

Proof state:
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
⊢ whiskerRight
        (NatTrans.mk fun X =>
          (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator F G X).hom)
        ((whiskeringLeft E D C).obj G) ≫
      (Functor.associator ((whiskeringLeft E D C).obj G) ((whiskeringLeft D E C).obj F)
            ((whiskeringLeft E D C).obj G)).hom ≫
        whiskerLeft ((whiskeringLeft E D C).obj G)
          (NatTrans.mk fun X =>
            (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom) =
    NatTrans.id (𝟭 (D ⥤ C) ⋙ (whiskeringLeft E D C).obj G)

Next tactic:
ext x
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by ext x; 

Proof state:
case w.h.w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
x : D ⥤ C
x✝ : E
⊢ ((whiskerRight
                (NatTrans.mk fun X =>
                  (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫
                    whiskerRight adj.unit X ≫ (Functor.associator F G X).hom)
                ((whiskeringLeft E D C).obj G) ≫
              (Functor.associator ((whiskeringLeft E D C).obj G) ((whiskeringLeft D E C).obj F)
                    ((whiskeringLeft E D C).obj G)).hom ≫
                whiskerLeft ((whiskeringLeft E D C).obj G)
                  (NatTrans.mk fun X =>
                    (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom)).app
          x).app
      x✝ =
    ((NatTrans.id (𝟭 (D ⥤ C) ⋙ (whiskeringLeft E D C).obj G)).app x).app x✝

Next tactic:
dsimp
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by ext x; dsimp; 

Proof state:
case w.h.w.h
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
x : D ⥤ C
x✝ : E
⊢ (𝟙 (x.obj (G.obj x✝)) ≫ x.map (adj.unit.app (G.obj x✝)) ≫ 𝟙 (x.obj (G.obj (F.obj (G.obj x✝))))) ≫
      𝟙 (x.obj (G.obj (F.obj (G.obj x✝)))) ≫
        𝟙 (x.obj (G.obj (F.obj (G.obj x✝)))) ≫ x.map (G.map (adj.counit.app x✝)) ≫ 𝟙 (x.obj (G.obj x✝)) =
    𝟙 (x.obj (G.obj x✝))

Next tactic:
simp [Category.id_comp, Category.comp_id, ← x.map_comp]
/-- Given an adjunction `F ⊣ G`, this provides the natural adjunction
  `(whiskeringLeft _ _ C).obj G ⊣ (whiskeringLeft _ _ C).obj F`. -/
@[simps! unit_app_app counit_app_app]
protected def whiskerLeft (adj : F ⊣ G) :
    (whiskeringLeft E D C).obj G ⊣ (whiskeringLeft D E C).obj F :=
  mkOfUnitCounit
    { unit :=
        { app := fun X =>
            (Functor.leftUnitor _).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator _ _ _).hom
          naturality := by intros; ext; dsimp; simp }
      counit :=
        { app := fun X =>
            (Functor.associator _ _ _).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor _).hom
          naturality := by intros; ext; dsimp; simp }
      left_triangle  := by ext x; dsimp; simp [Category.id_comp, Category.comp_id, ← x.map_comp]
      right_triangle := by 

Proof state:
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{?u.21084, u_1} C
inst✝¹ : Category.{?u.21088, u_2} D
inst✝ : Category.{?u.21092, u_3} E
F : D ⥤ E
G : E ⥤ D
adj : F ⊣ G
⊢ whiskerLeft ((whiskeringLeft D E C).obj F)
        (NatTrans.mk fun X =>
          (Functor.leftUnitor ((𝟭 (D ⥤ C)).obj X)).inv ≫ whiskerRight adj.unit X ≫ (Functor.associator F G X).hom) ≫
      (Functor.associator ((whiskeringLeft D E C).obj F) ((whiskeringLeft E D C).obj G)
            ((whiskeringLeft D E C).obj F)).inv ≫
        whiskerRight
          (NatTrans.mk fun X => (Functor.associator G F X).inv ≫ whiskerRight adj.counit X ≫ (Functor.leftUnitor X).hom)
          ((whiskeringLeft D E C).obj F) =
    NatTrans.id ((whiskeringLeft D E C).obj F ⋙ 𝟭 (D ⥤ C))

Next tactic:
ext x