awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : F.CommShift A
this : G.CommShift A := adj.rightAdjointCommShift A
a : A
X : C
⊢ Eq (α :=
    Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X ⟶
      Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X)))
    (NatTrans.app (Iso.hom (Functor.commShiftIso (𝟭 C) a)) X ≫ Functor.map (shiftFunctor C a) (adj.unit.app X) :
      Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X ⟶
        Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X)))
    (adj.unit.app (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X) ≫
        NatTrans.app (Iso.hom (Functor.commShiftIso (F ⋙ G) a)) X :
      Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X ⟶
        Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X)))

Tactic:
simpa only [Functor.commShiftIso_id_hom_app, Functor.comp_obj, Functor.id_obj, id_comp,
    Functor.commShiftIso_comp_hom_app] using RightAdjointCommShift.compatibilityUnit_iso adj a X

Premises used: CategoryTheory.Functor.comp_obj, CategoryTheory.Functor.commShiftIso_comp_hom_app, CategoryTheory.Functor.commShiftIso_id_hom_app, CategoryTheory.Adjunction.RightAdjointCommShift.compatibilityUnit_iso, CategoryTheory.Functor.id_obj, CategoryTheory.Category.id_comp
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
a b : A
h : a + b = 0
inst_5 : G.CommShift A
X : C
⊢ b + a = 0

Tactic:
simp [eq_neg_of_add_eq_zero_left h]

Premises used: eq_neg_of_add_eq_zero_left
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
a b : A
h : a + b = 0
inst_5 : G.CommShift A
X : C
⊢ b = -a

Tactic:
eq_neg_of_add_eq_zero_right h

Premises used: eq_neg_of_add_eq_zero_right
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
a b : A
h : a + b = 0
inst_5 : G.CommShift A
X : C
obtain :
  ∀ (h : a + -a = 0),
    Eq (α := (shiftFunctor C a ⋙ F).obj X ⟶ (F ⋙ shiftFunctor D a).obj X) (NatTrans.app (Iso.hom (iso adj a)) X)
      (F.map (Functor.map (shiftFunctor C a) (adj.unit.app X)) ≫
        F.map
            (Functor.map (shiftFunctor C a)
              (G.map (NatTrans.app (Iso.inv (shiftFunctorCompIsoId D a (-a) h)) (F.obj X)))) ≫
          F.map
              (Functor.map (shiftFunctor C a)
                (NatTrans.app (Iso.hom (Functor.commShiftIso G (-a)))
                  (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))) ≫
            F.map
                (NatTrans.app (Iso.hom (shiftFunctorCompIsoId C (-a) a ⋯))
                  (G.obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))) ≫
              adj.counit.app (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))
⊢ Eq (α := (shiftFunctor C a ⋙ F).obj X ⟶ (F ⋙ shiftFunctor D a).obj X) (NatTrans.app (Iso.hom (iso adj a)) X)
    (F.map (Functor.map (shiftFunctor C a) (adj.unit.app X)) ≫
      F.map
          (Functor.map (shiftFunctor C a) (G.map (NatTrans.app (Iso.inv (shiftFunctorCompIsoId D a b h)) (F.obj X)))) ≫
        F.map
            (Functor.map (shiftFunctor C a)
              (NatTrans.app (Iso.hom (Functor.commShiftIso G b))
                (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))) ≫
          F.map
              (NatTrans.app (Iso.hom (shiftFunctorCompIsoId C b a ⋯))
                (G.obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))) ≫
            adj.counit.app (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))

Tactic:
obtain rfl : b = -a := eq_neg_of_add_eq_zero_right h

