ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.shiftFunctorAdd_assoc_hom_app
@[reassoc]
lemma shiftFunctorAdd_assoc_hom_app (a₁ a₂ a₃ : A) (X : C) :
    (shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X ≫
      ((shiftFunctorAdd C a₁ a₂).hom.app X)⟦a₃⟧' =
    (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) (add_assoc _ _ _).symm).hom.app X ≫
      (shiftFunctorAdd C a₂ a₃).hom.app (X⟦a₁⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a₁ a₂ a₃ : A) (X : C)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd C (a₁ + a₂) a₃).hom.app X)
    ((CategoryTheory.shiftFunctor C a₃).map ((CategoryTheory.shiftFunctorAdd C a₁ a₂).hom.app X)) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯).hom.app X)
    ((CategoryTheory.shiftFunctorAdd C a₂ a₃).hom.app ((CategoryTheory.shiftFunctor C a₁).obj X))
-- CategoryTheory.shiftFunctorAdd_assoc_inv_app
@[reassoc]
lemma shiftFunctorAdd_assoc_inv_app (a₁ a₂ a₃ : A) (X : C) :
    ((shiftFunctorAdd C a₁ a₂).inv.app X)⟦a₃⟧' ≫
      (shiftFunctorAdd C (a₁ + a₂) a₃).inv.app X =
    (shiftFunctorAdd C a₂ a₃).inv.app (X⟦a₁⟧) ≫
      (shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) (add_assoc _ _ _).symm).inv.app X 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (a₁ a₂ a₃ : A) (X : C)
Goal: CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor C a₃).map ((CategoryTheory.shiftFunctorAdd C a₁ a₂).inv.app X))
    ((CategoryTheory.shiftFunctorAdd C (a₁ + a₂) a₃).inv.app X) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctorAdd C a₂ a₃).inv.app ((CategoryTheory.shiftFunctor C a₁).obj X))
    ((CategoryTheory.shiftFunctorAdd' C a₁ (a₂ + a₃) (a₁ + a₂ + a₃) ⋯).inv.app X)
-- CategoryTheory.HasShift.shift_obj_obj
@[simp]
theorem HasShift.shift_obj_obj (n : A) (X : C) : (HasShift.shift.obj ⟨n⟩).obj X = X⟦n⟧ 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (n : A) (X : C)
Goal: (CategoryTheory.HasShift.shift.obj { as := n }).obj X = (CategoryTheory.shiftFunctor C n).obj X
-- CategoryTheory.shift_shift'
theorem shift_shift' (i j : A) :
    f⟦i⟧'⟦j⟧' = (shiftAdd X i j).inv ≫ f⟦i + j⟧' ≫ (shiftAdd Y i j).hom 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (X Y : C) (f : X ⟶ Y) (i j : A)
Goal: (CategoryTheory.shiftFunctor C j).map ((CategoryTheory.shiftFunctor C i).map f) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.shiftAdd X i j).inv
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C (i + j)).map f)
      (CategoryTheory.shiftAdd Y i j).hom)
-- CategoryTheory.shiftZero'
theorem shiftZero' : f⟦(0 : A)⟧' = (shiftZero A X).hom ≫ f ≫ (shiftZero A Y).inv 
Arguments: {C : Type u} (A : Type u_1) [CategoryTheory.Category.{v, u} C] [AddMonoid A] [CategoryTheory.HasShift C A] (X Y : C) (f : X ⟶ Y)
Goal: (CategoryTheory.shiftFunctor C 0).map f =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.shiftZero A X).hom
    (CategoryTheory.CategoryStruct.comp f (CategoryTheory.shiftZero A Y).inv)
