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

Proof steps:
state_before: A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
⊢ (mateEquiv (adj₁.comp adj₃) (adj₂.comp adj₄)) (leftAdjointSquare.hcomp α β) =
    rightAdjointSquare.hcomp ((mateEquiv adj₁ adj₂) α) ((mateEquiv adj₃ adj₄) β)
state_after: A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
⊢ {
        toFun := fun α =>
          whiskerLeft ((R₃ ⋙ R₁) ⋙ G)
              { homEquiv := fun X Z => (adj₄.homEquiv (L₂.obj X) Z).trans (adj₂.homEquiv X (R₄.obj Z)),
                  unit := adj₂.unit ≫ whiskerLeft L₂ (whiskerRight adj₄.unit R₂) ≫ (L₂.associator (L₄ ⋙ R₄) R₂).inv,
                  counit :=
                    (R₄.associator R₂ (L₂ ⋙ L₄)).hom ≫ whiskerLeft R₄ (whiskerRight adj₂.counit L₄) ≫ adj₄.counit,
                  homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit ≫
            whiskerRight (whiskerLeft (R₃ ⋙ R₁) α) (R₄ ⋙ R₂) ≫
              whiskerRight
                { homEquiv := fun X Z => (adj₃.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (R₃.obj Z)),
                    unit := adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₃.unit R₁) ≫ (L₁.associator (L₃ ⋙ R₃) R₁).inv,
                    counit :=
                      (R₃.associator R₁ (L₁ ⋙ L₃)).hom ≫ whiskerLeft R₃ (whiskerRight adj₁.counit L₃) ≫ adj₃.counit,
                    homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit
                (K ⋙ R₄ ⋙ R₂),
        invFun := fun β =>
          whiskerRight
              { homEquiv := fun X Z => (adj₃.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (R₃.obj Z)),
                  unit := adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₃.unit R₁) ≫ (L₁.associator (L₃ ⋙ R₃) R₁).inv,
                  counit :=
                    (R₃.associator R₁ (L₁ ⋙ L₃)).hom ≫ whiskerLeft R₃ (whiskerRight adj₁.counit L₃) ≫ adj₃.counit,
                  homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit
              (G ⋙ L₂ ⋙ L₄) ≫
            whiskerRight (whiskerLeft (L₁ ⋙ L₃) β) (L₂ ⋙ L₄) ≫
              whiskerLeft ((L₁ ⋙ L₃) ⋙ K)
                { homEquiv := fun X Z => (adj₄.homEquiv (L₂.obj X) Z).trans (adj₂.homEquiv X (R₄.obj Z)),
                    unit := adj₂.unit ≫ whiskerLeft L₂ (whiskerRight adj₄.unit R₂) ≫ (L₂.associator (L₄ ⋙ R₄) R₂).inv,
                    counit :=
                      (R₄.associator R₂ (L₂ ⋙ L₄)).hom ≫ whiskerLeft R₄ (whiskerRight adj₂.counit L₄) ≫ adj₄.counit,
                    homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit,
        left_inv := ⋯, right_inv := ⋯ }
      (whiskerRight α L₄ ≫ whiskerLeft L₁ β) =
    whiskerLeft R₃
        ({
            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
        ({
            toFun := fun α =>
              whiskerLeft (R₃ ⋙ H) adj₄.unit ≫ whiskerRight (whiskerLeft R₃ α) R₄ ≫ whiskerRight adj₃.counit (K ⋙ R₄),
            invFun := fun β =>
              whiskerRight adj₃.unit (H ⋙ L₄) ≫ whiskerRight (whiskerLeft L₃ β) L₄ ≫ whiskerLeft (L₃ ⋙ K) adj₄.counit,
            left_inv := ⋯, right_inv := ⋯ }
          β)
        R₂
tactic: unfold leftAdjointSquare.hcomp rightAdjointSquare.hcomp mateEquiv Adjunction.comp
state_before: A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
⊢ {
        toFun := fun α =>
          whiskerLeft ((R₃ ⋙ R₁) ⋙ G)
              { homEquiv := fun X Z => (adj₄.homEquiv (L₂.obj X) Z).trans (adj₂.homEquiv X (R₄.obj Z)),
                  unit := adj₂.unit ≫ whiskerLeft L₂ (whiskerRight adj₄.unit R₂) ≫ (L₂.associator (L₄ ⋙ R₄) R₂).inv,
                  counit :=
                    (R₄.associator R₂ (L₂ ⋙ L₄)).hom ≫ whiskerLeft R₄ (whiskerRight adj₂.counit L₄) ≫ adj₄.counit,
                  homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit ≫
            whiskerRight (whiskerLeft (R₃ ⋙ R₁) α) (R₄ ⋙ R₂) ≫
              whiskerRight
                { homEquiv := fun X Z => (adj₃.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (R₃.obj Z)),
                    unit := adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₃.unit R₁) ≫ (L₁.associator (L₃ ⋙ R₃) R₁).inv,
                    counit :=
                      (R₃.associator R₁ (L₁ ⋙ L₃)).hom ≫ whiskerLeft R₃ (whiskerRight adj₁.counit L₃) ≫ adj₃.counit,
                    homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit
                (K ⋙ R₄ ⋙ R₂),
        invFun := fun β =>
          whiskerRight
              { homEquiv := fun X Z => (adj₃.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (R₃.obj Z)),
                  unit := adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₃.unit R₁) ≫ (L₁.associator (L₃ ⋙ R₃) R₁).inv,
                  counit :=
                    (R₃.associator R₁ (L₁ ⋙ L₃)).hom ≫ whiskerLeft R₃ (whiskerRight adj₁.counit L₃) ≫ adj₃.counit,
                  homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit
              (G ⋙ L₂ ⋙ L₄) ≫
            whiskerRight (whiskerLeft (L₁ ⋙ L₃) β) (L₂ ⋙ L₄) ≫
              whiskerLeft ((L₁ ⋙ L₃) ⋙ K)
                { homEquiv := fun X Z => (adj₄.homEquiv (L₂.obj X) Z).trans (adj₂.homEquiv X (R₄.obj Z)),
                    unit := adj₂.unit ≫ whiskerLeft L₂ (whiskerRight adj₄.unit R₂) ≫ (L₂.associator (L₄ ⋙ R₄) R₂).inv,
                    counit :=
                      (R₄.associator R₂ (L₂ ⋙ L₄)).hom ≫ whiskerLeft R₄ (whiskerRight adj₂.counit L₄) ≫ adj₄.counit,
                    homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit,
        left_inv := ⋯, right_inv := ⋯ }
      (whiskerRight α L₄ ≫ whiskerLeft L₁ β) =
    whiskerLeft R₃
        ({
            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
        ({
            toFun := fun α =>
              whiskerLeft (R₃ ⋙ H) adj₄.unit ≫ whiskerRight (whiskerLeft R₃ α) R₄ ≫ whiskerRight adj₃.counit (K ⋙ R₄),
            invFun := fun β =>
              whiskerRight adj₃.unit (H ⋙ L₄) ≫ whiskerRight (whiskerLeft L₃ β) L₄ ≫ whiskerLeft (L₃ ⋙ K) adj₄.counit,
            left_inv := ⋯, right_inv := ⋯ }
          β)
        R₂
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ ({
            toFun := fun α =>
              whiskerLeft ((R₃ ⋙ R₁) ⋙ G)
                  { homEquiv := fun X Z => (adj₄.homEquiv (L₂.obj X) Z).trans (adj₂.homEquiv X (R₄.obj Z)),
                      unit := adj₂.unit ≫ whiskerLeft L₂ (whiskerRight adj₄.unit R₂) ≫ (L₂.associator (L₄ ⋙ R₄) R₂).inv,
                      counit :=
                        (R₄.associator R₂ (L₂ ⋙ L₄)).hom ≫ whiskerLeft R₄ (whiskerRight adj₂.counit L₄) ≫ adj₄.counit,
                      homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit ≫
                whiskerRight (whiskerLeft (R₃ ⋙ R₁) α) (R₄ ⋙ R₂) ≫
                  whiskerRight
                    { homEquiv := fun X Z => (adj₃.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (R₃.obj Z)),
                        unit :=
                          adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₃.unit R₁) ≫ (L₁.associator (L₃ ⋙ R₃) R₁).inv,
                        counit :=
                          (R₃.associator R₁ (L₁ ⋙ L₃)).hom ≫ whiskerLeft R₃ (whiskerRight adj₁.counit L₃) ≫ adj₃.counit,
                        homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit
                    (K ⋙ R₄ ⋙ R₂),
            invFun := fun β =>
              whiskerRight
                  { homEquiv := fun X Z => (adj₃.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (R₃.obj Z)),
                      unit := adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₃.unit R₁) ≫ (L₁.associator (L₃ ⋙ R₃) R₁).inv,
                      counit :=
                        (R₃.associator R₁ (L₁ ⋙ L₃)).hom ≫ whiskerLeft R₃ (whiskerRight adj₁.counit L₃) ≫ adj₃.counit,
                      homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit
                  (G ⋙ L₂ ⋙ L₄) ≫
                whiskerRight (whiskerLeft (L₁ ⋙ L₃) β) (L₂ ⋙ L₄) ≫
                  whiskerLeft ((L₁ ⋙ L₃) ⋙ K)
                    { homEquiv := fun X Z => (adj₄.homEquiv (L₂.obj X) Z).trans (adj₂.homEquiv X (R₄.obj Z)),
                        unit :=
                          adj₂.unit ≫ whiskerLeft L₂ (whiskerRight adj₄.unit R₂) ≫ (L₂.associator (L₄ ⋙ R₄) R₂).inv,
                        counit :=
                          (R₄.associator R₂ (L₂ ⋙ L₄)).hom ≫ whiskerLeft R₄ (whiskerRight adj₂.counit L₄) ≫ adj₄.counit,
                        homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit,
            left_inv := ⋯, right_inv := ⋯ }
          (whiskerRight α L₄ ≫ whiskerLeft L₁ β)).app
      c =
    (whiskerLeft R₃
            ({
                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
            ({
                toFun := fun α =>
                  whiskerLeft (R₃ ⋙ H) adj₄.unit ≫
                    whiskerRight (whiskerLeft R₃ α) R₄ ≫ whiskerRight adj₃.counit (K ⋙ R₄),
                invFun := fun β =>
                  whiskerRight adj₃.unit (H ⋙ L₄) ≫
                    whiskerRight (whiskerLeft L₃ β) L₄ ≫ whiskerLeft (L₃ ⋙ K) adj₄.counit,
                left_inv := ⋯, right_inv := ⋯ }
              β)
            R₂).app
      c
tactic: ext c
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ ({
            toFun := fun α =>
              whiskerLeft ((R₃ ⋙ R₁) ⋙ G)
                  { homEquiv := fun X Z => (adj₄.homEquiv (L₂.obj X) Z).trans (adj₂.homEquiv X (R₄.obj Z)),
                      unit := adj₂.unit ≫ whiskerLeft L₂ (whiskerRight adj₄.unit R₂) ≫ (L₂.associator (L₄ ⋙ R₄) R₂).inv,
                      counit :=
                        (R₄.associator R₂ (L₂ ⋙ L₄)).hom ≫ whiskerLeft R₄ (whiskerRight adj₂.counit L₄) ≫ adj₄.counit,
                      homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit ≫
                whiskerRight (whiskerLeft (R₃ ⋙ R₁) α) (R₄ ⋙ R₂) ≫
                  whiskerRight
                    { homEquiv := fun X Z => (adj₃.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (R₃.obj Z)),
                        unit :=
                          adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₃.unit R₁) ≫ (L₁.associator (L₃ ⋙ R₃) R₁).inv,
                        counit :=
                          (R₃.associator R₁ (L₁ ⋙ L₃)).hom ≫ whiskerLeft R₃ (whiskerRight adj₁.counit L₃) ≫ adj₃.counit,
                        homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit
                    (K ⋙ R₄ ⋙ R₂),
            invFun := fun β =>
              whiskerRight
                  { homEquiv := fun X Z => (adj₃.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (R₃.obj Z)),
                      unit := adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₃.unit R₁) ≫ (L₁.associator (L₃ ⋙ R₃) R₁).inv,
                      counit :=
                        (R₃.associator R₁ (L₁ ⋙ L₃)).hom ≫ whiskerLeft R₃ (whiskerRight adj₁.counit L₃) ≫ adj₃.counit,
                      homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit
                  (G ⋙ L₂ ⋙ L₄) ≫
                whiskerRight (whiskerLeft (L₁ ⋙ L₃) β) (L₂ ⋙ L₄) ≫
                  whiskerLeft ((L₁ ⋙ L₃) ⋙ K)
                    { homEquiv := fun X Z => (adj₄.homEquiv (L₂.obj X) Z).trans (adj₂.homEquiv X (R₄.obj Z)),
                        unit :=
                          adj₂.unit ≫ whiskerLeft L₂ (whiskerRight adj₄.unit R₂) ≫ (L₂.associator (L₄ ⋙ R₄) R₂).inv,
                        counit :=
                          (R₄.associator R₂ (L₂ ⋙ L₄)).hom ≫ whiskerLeft R₄ (whiskerRight adj₂.counit L₄) ≫ adj₄.counit,
                        homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit,
            left_inv := ⋯, right_inv := ⋯ }
          (whiskerRight α L₄ ≫ whiskerLeft L₁ β)).app
      c =
    (whiskerLeft R₃
            ({
                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
            ({
                toFun := fun α =>
                  whiskerLeft (R₃ ⋙ H) adj₄.unit ≫
                    whiskerRight (whiskerLeft R₃ α) R₄ ≫ whiskerRight adj₃.counit (K ⋙ R₄),
                invFun := fun β =>
                  whiskerRight adj₃.unit (H ⋙ L₄) ≫
                    whiskerRight (whiskerLeft L₃ β) L₄ ≫ whiskerLeft (L₃ ⋙ K) adj₄.counit,
                left_inv := ⋯, right_inv := ⋯ }
              β)
            R₂).app
      c
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (K.map (L₃.map (adj₁.counit.app (R₃.obj c))))) ≫
              R₂.map (R₄.map (K.map (adj₃.counit.app c))) =
    adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (α.app (R₁.obj (R₃.obj c))) ≫
        R₂.map (H.map (adj₁.counit.app (R₃.obj c))) ≫
          R₂.map (adj₄.unit.app (H.obj (R₃.obj c))) ≫
            R₂.map (R₄.map (β.app (R₃.obj c))) ≫ R₂.map (R₄.map (K.map (adj₃.counit.app c)))
tactic: simp only [comp_obj, whiskerLeft_comp, whiskerLeft_twice, whiskerRight_comp, assoc,
    Equiv.coe_fn_mk, comp_app, whiskerLeft_app, whiskerRight_app, id_obj, associator_inv_app,
    Functor.comp_map, associator_hom_app, map_id, id_comp, whiskerRight_twice]
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (K.map (L₃.map (adj₁.counit.app (R₃.obj c))))) ≫
              R₂.map (R₄.map (K.map (adj₃.counit.app c))) =
    adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (α.app (R₁.obj (R₃.obj c))) ≫
        R₂.map (H.map (adj₁.counit.app (R₃.obj c))) ≫
          R₂.map (adj₄.unit.app (H.obj (R₃.obj c))) ≫
            R₂.map (R₄.map (β.app (R₃.obj c))) ≫ R₂.map (R₄.map (K.map (adj₃.counit.app c)))
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (K.map (L₃.map (adj₁.counit.app (R₃.obj c))))) ≫
              R₂.map (R₄.map (K.map (adj₃.counit.app c))) =
    adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      (R₂.map
            (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c)))) ≫
              R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c)) ≫ H.map (adj₁.counit.app (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (R₃.obj c)))) ≫
        R₂.map (R₄.map (K.map (adj₃.counit.app c)))
tactic: slice_rhs 2 4 =>
    {
      rw [← R₂.map_comp, ← R₂.map_comp, ← assoc, ← unit_naturality (adj₄)]
    }
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (K.map (L₃.map (adj₁.counit.app (R₃.obj c))))) ≫
              R₂.map (R₄.map (K.map (adj₃.counit.app c))) =
    adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      (R₂.map
            (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c)))) ≫
              R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c)) ≫ H.map (adj₁.counit.app (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (R₃.obj c)))) ≫
        R₂.map (R₄.map (K.map (adj₃.counit.app c)))
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (K.map (L₃.map (adj₁.counit.app (R₃.obj c))))) ≫
              R₂.map (R₄.map (K.map (adj₃.counit.app c))) =
    adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      ((R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
              R₂.map (R₄.map (L₄.map (H.map (adj₁.counit.app (R₃.obj c)))))) ≫
          R₂.map (R₄.map (β.app (R₃.obj c)))) ≫
        R₂.map (R₄.map (K.map (adj₃.counit.app c)))
tactic: rw [R₂.map_comp, L₄.map_comp, R₄.map_comp, R₂.map_comp]
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (K.map (L₃.map (adj₁.counit.app (R₃.obj c))))) ≫
              R₂.map (R₄.map (K.map (adj₃.counit.app c))) =
    adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      ((R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
              R₂.map (R₄.map (L₄.map (H.map (adj₁.counit.app (R₃.obj c)))))) ≫
          R₂.map (R₄.map (β.app (R₃.obj c)))) ≫
        R₂.map (R₄.map (K.map (adj₃.counit.app c)))
