File: Mathlib/CategoryTheory/Adjunction/Mates.lean

full_name: CategoryTheory.mateEquiv_apply
code: /-- Suppose we have a square of functors (where the top and bottom are adjunctions `L₁ ⊣ R₁`
and `L₂ ⊣ R₂` respectively).

      C ↔ D
    G ↓   ↓ H
      E ↔ F

Then we have a bijection between natural transformations `G ⋙ L₂ ⟶ L₁ ⋙ H` and
`R₁ ⋙ G ⟶ H ⋙ R₂`. This can be seen as a bijection of the 2-cells:

         L₁                  R₁
      C --→ D             C ←-- D
    G ↓  ↗  ↓ H         G ↓  ↘  ↓ H
      E --→ F             E ←-- F
         L₂                  R₂

Note that if one of the transformations is an iso, it does not imply the other is an iso.
-/
@[simps]
def mateEquiv : (G ⋙ L₂ ⟶ L₁ ⋙ H) ≃ (R₁ ⋙ G ⟶ H ⋙ R₂) 
goal: (CategoryTheory.mateEquiv adj₁ adj₂) α =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerLeft (R₁.comp G) adj₂.unit)
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight (CategoryTheory.whiskerLeft R₁ α) R₂)
      (CategoryTheory.whiskerRight adj₁.counit (H.comp R₂)))

full_name: CategoryTheory.mateEquiv
code: /-- Suppose we have a square of functors (where the top and bottom are adjunctions `L₁ ⊣ R₁`
and `L₂ ⊣ R₂` respectively).

      C ↔ D
    G ↓   ↓ H
      E ↔ F

Then we have a bijection between natural transformations `G ⋙ L₂ ⟶ L₁ ⋙ H` and
`R₁ ⋙ G ⟶ H ⋙ R₂`. This can be seen as a bijection of the 2-cells:

         L₁                  R₁
      C --→ D             C ←-- D
    G ↓  ↗  ↓ H         G ↓  ↘  ↓ H
      E --→ F             E ←-- F
         L₂                  R₂

Note that if one of the transformations is an iso, it does not imply the other is an iso.
-/
@[simps]
def mateEquiv : (G ⋙ L₂ ⟶ L₁ ⋙ H) ≃ (R₁ ⋙ G ⟶ H ⋙ R₂) 
goal: (G.comp L₂ ⟶ L₁.comp H) ≃ (R₁.comp G ⟶ H.comp R₂)

full_name: CategoryTheory.mateEquiv_symm_apply
code: /-- Suppose we have a square of functors (where the top and bottom are adjunctions `L₁ ⊣ R₁`
and `L₂ ⊣ R₂` respectively).

      C ↔ D
    G ↓   ↓ H
      E ↔ F

Then we have a bijection between natural transformations `G ⋙ L₂ ⟶ L₁ ⋙ H` and
`R₁ ⋙ G ⟶ H ⋙ R₂`. This can be seen as a bijection of the 2-cells:

         L₁                  R₁
      C --→ D             C ←-- D
    G ↓  ↗  ↓ H         G ↓  ↘  ↓ H
      E --→ F             E ←-- F
         L₂                  R₂

Note that if one of the transformations is an iso, it does not imply the other is an iso.
-/
@[simps]
def mateEquiv : (G ⋙ L₂ ⟶ L₁ ⋙ H) ≃ (R₁ ⋙ G ⟶ H ⋙ R₂) 
goal: (CategoryTheory.mateEquiv adj₁ adj₂).symm β =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight adj₁.unit (G.comp L₂))
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.whiskerRight (CategoryTheory.whiskerLeft L₁ β) L₂)
      (CategoryTheory.whiskerLeft (L₁.comp H) adj₂.counit))

full_name: CategoryTheory.mateEquiv_counit
code: /-- A component of a transposed version of the mates correspondence. -/
theorem mateEquiv_counit (α : G ⋙ L₂ ⟶ L₁ ⋙ H) (d : D) :
    L₂.map ((mateEquiv adj₁ adj₂ α).app _) ≫ adj₂.counit.app _ =
      α.app _ ≫ H.map (adj₁.counit.app d) 
goal: CategoryTheory.CategoryStruct.comp (L₂.map (((CategoryTheory.mateEquiv adj₁ adj₂) α).app d))
    (adj₂.counit.app (H.obj d)) =
  CategoryTheory.CategoryStruct.comp (α.app (R₁.obj d)) (H.map (adj₁.counit.app d))