-- CategoryTheory.shiftEquiv'_functor
@[simps]
def shiftEquiv' (i j : A) (h : i + j = 0) : C ≌ C 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (i j : A) (h : i + j = 0)
Goal: (CategoryTheory.shiftEquiv' C i j h).functor = CategoryTheory.shiftFunctor C i
-- CategoryTheory.shiftEquiv'_unitIso
@[simps]
def shiftEquiv' (i j : A) (h : i + j = 0) : C ≌ C 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (i j : A) (h : i + j = 0)
Goal: (CategoryTheory.shiftEquiv' C i j h).unitIso = (CategoryTheory.shiftFunctorCompIsoId C i j h).symm
-- CategoryTheory.shiftEquiv'_inverse
@[simps]
def shiftEquiv' (i j : A) (h : i + j = 0) : C ≌ C 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (i j : A) (h : i + j = 0)
Goal: (CategoryTheory.shiftEquiv' C i j h).inverse = CategoryTheory.shiftFunctor C j
-- CategoryTheory.shiftEquiv'_counitIso
@[simps]
def shiftEquiv' (i j : A) (h : i + j = 0) : C ≌ C 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (i j : A) (h : i + j = 0)
Goal: (CategoryTheory.shiftEquiv' C i j h).counitIso = CategoryTheory.shiftFunctorCompIsoId C j i ⋯
-- CategoryTheory.shift_shift_neg'
theorem shift_shift_neg' (i : A) :
    f⟦i⟧'⟦-i⟧' = (shiftFunctorCompIsoId C i (-i) (add_neg_self i)).hom.app X ≫
      f ≫ (shiftFunctorCompIsoId C i (-i) (add_neg_self i)).inv.app Y 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] {X Y : C} (f : X ⟶ Y) (i : A)
Goal: (CategoryTheory.shiftFunctor C (-i)).map ((CategoryTheory.shiftFunctor C i).map f) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorCompIsoId C i (-i) ⋯).hom.app X)
    (CategoryTheory.CategoryStruct.comp f ((CategoryTheory.shiftFunctorCompIsoId C i (-i) ⋯).inv.app Y))
-- CategoryTheory.shift_neg_shift'
theorem shift_neg_shift' (i : A) :
    f⟦-i⟧'⟦i⟧' = (shiftFunctorCompIsoId C (-i) i (neg_add_self i)).hom.app X ≫ f ≫
      (shiftFunctorCompIsoId C (-i) i (neg_add_self i)).inv.app Y 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] {X Y : C} (f : X ⟶ Y) (i : A)
Goal: (CategoryTheory.shiftFunctor C i).map ((CategoryTheory.shiftFunctor C (-i)).map f) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorCompIsoId C (-i) i ⋯).hom.app X)
    (CategoryTheory.CategoryStruct.comp f ((CategoryTheory.shiftFunctorCompIsoId C (-i) i ⋯).inv.app Y))
-- CategoryTheory.shift_equiv_triangle
theorem shift_equiv_triangle (n : A) (X : C) :
    (shiftShiftNeg X n).inv⟦n⟧' ≫ (shiftNegShift (X⟦n⟧) n).hom = 𝟙 (X⟦n⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (n : A) (X : C)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n).map (CategoryTheory.shiftShiftNeg X n).inv)
    (CategoryTheory.shiftNegShift ((CategoryTheory.shiftFunctor C n).obj X) n).hom =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.shiftFunctor C n).obj X)
-- CategoryTheory.shift_shiftFunctorCompIsoId_hom_app
theorem shift_shiftFunctorCompIsoId_hom_app (n m : A) (h : n + m = 0) (X : C) :
    ((shiftFunctorCompIsoId C n m h).hom.app X)⟦n⟧' =
    (shiftFunctorCompIsoId C m n
      (by rw [← neg_eq_of_add_eq_zero_left h, add_right_neg])).hom.app (X⟦n⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (n m : A) (h : n + m = 0) (X : C)
Goal: (CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorCompIsoId C n m h).hom.app X) =
  (CategoryTheory.shiftFunctorCompIsoId C m n ⋯).hom.app ((CategoryTheory.shiftFunctor C n).obj X)
