l3lab/ntp-mathlib huggingface dataset:
@[reassoc (attr := simp)]
theorem whiskerRight_naturality_comp (f : a ⟶ b) (g : b ⟶ c) (h : G.obj c ⟶ a') :
    η.naturality (f ≫ g) ▷ h ≫ (α_ _ _ _).hom ≫ η.app a ◁ G.mapComp f g ▷ h =
      F.mapComp f g ▷ η.app c ▷ h ≫
        (α_ _ _ _).hom ▷ h ≫
          (α_ _ _ _).hom ≫
            F.map f ◁ η.naturality g ▷ h ≫
              (α_ _ _ _).inv ≫
                (α_ _ _ _).inv ▷ h ≫
                  η.naturality f ▷ G.map g ▷ h ≫ (α_ _ _ _).hom ▷ h ≫ (α_ _ _ _).hom :=
  by 

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : a ⟶ b
g : b ⟶ c
h : (↑G.toPrelaxFunctor).obj c ⟶ a'
⊢ naturality η (f ≫ g) ▷ h ≫
      (α_ (η.app a) ((↑G.toPrelaxFunctor).map (f ≫ g)) h).hom ≫ η.app a ◁ OplaxFunctor.mapComp G f g ▷ h =
    OplaxFunctor.mapComp F f g ▷ η.app c ▷ h ≫
      (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) (η.app c)).hom ▷ h ≫
        (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g ≫ η.app c) h).hom ≫
          (↑F.toPrelaxFunctor).map f ◁ naturality η g ▷ h ≫
            (α_ ((↑F.toPrelaxFunctor).map f) (η.app b ≫ (↑G.toPrelaxFunctor).map g) h).inv ≫
              (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) ((↑G.toPrelaxFunctor).map g)).inv ▷ h ≫
                naturality η f ▷ (↑G.toPrelaxFunctor).map g ▷ h ≫
                  (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) ((↑G.toPrelaxFunctor).map g)).hom ▷ h ≫
                    (α_ (η.app a) ((↑G.toPrelaxFunctor).map f ≫ (↑G.toPrelaxFunctor).map g) h).hom

Next tactic:
rw [← associator_naturality_middle, ← comp_whiskerRight_assoc, naturality_comp]
@[reassoc (attr := simp)]
theorem whiskerRight_naturality_comp (f : a ⟶ b) (g : b ⟶ c) (h : G.obj c ⟶ a') :
    η.naturality (f ≫ g) ▷ h ≫ (α_ _ _ _).hom ≫ η.app a ◁ G.mapComp f g ▷ h =
      F.mapComp f g ▷ η.app c ▷ h ≫
        (α_ _ _ _).hom ▷ h ≫
          (α_ _ _ _).hom ≫
            F.map f ◁ η.naturality g ▷ h ≫
              (α_ _ _ _).inv ≫
                (α_ _ _ _).inv ▷ h ≫
                  η.naturality f ▷ G.map g ▷ h ≫ (α_ _ _ _).hom ▷ h ≫ (α_ _ _ _).hom :=
  by rw [← associator_naturality_middle, ← comp_whiskerRight_assoc, naturality_comp]; 

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : a ⟶ b
g : b ⟶ c
h : (↑G.toPrelaxFunctor).obj c ⟶ a'
⊢ (OplaxFunctor.mapComp F f g ▷ η.app c ≫
          (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) (η.app c)).hom ≫
            (↑F.toPrelaxFunctor).map f ◁ naturality η g ≫
              (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) ((↑G.toPrelaxFunctor).map g)).inv ≫
                naturality η f ▷ (↑G.toPrelaxFunctor).map g ≫
                  (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) ((↑G.toPrelaxFunctor).map g)).hom) ▷
        h ≫
      (α_ (η.app a) ((↑G.toPrelaxFunctor).map f ≫ (↑G.toPrelaxFunctor).map g) h).hom =
    OplaxFunctor.mapComp F f g ▷ η.app c ▷ h ≫
      (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) (η.app c)).hom ▷ h ≫
        (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g ≫ η.app c) h).hom ≫
          (↑F.toPrelaxFunctor).map f ◁ naturality η g ▷ h ≫
            (α_ ((↑F.toPrelaxFunctor).map f) (η.app b ≫ (↑G.toPrelaxFunctor).map g) h).inv ≫
              (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) ((↑G.toPrelaxFunctor).map g)).inv ▷ h ≫
                naturality η f ▷ (↑G.toPrelaxFunctor).map g ▷ h ≫
                  (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) ((↑G.toPrelaxFunctor).map g)).hom ▷ h ≫
                    (α_ (η.app a) ((↑G.toPrelaxFunctor).map f ≫ (↑G.toPrelaxFunctor).map g) h).hom

