Theorem: CategoryTheory.Adjunction.rightAdjointUniq_hom_app_counit
File: Mathlib/CategoryTheory/Adjunction/Opposites.lean

tactic: apply Quiver.Hom.op_inj
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
⊢ F.map ((rightAdjointUniq adj1 adj2).hom.app x) ≫ adj2.counit.app x = adj1.counit.app x

tactic: convert
  unit_leftAdjointUniq_hom_app (opAdjointOpOfAdjoint _ _ adj2)
    (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
state_before: case a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
⊢ (F.map ((rightAdjointUniq adj1 adj2).hom.app x) ≫ adj2.counit.app x).op = (adj1.counit.app x).op

tactic: simp only [Functor.id_obj, op_comp, Functor.comp_obj, Functor.op_obj, Opposite.unop_op,
  opAdjointOpOfAdjoint_unit_app, Functor.op_map]
state_before: case h.e'_2.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (((𝟭 D).obj x).op ⟶ (F.obj (G.obj x)).op) = ((𝟭 Dᵒᵖ).obj x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
⊢ (F.map ((rightAdjointUniq adj1 adj2).hom.app x) ≫ adj2.counit.app x).op =
    (opAdjointOpOfAdjoint G' F adj2).unit.app x.op ≫
      (Functor.op F).map
        ((leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op)

tactic: dsimp [opEquiv]
state_before: case h.e'_2.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (((𝟭 D).obj x).op ⟶ (F.obj (G.obj x)).op) = ((𝟭 Dᵒᵖ).obj x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
⊢ (adj2.counit.app x).op ≫ (F.map ((rightAdjointUniq adj1 adj2).hom.app x)).op =
    ↑(opEquiv x.op (F.toPrefunctor.1 (G'.obj x)).op).symm
        (F.map (↑(opEquiv (G'.obj x).op (G'.obj x).op) (𝟙 (G'.obj x).op)) ≫ adj2.counit.app x) ≫
      (F.map ((leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op).unop).op

tactic: simp only [← op_comp]
state_before: case h.e'_2.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (((𝟭 D).obj x).op ⟶ (F.obj (G.obj x)).op) = ((𝟭 Dᵒᵖ).obj x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
⊢ (adj2.counit.app x).op ≫ (F.map ((rightAdjointUniq adj1 adj2).hom.app x)).op =
    ((adj2.counit.app x).op ≫ (F.map (𝟙 (G'.obj x))).op) ≫
      (F.map ((leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op).unop).op

tactic: congr 2
state_before: case h.e'_2.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (((𝟭 D).obj x).op ⟶ (F.obj (G.obj x)).op) = ((𝟭 Dᵒᵖ).obj x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
⊢ (F.map ((rightAdjointUniq adj1 adj2).hom.app x) ≫ adj2.counit.app x).op =
    (F.map ((leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app x.op).unop ≫
        F.map (𝟙 (G'.obj x)) ≫ adj2.counit.app x).op

tactic: simp
state_before: case h.e'_2.h.e_f.e_a
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (((𝟭 D).obj x).op ⟶ (F.obj (G.obj x)).op) = ((𝟭 Dᵒᵖ).obj x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
⊢ adj2.counit.app x = F.map (𝟙 (G'.obj x)) ≫ adj2.counit.app x

tactic: simp only [Functor.id_obj, opAdjointOpOfAdjoint_unit_app, Opposite.unop_op]
state_before: case h.e'_3.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (((𝟭 D).obj x).op ⟶ (F.obj (G.obj x)).op) = ((𝟭 Dᵒᵖ).obj x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
⊢ (adj1.counit.app x).op = (opAdjointOpOfAdjoint G F adj1).unit.app x.op

tactic: erw [Functor.map_id, Category.id_comp]
state_before: case h.e'_3.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (((𝟭 D).obj x).op ⟶ (F.obj (G.obj x)).op) = ((𝟭 Dᵒᵖ).obj x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
⊢ (adj1.counit.app x).op =
    ↑(opEquiv x.op (F.toPrefunctor.1 (G.obj x)).op).symm
      (F.map (↑(opEquiv (G.obj x).op (G.obj x).op) (𝟙 (G.obj x).op)) ≫ adj1.counit.app x)

tactic: rfl
state_before: case h.e'_3.h
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (((𝟭 D).obj x).op ⟶ (F.obj (G.obj x)).op) = ((𝟭 Dᵒᵖ).obj x.op ⟶ (Functor.op F).obj ((Functor.op G).obj x.op))
⊢ (adj1.counit.app x).op = ↑(opEquiv x.op (F.toPrefunctor.1 (G.obj x)).op).symm (adj1.counit.app x)