Premises used: eq_neg_of_add_eq_zero_right, rfl
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
a : A
inst_5 : G.CommShift A
X : C
h : a + -a = 0
⊢ Eq (α := (shiftFunctor C a ⋙ F).obj X ⟶ (F ⋙ shiftFunctor D a).obj X) (NatTrans.app (Iso.hom (iso adj a)) X)
    (F.map (Functor.map (shiftFunctor C a) (adj.unit.app X)) ≫
      F.map
          (Functor.map (shiftFunctor C a)
            (G.map (NatTrans.app (Iso.inv (shiftFunctorCompIsoId D a (-a) h)) (F.obj X)))) ≫
        F.map
            (Functor.map (shiftFunctor C a)
              (NatTrans.app (Iso.hom (Functor.commShiftIso G (-a)))
                (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))) ≫
          F.map
              (NatTrans.app (Iso.hom (shiftFunctorCompIsoId C (-a) a ⋯))
                (G.obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))) ≫
            adj.counit.app (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))

Tactic:
simp [iso, iso', shiftEquiv']

Premises used: CategoryTheory.Adjunction.LeftAdjointCommShift.iso, CategoryTheory.shiftEquiv', CategoryTheory.Adjunction.LeftAdjointCommShift.iso'
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
a b : A
h : a + b = 0
inst_5 : G.CommShift A
Y : C
⊢ b + a = 0

Tactic:
simp [eq_neg_of_add_eq_zero_left h]

Premises used: eq_neg_of_add_eq_zero_left
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
a b : A
h : a + b = 0
inst_5 : G.CommShift A
Y : C
⊢ b = -a

Tactic:
eq_neg_of_add_eq_zero_right h

Premises used: eq_neg_of_add_eq_zero_right
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
a : A
inst_5 : G.CommShift A
Y : C
h : a + -a = 0
⊢ Eq (α := (F ⋙ shiftFunctor D a).obj Y ⟶ (shiftFunctor C a ⋙ F).obj Y) (NatTrans.app (Iso.inv (iso adj a)) Y)
    (CategoryStruct.comp (Y :=
      Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a)
        (F.obj (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a ⋙ shiftFunctor C (-a)) Y)))
      (Functor.map (shiftFunctor D a) (F.map (NatTrans.app (Iso.inv (shiftFunctorCompIsoId C a (-a) h)) Y)))
      (Functor.map (shiftFunctor D a)
          (F.map
            (Functor.map (shiftFunctor C (-a))
              (adj.unit.app (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) Y)))) ≫
        CategoryStruct.comp (Y :=
          Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a)
            (F.obj ((shiftFunctor D (-a) ⋙ G).obj (F.obj (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) Y)))))
          (Functor.map (shiftFunctor D a)
            (F.map
              (NatTrans.app (Iso.inv (Functor.commShiftIso G (-a)))
                (F.obj (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) Y)))))
          (Functor.map (shiftFunctor D a)
              (adj.counit.app
                (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D (-a))
                  (F.obj (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) Y)))) ≫
            NatTrans.app (Iso.hom (shiftFunctorCompIsoId D (-a) a ⋯))
              (F.obj (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) Y)))))

Tactic:
simp [iso, iso', shiftEquiv']

Premises used: CategoryTheory.Adjunction.LeftAdjointCommShift.iso, CategoryTheory.shiftEquiv', CategoryTheory.Adjunction.LeftAdjointCommShift.iso'
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
a : A
X : C
rw :
  Eq (α :=
    Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (Functor.obj.{v_1, v_1, u_1, u_1} (𝟭 C) X) ⟶
      Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) ((F ⋙ G).obj X))
    (Functor.map (shiftFunctor C a) (adj.unit.app X))
    (adj.unit.app (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X) ≫
      CategoryStruct.comp (Y := G.obj ((F ⋙ shiftFunctor D a).obj X))
        (G.map
          (F.map (Functor.map (shiftFunctor C a) (adj.unit.app X)) ≫
            F.map
                (Functor.map (shiftFunctor C a)
                  (G.map (NatTrans.app (Iso.inv (shiftFunctorCompIsoId D a (-a) ⋯)) (F.obj X)))) ≫
              F.map
                  (Functor.map (shiftFunctor C a)
                    (NatTrans.app (Iso.hom (Functor.commShiftIso G (-a)))
                      (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))) ≫
                F.map
                    (NatTrans.app (Iso.hom (shiftFunctorCompIsoId C (-a) a ⋯))
                      (G.obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))) ≫
                  adj.counit.app (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X))))
        (NatTrans.app (Iso.hom (Functor.commShiftIso G a)) (F.obj X)))