Next tactic:
simp
@[reassoc (attr := simp)]
theorem whiskerLeft_naturality_id (f : a' ⟶ G.obj a) :
    f ◁ θ.naturality (𝟙 a) ≫ f ◁ θ.app a ◁ H.mapId a =
      f ◁ G.mapId a ▷ θ.app a ≫ f ◁ (λ_ (θ.app a)).hom ≫ f ◁ (ρ_ (θ.app a)).inv :=
  by 

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : a' ⟶ (↑G.toPrelaxFunctor).obj a
⊢ f ◁ naturality θ (𝟙 a) ≫ f ◁ θ.app a ◁ OplaxFunctor.mapId H a =
    f ◁ OplaxFunctor.mapId G a ▷ θ.app a ≫ f ◁ (λ_ (θ.app a)).hom ≫ f ◁ (ρ_ (θ.app a)).inv

Next tactic:
simp_rw [← whiskerLeft_comp, naturality_id]
@[reassoc (attr := simp)]
theorem whiskerRight_naturality_id (f : G.obj a ⟶ a') :
    η.naturality (𝟙 a) ▷ f ≫ (α_ _ _ _).hom ≫ η.app a ◁ G.mapId a ▷ f =
      F.mapId a ▷ η.app a ▷ f ≫ (λ_ (η.app a)).hom ▷ f ≫ (ρ_ (η.app a)).inv ▷ f ≫ (α_ _ _ _).hom :=
  by 

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : (↑G.toPrelaxFunctor).obj a ⟶ a'
⊢ naturality η (𝟙 a) ▷ f ≫
      (α_ (η.app a) ((↑G.toPrelaxFunctor).map (𝟙 a)) f).hom ≫ η.app a ◁ OplaxFunctor.mapId G a ▷ f =
    OplaxFunctor.mapId F a ▷ η.app a ▷ f ≫
      (λ_ (η.app a)).hom ▷ f ≫ (ρ_ (η.app a)).inv ▷ f ≫ (α_ (η.app a) (𝟙 ((↑G.toPrelaxFunctor).obj a)) f).hom

Next tactic:
rw [← associator_naturality_middle, ← comp_whiskerRight_assoc, naturality_id]
@[reassoc (attr := simp)]
theorem whiskerRight_naturality_id (f : G.obj a ⟶ a') :
    η.naturality (𝟙 a) ▷ f ≫ (α_ _ _ _).hom ≫ η.app a ◁ G.mapId a ▷ f =
      F.mapId a ▷ η.app a ▷ f ≫ (λ_ (η.app a)).hom ▷ f ≫ (ρ_ (η.app a)).inv ▷ f ≫ (α_ _ _ _).hom :=
  by rw [← associator_naturality_middle, ← comp_whiskerRight_assoc, naturality_id]; 

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
a' : C
f : (↑G.toPrelaxFunctor).obj a ⟶ a'
⊢ (OplaxFunctor.mapId F a ▷ η.app a ≫ (λ_ (η.app a)).hom ≫ (ρ_ (η.app a)).inv) ▷ f ≫
      (α_ (η.app a) (𝟙 ((↑G.toPrelaxFunctor).obj a)) f).hom =
    OplaxFunctor.mapId F a ▷ η.app a ▷ f ≫
      (λ_ (η.app a)).hom ▷ f ≫ (ρ_ (η.app a)).inv ▷ f ≫ (α_ (η.app a) (𝟙 ((↑G.toPrelaxFunctor).obj a)) f).hom

Next tactic:
simp
/-- Vertical composition of oplax natural transformations. -/
@[simps]
def vcomp (η : OplaxNatTrans F G) (θ : OplaxNatTrans G H) : OplaxNatTrans F H where
  app a := η.app a ≫ θ.app a
  naturality {a b} f :=
    (α_ _ _ _).inv ≫
      η.naturality f ▷ θ.app b ≫ (α_ _ _ _).hom ≫ η.app a ◁ θ.naturality f ≫ (α_ _ _ _).inv
  naturality_comp {a b c} f g := by
    calc
      _ =
          ?_ ≫
            F.mapComp f g ▷ η.app c ▷ θ.app c ≫
              ?_ ≫
                F.map f ◁ η.naturality g ▷ θ.app c ≫
                  ?_ ≫
                    (F.map f ≫ η.app b) ◁ θ.naturality g ≫
                      η.naturality f ▷ (θ.app b ≫ H.map g) ≫
                        ?_ ≫ η.app a ◁ θ.naturality f ▷ H.map g ≫ ?_ :=
        ?_
      _ = _ := ?_
    exact (α_ _ _ _).inv
    exact (α_ _ _ _).hom ▷ _ ≫ (α_ _ _ _).hom
    exact _ ◁ (α_ _ _ _).hom ≫ (α_ _ _ _).inv
    exact (α_ _ _ _).hom ≫ _ ◁ (α_ _ _ _).inv
    exact _ ◁ (α_ _ _ _).hom ≫ (α_ _ _ _).inv
    · rw [whisker_exchange_assoc]
      -- Porting note: this used to be just `simp`
      simp only [comp_whiskerLeft, assoc, Iso.inv_hom_id_assoc, whiskerLeft_naturality_comp_assoc,
        whiskerRight_naturality_comp_assoc, pentagon_assoc, whiskerRight_comp,
        pentagon_hom_inv_inv_inv_inv_assoc]
    · simp
  naturality_id _ := by
    -- Porting note: this used to be automatic via `tidy`, which did `intros, simp`
    simp only [comp_whiskerLeft, assoc, Iso.inv_hom_id_assoc, whiskerLeft_naturality_id_assoc,
      whiskerLeft_rightUnitor_inv, Iso.hom_inv_id, comp_id, whiskerRight_naturality_id_assoc,
      leftUnitor_whiskerRight, triangle_assoc, inv_hom_whiskerRight_assoc, whiskerRight_comp]
  naturality_naturality {_ _ _ _} _ := by
    -- Porting note: this used to be automatic via `tidy`, which did `intros, simp`
    

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η✝ : OplaxNatTrans F G
θ✝ : OplaxNatTrans G H
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
x✝⁴ x✝³ : B
x✝² x✝¹ : x✝⁴ ⟶ x✝³
x✝ : x✝² ⟶ x✝¹
⊢ PrelaxFunctor.map₂ F.toPrelaxFunctor x✝ ▷ (fun a => η.app a ≫ θ.app a) x✝³ ≫
      (fun {a b} f =>
          (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) (θ.app b)).inv ≫
            naturality η f ▷ θ.app b ≫
              (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b)).hom ≫
                η.app a ◁ naturality θ f ≫ (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f)).inv)
        x✝¹ =
    (fun {a b} f =>
          (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) (θ.app b)).inv ≫
            naturality η f ▷ θ.app b ≫
              (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b)).hom ≫
                η.app a ◁ naturality θ f ≫ (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f)).inv)
        x✝² ≫
      (fun a => η.app a ≫ θ.app a) x✝⁴ ◁ PrelaxFunctor.map₂ H.toPrelaxFunctor x✝