full_name: CategoryTheory.mateEquiv_counit_symm
code: /-- A component of a transposed version of the inverse mates correspondence. -/
theorem mateEquiv_counit_symm (α : R₁ ⋙ G ⟶ H ⋙ R₂) (d : D) :
    L₂.map (α.app _) ≫ adj₂.counit.app _ =
      ((mateEquiv adj₁ adj₂).symm α).app _ ≫ H.map (adj₁.counit.app d) 
goal: CategoryTheory.CategoryStruct.comp (L₂.map (α.app d)) (adj₂.counit.app (H.obj d)) =
  CategoryTheory.CategoryStruct.comp (((CategoryTheory.mateEquiv adj₁ adj₂).symm α).app (R₁.obj d))
    (H.map (adj₁.counit.app d))

full_name: CategoryTheory.unit_mateEquiv
code: theorem unit_mateEquiv (α : G ⋙ L₂ ⟶ L₁ ⋙ H) (c : C) :
    G.map (adj₁.unit.app c) ≫ (mateEquiv adj₁ adj₂ α).app _ =
      adj₂.unit.app _ ≫ R₂.map (α.app _) 
goal: CategoryTheory.CategoryStruct.comp (G.map (adj₁.unit.app c)) (((CategoryTheory.mateEquiv adj₁ adj₂) α).app (L₁.obj c)) =
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app (G.obj ((CategoryTheory.Functor.id C).obj c)))
    (R₂.map (α.app ((CategoryTheory.Functor.id C).obj c)))

full_name: CategoryTheory.unit_mateEquiv_symm
code: /-- A component of a transposed version of the inverse mates correspondence. -/
theorem unit_mateEquiv_symm (α : R₁ ⋙ G ⟶ H ⋙ R₂) (c : C) :
    G.map (adj₁.unit.app c) ≫ α.app _ =
      adj₂.unit.app _ ≫ R₂.map (((mateEquiv adj₁ adj₂).symm α).app _) 
goal: CategoryTheory.CategoryStruct.comp (G.map (adj₁.unit.app c)) (α.app (L₁.obj c)) =
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app (G.obj ((CategoryTheory.Functor.id C).obj c)))
    (R₂.map (((CategoryTheory.mateEquiv adj₁ adj₂).symm α).app ((CategoryTheory.Functor.id C).obj c)))

full_name: CategoryTheory.leftAdjointSquare.vcomp
code: /-- Squares between left adjoints can be composed "vertically" by pasting. -/
def leftAdjointSquare.vcomp :
    (G₁ ⋙ L₂ ⟶ L₁ ⋙ H₁) → (G₂ ⋙ L₃ ⟶ L₂ ⋙ H₂) → ((G₁ ⋙ G₂) ⋙ L₃ ⟶ L₁ ⋙ (H₁ ⋙ H₂)) 
goal: (G₁.comp L₂ ⟶ L₁.comp H₁) → (G₂.comp L₃ ⟶ L₂.comp H₂) → ((G₁.comp G₂).comp L₃ ⟶ L₁.comp (H₁.comp H₂))

full_name: CategoryTheory.rightAdjointSquare.vcomp
code: /-- Squares between right adjoints can be composed "vertically" by pasting. -/
def rightAdjointSquare.vcomp :
    (R₁ ⋙ G₁ ⟶ H₁ ⋙ R₂) → (R₂ ⋙ G₂ ⟶ H₂ ⋙ R₃) → (R₁ ⋙ (G₁ ⋙ G₂) ⟶ (H₁ ⋙ H₂) ⋙ R₃) 
goal: (R₁.comp G₁ ⟶ H₁.comp R₂) → (R₂.comp G₂ ⟶ H₂.comp R₃) → (R₁.comp (G₁.comp G₂) ⟶ (H₁.comp H₂).comp R₃)

full_name: CategoryTheory.mateEquiv_vcomp
code: /-- The mates equivalence commutes with vertical composition. -/
theorem mateEquiv_vcomp
    (α : G₁ ⋙ L₂ ⟶ L₁ ⋙ H₁) (β : G₂ ⋙ L₃ ⟶ L₂ ⋙ H₂) :
    (mateEquiv (G := G₁ ⋙ G₂) (H := H₁ ⋙ H₂) adj₁ adj₃) (leftAdjointSquare.vcomp α β) =
      rightAdjointSquare.vcomp (mateEquiv adj₁ adj₂ α) (mateEquiv adj₂ adj₃ β) 
