Theorem: CategoryTheory.mateEquiv_conjugateEquiv_vcomp
File: Mathlib/CategoryTheory/Adjunction/Mates.lean

Proof steps:
state_before: A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
⊢ (mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β) =
    rightAdjointSquareConjugate.vcomp ((mateEquiv adj₁ adj₂) α) ((conjugateEquiv adj₂ adj₃) β)
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β)).app b =
    (rightAdjointSquareConjugate.vcomp ((mateEquiv adj₁ adj₂) α) ((conjugateEquiv adj₂ adj₃) β)).app b
tactic: ext b
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β)).app b =
    (rightAdjointSquareConjugate.vcomp ((mateEquiv adj₁ adj₂) α) ((conjugateEquiv adj₂ adj₃) β)).app b
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (leftAdjointSquare.vcomp α (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) α)
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β)).app b =
    (rightAdjointSquareConjugate.vcomp ((mateEquiv adj₁ adj₂) α) ((conjugateEquiv adj₂ adj₃) β)).app b
tactic: have vcomp := mateEquiv_vcomp adj₁ adj₂ adj₃ α (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (leftAdjointSquare.vcomp α (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) α)
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β)).app b =
    (rightAdjointSquareConjugate.vcomp ((mateEquiv adj₁ adj₂) α) ((conjugateEquiv adj₂ adj₃) β)).app b
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β)).app b =
    (rightAdjointSquareConjugate.vcomp ((mateEquiv adj₁ adj₂) α) ((conjugateEquiv adj₂ adj₃) β)).app b
tactic: unfold leftAdjointSquare.vcomp rightAdjointSquare.vcomp at vcomp
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β)).app b =
    (rightAdjointSquareConjugate.vcomp ((mateEquiv adj₁ adj₂) α) ((conjugateEquiv adj₂ adj₃) β)).app b
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
⊢ ((mateEquiv adj₁ adj₃) (whiskerLeft G β ≫ α)).app b =
    ((mateEquiv adj₁ adj₂) α ≫
          whiskerLeft H
            ((Trans.trans (Trans.trans (L₃.leftUnitor.homCongr L₂.rightUnitor).symm (mateEquiv adj₂ adj₃))
                (R₂.rightUnitor.homCongr R₃.leftUnitor))
              β)).app
      b
tactic: unfold leftAdjointSquareConjugate.vcomp rightAdjointSquareConjugate.vcomp conjugateEquiv
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
⊢ ((mateEquiv adj₁ adj₃) (whiskerLeft G β ≫ α)).app b =
    ((mateEquiv adj₁ adj₂) α ≫
          whiskerLeft H
            ((Trans.trans (Trans.trans (L₃.leftUnitor.homCongr L₂.rightUnitor).symm (mateEquiv adj₂ adj₃))
                (R₂.rightUnitor.homCongr R₃.leftUnitor))
              β)).app
      b
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompb :
  ((mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D))).app b =
    (whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
          whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))).app
      b
⊢ ((mateEquiv adj₁ adj₃) (whiskerLeft G β ≫ α)).app b =
    ((mateEquiv adj₁ adj₂) α ≫
          whiskerLeft H
            ((Trans.trans (Trans.trans (L₃.leftUnitor.homCongr L₂.rightUnitor).symm (mateEquiv adj₂ adj₃))
                (R₂.rightUnitor.homCongr R₃.leftUnitor))
              β)).app
      b
tactic: have vcompb := congr_app vcomp b
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompb :
  ((mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D))).app b =
    (whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
          whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))).app
      b
⊢ ((mateEquiv adj₁ adj₃) (whiskerLeft G β ≫ α)).app b =
    ((mateEquiv adj₁ adj₂) α ≫
          whiskerLeft H
            ((Trans.trans (Trans.trans (L₃.leftUnitor.homCongr L₂.rightUnitor).symm (mateEquiv adj₂ adj₃))
                (R₂.rightUnitor.homCongr R₃.leftUnitor))
              β)).app
      b
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (G.obj (R₁.obj b))) ≫ R₃.map (α.app (R₁.obj b)) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    adj₂.unit.app (G.obj (R₁.obj b)) ≫
      R₂.map (α.app (R₁.obj b)) ≫
        R₂.map (H.map (adj₁.counit.app b)) ≫
          adj₃.unit.app (R₂.obj (H.obj b)) ≫ R₃.map (β.app (R₂.obj (H.obj b))) ≫ R₃.map (adj₂.counit.app (H.obj b))
⊢ ((mateEquiv adj₁ adj₃) (whiskerLeft G β ≫ α)).app b =
    ((mateEquiv adj₁ adj₂) α ≫
          whiskerLeft H
            ((Trans.trans (Trans.trans (L₃.leftUnitor.homCongr L₂.rightUnitor).symm (mateEquiv adj₂ adj₃))
                (R₂.rightUnitor.homCongr R₃.leftUnitor))
              β)).app
      b