Next tactic:
simp only [whiskerRight_comp, assoc, Iso.hom_inv_id_assoc,
      whiskerRight_naturality_naturality_assoc, Iso.inv_hom_id_assoc,
      whiskerLeft_naturality_naturality_assoc, comp_whiskerLeft]
/-- Vertical composition of oplax natural transformations. -/
@[simps]
def vcomp (η : OplaxNatTrans F G) (θ : OplaxNatTrans G H) : OplaxNatTrans F H where
  app a := η.app a ≫ θ.app a
  naturality {a b} f :=
    (α_ _ _ _).inv ≫
      η.naturality f ▷ θ.app b ≫ (α_ _ _ _).hom ≫ η.app a ◁ θ.naturality f ≫ (α_ _ _ _).inv
  naturality_comp {a b c} f g := by
    calc
      _ =
          ?_ ≫
            F.mapComp f g ▷ η.app c ▷ θ.app c ≫
              ?_ ≫
                F.map f ◁ η.naturality g ▷ θ.app c ≫
                  ?_ ≫
                    (F.map f ≫ η.app b) ◁ θ.naturality g ≫
                      η.naturality f ▷ (θ.app b ≫ H.map g) ≫
                        ?_ ≫ η.app a ◁ θ.naturality f ▷ H.map g ≫ ?_ :=
        ?_
      _ = _ := ?_
    exact (α_ _ _ _).inv
    exact (α_ _ _ _).hom ▷ _ ≫ (α_ _ _ _).hom
    exact _ ◁ (α_ _ _ _).hom ≫ (α_ _ _ _).inv
    exact (α_ _ _ _).hom ≫ _ ◁ (α_ _ _ _).inv
    exact _ ◁ (α_ _ _ _).hom ≫ (α_ _ _ _).inv
    · rw [whisker_exchange_assoc]
      -- Porting note: this used to be just `simp`
      simp only [comp_whiskerLeft, assoc, Iso.inv_hom_id_assoc, whiskerLeft_naturality_comp_assoc,
        whiskerRight_naturality_comp_assoc, pentagon_assoc, whiskerRight_comp,
        pentagon_hom_inv_inv_inv_inv_assoc]
    · simp
  naturality_id _ := by
    -- Porting note: this used to be automatic via `tidy`, which did `intros, simp`
    

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η✝ : OplaxNatTrans F G
θ✝ : OplaxNatTrans G H
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
x✝ : B
⊢ (fun {a b} f =>
          (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) (θ.app b)).inv ≫
            naturality η f ▷ θ.app b ≫
              (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b)).hom ≫
                η.app a ◁ naturality θ f ≫ (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f)).inv)
        (𝟙 x✝) ≫
      (fun a => η.app a ≫ θ.app a) x✝ ◁ OplaxFunctor.mapId H x✝ =
    OplaxFunctor.mapId F x✝ ▷ (fun a => η.app a ≫ θ.app a) x✝ ≫
      (λ_ ((fun a => η.app a ≫ θ.app a) x✝)).hom ≫ (ρ_ ((fun a => η.app a ≫ θ.app a) x✝)).inv

