File: Mathlib/CategoryTheory/Shift/Induced.lean

full_name: CategoryTheory.HasShift.Induced.zero
code: /-- The `zero` field of the `ShiftMkCore` structure for the induced shift. -/
noncomputable def zero : s 0 ≅ 𝟭 D 
goal: s 0 ≅ CategoryTheory.Functor.id D

full_name: CategoryTheory.HasShift.Induced.add
code: /-- The `add` field of the `ShiftMkCore` structure for the induced shift. -/
noncomputable def add (a b : A) : s (a + b) ≅ s a ⋙ s b 
goal: s (a + b) ≅ (s a).comp (s b)

full_name: CategoryTheory.HasShift.Induced.zero_hom_app_obj
code: @[simp]
lemma zero_hom_app_obj (X : C) :
    (zero F s i).hom.app (F.obj X) =
      (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X) 
goal: (CategoryTheory.HasShift.Induced.zero F s i).hom.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((i 0).hom.app X) (F.map ((CategoryTheory.shiftFunctorZero C A).hom.app X))

full_name: CategoryTheory.HasShift.Induced.zero_inv_app_obj
code: @[simp]
lemma zero_inv_app_obj (X : C) :
    (zero F s i).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X 
goal: (CategoryTheory.HasShift.Induced.zero F s i).inv.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorZero C A).inv.app X)) ((i 0).inv.app X)

full_name: CategoryTheory.HasShift.Induced.add_hom_app_obj
code: @[simp]
lemma add_hom_app_obj (a b : A) (X : C) :
    (add F s i 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) 
goal: (CategoryTheory.HasShift.Induced.add F s i a b).hom.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((i (a + b)).hom.app X)
    (CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).hom.app X))
      (CategoryTheory.CategoryStruct.comp ((i b).inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        ((s b).map ((i a).inv.app X))))

full_name: CategoryTheory.HasShift.Induced.add_inv_app_obj
code: @[simp]
lemma add_inv_app_obj (a b : A) (X : C) :
    (add F s i 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 
goal: (CategoryTheory.HasShift.Induced.add F s i a b).inv.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((s b).map ((i a).hom.app X))
    (CategoryTheory.CategoryStruct.comp ((i b).hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).inv.app X))
        ((i (a + b)).inv.app X)))

full_name: CategoryTheory.HasShift.induced
code: /-- 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 
goal: CategoryTheory.HasShift D A

full_name: CategoryTheory.shiftFunctor_of_induced
code: @[simp]
lemma shiftFunctor_of_induced (a : A) :
    letI := HasShift.induced F A s i
    shiftFunctor D a = s a 
goal: CategoryTheory.shiftFunctor D a = s a

full_name: CategoryTheory.shiftFunctorZero_hom_app_obj_of_induced
code: @[simp]
lemma shiftFunctorZero_hom_app_obj_of_induced (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorZero D A).hom.app (F.obj X) =
      (i 0).hom.app X ≫ F.map ((shiftFunctorZero C A).hom.app X) 
goal: (CategoryTheory.shiftFunctorZero D A).hom.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((i 0).hom.app X) (F.map ((CategoryTheory.shiftFunctorZero C A).hom.app X))

full_name: CategoryTheory.shiftFunctorZero_inv_app_obj_of_induced
code: @[simp]
lemma shiftFunctorZero_inv_app_obj_of_induced (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorZero D A).inv.app (F.obj X) =
      F.map ((shiftFunctorZero C A).inv.app X) ≫ (i 0).inv.app X 
goal: (CategoryTheory.shiftFunctorZero D A).inv.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorZero C A).inv.app X)) ((i 0).inv.app X)

full_name: CategoryTheory.shiftFunctorAdd_hom_app_obj_of_induced
code: @[simp]
lemma shiftFunctorAdd_hom_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorAdd D 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) 
goal: (CategoryTheory.shiftFunctorAdd D a b).hom.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((i (a + b)).hom.app X)
    (CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).hom.app X))
      (CategoryTheory.CategoryStruct.comp ((i b).inv.app ((CategoryTheory.shiftFunctor C a).obj X))
        ((s b).map ((i a).inv.app X))))

full_name: CategoryTheory.shiftFunctorAdd_inv_app_obj_of_induced
code: @[simp]
lemma shiftFunctorAdd_inv_app_obj_of_induced (a b : A) (X : C) :
    letI := HasShift.induced F A s i
    (shiftFunctorAdd D 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 
goal: (CategoryTheory.shiftFunctorAdd D a b).inv.app (F.obj X) =
  CategoryTheory.CategoryStruct.comp ((s b).map ((i a).hom.app X))
    (CategoryTheory.CategoryStruct.comp ((i b).hom.app ((CategoryTheory.shiftFunctor C a).obj X))
      (CategoryTheory.CategoryStruct.comp (F.map ((CategoryTheory.shiftFunctorAdd C a b).inv.app X))
        ((i (a + b)).inv.app X)))

full_name: CategoryTheory.Functor.CommShift.ofInduced
code: /-- When the target category of a functor `F : C ⥤ D` is equipped with
the induced shift, this is the compatibility of `F` with the shifts on
the categories `C` and `D`. -/
def Functor.CommShift.ofInduced :
    letI := HasShift.induced F A s i
    F.CommShift A 
goal: F.CommShift A

full_name: CategoryTheory.Functor.commShiftIso_eq_ofInduced
code: lemma Functor.commShiftIso_eq_ofInduced (a : A) :
    letI := HasShift.induced F A s i
    letI := Functor.CommShift.ofInduced F A s i
    F.commShiftIso a = (i a).symm 
goal: F.commShiftIso a = (i a).symm