-- CategoryTheory.shift_shiftFunctorCompIsoId_inv_app
theorem shift_shiftFunctorCompIsoId_inv_app (n m : A) (h : n + m = 0) (X : C) :
    ((shiftFunctorCompIsoId C n m h).inv.app X)⟦n⟧' =
    ((shiftFunctorCompIsoId C m n
      (by rw [← neg_eq_of_add_eq_zero_left h, add_right_neg])).inv.app (X⟦n⟧)) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (n m : A) (h : n + m = 0) (X : C)
Goal: (CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorCompIsoId C n m h).inv.app X) =
  (CategoryTheory.shiftFunctorCompIsoId C m n ⋯).inv.app ((CategoryTheory.shiftFunctor C n).obj X)
-- CategoryTheory.shift_shiftFunctorCompIsoId_add_neg_self_hom_app
theorem shift_shiftFunctorCompIsoId_add_neg_self_hom_app (n : A) (X : C) :
    ((shiftFunctorCompIsoId C n (-n) (add_neg_self n)).hom.app X)⟦n⟧' =
    (shiftFunctorCompIsoId C (-n) n (neg_add_self n)).hom.app (X⟦n⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (n : A) (X : C)
Goal: (CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorCompIsoId C n (-n) ⋯).hom.app X) =
  (CategoryTheory.shiftFunctorCompIsoId C (-n) n ⋯).hom.app ((CategoryTheory.shiftFunctor C n).obj X)
-- CategoryTheory.shift_shiftFunctorCompIsoId_add_neg_self_inv_app
theorem shift_shiftFunctorCompIsoId_add_neg_self_inv_app (n : A) (X : C) :
    ((shiftFunctorCompIsoId C n (-n) (add_neg_self n)).inv.app X)⟦n⟧' =
    (shiftFunctorCompIsoId C (-n) n (neg_add_self n)).inv.app (X⟦n⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (n : A) (X : C)
Goal: (CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorCompIsoId C n (-n) ⋯).inv.app X) =
  (CategoryTheory.shiftFunctorCompIsoId C (-n) n ⋯).inv.app ((CategoryTheory.shiftFunctor C n).obj X)