Next tactic:
simp only [comp_whiskerLeft, assoc, Iso.inv_hom_id_assoc, whiskerLeft_naturality_id_assoc,
      whiskerLeft_rightUnitor_inv, Iso.hom_inv_id, comp_id, whiskerRight_naturality_id_assoc,
      leftUnitor_whiskerRight, triangle_assoc, inv_hom_whiskerRight_assoc, whiskerRight_comp]
/-- Vertical composition of oplax natural transformations. -/
@[simps]
def vcomp (η : OplaxNatTrans F G) (θ : OplaxNatTrans G H) : OplaxNatTrans F H where
  app a := η.app a ≫ θ.app a
  naturality {a b} f :=
    (α_ _ _ _).inv ≫
      η.naturality f ▷ θ.app b ≫ (α_ _ _ _).hom ≫ η.app a ◁ θ.naturality f ≫ (α_ _ _ _).inv
  naturality_comp {a b c} f g := by
    

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η✝ : OplaxNatTrans F G
θ✝ : OplaxNatTrans G H
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
f : a ⟶ b
g : b ⟶ c
⊢ (fun {a b} f =>
          (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) (θ.app b)).inv ≫
            naturality η f ▷ θ.app b ≫
              (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b)).hom ≫
                η.app a ◁ naturality θ f ≫ (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f)).inv)
        (f ≫ g) ≫
      (fun a => η.app a ≫ θ.app a) a ◁ OplaxFunctor.mapComp H f g =
    OplaxFunctor.mapComp F f g ▷ (fun a => η.app a ≫ θ.app a) c ≫
      (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) ((fun a => η.app a ≫ θ.app a) c)).hom ≫
        (↑F.toPrelaxFunctor).map f ◁
            (fun {a b} f =>
                (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) (θ.app b)).inv ≫
                  naturality η f ▷ θ.app b ≫
                    (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b)).hom ≫
                      η.app a ◁ naturality θ f ≫ (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f)).inv)
              g ≫
          (α_ ((↑F.toPrelaxFunctor).map f) ((fun a => η.app a ≫ θ.app a) b) ((↑H.toPrelaxFunctor).map g)).inv ≫
            (fun {a b} f =>
                    (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) (θ.app b)).inv ≫
                      naturality η f ▷ θ.app b ≫
                        (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b)).hom ≫
                          η.app a ◁ naturality θ f ≫ (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f)).inv)
                  f ▷
                (↑H.toPrelaxFunctor).map g ≫
              (α_ ((fun a => η.app a ≫ θ.app a) a) ((↑H.toPrelaxFunctor).map f) ((↑H.toPrelaxFunctor).map g)).hom