⊢ Eq (α :=
    Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (Functor.obj.{v_1, v_1, u_1, u_1} (𝟭 C) X) ⟶
      Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) ((F ⋙ G).obj X))
    (Functor.map (shiftFunctor C a) (adj.unit.app X))
    (adj.unit.app (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X) ≫
      CategoryStruct.comp (Y := G.obj ((F ⋙ shiftFunctor D a).obj X)) (G.map (NatTrans.app (Iso.hom (iso adj a)) X))
        (NatTrans.app (Iso.hom (Functor.commShiftIso G a)) (F.obj X)))

Tactic:
rw [LeftAdjointCommShift.iso_hom_app adj _ _ (add_neg_cancel a)]

Premises used: add_neg_cancel, CategoryTheory.Adjunction.LeftAdjointCommShift.iso_hom_app
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
a : A
X : C
a₁ :
  Functor.map (shiftFunctor C a)
    (𝟙 ((G ⋙ shiftFunctor C (-a)).obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X))))
| CategoryStruct.comp (Y :=
    Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a)
      (G.obj
        (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D (-a))
          (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))))
    (Functor.map (shiftFunctor C a)
      (NatTrans.app (Iso.inv (Functor.commShiftIso G (-a)))
        (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X))))
    (Functor.map (shiftFunctor C a)
      (NatTrans.app (Iso.hom (Functor.commShiftIso G (-a)))
        (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X))))

Tactic:
rw [← Functor.map_comp, Iso.inv_hom_id_app]

Premises used: CategoryTheory.Functor.map_comp, CategoryTheory.Iso.inv_hom_id_app
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
a : A
X : C
rw :
  Eq (α :=
    Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X ⟶
      Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X)))
    (Functor.map (shiftFunctor C a) (adj.unit.app X))
    (Functor.map (shiftFunctor C a) (adj.unit.app X) ≫
      CategoryStruct.comp (Y :=
        Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a)
          (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C (-a))
            (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X)))))
        (NatTrans.app (Iso.inv (shiftFunctorCompIsoId C (-a) a ⋯))
          (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X))))
        (NatTrans.app (Iso.hom (shiftFunctorCompIsoId C (-a) a ⋯))
            (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X))) ≫
          CategoryStruct.comp (Y :=
            Functor.obj.{v_1, v_1, u_1, u_1} (𝟭 C)
              (G.obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X))))
            (Functor.map (𝟭 C) (NatTrans.app (Iso.inv (Functor.commShiftIso G a)) (F.obj X)))
            (NatTrans.app (Iso.hom (Functor.commShiftIso G a)) (F.obj X))))
⊢ Eq (α :=
    Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X ⟶
      Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X)))
    (Functor.map (shiftFunctor C a) (adj.unit.app X))
    (Functor.map (shiftFunctor C a) (adj.unit.app X) ≫
      Functor.map (shiftFunctor C a) (NatTrans.app (Iso.inv (shiftFunctorCompIsoId C a (-a) ⋯)) (G.obj (F.obj X))) ≫
        CategoryStruct.comp (Y :=
          Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a)
            (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C (-a))
              (G.obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X)))))
          (Functor.map (shiftFunctor C a)
            (Functor.map (shiftFunctor C (-a)) (NatTrans.app (Iso.inv (Functor.commShiftIso G a)) (F.obj X))))
          (NatTrans.app (Iso.hom (shiftFunctorCompIsoId C (-a) a ⋯))
              (G.obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X))) ≫
            NatTrans.app (Iso.hom (Functor.commShiftIso G a)) (F.obj X)))