-- CategoryTheory.shift_shiftFunctorCompIsoId_neg_add_self_hom_app
theorem shift_shiftFunctorCompIsoId_neg_add_self_hom_app (n : A) (X : C) :
    ((shiftFunctorCompIsoId C (-n) n (neg_add_self n)).hom.app X)⟦-n⟧' =
    (shiftFunctorCompIsoId C n (-n) (add_neg_self n)).hom.app (X⟦-n⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (n : A) (X : C)
Goal: (CategoryTheory.shiftFunctor C (-n)).map ((CategoryTheory.shiftFunctorCompIsoId C (-n) n ⋯).hom.app X) =
  (CategoryTheory.shiftFunctorCompIsoId C n (-n) ⋯).hom.app ((CategoryTheory.shiftFunctor C (-n)).obj X)
-- CategoryTheory.shift_shiftFunctorCompIsoId_neg_add_self_inv_app
theorem shift_shiftFunctorCompIsoId_neg_add_self_inv_app (n : A) (X : C) :
    ((shiftFunctorCompIsoId C (-n) n (neg_add_self n)).inv.app X)⟦-n⟧' =
    (shiftFunctorCompIsoId C n (-n) (add_neg_self n)).inv.app (X⟦-n⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] (n : A) (X : C)
Goal: (CategoryTheory.shiftFunctor C (-n)).map ((CategoryTheory.shiftFunctorCompIsoId C (-n) n ⋯).inv.app X) =
  (CategoryTheory.shiftFunctorCompIsoId C n (-n) ⋯).inv.app ((CategoryTheory.shiftFunctor C (-n)).obj X)
-- CategoryTheory.shift_zero_eq_zero
theorem shift_zero_eq_zero (X Y : C) (n : A) : (0 : X ⟶ Y)⟦n⟧' = (0 : X⟦n⟧ ⟶ Y⟦n⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddGroup A] [CategoryTheory.HasShift C A] [CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C) (n : A)
Goal: (CategoryTheory.shiftFunctor C n).map 0 = 0
-- CategoryTheory.shiftFunctorComm_eq
lemma shiftFunctorComm_eq (i j k : A) (h : i + j = k) :
    shiftFunctorComm C i j = (shiftFunctorAdd' C i j k h).symm ≪≫
      shiftFunctorAdd' C j i k (by rw [add_comm j i, h]) 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] (i j k : A) (h : i + j = k)
Goal: CategoryTheory.shiftFunctorComm C i j =
  (CategoryTheory.shiftFunctorAdd' C i j k h).symm ≪≫ CategoryTheory.shiftFunctorAdd' C j i k ⋯
-- CategoryTheory.shiftFunctorComm_eq_refl
@[simp]
lemma shiftFunctorComm_eq_refl (i : A) :
    shiftFunctorComm C i i = Iso.refl _ 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] (i : A)
Goal: CategoryTheory.shiftFunctorComm C i i =
  CategoryTheory.Iso.refl ((CategoryTheory.shiftFunctor C i).comp (CategoryTheory.shiftFunctor C i))
-- CategoryTheory.shiftFunctorComm_symm
lemma shiftFunctorComm_symm (i j : A) :
    (shiftFunctorComm C i j).symm = shiftFunctorComm C j i 
Arguments: (C : Type u) {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] (i j : A)
Goal: (CategoryTheory.shiftFunctorComm C i j).symm = CategoryTheory.shiftFunctorComm C j i
-- CategoryTheory.shiftComm_symm
@[simp]
theorem shiftComm_symm (i j : A) : (shiftComm X i j).symm = shiftComm X j i 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] (X : C) (i j : A)
Goal: (CategoryTheory.shiftComm X i j).symm = CategoryTheory.shiftComm X j i
-- CategoryTheory.shiftComm'
theorem shiftComm' (i j : A) :
    f⟦i⟧'⟦j⟧' = (shiftComm _ _ _).hom ≫ f⟦j⟧'⟦i⟧' ≫ (shiftComm _ _ _).hom 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] {X Y : C} (f : X ⟶ Y) (i j : A)
Goal: (CategoryTheory.shiftFunctor C j).map ((CategoryTheory.shiftFunctor C i).map f) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.shiftComm X i j).hom
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.shiftFunctor C i).map ((CategoryTheory.shiftFunctor C j).map f))
      (CategoryTheory.shiftComm Y j i).hom)
-- CategoryTheory.shiftComm_hom_comp
@[reassoc]
theorem shiftComm_hom_comp (i j : A) :
    (shiftComm X i j).hom ≫ f⟦j⟧'⟦i⟧' = f⟦i⟧'⟦j⟧' ≫ (shiftComm Y i j).hom 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] {X Y : C} (f : X ⟶ Y) (i j : A)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.shiftComm X i j).hom
    ((CategoryTheory.shiftFunctor C i).map ((CategoryTheory.shiftFunctor C j).map f)) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C j).map ((CategoryTheory.shiftFunctor C i).map f))
    (CategoryTheory.shiftComm Y i j).hom
-- CategoryTheory.shiftFunctorZero_hom_app_shift
lemma shiftFunctorZero_hom_app_shift (n : A) :
    (shiftFunctorZero C A).hom.app (X⟦n⟧) =
    (shiftFunctorComm C n 0).hom.app X ≫ ((shiftFunctorZero C A).hom.app X)⟦n⟧' 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] {X : C} (n : A)
Goal: (CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C n).obj X) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorComm C n 0).hom.app X)
    ((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorZero C A).hom.app X))