Next tactic:
calc
      _ =
          ?_ ≫
            F.mapComp f g ▷ η.app c ▷ θ.app c ≫
              ?_ ≫
                F.map f ◁ η.naturality g ▷ θ.app c ≫
                  ?_ ≫
                    (F.map f ≫ η.app b) ◁ θ.naturality g ≫
                      η.naturality f ▷ (θ.app b ≫ H.map g) ≫
                        ?_ ≫ η.app a ◁ θ.naturality f ▷ H.map g ≫ ?_ :=
        ?_
      _ = _ := ?_
/-- Vertical composition of oplax natural transformations. -/
@[simps]
def vcomp (η : OplaxNatTrans F G) (θ : OplaxNatTrans G H) : OplaxNatTrans F H where
  app a := η.app a ≫ θ.app a
  naturality {a b} f :=
    (α_ _ _ _).inv ≫
      η.naturality f ▷ θ.app b ≫ (α_ _ _ _).hom ≫ η.app a ◁ θ.naturality f ≫ (α_ _ _ _).inv
  naturality_comp {a b c} f g := by
    calc
      _ =
          ?_ ≫
            F.mapComp f g ▷ η.app c ▷ θ.app c ≫
              ?_ ≫
                F.map f ◁ η.naturality g ▷ θ.app c ≫
                  ?_ ≫
                    (F.map f ≫ η.app b) ◁ θ.naturality g ≫
                      η.naturality f ▷ (θ.app b ≫ H.map g) ≫
                        ?_ ≫ η.app a ◁ θ.naturality f ▷ H.map g ≫ ?_ :=
        ?_
      _ = _ := ?_
    exact (α_ _ _ _).inv
    exact (α_ _ _ _).hom ▷ _ ≫ (α_ _ _ _).hom
    exact _ ◁ (α_ _ _ _).hom ≫ (α_ _ _ _).inv
    exact (α_ _ _ _).hom ≫ _ ◁ (α_ _ _ _).inv
    exact _ ◁ (α_ _ _ _).hom ≫ (α_ _ _ _).inv
    · 

