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

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
⊢ (conjugateEquiv adj₁ adj₂) α ≫ (conjugateEquiv adj₂ adj₃) β = (conjugateEquiv adj₁ adj₃) (β ≫ α)
state_after: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
⊢ ((conjugateEquiv adj₁ adj₂) α ≫ (conjugateEquiv adj₂ adj₃) β).app d = ((conjugateEquiv adj₁ adj₃) (β ≫ α)).app d
tactic: ext d
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
⊢ ((conjugateEquiv adj₁ adj₂) α ≫ (conjugateEquiv adj₂ adj₃) β).app d = ((conjugateEquiv adj₁ adj₃) (β ≫ α)).app d
state_after: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
tactic: dsimp [conjugateEquiv, mateEquiv]
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
state_after: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
tactic: have vcomp := mateEquiv_vcomp adj₁ adj₂ adj₃
    (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
    (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
state_after: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompd :
  ((mateEquiv adj₁ adj₃)
          (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
            (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))).app
      d =
    (rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
          ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))).app
      d
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
tactic: have vcompd := congr_app vcomp d
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompd :
  ((mateEquiv adj₁ adj₃)
          (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
            (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))).app
      d =
    (rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
          ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))).app
      d
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
state_after: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompd :
  adj₃.unit.app (R₁.obj d) ≫
      R₃.map
          ((𝟙 (L₃.obj (R₁.obj d)) ≫ β.app (R₁.obj d) ≫ 𝟙 (L₂.obj (R₁.obj d))) ≫
            𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
        R₃.map (adj₁.counit.app d) =
    (adj₂.unit.app (R₁.obj d) ≫
        R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
      adj₃.unit.app (R₂.obj d) ≫
        R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
tactic: dsimp [mateEquiv, leftAdjointSquare.vcomp, rightAdjointSquare.vcomp] at vcompd
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompd :
  adj₃.unit.app (R₁.obj d) ≫
      R₃.map
          ((𝟙 (L₃.obj (R₁.obj d)) ≫ β.app (R₁.obj d) ≫ 𝟙 (L₂.obj (R₁.obj d))) ≫
            𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
        R₃.map (adj₁.counit.app d) =
    (adj₂.unit.app (R₁.obj d) ≫
        R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
      adj₃.unit.app (R₂.obj d) ≫
        R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
state_after: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompd :
  adj₃.unit.app (R₁.obj d) ≫ R₃.map (β.app (R₁.obj d)) ≫ R₃.map (α.app (R₁.obj d)) ≫ R₃.map (adj₁.counit.app d) =
    adj₂.unit.app (R₁.obj d) ≫
      R₂.map (α.app (R₁.obj d)) ≫
        R₂.map (adj₁.counit.app d) ≫ adj₃.unit.app (R₂.obj d) ≫ R₃.map (β.app (R₂.obj d)) ≫ R₃.map (adj₂.counit.app d)
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
tactic: simp at vcompd
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompd :
  adj₃.unit.app (R₁.obj d) ≫ R₃.map (β.app (R₁.obj d)) ≫ R₃.map (α.app (R₁.obj d)) ≫ R₃.map (adj₁.counit.app d) =
    adj₂.unit.app (R₁.obj d) ≫
      R₂.map (α.app (R₁.obj d)) ≫
        R₂.map (adj₁.counit.app d) ≫ adj₃.unit.app (R₂.obj d) ≫ R₃.map (β.app (R₂.obj d)) ≫ R₃.map (adj₂.counit.app d)
⊢ (𝟙 (R₁.obj d) ≫
        (adj₂.unit.app (R₁.obj d) ≫
            R₂.map (𝟙 (L₂.obj (R₁.obj d)) ≫ α.app (R₁.obj d) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫ R₂.map (adj₁.counit.app d)) ≫
          𝟙 (R₂.obj d)) ≫
      𝟙 (R₂.obj d) ≫
        (adj₃.unit.app (R₂.obj d) ≫
            R₃.map (𝟙 (L₃.obj (R₂.obj d)) ≫ β.app (R₂.obj d) ≫ 𝟙 (L₂.obj (R₂.obj d))) ≫ R₃.map (adj₂.counit.app d)) ≫
          𝟙 (R₃.obj d) =
    𝟙 (R₁.obj d) ≫
      (adj₃.unit.app (R₁.obj d) ≫
          R₃.map (𝟙 (L₃.obj (R₁.obj d)) ≫ (β.app (R₁.obj d) ≫ α.app (R₁.obj d)) ≫ 𝟙 (L₁.obj (R₁.obj d))) ≫
            R₃.map (adj₁.counit.app d)) ≫
        𝟙 (R₃.obj d)
state_after: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompd :
  adj₃.unit.app (R₁.obj d) ≫ R₃.map (β.app (R₁.obj d)) ≫ R₃.map (α.app (R₁.obj d)) ≫ R₃.map (adj₁.counit.app d) =
    adj₂.unit.app (R₁.obj d) ≫
      R₂.map (α.app (R₁.obj d)) ≫
        R₂.map (adj₁.counit.app d) ≫ adj₃.unit.app (R₂.obj d) ≫ R₃.map (β.app (R₂.obj d)) ≫ R₃.map (adj₂.counit.app d)
⊢ adj₂.unit.app (R₁.obj d) ≫
      R₂.map (α.app (R₁.obj d)) ≫
        R₂.map (adj₁.counit.app d) ≫ adj₃.unit.app (R₂.obj d) ≫ R₃.map (β.app (R₂.obj d)) ≫ R₃.map (adj₂.counit.app d) =
    adj₃.unit.app (R₁.obj d) ≫ R₃.map (β.app (R₁.obj d)) ≫ R₃.map (α.app (R₁.obj d)) ≫ R₃.map (adj₁.counit.app d)
tactic: simp only [comp_id, id_comp, assoc, map_comp]
state_before: case w.h
C : Type u₁
D : Type u₂
inst✝¹ : Category.{v₁, u₁} C
inst✝ : Category.{v₂, u₂} D
L₁ L₂ L₃ : C ⥤ D
R₁ R₂ R₃ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : L₃ ⊣ R₃
α : L₂ ⟶ L₁
β : L₃ ⟶ L₂
d : D
vcomp :
  (mateEquiv adj₁ adj₃)
      (leftAdjointSquare.vcomp (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv)
        (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv)) =
    rightAdjointSquare.vcomp ((mateEquiv adj₁ adj₂) (L₂.leftUnitor.hom ≫ α ≫ L₁.rightUnitor.inv))
      ((mateEquiv adj₂ adj₃) (L₃.leftUnitor.hom ≫ β ≫ L₂.rightUnitor.inv))
vcompd :
  adj₃.unit.app (R₁.obj d) ≫ R₃.map (β.app (R₁.obj d)) ≫ R₃.map (α.app (R₁.obj d)) ≫ R₃.map (adj₁.counit.app d) =
    adj₂.unit.app (R₁.obj d) ≫
      R₂.map (α.app (R₁.obj d)) ≫
        R₂.map (adj₁.counit.app d) ≫ adj₃.unit.app (R₂.obj d) ≫ R₃.map (β.app (R₂.obj d)) ≫ R₃.map (adj₂.counit.app d)
⊢ adj₂.unit.app (R₁.obj d) ≫
      R₂.map (α.app (R₁.obj d)) ≫
        R₂.map (adj₁.counit.app d) ≫ adj₃.unit.app (R₂.obj d) ≫ R₃.map (β.app (R₂.obj d)) ≫ R₃.map (adj₂.counit.app d) =
    adj₃.unit.app (R₁.obj d) ≫ R₃.map (β.app (R₁.obj d)) ≫ R₃.map (α.app (R₁.obj d)) ≫ R₃.map (adj₁.counit.app d)
state_after: no goals
tactic: rw [vcompd]