goal: (CategoryTheory.mateEquiv adj₁ adj₃) (CategoryTheory.leftAdjointSquare.vcomp α β) =
  CategoryTheory.rightAdjointSquare.vcomp ((CategoryTheory.mateEquiv adj₁ adj₂) α)
    ((CategoryTheory.mateEquiv adj₂ adj₃) β)

full_name: CategoryTheory.leftAdjointSquare.hcomp
code: /-- Squares between left adjoints can be composed "horizontally" by pasting. -/
def leftAdjointSquare.hcomp :
    (G ⋙ L₂ ⟶ L₁ ⋙ H) → (H ⋙ L₄ ⟶ L₃ ⋙ K) → (G ⋙ (L₂ ⋙ L₄) ⟶ (L₁ ⋙ L₃) ⋙ K) 
goal: (G.comp L₂ ⟶ L₁.comp H) → (H.comp L₄ ⟶ L₃.comp K) → (G.comp (L₂.comp L₄) ⟶ (L₁.comp L₃).comp K)

full_name: CategoryTheory.rightAdjointSquare.hcomp
code: /-- Squares between right adjoints can be composed "horizontally" by pasting. -/
def rightAdjointSquare.hcomp :
    (R₁ ⋙ G ⟶ H ⋙ R₂) → (R₃ ⋙ H ⟶ K ⋙ R₄) → ((R₃ ⋙ R₁) ⋙ G ⟶ K ⋙ (R₄ ⋙ R₂)) 
goal: (R₁.comp G ⟶ H.comp R₂) → (R₃.comp H ⟶ K.comp R₄) → ((R₃.comp R₁).comp G ⟶ K.comp (R₄.comp R₂))

full_name: CategoryTheory.mateEquiv_hcomp
code: /-- The mates equivalence commutes with horizontal composition of squares. -/
theorem mateEquiv_hcomp
    (α : 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₄ β) 
goal: (CategoryTheory.mateEquiv (adj₁.comp adj₃) (adj₂.comp adj₄)) (CategoryTheory.leftAdjointSquare.hcomp α β) =
  CategoryTheory.rightAdjointSquare.hcomp ((CategoryTheory.mateEquiv adj₁ adj₂) α)
    ((CategoryTheory.mateEquiv adj₃ adj₄) β)

full_name: CategoryTheory.leftAdjointSquare.comp
code: /-- Squares of squares between left adjoints can be composed by iterating vertical and horizontal
composition.
-/
def leftAdjointSquare.comp
    (α : G₁ ⋙ L₃ ⟶ L₁ ⋙ H₁) (β : H₁ ⋙ L₄ ⟶ L₂ ⋙ K₁)
    (γ : G₂ ⋙ L₅ ⟶ L₃ ⋙ H₂) (δ : H₂ ⋙ L₆ ⟶ L₄ ⋙ K₂) :
    ((G₁ ⋙ G₂) ⋙ (L₅ ⋙ L₆)) ⟶ ((L₁ ⋙ L₂) ⋙ (K₁ ⋙ K₂)) 
goal: (G₁.comp G₂).comp (L₅.comp L₆) ⟶ (L₁.comp L₂).comp (K₁.comp K₂)

full_name: CategoryTheory.leftAdjointSquare.comp_vhcomp
code: theorem leftAdjointSquare.comp_vhcomp
    (α : G₁ ⋙ L₃ ⟶ L₁ ⋙ H₁) (β : H₁ ⋙ L₄ ⟶ L₂ ⋙ K₁)
    (γ : G₂ ⋙ L₅ ⟶ L₃ ⋙ H₂) (δ : H₂ ⋙ L₆ ⟶ L₄ ⋙ K₂) :
    leftAdjointSquare.comp α β γ δ =
      leftAdjointSquare.vcomp (leftAdjointSquare.hcomp α β) (leftAdjointSquare.hcomp γ δ) 
goal: CategoryTheory.leftAdjointSquare.comp α β γ δ =
  CategoryTheory.leftAdjointSquare.vcomp (CategoryTheory.leftAdjointSquare.hcomp α β)
    (CategoryTheory.leftAdjointSquare.hcomp γ δ)