Proof state:
case calc_6
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η✝ : OplaxNatTrans F G
θ✝ : OplaxNatTrans G H
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
f : a ⟶ b
g : b ⟶ c
⊢ (fun {a b} f =>
          (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) (θ.app b)).inv ≫
            naturality η f ▷ θ.app b ≫
              (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b)).hom ≫
                η.app a ◁ naturality θ f ≫ (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f)).inv)
        (f ≫ g) ≫
      (fun a => η.app a ≫ θ.app a) a ◁ OplaxFunctor.mapComp H f g =
    (α_ ((↑F.toPrelaxFunctor).map (f ≫ g)) (η.app c) (θ.app c)).inv ≫
      OplaxFunctor.mapComp F f g ▷ η.app c ▷ θ.app c ≫
        ((α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) (η.app c)).hom ▷ θ.app c ≫
            (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g ≫ η.app c) (θ.app c)).hom) ≫
          (↑F.toPrelaxFunctor).map f ◁ naturality η g ▷ θ.app c ≫
            ((↑F.toPrelaxFunctor).map f ◁ (α_ (η.app b) ((↑G.toPrelaxFunctor).map g) (θ.app c)).hom ≫
                (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) ((↑G.toPrelaxFunctor).map g ≫ θ.app c)).inv) ≫
              ((↑F.toPrelaxFunctor).map f ≫ η.app b) ◁ naturality θ g ≫
                naturality η f ▷ (θ.app b ≫ (↑H.toPrelaxFunctor).map g) ≫
                  ((α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b ≫ (↑H.toPrelaxFunctor).map g)).hom ≫
                      η.app a ◁ (α_ ((↑G.toPrelaxFunctor).map f) (θ.app b) ((↑H.toPrelaxFunctor).map g)).inv) ≫
                    η.app a ◁ naturality θ f ▷ (↑H.toPrelaxFunctor).map g ≫
                      η.app a ◁ (α_ (θ.app a) ((↑H.toPrelaxFunctor).map f) ((↑H.toPrelaxFunctor).map g)).hom ≫
                        (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f ≫ (↑H.toPrelaxFunctor).map g)).inv

Next tactic:
rw [whisker_exchange_assoc]
/-- Vertical composition of oplax natural transformations. -/
@[simps]
def vcomp (η : OplaxNatTrans F G) (θ : OplaxNatTrans G H) : OplaxNatTrans F H where
  app a := η.app a ≫ θ.app a
  naturality {a b} f :=
    (α_ _ _ _).inv ≫
      η.naturality f ▷ θ.app b ≫ (α_ _ _ _).hom ≫ η.app a ◁ θ.naturality f ≫ (α_ _ _ _).inv
  naturality_comp {a b c} f g := by
    calc
      _ =
          ?_ ≫
            F.mapComp f g ▷ η.app c ▷ θ.app c ≫
              ?_ ≫
                F.map f ◁ η.naturality g ▷ θ.app c ≫
                  ?_ ≫
                    (F.map f ≫ η.app b) ◁ θ.naturality g ≫
                      η.naturality f ▷ (θ.app b ≫ H.map g) ≫
                        ?_ ≫ η.app a ◁ θ.naturality f ▷ H.map g ≫ ?_ :=
        ?_
      _ = _ := ?_
    exact (α_ _ _ _).inv
    exact (α_ _ _ _).hom ▷ _ ≫ (α_ _ _ _).hom
    exact _ ◁ (α_ _ _ _).hom ≫ (α_ _ _ _).inv
    exact (α_ _ _ _).hom ≫ _ ◁ (α_ _ _ _).inv
    exact _ ◁ (α_ _ _ _).hom ≫ (α_ _ _ _).inv
    · rw [whisker_exchange_assoc]
      -- Porting note: this used to be just `simp`
      