Tactic:
rw [shift_shiftFunctorCompIsoId_inv_app, ← Functor.comp_map,
    (shiftFunctorCompIsoId C _ _ (neg_add_cancel a)).hom.naturality_assoc]

Premises used: neg_add_cancel, CategoryTheory.shift_shiftFunctorCompIsoId_inv_app, CategoryTheory.shiftFunctorCompIsoId, CategoryTheory.Iso.hom, CategoryTheory.Functor.comp_map, CategoryTheory.NatTrans.naturality_assoc
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
a : A
X : C
⊢ Eq (α :=
    Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) X ⟶
      Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X)))
    (Functor.map (shiftFunctor C a) (adj.unit.app X))
    (Functor.map (shiftFunctor C a) (adj.unit.app X) ≫
      CategoryStruct.comp (Y :=
        Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a)
          (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C (-a))
            (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X)))))
        (NatTrans.app (Iso.inv (shiftFunctorCompIsoId C (-a) a ⋯))
          (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X))))
        (NatTrans.app (Iso.hom (shiftFunctorCompIsoId C (-a) a ⋯))
            (Functor.obj.{v_1, v_1, u_1, u_1} (shiftFunctor C a) (G.obj (F.obj X))) ≫
          CategoryStruct.comp (Y :=
            Functor.obj.{v_1, v_1, u_1, u_1} (𝟭 C)
              (G.obj (Functor.obj.{v_2, v_2, u_2, u_2} (shiftFunctor D a) (F.obj X))))
            (Functor.map (𝟭 C) (NatTrans.app (Iso.inv (Functor.commShiftIso G a)) (F.obj X)))
            (NatTrans.app (Iso.hom (Functor.commShiftIso G a)) (F.obj X))))

Tactic:
simp
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
⊢ Eq (α := shiftFunctor.{v_1, u_1, u_3} C (A := A) 0 ⋙ F ≅ F ⋙ shiftFunctor.{v_2, u_2, u_3} D (A := A) 0) (iso adj 0)
    (Functor.CommShift.isoZero F A)

Tactic:
CommShift.compatibilityUnit_unique_left adj _ _ (G.commShiftIso 0)
      (compatibilityUnit_iso adj 0) ?_

Premises used: CategoryTheory.Adjunction.LeftAdjointCommShift.compatibilityUnit_iso, OfNat.ofNat, CategoryTheory.Functor.CommShift.commShiftIso, CategoryTheory.Adjunction.CommShift.compatibilityUnit_unique_left
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
refine : CommShift.CompatibilityUnit adj (Functor.CommShift.isoZero F A) (Functor.commShiftIso G 0)
⊢ Eq (α := shiftFunctor.{v_1, u_1, u_3} C (A := A) 0 ⋙ F ≅ F ⋙ shiftFunctor.{v_2, u_2, u_3} D (A := A) 0) (iso adj 0)
    (Functor.CommShift.isoZero F A)

Tactic:
refine CommShift.compatibilityUnit_unique_left adj _ _ (G.commShiftIso 0)
      (compatibilityUnit_iso adj 0) ?_

Premises used: CategoryTheory.Adjunction.LeftAdjointCommShift.compatibilityUnit_iso, OfNat.ofNat, CategoryTheory.Functor.CommShift.commShiftIso, CategoryTheory.Adjunction.CommShift.compatibilityUnit_unique_left
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
rw : CommShift.CompatibilityUnit adj (Functor.CommShift.isoZero F A) (Functor.CommShift.isoZero G A)
⊢ CommShift.CompatibilityUnit adj (Functor.CommShift.isoZero F A) (Functor.commShiftIso G 0)

Tactic:
rw [G.commShiftIso_zero]

Premises used: CategoryTheory.Functor.CommShift.commShiftIso_zero
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
⊢ CommShift.CompatibilityUnit adj (Functor.CommShift.isoZero F A) (Functor.CommShift.isoZero G A)