tactic: simp at vcompb
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (G.obj (R₁.obj b))) ≫ R₃.map (α.app (R₁.obj b)) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    adj₂.unit.app (G.obj (R₁.obj b)) ≫
      R₂.map (α.app (R₁.obj b)) ≫
        R₂.map (H.map (adj₁.counit.app b)) ≫
          adj₃.unit.app (R₂.obj (H.obj b)) ≫ R₃.map (β.app (R₂.obj (H.obj b))) ≫ R₃.map (adj₂.counit.app (H.obj b))
⊢ ((mateEquiv adj₁ adj₃) (whiskerLeft G β ≫ α)).app b =
    ((mateEquiv adj₁ adj₂) α ≫
          whiskerLeft H
            ((Trans.trans (Trans.trans (L₃.leftUnitor.homCongr L₂.rightUnitor).symm (mateEquiv adj₂ adj₃))
                (R₂.rightUnitor.homCongr R₃.leftUnitor))
              β)).app
      b
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (G.obj (R₁.obj b))) ≫ R₃.map (α.app (R₁.obj b)) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    adj₂.unit.app (G.obj (R₁.obj b)) ≫
      R₂.map (α.app (R₁.obj b)) ≫
        R₂.map (H.map (adj₁.counit.app b)) ≫
          adj₃.unit.app (R₂.obj (H.obj b)) ≫ R₃.map (β.app (R₂.obj (H.obj b))) ≫ R₃.map (adj₂.counit.app (H.obj b))
⊢ ({
            toFun := fun α =>
              whiskerLeft (R₁ ⋙ G) adj₃.unit ≫ whiskerRight (whiskerLeft R₁ α) R₃ ≫ whiskerRight adj₁.counit (H ⋙ R₃),
            invFun := fun β =>
              whiskerRight adj₁.unit (G ⋙ L₃) ≫ whiskerRight (whiskerLeft L₁ β) L₃ ≫ whiskerLeft (L₁ ⋙ H) adj₃.counit,
            left_inv := ⋯, right_inv := ⋯ }
          (whiskerLeft G β ≫ α)).app
      b =
    ({
              toFun := fun α =>
                whiskerLeft (R₁ ⋙ G) adj₂.unit ≫ whiskerRight (whiskerLeft R₁ α) R₂ ≫ whiskerRight adj₁.counit (H ⋙ R₂),
              invFun := fun β =>
                whiskerRight adj₁.unit (G ⋙ L₂) ≫ whiskerRight (whiskerLeft L₁ β) L₂ ≫ whiskerLeft (L₁ ⋙ H) adj₂.counit,
              left_inv := ⋯, right_inv := ⋯ }
            α ≫
          whiskerLeft H
            ((Trans.trans
                (Trans.trans (L₃.leftUnitor.homCongr L₂.rightUnitor).symm
                  {
                    toFun := fun α =>
                      whiskerLeft (R₂ ⋙ 𝟭 C) adj₃.unit ≫
                        whiskerRight (whiskerLeft R₂ α) R₃ ≫ whiskerRight adj₂.counit (𝟭 D ⋙ R₃),
                    invFun := fun β =>
                      whiskerRight adj₂.unit (𝟭 C ⋙ L₃) ≫
                        whiskerRight (whiskerLeft L₂ β) L₃ ≫ whiskerLeft (L₂ ⋙ 𝟭 D) adj₃.counit,
                    left_inv := ⋯, right_inv := ⋯ })
                (R₂.rightUnitor.homCongr R₃.leftUnitor))
              β)).app
      b
tactic: unfold mateEquiv
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (G.obj (R₁.obj b))) ≫ R₃.map (α.app (R₁.obj b)) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    adj₂.unit.app (G.obj (R₁.obj b)) ≫
      R₂.map (α.app (R₁.obj b)) ≫
        R₂.map (H.map (adj₁.counit.app b)) ≫
          adj₃.unit.app (R₂.obj (H.obj b)) ≫ R₃.map (β.app (R₂.obj (H.obj b))) ≫ R₃.map (adj₂.counit.app (H.obj b))