Proof state:
case calc_6
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H : OplaxFunctor B C
η✝ : OplaxNatTrans F G
θ✝ : OplaxNatTrans G H
η : OplaxNatTrans F G
θ : OplaxNatTrans G H
a b c : B
f : a ⟶ b
g : b ⟶ c
⊢ (fun {a b} f =>
          (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) (θ.app b)).inv ≫
            naturality η f ▷ θ.app b ≫
              (α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b)).hom ≫
                η.app a ◁ naturality θ f ≫ (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f)).inv)
        (f ≫ g) ≫
      (fun a => η.app a ≫ θ.app a) a ◁ OplaxFunctor.mapComp H f g =
    (α_ ((↑F.toPrelaxFunctor).map (f ≫ g)) (η.app c) (θ.app c)).inv ≫
      OplaxFunctor.mapComp F f g ▷ η.app c ▷ θ.app c ≫
        ((α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g) (η.app c)).hom ▷ θ.app c ≫
            (α_ ((↑F.toPrelaxFunctor).map f) ((↑F.toPrelaxFunctor).map g ≫ η.app c) (θ.app c)).hom) ≫
          (↑F.toPrelaxFunctor).map f ◁ naturality η g ▷ θ.app c ≫
            ((↑F.toPrelaxFunctor).map f ◁ (α_ (η.app b) ((↑G.toPrelaxFunctor).map g) (θ.app c)).hom ≫
                (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) ((↑G.toPrelaxFunctor).map g ≫ θ.app c)).inv) ≫
              naturality η f ▷ ((↑G.toPrelaxFunctor).map g ≫ θ.app c) ≫
                (η.app a ≫ (↑G.toPrelaxFunctor).map f) ◁ naturality θ g ≫
                  ((α_ (η.app a) ((↑G.toPrelaxFunctor).map f) (θ.app b ≫ (↑H.toPrelaxFunctor).map g)).hom ≫
                      η.app a ◁ (α_ ((↑G.toPrelaxFunctor).map f) (θ.app b) ((↑H.toPrelaxFunctor).map g)).inv) ≫
                    η.app a ◁ naturality θ f ▷ (↑H.toPrelaxFunctor).map g ≫
                      η.app a ◁ (α_ (θ.app a) ((↑H.toPrelaxFunctor).map f) ((↑H.toPrelaxFunctor).map g)).hom ≫
                        (α_ (η.app a) (θ.app a) ((↑H.toPrelaxFunctor).map f ≫ (↑H.toPrelaxFunctor).map g)).inv

Next tactic:
simp only [comp_whiskerLeft, assoc, Iso.inv_hom_id_assoc, whiskerLeft_naturality_comp_assoc,
        whiskerRight_naturality_comp_assoc, pentagon_assoc, whiskerRight_comp,
        pentagon_hom_inv_inv_inv_inv_assoc]
