l3lab/ntp-mathlib huggingface dataset:
theorem homEquiv_symm_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G)
    (adj2 : F ⊣ G') (x : D) :
    (adj2.homEquiv _ _).symm ((rightAdjointUniq adj1 adj2).hom.app x) = adj1.counit.app x := by
  apply Quiver.Hom.op_inj
  convert homEquiv_leftAdjointUniq_hom_app (opAdjointOpOfAdjoint _ F adj2)
    (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x)
  -- Porting note: was `simpa`
  simp only [opAdjointOpOfAdjoint, Functor.op_obj, Opposite.unop_op, mkOfHomEquiv_unit_app,
    Equiv.trans_apply, homEquiv_counit, Functor.id_obj]
  -- Porting note: Yet another `erw`...
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  

Proof state:
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (Opposite.op x ⟶ Opposite.op (F.obj (G.obj x))) = (Opposite.op x ⟶ F.op.obj (G.op.obj (Opposite.op x)))
⊢ (adj1.counit.app x).op =
    (opEquiv (Opposite.op x) (Opposite.op (F.toPrefunctor.1 (G.obj x)))).symm
      (F.map ((opEquiv (Opposite.op (G.obj x)) (Opposite.op (G.obj x))) (𝟙 (Opposite.op (G.obj x)))) ≫
        adj1.counit.app x)

Next tactic:
erw [F.map_id]
theorem homEquiv_symm_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G)
    (adj2 : F ⊣ G') (x : D) :
    (adj2.homEquiv _ _).symm ((rightAdjointUniq adj1 adj2).hom.app x) = adj1.counit.app x := by
  apply Quiver.Hom.op_inj
  convert homEquiv_leftAdjointUniq_hom_app (opAdjointOpOfAdjoint _ F adj2)
    (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x)
  -- Porting note: was `simpa`
  simp only [opAdjointOpOfAdjoint, Functor.op_obj, Opposite.unop_op, mkOfHomEquiv_unit_app,
    Equiv.trans_apply, homEquiv_counit, Functor.id_obj]
  -- Porting note: Yet another `erw`...
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [F.map_id]
  

Proof state:
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (Opposite.op x ⟶ Opposite.op (F.obj (G.obj x))) = (Opposite.op x ⟶ F.op.obj (G.op.obj (Opposite.op x)))
⊢ (adj1.counit.app x).op =
    (opEquiv (Opposite.op x) (Opposite.op (F.toPrefunctor.1 (G.obj x)))).symm (𝟙 (F.obj (G.obj x)) ≫ adj1.counit.app x)

Next tactic:
rw [Category.id_comp]
theorem homEquiv_symm_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G)
    (adj2 : F ⊣ G') (x : D) :
    (adj2.homEquiv _ _).symm ((rightAdjointUniq adj1 adj2).hom.app x) = adj1.counit.app x := by
  apply Quiver.Hom.op_inj
  convert homEquiv_leftAdjointUniq_hom_app (opAdjointOpOfAdjoint _ F adj2)
    (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x)
  -- Porting note: was `simpa`
  simp only [opAdjointOpOfAdjoint, Functor.op_obj, Opposite.unop_op, mkOfHomEquiv_unit_app,
    Equiv.trans_apply, homEquiv_counit, Functor.id_obj]
  -- Porting note: Yet another `erw`...
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [F.map_id]
  rw [Category.id_comp]
  

Proof state:
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : D
e_1✝ : (Opposite.op x ⟶ Opposite.op (F.obj (G.obj x))) = (Opposite.op x ⟶ F.op.obj (G.op.obj (Opposite.op x)))
⊢ (adj1.counit.app x).op = (opEquiv (Opposite.op x) (Opposite.op (F.toPrefunctor.1 (G.obj x)))).symm (adj1.counit.app x)

Next tactic:
rfl
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
⊢ adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) = adj2.unit.app x

Next tactic:
apply Quiver.Hom.op_inj
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  