-- CategoryTheory.shiftFunctorZero_inv_app_shift
lemma shiftFunctorZero_inv_app_shift (n : A) :
    (shiftFunctorZero C A).inv.app (X⟦n⟧) =
  ((shiftFunctorZero C A).inv.app X)⟦n⟧' ≫ (shiftFunctorComm C n 0).inv.app X 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] {X : C} (n : A)
Goal: (CategoryTheory.shiftFunctorZero C A).inv.app ((CategoryTheory.shiftFunctor C n).obj X) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctorZero C A).inv.app X))
    ((CategoryTheory.shiftFunctorComm C n 0).inv.app X)
-- CategoryTheory.shiftFunctorComm_zero_hom_app
lemma shiftFunctorComm_zero_hom_app (a : A) :
    (shiftFunctorComm C a 0).hom.app X =
      (shiftFunctorZero C A).hom.app (X⟦a⟧) ≫ ((shiftFunctorZero C A).inv.app X)⟦a⟧' 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] {X : C} (a : A)
Goal: (CategoryTheory.shiftFunctorComm C a 0).hom.app X =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctorZero C A).hom.app ((CategoryTheory.shiftFunctor C a).obj X))
    ((CategoryTheory.shiftFunctor C a).map ((CategoryTheory.shiftFunctorZero C A).inv.app X))
-- CategoryTheory.shiftFunctorComm_hom_app_comp_shift_shiftFunctorAdd_hom_app
@[reassoc]
lemma shiftFunctorComm_hom_app_comp_shift_shiftFunctorAdd_hom_app (m₁ m₂ m₃ : A) (X : C) :
    (shiftFunctorComm C m₁ (m₂ + m₃)).hom.app X ≫
    ((shiftFunctorAdd C m₂ m₃).hom.app X)⟦m₁⟧' =
  (shiftFunctorAdd C m₂ m₃).hom.app (X⟦m₁⟧) ≫
    ((shiftFunctorComm C m₁ m₂).hom.app X)⟦m₃⟧' ≫
    (shiftFunctorComm C m₁ m₃).hom.app (X⟦m₂⟧) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] [AddCommMonoid A] [CategoryTheory.HasShift C A] (m₁ m₂ m₃ : A) (X : C)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorComm C m₁ (m₂ + m₃)).hom.app X)
    ((CategoryTheory.shiftFunctor C m₁).map ((CategoryTheory.shiftFunctorAdd C m₂ m₃).hom.app X)) =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.shiftFunctorAdd C m₂ m₃).hom.app ((CategoryTheory.shiftFunctor C m₁).obj X))
    (CategoryTheory.CategoryStruct.comp
      ((CategoryTheory.shiftFunctor C m₃).map ((CategoryTheory.shiftFunctorComm C m₁ m₂).hom.app X))
      ((CategoryTheory.shiftFunctorComm C m₁ m₃).hom.app ((CategoryTheory.shiftFunctor C m₂).obj X)))
-- CategoryTheory.Functor.FullyFaithful.hasShift.map_zero_hom_app
@[simp]
lemma map_zero_hom_app (X : C) :
    F.map ((zero hF s i).hom.app X) =
      (i 0).hom.app X ≫ (shiftFunctorZero D A).hom.app (F.obj X) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] [AddMonoid A] [CategoryTheory.HasShift D A] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (s : A → CategoryTheory.Functor C C) (i : (i : A) → (s i).comp F ≅ F.comp (CategoryTheory.shiftFunctor D i)) (X : C)
Goal: F.map ((CategoryTheory.Functor.FullyFaithful.hasShift.zero hF s i).hom.app X) =
  CategoryTheory.CategoryStruct.comp ((i 0).hom.app X) ((CategoryTheory.shiftFunctorZero D A).hom.app (F.obj X))
