l3lab/ntp-mathlib huggingface dataset:
@[simp]
lemma zero_hom_app_obj (X : C) :
    (zero F s i hF).hom.app (F.obj X) =
      (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X) := by
  letI := hF.1.some
  have h : whiskerLeft F (zero F s i hF).hom = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
  exact (NatTrans.congr_app h X).trans (by 

Proof state:
C : Type u_5
D : Type u_2
inst✝³ : Category.{u_4, u_5} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
h :
  whiskerLeft F (zero F s i hF).hom =
    (i 0 ≪≫ isoWhiskerRight (shiftFunctorZero C A) F ≪≫ Functor.leftUnitor F ≪≫ (Functor.rightUnitor F).symm).hom
⊢ (i 0 ≪≫ isoWhiskerRight (shiftFunctorZero C A) F ≪≫ Functor.leftUnitor F ≪≫ (Functor.rightUnitor F).symm).hom.app X =
    (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X)

Next tactic:
simp
@[simp]
lemma zero_inv_app_obj (X : C) :
    (zero F s i hF).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X := by
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
X : C
⊢ (zero F s i hF).inv.app (F.obj X) = F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X

Next tactic:
letI := hF.1.some
@[simp]
lemma zero_inv_app_obj (X : C) :
    (zero F s i hF).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X := by
  letI := hF.1.some
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
⊢ (zero F s i hF).inv.app (F.obj X) = F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X

Next tactic:
have h : whiskerLeft F (zero F s i hF).inv = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
@[simp]
lemma zero_inv_app_obj (X : C) :
    (zero F s i hF).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X := by
  letI := hF.1.some
  have h : whiskerLeft F (zero F s i hF).inv = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
h :
  whiskerLeft F (zero F s i hF).inv =
    (i 0 ≪≫ isoWhiskerRight (shiftFunctorZero C A) F ≪≫ Functor.leftUnitor F ≪≫ (Functor.rightUnitor F).symm).inv
⊢ (zero F s i hF).inv.app (F.obj X) = F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X

Next tactic:
exact (NatTrans.congr_app h X).trans (by simp)
@[simp]
lemma zero_inv_app_obj (X : C) :
    (zero F s i hF).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X := by
  letI := hF.1.some
  have h : whiskerLeft F (zero F s i hF).inv = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
  exact (NatTrans.congr_app h X).trans (by 

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
h :
  whiskerLeft F (zero F s i hF).inv =
    (i 0 ≪≫ isoWhiskerRight (shiftFunctorZero C A) F ≪≫ Functor.leftUnitor F ≪≫ (Functor.rightUnitor F).symm).inv
⊢ (i 0 ≪≫ isoWhiskerRight (shiftFunctorZero C A) F ≪≫ Functor.leftUnitor F ≪≫ (Functor.rightUnitor F).symm).inv.app X =
    F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X

Next tactic:
simp
@[simp]
lemma add_hom_app_obj (a b : A) (X : C) :
    (add F s i hF a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫ F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X) := by
  

Proof state:
C : Type u_5
D : Type u_2
inst✝³ : Category.{u_4, u_5} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
⊢ (add F s i hF a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)

Next tactic:
letI := hF.1.some
@[simp]
lemma add_hom_app_obj (a b : A) (X : C) :
    (add F s i hF a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫ F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X) := by
  letI := hF.1.some
  

Proof state:
C : Type u_5
D : Type u_2
inst✝³ : Category.{u_4, u_5} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
⊢ (add F s i hF a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)

Next tactic:
have h : whiskerLeft F (add F s i hF a b).hom = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
@[simp]
lemma add_hom_app_obj (a b : A) (X : C) :
    (add F s i hF a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫ F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X) := by
  letI := hF.1.some
  have h : whiskerLeft F (add F s i hF a b).hom = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
  

Proof state:
C : Type u_5
D : Type u_2
inst✝³ : Category.{u_4, u_5} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
h :
  whiskerLeft F (add F s i hF a b).hom =
    (i (a + b) ≪≫
        isoWhiskerRight (shiftFunctorAdd C a b) F ≪≫
          Functor.associator (shiftFunctor C a) (shiftFunctor C b) F ≪≫
            isoWhiskerLeft (shiftFunctor C a) (i b).symm ≪≫
              (Functor.associator (shiftFunctor C a) F (s b)).symm ≪≫
                isoWhiskerRight (i a).symm (s b) ≪≫ Functor.associator F (s a) (s b)).hom
⊢ (add F s i hF a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)

Next tactic:
exact (NatTrans.congr_app h X).trans (by simp)
@[simp]
lemma add_hom_app_obj (a b : A) (X : C) :
    (add F s i hF a b).hom.app (F.obj X) =
      (i (a + b)).hom.app X ≫ F.map ((shiftFunctorAdd C a b).hom.app X) ≫
        (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X) := by
  letI := hF.1.some
  have h : whiskerLeft F (add F s i hF a b).hom = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
  exact (NatTrans.congr_app h X).trans (by 

Proof state:
C : Type u_5
D : Type u_2
inst✝³ : Category.{u_4, u_5} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
h :
  whiskerLeft F (add F s i hF a b).hom =
    (i (a + b) ≪≫
        isoWhiskerRight (shiftFunctorAdd C a b) F ≪≫
          Functor.associator (shiftFunctor C a) (shiftFunctor C b) F ≪≫
            isoWhiskerLeft (shiftFunctor C a) (i b).symm ≪≫
              (Functor.associator (shiftFunctor C a) F (s b)).symm ≪≫
                isoWhiskerRight (i a).symm (s b) ≪≫ Functor.associator F (s a) (s b)).hom
⊢ (i (a + b) ≪≫
            isoWhiskerRight (shiftFunctorAdd C a b) F ≪≫
              Functor.associator (shiftFunctor C a) (shiftFunctor C b) F ≪≫
                isoWhiskerLeft (shiftFunctor C a) (i b).symm ≪≫
                  (Functor.associator (shiftFunctor C a) F (s b)).symm ≪≫
                    isoWhiskerRight (i a).symm (s b) ≪≫ Functor.associator F (s a) (s b)).hom.app
      X =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)

Next tactic:
simp
@[simp]
lemma add_inv_app_obj (a b : A) (X : C) :
    (add F s i hF a b).inv.app (F.obj X) =
      (s b).map ((i a).hom.app X) ≫ (i b).hom.app ((shiftFunctor C a).obj X) ≫
        F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X := by
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
⊢ (add F s i hF a b).inv.app (F.obj X) =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X

Next tactic:
letI := hF.1.some
@[simp]
lemma add_inv_app_obj (a b : A) (X : C) :
    (add F s i hF a b).inv.app (F.obj X) =
      (s b).map ((i a).hom.app X) ≫ (i b).hom.app ((shiftFunctor C a).obj X) ≫
        F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X := by
  letI := hF.1.some
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
⊢ (add F s i hF a b).inv.app (F.obj X) =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X

Next tactic:
have h : whiskerLeft F (add F s i hF a b).inv = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
@[simp]
lemma add_inv_app_obj (a b : A) (X : C) :
    (add F s i hF a b).inv.app (F.obj X) =
      (s b).map ((i a).hom.app X) ≫ (i b).hom.app ((shiftFunctor C a).obj X) ≫
        F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X := by
  letI := hF.1.some
  have h : whiskerLeft F (add F s i hF a b).inv = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
  

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
h :
  whiskerLeft F (add F s i hF a b).inv =
    (i (a + b) ≪≫
        isoWhiskerRight (shiftFunctorAdd C a b) F ≪≫
          Functor.associator (shiftFunctor C a) (shiftFunctor C b) F ≪≫
            isoWhiskerLeft (shiftFunctor C a) (i b).symm ≪≫
              (Functor.associator (shiftFunctor C a) F (s b)).symm ≪≫
                isoWhiskerRight (i a).symm (s b) ≪≫ Functor.associator F (s a) (s b)).inv
⊢ (add F s i hF a b).inv.app (F.obj X) =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X

Next tactic:
exact (NatTrans.congr_app h X).trans (by simp)
@[simp]
lemma add_inv_app_obj (a b : A) (X : C) :
    (add F s i hF a b).inv.app (F.obj X) =
      (s b).map ((i a).hom.app X) ≫ (i b).hom.app ((shiftFunctor C a).obj X) ≫
        F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X := by
  letI := hF.1.some
  have h : whiskerLeft F (add F s i hF a b).inv = _ :=
    ((whiskeringLeft C D D).obj F).image_preimage _
  exact (NatTrans.congr_app h X).trans (by 

Proof state:
C : Type u_4
D : Type u_2
inst✝³ : Category.{u_3, u_4} C
inst✝² : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_5
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
a b : A
X : C
this : Full ((whiskeringLeft C D D).obj F) := Nonempty.some (_ : Nonempty (Full ((whiskeringLeft C D D).obj F)))
h :
  whiskerLeft F (add F s i hF a b).inv =
    (i (a + b) ≪≫
        isoWhiskerRight (shiftFunctorAdd C a b) F ≪≫
          Functor.associator (shiftFunctor C a) (shiftFunctor C b) F ≪≫
            isoWhiskerLeft (shiftFunctor C a) (i b).symm ≪≫
              (Functor.associator (shiftFunctor C a) F (s b)).symm ≪≫
                isoWhiskerRight (i a).symm (s b) ≪≫ Functor.associator F (s a) (s b)).inv
⊢ (i (a + b) ≪≫
            isoWhiskerRight (shiftFunctorAdd C a b) F ≪≫
              Functor.associator (shiftFunctor C a) (shiftFunctor C b) F ≪≫
                isoWhiskerLeft (shiftFunctor C a) (i b).symm ≪≫
                  (Functor.associator (shiftFunctor C a) F (s b)).symm ≪≫
                    isoWhiskerRight (i a).symm (s b) ≪≫ Functor.associator F (s a) (s b)).inv.app
      X =
    (s b).map ((i a).hom.app X) ≫
      (i b).hom.app ((shiftFunctor C a).obj X) ≫ F.map ((shiftFunctorAdd C a b).inv.app X) ≫ (i (a + b)).inv.app X

Next tactic:
simp
/-- When `F : C ⥤ D` is a functor satisfying suitable technical assumptions,
this is the induced term of type `HasShift D A` deduced from `[HasShift C A]`. -/
noncomputable def induced : HasShift D A :=
  hasShiftMk D A
    { F := s
      zero := Induced.zero F s i hF
      add := Induced.add F s i hF
      zero_add_hom_app := fun n => by
        have := hF.2
        suffices (Induced.add F s i hF 0 n).hom =
          eqToHom (by rw [zero_add]; rfl) ≫ whiskerRight (Induced.zero F s i hF).inv (s n) by
          intro X
          simpa using NatTrans.congr_app this X
        apply ((whiskeringLeft C D D).obj F).map_injective
        ext X
        have eq := dcongr_arg (fun a => (i a).hom.app X) (zero_add n)
        dsimp
        simp only [Induced.add_hom_app_obj, eq, shiftFunctorAdd_zero_add_hom_app,
          Functor.map_comp, eqToHom_map, Category.assoc, eqToHom_trans_assoc,
          eqToHom_refl, Category.id_comp, eqToHom_app, Induced.zero_inv_app_obj]
        erw [← NatTrans.naturality_assoc, Iso.hom_inv_id_app_assoc]
        rfl
      add_zero_hom_app := fun n => by
        have := hF.2
        suffices (Induced.add F s i hF n 0).hom =
            eqToHom (by rw [add_zero]; rfl) ≫ whiskerLeft (s n) (Induced.zero F s i hF).inv by
          intro X
          simpa using NatTrans.congr_app this X
        apply ((whiskeringLeft C D D).obj F).map_injective
        ext X
        dsimp
        erw [Induced.add_hom_app_obj, dcongr_arg (fun a => (i a).hom.app X) (add_zero n),
          ← cancel_mono ((s 0).map ((i n).hom.app X)), Category.assoc,
          Category.assoc, Category.assoc, Category.assoc, Category.assoc,
          Category.assoc, ← (s 0).map_comp, Iso.inv_hom_id_app, Functor.map_id, Category.comp_id,
          ← NatTrans.naturality, Induced.zero_inv_app_obj,
          shiftFunctorAdd_add_zero_hom_app]
        simp [eqToHom_map, eqToHom_app]
      assoc_hom_app := fun m₁ m₂ m₃ => by
        

Proof state:
C : Type ?u.46399
D : Type ?u.46402
inst✝³ : Category.{?u.46406, ?u.46399} C
inst✝² : Category.{?u.46410, ?u.46402} D
F : C ⥤ D
A : Type ?u.46441
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
m₁ m₂ m₃ : A
⊢ ∀ (X : D),
    (Induced.add F s i hF (m₁ + m₂) m₃).hom.app X ≫ (s m₃).map ((Induced.add F s i hF m₁ m₂).hom.app X) =
      eqToHom (_ : (s (m₁ + m₂ + m₃)).obj X = (s (m₁ + (m₂ + m₃))).obj X) ≫
        (Induced.add F s i hF m₁ (m₂ + m₃)).hom.app X ≫ (Induced.add F s i hF m₂ m₃).hom.app ((s m₁).obj X)

Next tactic:
have := hF.2
/-- When `F : C ⥤ D` is a functor satisfying suitable technical assumptions,
this is the induced term of type `HasShift D A` deduced from `[HasShift C A]`. -/
noncomputable def induced : HasShift D A :=
  hasShiftMk D A
    { F := s
      zero := Induced.zero F s i hF
      add := Induced.add F s i hF
      zero_add_hom_app := fun n => by
        have := hF.2
        suffices (Induced.add F s i hF 0 n).hom =
          eqToHom (by rw [zero_add]; rfl) ≫ whiskerRight (Induced.zero F s i hF).inv (s n) by
          intro X
          simpa using NatTrans.congr_app this X
        apply ((whiskeringLeft C D D).obj F).map_injective
        ext X
        have eq := dcongr_arg (fun a => (i a).hom.app X) (zero_add n)
        dsimp
        simp only [Induced.add_hom_app_obj, eq, shiftFunctorAdd_zero_add_hom_app,
          Functor.map_comp, eqToHom_map, Category.assoc, eqToHom_trans_assoc,
          eqToHom_refl, Category.id_comp, eqToHom_app, Induced.zero_inv_app_obj]
        erw [← NatTrans.naturality_assoc, Iso.hom_inv_id_app_assoc]
        rfl
      add_zero_hom_app := fun n => by
        have := hF.2
        suffices (Induced.add F s i hF n 0).hom =
            eqToHom (by rw [add_zero]; rfl) ≫ whiskerLeft (s n) (Induced.zero F s i hF).inv by
          intro X
          simpa using NatTrans.congr_app this X
        apply ((whiskeringLeft C D D).obj F).map_injective
        ext X
        dsimp
        erw [Induced.add_hom_app_obj, dcongr_arg (fun a => (i a).hom.app X) (add_zero n),
          ← cancel_mono ((s 0).map ((i n).hom.app X)), Category.assoc,
          Category.assoc, Category.assoc, Category.assoc, Category.assoc,
          Category.assoc, ← (s 0).map_comp, Iso.inv_hom_id_app, Functor.map_id, Category.comp_id,
          ← NatTrans.naturality, Induced.zero_inv_app_obj,
          shiftFunctorAdd_add_zero_hom_app]
        simp [eqToHom_map, eqToHom_app]
      assoc_hom_app := fun m₁ m₂ m₃ => by
        have := hF.2
        

Proof state:
C : Type ?u.46399
D : Type ?u.46402
inst✝³ : Category.{?u.46406, ?u.46399} C
inst✝² : Category.{?u.46410, ?u.46402} D
F : C ⥤ D
A : Type ?u.46441
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
m₁ m₂ m₃ : A
this : Faithful ((whiskeringLeft C D D).obj F)
⊢ ∀ (X : D),
    (Induced.add F s i hF (m₁ + m₂) m₃).hom.app X ≫ (s m₃).map ((Induced.add F s i hF m₁ m₂).hom.app X) =
      eqToHom (_ : (s (m₁ + m₂ + m₃)).obj X = (s (m₁ + (m₂ + m₃))).obj X) ≫
        (Induced.add F s i hF m₁ (m₂ + m₃)).hom.app X ≫ (Induced.add F s i hF m₂ m₃).hom.app ((s m₁).obj X)

Next tactic:
suffices (Induced.add F s i hF (m₁ + m₂) m₃).hom ≫
            whiskerRight (Induced.add F s i hF m₁ m₂).hom (s m₃) =
            eqToHom (by rw [add_assoc]) ≫ (Induced.add F s i hF m₁ (m₂ + m₃)).hom ≫
              whiskerLeft (s m₁) (Induced.add F s i hF m₂ m₃).hom by
          intro X
          simpa using NatTrans.congr_app this X
/-- When `F : C ⥤ D` is a functor satisfying suitable technical assumptions,
this is the induced term of type `HasShift D A` deduced from `[HasShift C A]`. -/
noncomputable def induced : HasShift D A :=
  hasShiftMk D A
    { F := s
      zero := Induced.zero F s i hF
      add := Induced.add F s i hF
      zero_add_hom_app := fun n => by
        have := hF.2
        suffices (Induced.add F s i hF 0 n).hom =
          eqToHom (by rw [zero_add]; rfl) ≫ whiskerRight (Induced.zero F s i hF).inv (s n) by
          intro X
          simpa using NatTrans.congr_app this X
        apply ((whiskeringLeft C D D).obj F).map_injective
        ext X
        have eq := dcongr_arg (fun a => (i a).hom.app X) (zero_add n)
        dsimp
        simp only [Induced.add_hom_app_obj, eq, shiftFunctorAdd_zero_add_hom_app,
          Functor.map_comp, eqToHom_map, Category.assoc, eqToHom_trans_assoc,
          eqToHom_refl, Category.id_comp, eqToHom_app, Induced.zero_inv_app_obj]
        erw [← NatTrans.naturality_assoc, Iso.hom_inv_id_app_assoc]
        rfl
      add_zero_hom_app := fun n => by
        have := hF.2
        suffices (Induced.add F s i hF n 0).hom =
            eqToHom (by rw [add_zero]; rfl) ≫ whiskerLeft (s n) (Induced.zero F s i hF).inv by
          intro X
          simpa using NatTrans.congr_app this X
        apply ((whiskeringLeft C D D).obj F).map_injective
        ext X
        dsimp
        erw [Induced.add_hom_app_obj, dcongr_arg (fun a => (i a).hom.app X) (add_zero n),
          ← cancel_mono ((s 0).map ((i n).hom.app X)), Category.assoc,
          Category.assoc, Category.assoc, Category.assoc, Category.assoc,
          Category.assoc, ← (s 0).map_comp, Iso.inv_hom_id_app, Functor.map_id, Category.comp_id,
          ← NatTrans.naturality, Induced.zero_inv_app_obj,
          shiftFunctorAdd_add_zero_hom_app]
        simp [eqToHom_map, eqToHom_app]
      assoc_hom_app := fun m₁ m₂ m₃ => by
        have := hF.2
        suffices (Induced.add F s i hF (m₁ + m₂) m₃).hom ≫
            whiskerRight (Induced.add F s i hF m₁ m₂).hom (s m₃) =
            eqToHom (by 

Proof state:
C : Type ?u.46399
D : Type ?u.46402
inst✝³ : Category.{?u.46406, ?u.46399} C
inst✝² : Category.{?u.46410, ?u.46402} D
F : C ⥤ D
A : Type ?u.46441
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
hF : Nonempty (Full ((whiskeringLeft C D D).obj F)) ∧ Faithful ((whiskeringLeft C D D).obj F)
m₁ m₂ m₃ : A
this : Faithful ((whiskeringLeft C D D).obj F)
⊢ s (m₁ + m₂ + m₃) = s (m₁ + (m₂ + m₃))

Next tactic:
rw [add_assoc]