File: Mathlib/CategoryTheory/Shift/Pullback.lean

full_name: CategoryTheory.PullbackShift
code: /-- The category `PullbackShift C φ` is equipped with a shift such that for all `a`,
the shift functor by `a` is `shiftFunctor C (φ a)`. -/
@[nolint unusedArguments]
def PullbackShift (_ : A →+ B) [HasShift C B] 
goal: (A →+ B) → [inst : CategoryTheory.HasShift C B] → Type u_1

full_name: CategoryTheory.instCategoryPullbackShift
code: instance : Category (PullbackShift C φ) 
goal: CategoryTheory.Category.{u_4, u_1} (CategoryTheory.PullbackShift C φ)

full_name: CategoryTheory.instHasShiftPullbackShift
code: /-- The shift on `PullbackShift C φ` is obtained by precomposing the shift on `C` with
the monoidal functor `Discrete.addMonoidalFunctor φ : Discrete A ⥤ Discrete B`. -/
noncomputable instance : HasShift (PullbackShift C φ) A 
goal: CategoryTheory.HasShift (CategoryTheory.PullbackShift C φ) A

full_name: CategoryTheory.instHasZeroObjectPullbackShift
code: instance [HasZeroObject C] : HasZeroObject (PullbackShift C φ) 
goal: CategoryTheory.Limits.HasZeroObject (CategoryTheory.PullbackShift C φ)

full_name: CategoryTheory.instPreadditivePullbackShift
code: instance [Preadditive C] : Preadditive (PullbackShift C φ) 
goal: CategoryTheory.Preadditive (CategoryTheory.PullbackShift C φ)

full_name: CategoryTheory.instAdditivePullbackShiftShiftFunctorOfCoeAddMonoidHom
code: instance [Preadditive C] (a : A) [(shiftFunctor C (φ a)).Additive] :
    (shiftFunctor (PullbackShift C φ) a).Additive 
goal: (CategoryTheory.shiftFunctor (CategoryTheory.PullbackShift C φ) a).Additive

full_name: CategoryTheory.pullbackShiftIso
code: /-- When `b = φ a`, this is the canonical
isomorphism `shiftFunctor (PullbackShift C φ) a ≅ shiftFunctor C b`. -/
noncomputable def pullbackShiftIso (a : A) (b : B) (h : b = φ a) :
    shiftFunctor (PullbackShift C φ) a ≅ shiftFunctor C b 
goal: CategoryTheory.shiftFunctor (CategoryTheory.PullbackShift C φ) a ≅ CategoryTheory.shiftFunctor C b

full_name: CategoryTheory.pullbackShiftFunctorZero_inv_app
code: lemma pullbackShiftFunctorZero_inv_app :
    (shiftFunctorZero _ A).inv.app X =
      (shiftFunctorZero C B).inv.app X ≫ (pullbackShiftIso C φ 0 0 (by simp)).inv.app X 
goal: (CategoryTheory.shiftFunctorZero (CategoryTheory.PullbackShift C φ) A).inv.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorZero C B).inv.app X)
    ((CategoryTheory.pullbackShiftIso C φ 0 0 ⋯).inv.app X)

full_name: CategoryTheory.pullbackShiftFunctorZero_hom_app
code: lemma pullbackShiftFunctorZero_hom_app :
    (shiftFunctorZero _ A).hom.app X =
      (pullbackShiftIso C φ 0 0 (by simp)).hom.app X ≫ (shiftFunctorZero C B).hom.app X 
goal: (CategoryTheory.shiftFunctorZero (CategoryTheory.PullbackShift C φ) A).hom.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.pullbackShiftIso C φ 0 0 ⋯).hom.app X)
    ((CategoryTheory.shiftFunctorZero C B).hom.app X)

full_name: CategoryTheory.pullbackShiftFunctorAdd'_inv_app
code: lemma pullbackShiftFunctorAdd'_inv_app :
    (shiftFunctorAdd' _ a₁ a₂ a₃ h).inv.app X =
      (shiftFunctor (PullbackShift C φ) a₂).map ((pullbackShiftIso C φ a₁ b₁ h₁).hom.app X) ≫
        (pullbackShiftIso C φ a₂ b₂ h₂).hom.app _ ≫
        (shiftFunctorAdd' C b₁ b₂ b₃ (by rw [h₁, h₂, h₃, ← h, φ.map_add])).inv.app X ≫
        (pullbackShiftIso C φ a₃ b₃ h₃).inv.app X 
goal: (CategoryTheory.shiftFunctorAdd' (CategoryTheory.PullbackShift C φ) a₁ a₂ a₃ h).inv.app X =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor (CategoryTheory.PullbackShift C φ) a₂).map
      ((CategoryTheory.pullbackShiftIso C φ a₁ b₁ h₁).hom.app X))
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.pullbackShiftIso C φ a₂ b₂ h₂).hom.app ((CategoryTheory.shiftFunctor C b₁).obj X))
      (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' C b₁ b₂ b₃ ⋯).inv.app X)
        ((CategoryTheory.pullbackShiftIso C φ a₃ b₃ h₃).inv.app X)))

full_name: CategoryTheory.pullbackShiftFunctorAdd'_hom_app
code: lemma pullbackShiftFunctorAdd'_hom_app :
    (shiftFunctorAdd' _ a₁ a₂ a₃ h).hom.app X =
      (pullbackShiftIso C φ a₃ b₃ h₃).hom.app X ≫
      (shiftFunctorAdd' C b₁ b₂ b₃ (by rw [h₁, h₂, h₃, ← h, φ.map_add])).hom.app X ≫
      (pullbackShiftIso C φ a₂ b₂ h₂).inv.app _ ≫
      (shiftFunctor (PullbackShift C φ) a₂).map ((pullbackShiftIso C φ a₁ b₁ h₁).inv.app X) 
goal: (CategoryTheory.shiftFunctorAdd' (CategoryTheory.PullbackShift C φ) a₁ a₂ a₃ h).hom.app X =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.pullbackShiftIso C φ a₃ b₃ h₃).hom.app X)
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' C b₁ b₂ b₃ ⋯).hom.app X)
      (CategoryTheory.CategoryStruct.comp
        ((CategoryTheory.pullbackShiftIso C φ a₂ b₂ h₂).inv.app ((CategoryTheory.shiftFunctor C b₁).obj X))
        ((CategoryTheory.shiftFunctor (CategoryTheory.PullbackShift C φ) a₂).map
          ((CategoryTheory.pullbackShiftIso C φ a₁ b₁ h₁).inv.app X))))