-- CategoryTheory.Functor.FullyFaithful.hasShift.map_zero_inv_app
@[simp]
lemma map_zero_inv_app (X : C) :
    F.map ((zero hF s i).inv.app X) =
      (shiftFunctorZero D A).inv.app (F.obj X) ≫ (i 0).inv.app X 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] [AddMonoid A] [CategoryTheory.HasShift D A] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (s : A → CategoryTheory.Functor C C) (i : (i : A) → (s i).comp F ≅ F.comp (CategoryTheory.shiftFunctor D i)) (X : C)
Goal: F.map ((CategoryTheory.Functor.FullyFaithful.hasShift.zero hF s i).inv.app X) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorZero D A).inv.app (F.obj X)) ((i 0).inv.app X)
-- CategoryTheory.Functor.FullyFaithful.hasShift.map_add_hom_app
@[simp]
lemma map_add_hom_app (a b : A) (X : C) :
    F.map ((add hF s i a b).hom.app X) =
      (i (a + b)).hom.app X ≫ (shiftFunctorAdd D a b).hom.app (F.obj X) ≫
        ((i a).inv.app X)⟦b⟧' ≫ (i b).inv.app ((s a).obj X) 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] [AddMonoid A] [CategoryTheory.HasShift D A] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (s : A → CategoryTheory.Functor C C) (i : (i : A) → (s i).comp F ≅ F.comp (CategoryTheory.shiftFunctor D i)) (a b : A) (X : C)
Goal: F.map ((CategoryTheory.Functor.FullyFaithful.hasShift.add hF s i a b).hom.app X) =
  CategoryTheory.CategoryStruct.comp ((i (a + b)).hom.app X)
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd D a b).hom.app (F.obj X))
      (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D b).map ((i a).inv.app X))
        ((i b).inv.app ((s a).obj X))))
-- CategoryTheory.Functor.FullyFaithful.hasShift.map_add_inv_app
@[simp]
lemma map_add_inv_app (a b : A) (X : C) :
    F.map ((add hF s i a b).inv.app X) =
      (i b).hom.app ((s a).obj X) ≫ ((i a).hom.app X)⟦b⟧' ≫
        (shiftFunctorAdd D a b).inv.app (F.obj X) ≫ (i (a + b)).inv.app X 
Arguments: {C : Type u} {A : Type u_1} [CategoryTheory.Category.{v, u} C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] [AddMonoid A] [CategoryTheory.HasShift D A] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (s : A → CategoryTheory.Functor C C) (i : (i : A) → (s i).comp F ≅ F.comp (CategoryTheory.shiftFunctor D i)) (a b : A) (X : C)
Goal: F.map ((CategoryTheory.Functor.FullyFaithful.hasShift.add hF s i a b).inv.app X) =
  CategoryTheory.CategoryStruct.comp ((i b).hom.app ((s a).obj X))
    (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor D b).map ((i a).hom.app X))
      (CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctorAdd D a b).inv.app (F.obj X))
        ((i (a + b)).inv.app X)))
-- CategoryTheory.extendFan_π_app
@[simps!] -- Porting note: removed semi-reducible config
def extendFan {n : ℕ} {f : Fin (n + 1) → C} (c₁ : Fan fun i : Fin n => f i.succ)
    (c₂ : BinaryFan (f 0) c₁.pt) : Fan f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {n : ℕ} {f : Fin (n + 1) → C} (c₁ : CategoryTheory.Limits.Fan fun i => f i.succ) (c₂ : CategoryTheory.Limits.BinaryFan (f 0) c₁.pt) (X : CategoryTheory.Discrete (Fin (n + 1)))
Goal: (CategoryTheory.extendFan c₁ c₂).π.app X = Fin.cases c₂.fst (fun i => c₂.snd ≫ c₁.π.app { as := i }) X.as
-- CategoryTheory.extendFan_pt
@[simps!] -- Porting note: removed semi-reducible config
def extendFan {n : ℕ} {f : Fin (n + 1) → C} (c₁ : Fan fun i : Fin n => f i.succ)
    (c₂ : BinaryFan (f 0) c₁.pt) : Fan f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {n : ℕ} {f : Fin (n + 1) → C} (c₁ : CategoryTheory.Limits.Fan fun i => f i.succ) (c₂ : CategoryTheory.Limits.BinaryFan (f 0) c₁.pt)