⊢ ({
            toFun := fun α =>
              whiskerLeft (R₁ ⋙ G) adj₃.unit ≫ whiskerRight (whiskerLeft R₁ α) R₃ ≫ whiskerRight adj₁.counit (H ⋙ R₃),
            invFun := fun β =>
              whiskerRight adj₁.unit (G ⋙ L₃) ≫ whiskerRight (whiskerLeft L₁ β) L₃ ≫ whiskerLeft (L₁ ⋙ H) adj₃.counit,
            left_inv := ⋯, right_inv := ⋯ }
          (whiskerLeft G β ≫ α)).app
      b =
    ({
              toFun := fun α =>
                whiskerLeft (R₁ ⋙ G) adj₂.unit ≫ whiskerRight (whiskerLeft R₁ α) R₂ ≫ whiskerRight adj₁.counit (H ⋙ R₂),
              invFun := fun β =>
                whiskerRight adj₁.unit (G ⋙ L₂) ≫ whiskerRight (whiskerLeft L₁ β) L₂ ≫ whiskerLeft (L₁ ⋙ H) adj₂.counit,
              left_inv := ⋯, right_inv := ⋯ }
            α ≫
          whiskerLeft H
            ((Trans.trans
                (Trans.trans (L₃.leftUnitor.homCongr L₂.rightUnitor).symm
                  {
                    toFun := fun α =>
                      whiskerLeft (R₂ ⋙ 𝟭 C) adj₃.unit ≫
                        whiskerRight (whiskerLeft R₂ α) R₃ ≫ whiskerRight adj₂.counit (𝟭 D ⋙ R₃),
                    invFun := fun β =>
                      whiskerRight adj₂.unit (𝟭 C ⋙ L₃) ≫
                        whiskerRight (whiskerLeft L₂ β) L₃ ≫ whiskerLeft (L₂ ⋙ 𝟭 D) adj₃.counit,
                    left_inv := ⋯, right_inv := ⋯ })
                (R₂.rightUnitor.homCongr R₃.leftUnitor))
              β)).app
      b
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (G.obj (R₁.obj b))) ≫ R₃.map (α.app (R₁.obj b)) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    adj₂.unit.app (G.obj (R₁.obj b)) ≫
      R₂.map (α.app (R₁.obj b)) ≫
        R₂.map (H.map (adj₁.counit.app b)) ≫
          adj₃.unit.app (R₂.obj (H.obj b)) ≫ R₃.map (β.app (R₂.obj (H.obj b))) ≫ R₃.map (adj₂.counit.app (H.obj b))
⊢ adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (G.obj (R₁.obj b))) ≫ R₃.map (α.app (R₁.obj b)) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    adj₂.unit.app (G.obj (R₁.obj b)) ≫
      R₂.map (α.app (R₁.obj b)) ≫
        R₂.map (H.map (adj₁.counit.app b)) ≫
          adj₃.unit.app (R₂.obj (H.obj b)) ≫ R₃.map (β.app (R₂.obj (H.obj b))) ≫ R₃.map (adj₂.counit.app (H.obj b))
tactic: simp only [comp_obj, Equiv.coe_fn_mk, whiskerLeft_comp, whiskerLeft_twice, whiskerRight_comp,
    assoc, comp_app, whiskerLeft_app, whiskerRight_app, id_obj, Functor.comp_map, Iso.homCongr_symm,
    Equiv.instTrans_trans, Equiv.trans_apply, Iso.homCongr_apply, Iso.symm_inv, Iso.symm_hom,
    rightUnitor_inv_app, leftUnitor_hom_app, map_id, Functor.id_map, comp_id, id_comp]
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
inst✝³ : Category.{v₁, u₁} A
inst✝² : Category.{v₂, u₂} B
inst✝¹ : Category.{v₃, u₃} C
inst✝ : Category.{v₄, u₄} D
G : A ⥤ C
H : B ⥤ D
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : L₃ ⟶ L₂
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft G (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv) ≫ whiskerRight α (𝟭 D)) =
    whiskerRight ((mateEquiv adj₁ adj₂) α) (𝟭 C) ≫
      whiskerLeft H ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (G.obj (R₁.obj b))) ≫ R₃.map (α.app (R₁.obj b)) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    adj₂.unit.app (G.obj (R₁.obj b)) ≫
      R₂.map (α.app (R₁.obj b)) ≫
        R₂.map (H.map (adj₁.counit.app b)) ≫
          adj₃.unit.app (R₂.obj (H.obj b)) ≫ R₃.map (β.app (R₂.obj (H.obj b))) ≫ R₃.map (adj₂.counit.app (H.obj b))
⊢ adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (G.obj (R₁.obj b))) ≫ R₃.map (α.app (R₁.obj b)) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    adj₂.unit.app (G.obj (R₁.obj b)) ≫
      R₂.map (α.app (R₁.obj b)) ≫
        R₂.map (H.map (adj₁.counit.app b)) ≫
          adj₃.unit.app (R₂.obj (H.obj b)) ≫ R₃.map (β.app (R₂.obj (H.obj b))) ≫ R₃.map (adj₂.counit.app (H.obj b))
state_after: no goals
tactic: exact vcompb