Proof state:
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
⊢ (adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op = (adj2.unit.app x).op

Next tactic:
convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  

Proof state:
case h.e'_2.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op =
    (leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app
        (F.op.obj (Opposite.op x)) ≫
      (opAdjointOpOfAdjoint G F adj1).counit.app (Opposite.op x)
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj2.unit.app x).op = (opAdjointOpOfAdjoint G' F adj2).counit.app (Opposite.op x)

Next tactic:
all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    erw [Functor.map_id]
    rw [Category.comp_id]
    rfl }
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals 

Proof state:
case h.e'_2.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op =
    (leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app
        (F.op.obj (Opposite.op x)) ≫
      (opAdjointOpOfAdjoint G F adj1).counit.app (Opposite.op x)

Next tactic:
{
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    erw [Functor.map_id]
    rw [Category.comp_id]
    rfl }
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    

Proof state:
case h.e'_2.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op =
    (leftAdjointUniq (opAdjointOpOfAdjoint G' F adj2) (opAdjointOpOfAdjoint G F adj1)).hom.app
        (F.op.obj (Opposite.op x)) ≫
      (opAdjointOpOfAdjoint G F adj1).counit.app (Opposite.op x)

Next tactic:
simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    

Proof state:
case h.e'_2.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ ((rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op ≫ (adj1.unit.app x).op =
    (leftAdjointUniq
              (mkOfHomEquiv
                (CoreHomEquiv.mk fun X Y =>
                  (opEquiv (Opposite.op (G'.obj X.unop)) Y).trans
                    ((homEquiv adj2 Y.unop X.unop).symm.trans
                      (opEquiv X (Opposite.op (F.toPrefunctor.1 Y.unop))).symm)))
              (mkOfHomEquiv
                (CoreHomEquiv.mk fun X Y =>
                  (opEquiv (Opposite.op (G.obj X.unop)) Y).trans
                    ((homEquiv adj1 Y.unop X.unop).symm.trans
                      (opEquiv X (Opposite.op (F.toPrefunctor.1 Y.unop))).symm)))).hom.app
        (Opposite.op (F.obj x)) ≫
      (opEquiv (Opposite.op (G.obj (F.obj x))) (Opposite.op x)).symm
        (adj1.unit.app x ≫
          G.map ((opEquiv (Opposite.op (F.obj x)) (Opposite.op (F.toPrefunctor.1 x))) (𝟙 (Opposite.op (F.obj x)))))

Next tactic:
erw [Functor.map_id]
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    erw [Functor.map_id]
    

Proof state:
case h.e'_2.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ ((rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op ≫ (adj1.unit.app x).op =
    (leftAdjointUniq
              (mkOfHomEquiv
                (CoreHomEquiv.mk fun X Y =>
                  (opEquiv (Opposite.op (G'.obj X.unop)) Y).trans
                    ((homEquiv adj2 Y.unop X.unop).symm.trans
                      (opEquiv X (Opposite.op (F.toPrefunctor.1 Y.unop))).symm)))
              (mkOfHomEquiv
                (CoreHomEquiv.mk fun X Y =>
                  (opEquiv (Opposite.op (G.obj X.unop)) Y).trans
                    ((homEquiv adj1 Y.unop X.unop).symm.trans
                      (opEquiv X (Opposite.op (F.toPrefunctor.1 Y.unop))).symm)))).hom.app
        (Opposite.op (F.obj x)) ≫
      (opEquiv (Opposite.op (G.obj (F.obj x))) (Opposite.op x)).symm (adj1.unit.app x ≫ 𝟙 (G.obj (F.obj x)))

Next tactic:
rw [Category.comp_id]
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    erw [Functor.map_id]
    rw [Category.comp_id]
    

Proof state:
case h.e'_2.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ ((rightAdjointUniq adj1 adj2).hom.app (F.obj x)).op ≫ (adj1.unit.app x).op =
    (leftAdjointUniq
              (mkOfHomEquiv
                (CoreHomEquiv.mk fun X Y =>
                  (opEquiv (Opposite.op (G'.obj X.unop)) Y).trans
                    ((homEquiv adj2 Y.unop X.unop).symm.trans
                      (opEquiv X (Opposite.op (F.toPrefunctor.1 Y.unop))).symm)))
              (mkOfHomEquiv
                (CoreHomEquiv.mk fun X Y =>
                  (opEquiv (Opposite.op (G.obj X.unop)) Y).trans
                    ((homEquiv adj1 Y.unop X.unop).symm.trans
                      (opEquiv X (Opposite.op (F.toPrefunctor.1 Y.unop))).symm)))).hom.app
        (Opposite.op (F.obj x)) ≫
      (opEquiv (Opposite.op (G.obj (F.obj x))) (Opposite.op x)).symm (adj1.unit.app x)

Next tactic:
rfl
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals 

Proof state:
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj2.unit.app x).op = (opAdjointOpOfAdjoint G' F adj2).counit.app (Opposite.op x)

Next tactic:
{
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    erw [Functor.map_id]
    rw [Category.comp_id]
    rfl }
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    

Proof state:
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj2.unit.app x).op = (opAdjointOpOfAdjoint G' F adj2).counit.app (Opposite.op x)

Next tactic:
simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    

Proof state:
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj2.unit.app x).op =
    (opEquiv (Opposite.op (G'.obj (F.obj x))) (Opposite.op x)).symm
      (adj2.unit.app x ≫
        G'.map ((opEquiv (Opposite.op (F.obj x)) (Opposite.op (F.toPrefunctor.1 x))) (𝟙 (Opposite.op (F.obj x)))))

Next tactic:
erw [Functor.map_id]
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    erw [Functor.map_id]
    

Proof state:
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj2.unit.app x).op =
    (opEquiv (Opposite.op (G'.obj (F.obj x))) (Opposite.op x)).symm (adj2.unit.app x ≫ 𝟙 (G'.obj (F.obj x)))

Next tactic:
rw [Category.comp_id]
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom_app {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G')
    (x : C) : adj1.unit.app x ≫ (rightAdjointUniq adj1 adj2).hom.app (F.obj x) =
      adj2.unit.app x := by
  apply Quiver.Hom.op_inj
  convert
    leftAdjointUniq_hom_app_counit (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1
  --all_goals simp
  all_goals {
    -- Porting note: Again, something seems wrong here... Some `simp` lemmas are not firing!
    simp only [Functor.id_obj, Functor.comp_obj, op_comp, Functor.op_obj, Opposite.unop_op,
      opAdjointOpOfAdjoint, mkOfHomEquiv_counit_app, Equiv.invFun_as_coe, Equiv.symm_trans_apply,
      Equiv.symm_symm, homEquiv_unit]
    erw [Functor.map_id]
    rw [Category.comp_id]
    

Proof state:
case h.e'_3.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
e_1✝ :
  (Opposite.op (G'.obj (F.obj x)) ⟶ Opposite.op ((𝟭 C).obj x)) =
    (G'.op.obj (F.op.obj (Opposite.op x)) ⟶ (𝟭 Cᵒᵖ).obj (Opposite.op x))
⊢ (adj2.unit.app x).op = (opEquiv (Opposite.op (G'.obj (F.obj x))) (Opposite.op x)).symm (adj2.unit.app x)

Next tactic:
rfl
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G') :
    adj1.unit ≫ whiskerLeft F (rightAdjointUniq adj1 adj2).hom = adj2.unit := by
  

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
⊢ adj1.unit ≫ whiskerLeft F (rightAdjointUniq adj1 adj2).hom = adj2.unit

Next tactic:
ext x
@[reassoc (attr := simp)]
theorem unit_rightAdjointUniq_hom {F : C ⥤ D} {G G' : D ⥤ C} (adj1 : F ⊣ G) (adj2 : F ⊣ G') :
    adj1.unit ≫ whiskerLeft F (rightAdjointUniq adj1 adj2).hom = adj2.unit := by
  ext x
  

Proof state:
case w.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G G' : D ⥤ C
adj1 : F ⊣ G
adj2 : F ⊣ G'
x : C
⊢ (adj1.unit ≫ whiskerLeft F (rightAdjointUniq adj1 adj2).hom).app x = adj2.unit.app x

Next tactic:
simp
@[reassoc (attr := simp)]
theorem rightAdjointUniq_hom_app_counit {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 := by
  

Proof state:
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} 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

Next tactic:
apply Quiver.Hom.op_inj
@[reassoc (attr := simp)]
theorem rightAdjointUniq_hom_app_counit {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 := by
  apply Quiver.Hom.op_inj
  

Proof state:
case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} 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

Next tactic:
convert
    unit_leftAdjointUniq_hom_app (opAdjointOpOfAdjoint _ _ adj2)
      (opAdjointOpOfAdjoint _ _ adj1) (Opposite.op x) using 1