Theorem: CategoryTheory.iterated_mateEquiv_conjugateEquiv
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
F₁ : A ⥤ C
U₁ : C ⥤ A
F₂ : B ⥤ D
U₂ : D ⥤ B
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : F₁ ⊣ U₁
adj₄ : F₂ ⊣ U₂
α : F₁ ⋙ L₂ ⟶ L₁ ⋙ F₂
⊢ (mateEquiv adj₄ adj₃) ((mateEquiv adj₁ adj₂) α) = (conjugateEquiv (adj₁.comp adj₄) (adj₃.comp 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
F₁ : A ⥤ C
U₁ : C ⥤ A
F₂ : B ⥤ D
U₂ : D ⥤ B
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : F₁ ⊣ U₁
adj₄ : F₂ ⊣ U₂
α : F₁ ⋙ L₂ ⟶ L₁ ⋙ F₂
d : D
⊢ ((mateEquiv adj₄ adj₃) ((mateEquiv adj₁ adj₂) α)).app d = ((conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)) α).app d
tactic: ext d
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
F₁ : A ⥤ C
U₁ : C ⥤ A
F₂ : B ⥤ D
U₂ : D ⥤ B
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : F₁ ⊣ U₁
adj₄ : F₂ ⊣ U₂
α : F₁ ⋙ L₂ ⟶ L₁ ⋙ F₂
d : D
⊢ ((mateEquiv adj₄ adj₃) ((mateEquiv adj₁ adj₂) α)).app d = ((conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)) α).app d
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
F₁ : A ⥤ C
U₁ : C ⥤ A
F₂ : B ⥤ D
U₂ : D ⥤ B
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : F₁ ⊣ U₁
adj₄ : F₂ ⊣ U₂
α : F₁ ⋙ L₂ ⟶ L₁ ⋙ F₂
d : D
⊢ ({
            toFun := fun α =>
              whiskerLeft (U₂ ⋙ R₁) adj₃.unit ≫ whiskerRight (whiskerLeft U₂ α) U₁ ≫ whiskerRight adj₄.counit (R₂ ⋙ U₁),
            invFun := fun β =>
              whiskerRight adj₄.unit (R₁ ⋙ F₁) ≫ whiskerRight (whiskerLeft F₂ β) F₁ ≫ whiskerLeft (F₂ ⋙ R₂) adj₃.counit,
            left_inv := ⋯, right_inv := ⋯ }
          ({
              toFun := fun α =>
                whiskerLeft (R₁ ⋙ F₁) adj₂.unit ≫
                  whiskerRight (whiskerLeft R₁ α) R₂ ≫ whiskerRight adj₁.counit (F₂ ⋙ R₂),
              invFun := fun β =>
                whiskerRight adj₁.unit (F₁ ⋙ L₂) ≫
                  whiskerRight (whiskerLeft L₁ β) L₂ ≫ whiskerLeft (L₁ ⋙ F₂) adj₂.counit,
              left_inv := ⋯, right_inv := ⋯ }
            α)).app
      d =
    ((Trans.trans
            (Trans.trans ((F₁ ⋙ L₂).leftUnitor.homCongr (L₁ ⋙ F₂).rightUnitor).symm
              {
                toFun := fun α =>
                  whiskerLeft ((U₂ ⋙ R₁) ⋙ 𝟭 A)
                      { homEquiv := fun X Z => (adj₂.homEquiv (F₁.obj X) Z).trans (adj₃.homEquiv X (R₂.obj Z)),
                          unit :=
                            adj₃.unit ≫ whiskerLeft F₁ (whiskerRight adj₂.unit U₁) ≫ (F₁.associator (L₂ ⋙ R₂) U₁).inv,
                          counit :=
                            (R₂.associator U₁ (F₁ ⋙ L₂)).hom ≫
                              whiskerLeft R₂ (whiskerRight adj₃.counit L₂) ≫ adj₂.counit,
                          homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit ≫
                    whiskerRight (whiskerLeft (U₂ ⋙ R₁) α) (R₂ ⋙ U₁) ≫
                      whiskerRight
                        { homEquiv := fun X Z => (adj₄.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (U₂.obj Z)),
                            unit :=
                              adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₄.unit R₁) ≫ (L₁.associator (F₂ ⋙ U₂) R₁).inv,
                            counit :=
                              (U₂.associator R₁ (L₁ ⋙ F₂)).hom ≫
                                whiskerLeft U₂ (whiskerRight adj₁.counit F₂) ≫ adj₄.counit,
                            homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit
                        (𝟭 D ⋙ R₂ ⋙ U₁),
                invFun := fun β =>
                  whiskerRight
                      { homEquiv := fun X Z => (adj₄.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (U₂.obj Z)),
                          unit :=
                            adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₄.unit R₁) ≫ (L₁.associator (F₂ ⋙ U₂) R₁).inv,
                          counit :=
                            (U₂.associator R₁ (L₁ ⋙ F₂)).hom ≫
                              whiskerLeft U₂ (whiskerRight adj₁.counit F₂) ≫ adj₄.counit,
                          homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit
                      (𝟭 A ⋙ F₁ ⋙ L₂) ≫
                    whiskerRight (whiskerLeft (L₁ ⋙ F₂) β) (F₁ ⋙ L₂) ≫
                      whiskerLeft ((L₁ ⋙ F₂) ⋙ 𝟭 D)
                        { homEquiv := fun X Z => (adj₂.homEquiv (F₁.obj X) Z).trans (adj₃.homEquiv X (R₂.obj Z)),
                            unit :=
                              adj₃.unit ≫ whiskerLeft F₁ (whiskerRight adj₂.unit U₁) ≫ (F₁.associator (L₂ ⋙ R₂) U₁).inv,
                            counit :=
                              (R₂.associator U₁ (F₁ ⋙ L₂)).hom ≫
                                whiskerLeft R₂ (whiskerRight adj₃.counit L₂) ≫ adj₂.counit,
                            homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit,
                left_inv := ⋯, right_inv := ⋯ })
            ((U₂ ⋙ R₁).rightUnitor.homCongr (R₂ ⋙ U₁).leftUnitor))
          α).app
      d
tactic: unfold conjugateEquiv mateEquiv Adjunction.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
F₁ : A ⥤ C
U₁ : C ⥤ A
F₂ : B ⥤ D
U₂ : D ⥤ B
L₁ : A ⥤ B
R₁ : B ⥤ A
L₂ : C ⥤ D
R₂ : D ⥤ C
adj₁ : L₁ ⊣ R₁
adj₂ : L₂ ⊣ R₂
adj₃ : F₁ ⊣ U₁
adj₄ : F₂ ⊣ U₂
α : F₁ ⋙ L₂ ⟶ L₁ ⋙ F₂
d : D
⊢ ({
            toFun := fun α =>
              whiskerLeft (U₂ ⋙ R₁) adj₃.unit ≫ whiskerRight (whiskerLeft U₂ α) U₁ ≫ whiskerRight adj₄.counit (R₂ ⋙ U₁),
            invFun := fun β =>
              whiskerRight adj₄.unit (R₁ ⋙ F₁) ≫ whiskerRight (whiskerLeft F₂ β) F₁ ≫ whiskerLeft (F₂ ⋙ R₂) adj₃.counit,
            left_inv := ⋯, right_inv := ⋯ }
          ({
              toFun := fun α =>
                whiskerLeft (R₁ ⋙ F₁) adj₂.unit ≫
                  whiskerRight (whiskerLeft R₁ α) R₂ ≫ whiskerRight adj₁.counit (F₂ ⋙ R₂),
              invFun := fun β =>
                whiskerRight adj₁.unit (F₁ ⋙ L₂) ≫
                  whiskerRight (whiskerLeft L₁ β) L₂ ≫ whiskerLeft (L₁ ⋙ F₂) adj₂.counit,
              left_inv := ⋯, right_inv := ⋯ }
            α)).app
      d =
    ((Trans.trans
            (Trans.trans ((F₁ ⋙ L₂).leftUnitor.homCongr (L₁ ⋙ F₂).rightUnitor).symm
              {
                toFun := fun α =>
                  whiskerLeft ((U₂ ⋙ R₁) ⋙ 𝟭 A)
                      { homEquiv := fun X Z => (adj₂.homEquiv (F₁.obj X) Z).trans (adj₃.homEquiv X (R₂.obj Z)),
                          unit :=
                            adj₃.unit ≫ whiskerLeft F₁ (whiskerRight adj₂.unit U₁) ≫ (F₁.associator (L₂ ⋙ R₂) U₁).inv,
                          counit :=
                            (R₂.associator U₁ (F₁ ⋙ L₂)).hom ≫
                              whiskerLeft R₂ (whiskerRight adj₃.counit L₂) ≫ adj₂.counit,
                          homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit ≫
                    whiskerRight (whiskerLeft (U₂ ⋙ R₁) α) (R₂ ⋙ U₁) ≫
                      whiskerRight
                        { homEquiv := fun X Z => (adj₄.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (U₂.obj Z)),
                            unit :=
                              adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₄.unit R₁) ≫ (L₁.associator (F₂ ⋙ U₂) R₁).inv,
                            counit :=
                              (U₂.associator R₁ (L₁ ⋙ F₂)).hom ≫
                                whiskerLeft U₂ (whiskerRight adj₁.counit F₂) ≫ adj₄.counit,
                            homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit
                        (𝟭 D ⋙ R₂ ⋙ U₁),
                invFun := fun β =>
                  whiskerRight
                      { homEquiv := fun X Z => (adj₄.homEquiv (L₁.obj X) Z).trans (adj₁.homEquiv X (U₂.obj Z)),
                          unit :=
                            adj₁.unit ≫ whiskerLeft L₁ (whiskerRight adj₄.unit R₁) ≫ (L₁.associator (F₂ ⋙ U₂) R₁).inv,
                          counit :=
                            (U₂.associator R₁ (L₁ ⋙ F₂)).hom ≫
                              whiskerLeft U₂ (whiskerRight adj₁.counit F₂) ≫ adj₄.counit,
                          homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.unit
                      (𝟭 A ⋙ F₁ ⋙ L₂) ≫
                    whiskerRight (whiskerLeft (L₁ ⋙ F₂) β) (F₁ ⋙ L₂) ≫
                      whiskerLeft ((L₁ ⋙ F₂) ⋙ 𝟭 D)
                        { homEquiv := fun X Z => (adj₂.homEquiv (F₁.obj X) Z).trans (adj₃.homEquiv X (R₂.obj Z)),
                            unit :=
                              adj₃.unit ≫ whiskerLeft F₁ (whiskerRight adj₂.unit U₁) ≫ (F₁.associator (L₂ ⋙ R₂) U₁).inv,
                            counit :=
                              (R₂.associator U₁ (F₁ ⋙ L₂)).hom ≫
                                whiskerLeft R₂ (whiskerRight adj₃.counit L₂) ≫ adj₂.counit,
                            homEquiv_unit := ⋯, homEquiv_counit := ⋯ }.counit,
                left_inv := ⋯, right_inv := ⋯ })
            ((U₂ ⋙ R₁).rightUnitor.homCongr (R₂ ⋙ U₁).leftUnitor))
          α).app
      d
state_after: no goals
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, associator_inv_app, leftUnitor_hom_app, map_id, associator_hom_app,
    Functor.id_map, comp_id, id_comp]