Tactic:
CommShift.compatibilityUnit_isoZero adj

Premises used: CategoryTheory.Adjunction.CommShift.compatibilityUnit_isoZero
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
⊢ CommShift.CompatibilityUnit adj (Functor.CommShift.isoZero F A) (Functor.CommShift.isoZero G A)

Tactic:
exact CommShift.compatibilityUnit_isoZero adj

Premises used: CategoryTheory.Adjunction.CommShift.compatibilityUnit_isoZero
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
a b : A
⊢ Eq (α := shiftFunctor C (a + b) ⋙ F ≅ F ⋙ shiftFunctor D (a + b)) (iso adj (a + b))
    (Functor.CommShift.isoAdd (iso adj a) (iso adj b))

Tactic:
CommShift.compatibilityUnit_unique_left adj _ _ (G.commShiftIso (a + b))
      (compatibilityUnit_iso adj (a + b)) ?_

Premises used: CategoryTheory.Adjunction.LeftAdjointCommShift.compatibilityUnit_iso, HAdd.hAdd, CategoryTheory.Functor.CommShift.commShiftIso, CategoryTheory.Adjunction.CommShift.compatibilityUnit_unique_left
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
a b : A
refine :
  CommShift.CompatibilityUnit adj (Functor.CommShift.isoAdd (iso adj a) (iso adj b)) (Functor.commShiftIso G (a + b))
⊢ Eq (α := shiftFunctor C (a + b) ⋙ F ≅ F ⋙ shiftFunctor D (a + b)) (iso adj (a + b))
    (Functor.CommShift.isoAdd (iso adj a) (iso adj b))

Tactic:
refine CommShift.compatibilityUnit_unique_left adj _ _ (G.commShiftIso (a + b))
      (compatibilityUnit_iso adj (a + b)) ?_

Premises used: CategoryTheory.Adjunction.LeftAdjointCommShift.compatibilityUnit_iso, HAdd.hAdd, CategoryTheory.Functor.CommShift.commShiftIso, CategoryTheory.Adjunction.CommShift.compatibilityUnit_unique_left
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
a b : A
rw :
  CommShift.CompatibilityUnit adj (Functor.CommShift.isoAdd (iso adj a) (iso adj b))
    (Functor.CommShift.isoAdd (Functor.commShiftIso G a) (Functor.commShiftIso G b))
⊢ CommShift.CompatibilityUnit adj (Functor.CommShift.isoAdd (iso adj a) (iso adj b)) (Functor.commShiftIso G (a + b))

Tactic:
rw [G.commShiftIso_add]

Premises used: CategoryTheory.Functor.CommShift.commShiftIso_add
-- Module: Mathlib.CategoryTheory.Shift.Adjunction
Goal:
C : Type u_1
D : Type u_2
inst : Category.{v_1, u_1} C
inst_1 : Category.{v_2, u_2} D
F : Functor.{v_1, v_2, u_1, u_2} C D
G : Functor.{v_2, v_1, u_2, u_1} D C
adj : F ⊣ G
A : Type u_3
inst_2 : AddGroup A
inst_3 : HasShift.{v_1, u_1, u_3} C A
inst_4 : HasShift.{v_2, u_2, u_3} D A
inst_5 : G.CommShift A
a b : A
⊢ CommShift.CompatibilityUnit adj (Functor.CommShift.isoAdd (iso adj a) (iso adj b))
    (Functor.CommShift.isoAdd (Functor.commShiftIso G a) (Functor.commShiftIso G b))

Tactic:
CommShift.compatibilityUnit_isoAdd adj _ _ _ _
      (compatibilityUnit_iso adj a) (compatibilityUnit_iso adj b)

Premises used: CategoryTheory.Adjunction.LeftAdjointCommShift.compatibilityUnit_iso, CategoryTheory.Adjunction.CommShift.compatibilityUnit_isoAdd