Theorem: CategoryTheory.conjugateEquiv_mateEquiv_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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
⊢ (mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β) =
    rightAdjointConjugateSquare.vcomp ((conjugateEquiv adj₁ adj₂) α) ((mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β)).app b =
    (rightAdjointConjugateSquare.vcomp ((conjugateEquiv adj₁ adj₂) α) ((mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β)).app b =
    (rightAdjointConjugateSquare.vcomp ((conjugateEquiv adj₁ adj₂) α) ((mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) β) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) β)
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β)).app b =
    (rightAdjointConjugateSquare.vcomp ((conjugateEquiv adj₁ adj₂) α) ((mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) β) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) β)
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β)).app b =
    (rightAdjointConjugateSquare.vcomp ((conjugateEquiv adj₁ adj₂) α) ((mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β)).app b =
    (rightAdjointConjugateSquare.vcomp ((conjugateEquiv adj₁ adj₂) α) ((mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
⊢ ((mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β)).app b =
    (rightAdjointConjugateSquare.vcomp ((conjugateEquiv adj₁ adj₂) α) ((mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
⊢ ((mateEquiv adj₁ adj₃) (β ≫ whiskerRight α H)).app b =
    (whiskerRight
            ((Trans.trans (Trans.trans (L₂.leftUnitor.homCongr L₁.rightUnitor).symm (mateEquiv adj₁ adj₂))
                (R₁.rightUnitor.homCongr R₂.leftUnitor))
              α)
            G ≫
          (mateEquiv adj₂ adj₃) β).app
      b
tactic: unfold leftAdjointConjugateSquare.vcomp rightAdjointConjugateSquare.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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
⊢ ((mateEquiv adj₁ adj₃) (β ≫ whiskerRight α H)).app b =
    (whiskerRight
            ((Trans.trans (Trans.trans (L₂.leftUnitor.homCongr L₁.rightUnitor).symm (mateEquiv adj₁ adj₂))
                (R₁.rightUnitor.homCongr R₂.leftUnitor))
              α)
            G ≫
          (mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
vcompb :
  ((mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H)).app b =
    (whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
          whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)).app
      b
⊢ ((mateEquiv adj₁ adj₃) (β ≫ whiskerRight α H)).app b =
    (whiskerRight
            ((Trans.trans (Trans.trans (L₂.leftUnitor.homCongr L₁.rightUnitor).symm (mateEquiv adj₁ adj₂))
                (R₁.rightUnitor.homCongr R₂.leftUnitor))
              α)
            G ≫
          (mateEquiv adj₂ adj₃) β).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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
vcompb :
  ((mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H)).app b =
    (whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
          whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)).app
      b
⊢ ((mateEquiv adj₁ adj₃) (β ≫ whiskerRight α H)).app b =
    (whiskerRight
            ((Trans.trans (Trans.trans (L₂.leftUnitor.homCongr L₁.rightUnitor).symm (mateEquiv adj₁ adj₂))
                (R₁.rightUnitor.homCongr R₂.leftUnitor))
              α)
            G ≫
          (mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (R₁.obj b)) ≫ R₃.map (H.map (α.app (R₁.obj b))) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    G.map (adj₂.unit.app (R₁.obj b)) ≫
      G.map (R₂.map (α.app (R₁.obj b))) ≫
        G.map (R₂.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))
⊢ ((mateEquiv adj₁ adj₃) (β ≫ whiskerRight α H)).app b =
    (whiskerRight
            ((Trans.trans (Trans.trans (L₂.leftUnitor.homCongr L₁.rightUnitor).symm (mateEquiv adj₁ adj₂))
                (R₁.rightUnitor.homCongr R₂.leftUnitor))
              α)
            G ≫
          (mateEquiv adj₂ adj₃) β).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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (R₁.obj b)) ≫ R₃.map (H.map (α.app (R₁.obj b))) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    G.map (adj₂.unit.app (R₁.obj b)) ≫
      G.map (R₂.map (α.app (R₁.obj b))) ≫
        G.map (R₂.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))
⊢ ((mateEquiv adj₁ adj₃) (β ≫ whiskerRight α H)).app b =
    (whiskerRight
            ((Trans.trans (Trans.trans (L₂.leftUnitor.homCongr L₁.rightUnitor).symm (mateEquiv adj₁ adj₂))
                (R₁.rightUnitor.homCongr R₂.leftUnitor))
              α)
            G ≫
          (mateEquiv 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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (R₁.obj b)) ≫ R₃.map (H.map (α.app (R₁.obj b))) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    G.map (adj₂.unit.app (R₁.obj b)) ≫
      G.map (R₂.map (α.app (R₁.obj b))) ≫
        G.map (R₂.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))
⊢ ({
            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 := ⋯ }
          (β ≫ whiskerRight α H)).app
      b =
    (whiskerRight
            ((Trans.trans
                (Trans.trans (L₂.leftUnitor.homCongr L₁.rightUnitor).symm
                  {
                    toFun := fun α =>
                      whiskerLeft (R₁ ⋙ 𝟭 A) adj₂.unit ≫
                        whiskerRight (whiskerLeft R₁ α) R₂ ≫ whiskerRight adj₁.counit (𝟭 B ⋙ R₂),
                    invFun := fun β =>
                      whiskerRight adj₁.unit (𝟭 A ⋙ L₂) ≫
                        whiskerRight (whiskerLeft L₁ β) L₂ ≫ whiskerLeft (L₁ ⋙ 𝟭 B) adj₂.counit,
                    left_inv := ⋯, right_inv := ⋯ })
                (R₁.rightUnitor.homCongr R₂.leftUnitor))
              α)
            G ≫
          {
              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 := ⋯ }
            β).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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (R₁.obj b)) ≫ R₃.map (H.map (α.app (R₁.obj b))) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    G.map (adj₂.unit.app (R₁.obj b)) ≫
      G.map (R₂.map (α.app (R₁.obj b))) ≫
        G.map (R₂.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))
⊢ ({
            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 := ⋯ }
          (β ≫ whiskerRight α H)).app
      b =
    (whiskerRight
            ((Trans.trans
                (Trans.trans (L₂.leftUnitor.homCongr L₁.rightUnitor).symm
                  {
                    toFun := fun α =>
                      whiskerLeft (R₁ ⋙ 𝟭 A) adj₂.unit ≫
                        whiskerRight (whiskerLeft R₁ α) R₂ ≫ whiskerRight adj₁.counit (𝟭 B ⋙ R₂),
                    invFun := fun β =>
                      whiskerRight adj₁.unit (𝟭 A ⋙ L₂) ≫
                        whiskerRight (whiskerLeft L₁ β) L₂ ≫ whiskerLeft (L₁ ⋙ 𝟭 B) adj₂.counit,
                    left_inv := ⋯, right_inv := ⋯ })
                (R₁.rightUnitor.homCongr R₂.leftUnitor))
              α)
            G ≫
          {
              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 := ⋯ }
            β).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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (R₁.obj b)) ≫ R₃.map (H.map (α.app (R₁.obj b))) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    G.map (adj₂.unit.app (R₁.obj b)) ≫
      G.map (R₂.map (α.app (R₁.obj b))) ≫
        G.map (R₂.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 (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (R₁.obj b)) ≫ R₃.map (H.map (α.app (R₁.obj b))) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    G.map (adj₂.unit.app (R₁.obj b)) ≫
      G.map (R₂.map (α.app (R₁.obj b))) ≫
        G.map (R₂.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))
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₂ : A ⥤ B
R₂ : B ⥤ A
L₃ : C ⥤ D
R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : G ⋙ L₃ ⟶ L₂ ⋙ H
b : B
vcomp :
  (mateEquiv adj₁ adj₃) (whiskerLeft (𝟭 A) β ≫ whiskerRight (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv) H) =
    whiskerRight ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)) G ≫
      whiskerLeft (𝟭 B) ((mateEquiv adj₂ adj₃) β)
vcompb :
  adj₃.unit.app (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (R₁.obj b)) ≫ R₃.map (H.map (α.app (R₁.obj b))) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    G.map (adj₂.unit.app (R₁.obj b)) ≫
      G.map (R₂.map (α.app (R₁.obj b))) ≫
        G.map (R₂.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 (G.obj (R₁.obj b)) ≫
      R₃.map (β.app (R₁.obj b)) ≫ R₃.map (H.map (α.app (R₁.obj b))) ≫ R₃.map (H.map (adj₁.counit.app b)) =
    G.map (adj₂.unit.app (R₁.obj b)) ≫
      G.map (R₂.map (α.app (R₁.obj b))) ≫
        G.map (R₂.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))
state_after: no goals
tactic: exact vcompb