Goal: (CategoryTheory.extendFan c₁ c₂).pt = c₂.pt
-- _private.Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts.0.CategoryTheory.hasProduct_fin
private theorem hasProduct_fin : ∀ (n : ℕ) (f : Fin n → C), HasProduct f
  
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryProducts C] [CategoryTheory.Limits.HasTerminal C] (n : ℕ) (f : Fin n → C)
Goal: CategoryTheory.Limits.HasProduct f
-- CategoryTheory.hasFiniteProducts_of_has_binary_and_terminal
theorem hasFiniteProducts_of_has_binary_and_terminal : HasFiniteProducts C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryProducts C] [CategoryTheory.Limits.HasTerminal C]
Goal: CategoryTheory.Limits.HasFiniteProducts C
-- CategoryTheory.extendCofan_ι_app

@[simps!] -- Porting note: removed semireducible config
def extendCofan {n : ℕ} {f : Fin (n + 1) → C} (c₁ : Cofan fun i : Fin n => f i.succ)
    (c₂ : BinaryCofan (f 0) c₁.pt) : Cofan f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {n : ℕ} {f : Fin (n + 1) → C} (c₁ : CategoryTheory.Limits.Cofan fun i => f i.succ) (c₂ : CategoryTheory.Limits.BinaryCofan (f 0) c₁.pt) (X : CategoryTheory.Discrete (Fin (n + 1)))
Goal: (CategoryTheory.extendCofan c₁ c₂).ι.app X = Fin.cases c₂.inl (fun i => c₁.ι.app { as := i } ≫ c₂.inr) X.as
-- CategoryTheory.extendCofan_pt

@[simps!] -- Porting note: removed semireducible config
def extendCofan {n : ℕ} {f : Fin (n + 1) → C} (c₁ : Cofan fun i : Fin n => f i.succ)
    (c₂ : BinaryCofan (f 0) c₁.pt) : Cofan f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {n : ℕ} {f : Fin (n + 1) → C} (c₁ : CategoryTheory.Limits.Cofan fun i => f i.succ) (c₂ : CategoryTheory.Limits.BinaryCofan (f 0) c₁.pt)
Goal: (CategoryTheory.extendCofan c₁ c₂).pt = c₂.pt
-- _private.Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts.0.CategoryTheory.hasCoproduct_fin
private theorem hasCoproduct_fin : ∀ (n : ℕ) (f : Fin n → C), HasCoproduct f
  
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C] [CategoryTheory.Limits.HasInitial C] (n : ℕ) (f : Fin n → C)
Goal: CategoryTheory.Limits.HasCoproduct f
-- CategoryTheory.hasFiniteCoproducts_of_has_binary_and_initial
theorem hasFiniteCoproducts_of_has_binary_and_initial : HasFiniteCoproducts C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C] [CategoryTheory.Limits.HasInitial C]
Goal: CategoryTheory.Limits.HasFiniteCoproducts C
-- CategoryTheory.MorphismProperty.LeftFraction.hs
structure LeftFraction (W : MorphismProperty C) (X Y : C) where
    {Y' : C}
    f : X ⟶ Y'
    s : Y ⟶ Y'
    hs : W s
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C} (self : W.LeftFraction X Y)
Goal: W self.s
-- CategoryTheory.MorphismProperty.LeftFraction.ofHom_Y'
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.LeftFraction X Y 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] (W : CategoryTheory.MorphismProperty C) {X Y : C} (f : X ⟶ Y) [W.ContainsIdentities]
Goal: (CategoryTheory.MorphismProperty.LeftFraction.ofHom W f).Y' = Y