@[reassoc (attr := simp)]
theorem whiskerLeft_naturality (f : a' ⟶ F.obj b) (g : b ⟶ c) :
    f ◁ F.map g ◁ Γ.app c ≫ f ◁ θ.naturality g = f ◁ η.naturality g ≫ f ◁ Γ.app b ▷ G.map g := by
  

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
Γ : Modification η θ
a b c : B
a' : C
f : a' ⟶ (↑F.toPrelaxFunctor).obj b
g : b ⟶ c
⊢ f ◁ (↑F.toPrelaxFunctor).map g ◁ Γ.app c ≫ f ◁ OplaxNatTrans.naturality θ g =
    f ◁ OplaxNatTrans.naturality η g ≫ f ◁ Γ.app b ▷ (↑G.toPrelaxFunctor).map g

Next tactic:
simp_rw [← whiskerLeft_comp, naturality]
@[reassoc (attr := simp)]
theorem whiskerRight_naturality (f : a ⟶ b) (g : G.obj b ⟶ a') :
    F.map f ◁ Γ.app b ▷ g ≫ (α_ _ _ _).inv ≫ θ.naturality f ▷ g =
      (α_ _ _ _).inv ≫ η.naturality f ▷ g ≫ Γ.app a ▷ G.map f ▷ g :=
  by 

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
Γ : Modification η θ
a b c : B
a' : C
f : a ⟶ b
g : (↑G.toPrelaxFunctor).obj b ⟶ a'
⊢ (↑F.toPrelaxFunctor).map f ◁ Γ.app b ▷ g ≫
      (α_ ((↑F.toPrelaxFunctor).map f) (θ.app b) g).inv ≫ OplaxNatTrans.naturality θ f ▷ g =
    (α_ ((↑F.toPrelaxFunctor).map f) (η.app b) g).inv ≫
      OplaxNatTrans.naturality η f ▷ g ≫ Γ.app a ▷ (↑G.toPrelaxFunctor).map f ▷ g

Next tactic:
simp_rw [associator_inv_naturality_middle_assoc, ← comp_whiskerRight, naturality]
/-- Vertical composition of modifications. -/
@[simps]
def vcomp (Γ : Modification η θ) (Δ : Modification θ ι) : Modification η ι where
  app a := Γ.app a ≫ Δ.app a
  naturality := by
    -- Porting note: this used to be automatic via `tidy`, which did `intros, simp`
    

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
Γ : Modification η θ
Δ : Modification θ ι
⊢ ∀ {a b : B} (f : a ⟶ b),
    (↑F.toPrelaxFunctor).map f ◁ (fun a => Γ.app a ≫ Δ.app a) b ≫ OplaxNatTrans.naturality ι f =
      OplaxNatTrans.naturality η f ≫ (fun a => Γ.app a ≫ Δ.app a) a ▷ (↑G.toPrelaxFunctor).map f

Next tactic:
intros
/-- Vertical composition of modifications. -/
@[simps]
def vcomp (Γ : Modification η θ) (Δ : Modification θ ι) : Modification η ι where
  app a := Γ.app a ≫ Δ.app a
  naturality := by
    -- Porting note: this used to be automatic via `tidy`, which did `intros, simp`
    intros
    

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
Γ : Modification η θ
Δ : Modification θ ι
a✝ b✝ : B
f✝ : a✝ ⟶ b✝
⊢ (↑F.toPrelaxFunctor).map f✝ ◁ (fun a => Γ.app a ≫ Δ.app a) b✝ ≫ OplaxNatTrans.naturality ι f✝ =
    OplaxNatTrans.naturality η f✝ ≫ (fun a => Γ.app a ≫ Δ.app a) a✝ ▷ (↑G.toPrelaxFunctor).map f✝

Next tactic:
simp only [whiskerLeft_comp, assoc, naturality, naturality_assoc, comp_whiskerRight]
@[ext]
lemma ext {F G : OplaxFunctor B C} {α β : F ⟶ G} {m n : α ⟶ β} (w : ∀ b, m.app b = n.app b) :
    m = n := by
  

Proof state:
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F✝ G✝ : OplaxFunctor B C
η θ ι : F✝ ⟶ G✝
F G : OplaxFunctor B C
α β : F ⟶ G
m n : α ⟶ β
w : ∀ (b : B), m.app b = n.app b
⊢ m = n

Next tactic:
apply Modification.ext
@[ext]
lemma ext {F G : OplaxFunctor B C} {α β : F ⟶ G} {m n : α ⟶ β} (w : ∀ b, m.app b = n.app b) :
    m = n := by
  apply Modification.ext
  

Proof state:
case app
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F✝ G✝ : OplaxFunctor B C
η θ ι : F✝ ⟶ G✝
F G : OplaxFunctor B C
α β : F ⟶ G
m n : α ⟶ β
w : ∀ (b : B), m.app b = n.app b
⊢ m.app = n.app

Next tactic:
ext
@[ext]
lemma ext {F G : OplaxFunctor B C} {α β : F ⟶ G} {m n : α ⟶ β} (w : ∀ b, m.app b = n.app b) :
    m = n := by
  apply Modification.ext
  ext
  

Proof state:
case app.h
B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F✝ G✝ : OplaxFunctor B C
η θ ι : F✝ ⟶ G✝
F G : OplaxFunctor B C
α β : F ⟶ G
m n : α ⟶ β
w : ∀ (b : B), m.app b = n.app b
x✝ : B
⊢ m.app x✝ = n.app x✝

Next tactic:
apply w