state_after: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (K.map (L₃.map (adj₁.counit.app (R₃.obj c))))) ≫
              R₂.map (R₄.map (K.map (adj₃.counit.app c))) =
    adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))) ≫ (L₃ ⋙ K).map (adj₁.counit.app (R₃.obj c)))) ≫
            R₂.map (R₄.map (K.map (adj₃.counit.app c)))
tactic: slice_rhs 4 5 =>
    {
      rw [← R₂.map_comp, ← R₄.map_comp, ← Functor.comp_map _ L₄ , β.naturality]
    }
state_before: case w.h
A : Type u₁
B : Type u₂
C : Type u₃
D : Type u₄
E : Type u₅
F : Type u₆
inst✝⁵ : Category.{v₁, u₁} A
inst✝⁴ : Category.{v₂, u₂} B
inst✝³ : Category.{v₃, u₃} C
inst✝² : Category.{v₄, u₄} D
inst✝¹ : Category.{v₅, u₅} E
inst✝ : Category.{v₆, u₆} F
G : A ⥤ D
H : B ⥤ E
K : C ⥤ F
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : D ⥤ E
R₂ : E ⥤ D
L₃ : B ⥤ C
R₃ : C ⥤ B
L₄ : E ⥤ F
R₄ : F ⥤ E
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
adj₄ : L₄ ⊣ R₄
α : G ⋙ L₂ ⟶ L₁ ⋙ H
β : H ⋙ L₄ ⟶ L₃ ⋙ K
c : C
⊢ adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))))) ≫
            R₂.map (R₄.map (K.map (L₃.map (adj₁.counit.app (R₃.obj c))))) ≫
              R₂.map (R₄.map (K.map (adj₃.counit.app c))) =
    adj₂.unit.app (G.obj (R₁.obj (R₃.obj c))) ≫
      R₂.map (adj₄.unit.app (L₂.obj (G.obj (R₁.obj (R₃.obj c))))) ≫
        R₂.map (R₄.map (L₄.map (α.app (R₁.obj (R₃.obj c))))) ≫
          R₂.map (R₄.map (β.app (L₁.obj (R₁.obj (R₃.obj c))) ≫ (L₃ ⋙ K).map (adj₁.counit.app (R₃.obj c)))) ≫
            R₂.map (R₄.map (K.map (adj₃.counit.app c)))
state_after: no goals
tactic: simp only [comp_obj, Functor.comp_map, map_comp, assoc]