full_name: CategoryTheory.leftAdjointSquare.comp_hvcomp
code: /-- Horizontal and vertical composition of squares commutes.-/
theorem leftAdjointSquare.comp_hvcomp
    (α : G₁ ⋙ L₃ ⟶ L₁ ⋙ H₁) (β : H₁ ⋙ L₄ ⟶ L₂ ⋙ K₁)
    (γ : G₂ ⋙ L₅ ⟶ L₃ ⋙ H₂) (δ : H₂ ⋙ L₆ ⟶ L₄ ⋙ K₂) :
    leftAdjointSquare.comp α β γ δ =
      leftAdjointSquare.hcomp (leftAdjointSquare.vcomp α γ) (leftAdjointSquare.vcomp β δ) 
goal: CategoryTheory.leftAdjointSquare.comp α β γ δ =
  CategoryTheory.leftAdjointSquare.hcomp (CategoryTheory.leftAdjointSquare.vcomp α γ)
    (CategoryTheory.leftAdjointSquare.vcomp β δ)

full_name: CategoryTheory.rightAdjointSquare.comp
code: /-- Squares of squares between right adjoints can be composed by iterating vertical and horizontal
composition.
-/
def rightAdjointSquare.comp
    (α : R₁ ⋙ G₁ ⟶ H₁ ⋙ R₃) (β : R₂ ⋙ H₁ ⟶ K₁ ⋙ R₄)
    (γ : R₃ ⋙ G₂ ⟶ H₂ ⋙ R₅) (δ : R₄ ⋙ H₂ ⟶ K₂ ⋙ R₆) :
    ((R₂ ⋙ R₁) ⋙ (G₁ ⋙ G₂) ⟶ (K₁ ⋙ K₂) ⋙ (R₆ ⋙ R₅)) 
goal: (R₂.comp R₁).comp (G₁.comp G₂) ⟶ (K₁.comp K₂).comp (R₆.comp R₅)

full_name: CategoryTheory.rightAdjointSquare.comp_vhcomp
code: theorem rightAdjointSquare.comp_vhcomp
    (α : R₁ ⋙ G₁ ⟶ H₁ ⋙ R₃) (β : R₂ ⋙ H₁ ⟶ K₁ ⋙ R₄)
    (γ : R₃ ⋙ G₂ ⟶ H₂ ⋙ R₅) (δ : R₄ ⋙ H₂ ⟶ K₂ ⋙ R₆) :
    rightAdjointSquare.comp α β γ δ =
    rightAdjointSquare.vcomp (rightAdjointSquare.hcomp α β) (rightAdjointSquare.hcomp γ δ) 
goal: CategoryTheory.rightAdjointSquare.comp α β γ δ =
  CategoryTheory.rightAdjointSquare.vcomp (CategoryTheory.rightAdjointSquare.hcomp α β)
    (CategoryTheory.rightAdjointSquare.hcomp γ δ)

full_name: CategoryTheory.rightAdjointSquare.comp_hvcomp
code: /-- Horizontal and vertical composition of squares commutes.-/
theorem rightAdjointSquare.comp_hvcomp
    (α : R₁ ⋙ G₁ ⟶ H₁ ⋙ R₃) (β : R₂ ⋙ H₁ ⟶ K₁ ⋙ R₄)
    (γ : R₃ ⋙ G₂ ⟶ H₂ ⋙ R₅) (δ : R₄ ⋙ H₂ ⟶ K₂ ⋙ R₆) :
    rightAdjointSquare.comp α β γ δ =
    rightAdjointSquare.hcomp (rightAdjointSquare.vcomp α γ) (rightAdjointSquare.vcomp β δ) 
goal: CategoryTheory.rightAdjointSquare.comp α β γ δ =
  CategoryTheory.rightAdjointSquare.hcomp (CategoryTheory.rightAdjointSquare.vcomp α γ)
    (CategoryTheory.rightAdjointSquare.vcomp β δ)

full_name: CategoryTheory.mateEquiv_square
code: /-- The mates equivalence commutes with composition of squares of squares. These results form the
basis for an isomorphism of double categories to be proven later.
-/
theorem mateEquiv_square
    (α : G₁ ⋙ L₃ ⟶ L₁ ⋙ H₁) (β : H₁ ⋙ L₄ ⟶ L₂ ⋙ K₁)
    (γ : G₂ ⋙ L₅ ⟶ L₃ ⋙ H₂) (δ : H₂ ⋙ L₆ ⟶ L₄ ⋙ K₂) :
    (mateEquiv (G := G₁ ⋙ G₂) (H := K₁ ⋙ K₂) (adj₁.comp adj₂) (adj₅.comp adj₆))
        (leftAdjointSquare.comp α β γ δ) =
      rightAdjointSquare.comp
        (mateEquiv adj₁ adj₃ α) (mateEquiv adj₂ adj₄ β)
        (mateEquiv adj₃ adj₅ γ) (mateEquiv adj₄ adj₆ δ) 
goal: (CategoryTheory.mateEquiv (adj₁.comp adj₂) (adj₅.comp adj₆)) (CategoryTheory.leftAdjointSquare.comp α β γ δ) =
  CategoryTheory.rightAdjointSquare.comp ((CategoryTheory.mateEquiv adj₁ adj₃) α)
    ((CategoryTheory.mateEquiv adj₂ adj₄) β) ((CategoryTheory.mateEquiv adj₃ adj₅) γ)
    ((CategoryTheory.mateEquiv adj₄ adj₆) δ)

full_name: CategoryTheory.conjugateEquiv
code: /-- Given two adjunctions `L₁ ⊣ R₁` and `L₂ ⊣ R₂` both between categories `C`, `D`, there is a
bijection between natural transformations `L₂ ⟶ L₁` and natural transformations `R₁ ⟶ R₂`. This is
defined as a special case of `mateEquiv`, where the two "vertical" functors are identity, modulo
composition with the unitors. Corresponding natural transformations are called `conjugateEquiv`.
TODO: Generalise to when the two vertical functors are equivalences rather than being exactly `𝟭`.

Furthermore, this bijection preserves (and reflects) isomorphisms, i.e. a transformation is an iso
iff its image under the bijection is an iso, see eg `CategoryTheory.conjugateIsoEquiv`.
This is in contrast to the general case `mateEquiv` which does not in general have this property.
-/
def conjugateEquiv : (L₂ ⟶ L₁) ≃ (R₁ ⟶ R₂) 
goal: (L₂ ⟶ L₁) ≃ (R₁ ⟶ R₂)

full_name: CategoryTheory.conjugateEquiv_counit
code: /-- A component of a transposed form of the conjugation definition. -/
theorem conjugateEquiv_counit (α : L₂ ⟶ L₁) (d : D) :
    L₂.map ((conjugateEquiv adj₁ adj₂ α).app _) ≫ adj₂.counit.app d =
      α.app _ ≫ adj₁.counit.app d 
goal: CategoryTheory.CategoryStruct.comp (L₂.map (((CategoryTheory.conjugateEquiv adj₁ adj₂) α).app d)) (adj₂.counit.app d) =
  CategoryTheory.CategoryStruct.comp (α.app (R₁.obj d)) (adj₁.counit.app d)

full_name: CategoryTheory.conjugateEquiv_counit_symm
code: /-- A component of a transposed form of the inverse conjugation definition. -/
theorem conjugateEquiv_counit_symm (α : R₁ ⟶ R₂) (d : D) :
    L₂.map (α.app _) ≫ adj₂.counit.app d =
      ((conjugateEquiv adj₁ adj₂).symm α).app _ ≫ adj₁.counit.app d 
goal: CategoryTheory.CategoryStruct.comp (L₂.map (α.app d)) (adj₂.counit.app d) =
  CategoryTheory.CategoryStruct.comp (((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α).app (R₁.obj d))
    (adj₁.counit.app d)

full_name: CategoryTheory.unit_conjugateEquiv
code: /-- A component of a transposed form of the conjugation definition. -/
theorem unit_conjugateEquiv (α : L₂ ⟶ L₁) (c : C) :
    adj₁.unit.app _ ≫ (conjugateEquiv adj₁ adj₂ α).app _ =
      adj₂.unit.app c ≫ R₂.map (α.app _) 
goal: CategoryTheory.CategoryStruct.comp (adj₁.unit.app c) (((CategoryTheory.conjugateEquiv adj₁ adj₂) α).app (L₁.obj c)) =
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app c) (R₂.map (α.app c))

full_name: CategoryTheory.unit_conjugateEquiv_symm
code: /-- A component of a transposed form of the inverse conjugation definition. -/
theorem unit_conjugateEquiv_symm (α : R₁ ⟶ R₂) (c : C) :
    adj₁.unit.app _ ≫ α.app _ =
      adj₂.unit.app c ≫ R₂.map (((conjugateEquiv adj₁ adj₂).symm α).app _) 
goal: CategoryTheory.CategoryStruct.comp (adj₁.unit.app c) (α.app (L₁.obj c)) =
  CategoryTheory.CategoryStruct.comp (adj₂.unit.app c)
    (R₂.map (((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α).app c))

full_name: CategoryTheory.conjugateEquiv_id
code: @[simp]
theorem conjugateEquiv_id : conjugateEquiv adj₁ adj₁ (𝟙 _) = 𝟙 _ 
goal: (CategoryTheory.conjugateEquiv adj₁ adj₁) (CategoryTheory.CategoryStruct.id L₁) = CategoryTheory.CategoryStruct.id R₁

full_name: CategoryTheory.conjugateEquiv_symm_id
code: @[simp]
theorem conjugateEquiv_symm_id : (conjugateEquiv adj₁ adj₁).symm (𝟙 _) = 𝟙 _ 
goal: (CategoryTheory.conjugateEquiv adj₁ adj₁).symm (CategoryTheory.CategoryStruct.id R₁) =
  CategoryTheory.CategoryStruct.id L₁

full_name: CategoryTheory.conjugateEquiv_adjunction_id
code: theorem conjugateEquiv_adjunction_id {L R : C ⥤ C} (adj : L ⊣ R) (α : 𝟭 C ⟶ L) (c : C) :
    (conjugateEquiv adj Adjunction.id α).app c = α.app (R.obj c) ≫ adj.counit.app c 
goal: ((CategoryTheory.conjugateEquiv adj CategoryTheory.Adjunction.id) α).app c =
  CategoryTheory.CategoryStruct.comp (α.app (R.obj c)) (adj.counit.app c)

full_name: CategoryTheory.conjugateEquiv_adjunction_id_symm
code: theorem conjugateEquiv_adjunction_id_symm {L R : C ⥤ C} (adj : L ⊣ R) (α : R ⟶ 𝟭 C) (c : C) :
    ((conjugateEquiv adj Adjunction.id).symm α).app c = adj.unit.app c ≫ α.app (L.obj c) 
goal: ((CategoryTheory.conjugateEquiv adj CategoryTheory.Adjunction.id).symm α).app c =
  CategoryTheory.CategoryStruct.comp (adj.unit.app c) (α.app (L.obj c))

full_name: CategoryTheory.conjugateEquiv_comp
code: theorem conjugateEquiv_comp (α : L₂ ⟶ L₁) (β : L₃ ⟶ L₂) :
    conjugateEquiv adj₁ adj₂ α ≫ conjugateEquiv adj₂ adj₃ β =
      conjugateEquiv adj₁ adj₃ (β ≫ α) 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.conjugateEquiv adj₁ adj₂) α)
    ((CategoryTheory.conjugateEquiv adj₂ adj₃) β) =
  (CategoryTheory.conjugateEquiv adj₁ adj₃) (CategoryTheory.CategoryStruct.comp β α)

full_name: CategoryTheory.conjugateEquiv_symm_comp
code: theorem conjugateEquiv_symm_comp (α : R₁ ⟶ R₂) (β : R₂ ⟶ R₃) :
    (conjugateEquiv adj₂ adj₃).symm β ≫ (conjugateEquiv adj₁ adj₂).symm α =
      (conjugateEquiv adj₁ adj₃).symm (α ≫ β) 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.conjugateEquiv adj₂ adj₃).symm β)
    ((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α) =
  (CategoryTheory.conjugateEquiv adj₁ adj₃).symm (CategoryTheory.CategoryStruct.comp α β)

full_name: CategoryTheory.conjugateEquiv_comm
code: theorem conjugateEquiv_comm {α : L₂ ⟶ L₁} {β : L₁ ⟶ L₂} (βα : β ≫ α = 𝟙 _) :
    conjugateEquiv adj₁ adj₂ α ≫ conjugateEquiv adj₂ adj₁ β = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.conjugateEquiv adj₁ adj₂) α)
    ((CategoryTheory.conjugateEquiv adj₂ adj₁) β) =
  CategoryTheory.CategoryStruct.id R₁

full_name: CategoryTheory.conjugateEquiv_symm_comm
code: theorem conjugateEquiv_symm_comm {α : R₁ ⟶ R₂}{β : R₂ ⟶ R₁} (αβ : α ≫ β = 𝟙 _) :
    (conjugateEquiv adj₂ adj₁).symm β ≫ (conjugateEquiv adj₁ adj₂).symm α = 𝟙 _ 
goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.conjugateEquiv adj₂ adj₁).symm β)
    ((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α) =
  CategoryTheory.CategoryStruct.id L₁

full_name: CategoryTheory.conjugateEquiv_iso
code: /-- If `α` is an isomorphism between left adjoints, then its conjugate transformation is an
isomorphism. The converse is given in `conjugateEquiv_of_iso`.
-/
instance conjugateEquiv_iso (α : L₂ ⟶ L₁) [IsIso α] :
    IsIso (conjugateEquiv adj₁ adj₂ α) 
goal: CategoryTheory.IsIso ((CategoryTheory.conjugateEquiv adj₁ adj₂) α)

full_name: CategoryTheory.conjugateEquiv_symm_iso
code: /-- If `α` is an isomorphism between right adjoints, then its conjugate transformation is an
isomorphism. The converse is given in `conjugateEquiv_symm_of_iso`.
-/
instance conjugateEquiv_symm_iso (α : R₁ ⟶ R₂) [IsIso α] :
    IsIso ((conjugateEquiv adj₁ adj₂).symm α) 
goal: CategoryTheory.IsIso ((CategoryTheory.conjugateEquiv adj₁ adj₂).symm α)

full_name: CategoryTheory.conjugateEquiv_of_iso
code: /-- If `α` is a natural transformation between left adjoints whose conjugate natural transformation
is an isomorphism, then `α` is an isomorphism. The converse is given in `Conjugate_iso`.
-/
theorem conjugateEquiv_of_iso (α : L₂ ⟶ L₁) [IsIso (conjugateEquiv adj₁ adj₂ α)] :
    IsIso α 
goal: CategoryTheory.IsIso α

full_name: CategoryTheory.conjugateEquiv_symm_of_iso
code: /--
If `α` is a natural transformation between right adjoints whose conjugate natural transformation is
an isomorphism, then `α` is an isomorphism. The converse is given in `conjugateEquiv_symm_iso`.
-/
theorem conjugateEquiv_symm_of_iso (α : R₁ ⟶ R₂)
    [IsIso ((conjugateEquiv adj₁ adj₂).symm α)] : IsIso α 
goal: CategoryTheory.IsIso α

full_name: CategoryTheory.conjugateIsoEquiv
code: /-- Thus conjugation defines an equivalence between natural isomorphisms. -/
noncomputable def conjugateIsoEquiv : (L₂ ≅ L₁) ≃ (R₁ ≅ R₂) 
goal: (L₂ ≅ L₁) ≃ (R₁ ≅ R₂)

full_name: CategoryTheory.iterated_mateEquiv_conjugateEquiv
code: /-- When all four functors in a sequare are left adjoints, the mates operation can be iterated:

         L₁                  R₁                  R₁
      C --→ D             C ←-- D             C ←-- D
   F₁ ↓  ↗  ↓  F₂      F₁ ↓  ↘  ↓ F₂       U₁ ↑  ↙  ↑ U₂
      E --→ F             E ←-- F             E ←-- F
         L₂                  R₂                  R₂

In this case the iterated mate equals the conjugate of the original transformation and is thus an
isomorphism if and only if the original transformation is. This explains why some Beck-Chevalley
natural transformations are natural isomorphisms.
-/
theorem iterated_mateEquiv_conjugateEquiv (α : F₁ ⋙ L₂ ⟶ L₁ ⋙ F₂) :
    mateEquiv adj₄ adj₃ (mateEquiv adj₁ adj₂ α) =
      conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂) α 
goal: (CategoryTheory.mateEquiv adj₄ adj₃) ((CategoryTheory.mateEquiv adj₁ adj₂) α) =
  (CategoryTheory.conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)) α

full_name: CategoryTheory.iterated_mateEquiv_conjugateEquiv_symm
code: theorem iterated_mateEquiv_conjugateEquiv_symm (α : U₂ ⋙ R₁ ⟶ R₂ ⋙ U₁) :
    (mateEquiv adj₁ adj₂).symm ((mateEquiv adj₄ adj₃).symm α) =
      (conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)).symm α 
goal: (CategoryTheory.mateEquiv adj₁ adj₂).symm ((CategoryTheory.mateEquiv adj₄ adj₃).symm α) =
  (CategoryTheory.conjugateEquiv (adj₁.comp adj₄) (adj₃.comp adj₂)).symm α

full_name: CategoryTheory.leftAdjointSquareConjugate.vcomp
code: /-- Composition of a squares between left adjoints with a conjugate square. -/
def leftAdjointSquareConjugate.vcomp :
    (G ⋙ L₂ ⟶ L₁ ⋙ H) → (L₃ ⟶ L₂) → (G ⋙ L₃ ⟶ L₁ ⋙ H) 
goal: (G.comp L₂ ⟶ L₁.comp H) → (L₃ ⟶ L₂) → (G.comp L₃ ⟶ L₁.comp H)

full_name: CategoryTheory.rightAdjointSquareConjugate.vcomp
code: /-- Composition of a squares between right adjoints with a conjugate square. -/
def rightAdjointSquareConjugate.vcomp :
    (R₁ ⋙ G ⟶ H ⋙ R₂) → (R₂ ⟶ R₃) → (R₁ ⋙ G ⟶ H ⋙ R₃) 
goal: (R₁.comp G ⟶ H.comp R₂) → (R₂ ⟶ R₃) → (R₁.comp G ⟶ H.comp R₃)

full_name: CategoryTheory.mateEquiv_conjugateEquiv_vcomp
code: /-- The mates equivalence commutes with this composition, essentially by `mateEquiv_vcomp`. -/
theorem mateEquiv_conjugateEquiv_vcomp
    (α : G ⋙ L₂ ⟶ L₁ ⋙ H) (β : L₃ ⟶ L₂) :
    (mateEquiv adj₁ adj₃) (leftAdjointSquareConjugate.vcomp α β) =
      rightAdjointSquareConjugate.vcomp (mateEquiv adj₁ adj₂ α) (conjugateEquiv adj₂ adj₃ β) 
goal: (CategoryTheory.mateEquiv adj₁ adj₃) (CategoryTheory.leftAdjointSquareConjugate.vcomp α β) =
  CategoryTheory.rightAdjointSquareConjugate.vcomp ((CategoryTheory.mateEquiv adj₁ adj₂) α)
    ((CategoryTheory.conjugateEquiv adj₂ adj₃) β)

full_name: CategoryTheory.leftAdjointConjugateSquare.vcomp
code: /-- Composition of a conjugate square with a squares between left adjoints. -/
def leftAdjointConjugateSquare.vcomp :
    (L₂ ⟶ L₁) → (G ⋙ L₃ ⟶ L₂ ⋙ H) → (G ⋙ L₃ ⟶ L₁ ⋙ H) 
goal: (L₂ ⟶ L₁) → (G.comp L₃ ⟶ L₂.comp H) → (G.comp L₃ ⟶ L₁.comp H)

full_name: CategoryTheory.rightAdjointConjugateSquare.vcomp
code: /-- Composition of a conjugate square with a squares between right adjoints. -/
def rightAdjointConjugateSquare.vcomp :
    (R₁ ⟶ R₂) → (R₂ ⋙ G ⟶ H ⋙ R₃) → (R₁ ⋙ G ⟶ H ⋙ R₃) 
goal: (R₁ ⟶ R₂) → (R₂.comp G ⟶ H.comp R₃) → (R₁.comp G ⟶ H.comp R₃)

full_name: CategoryTheory.conjugateEquiv_mateEquiv_vcomp
code: /-- The mates equivalence commutes with this composition, essentially by `mateEquiv_vcomp`. -/
theorem conjugateEquiv_mateEquiv_vcomp
    (α : L₂ ⟶ L₁) (β : G ⋙ L₃ ⟶ L₂ ⋙ H) :
    (mateEquiv adj₁ adj₃) (leftAdjointConjugateSquare.vcomp α β) =
      rightAdjointConjugateSquare.vcomp (conjugateEquiv adj₁ adj₂ α) (mateEquiv adj₂ adj₃ β) 
goal: (CategoryTheory.mateEquiv adj₁ adj₃) (CategoryTheory.leftAdjointConjugateSquare.vcomp α β) =
  CategoryTheory.rightAdjointConjugateSquare.vcomp ((CategoryTheory.conjugateEquiv adj₁ adj₂) α)
    ((CategoryTheory.mateEquiv adj₂ adj₃) β)