ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Discrete.functor_map
@[simp]
theorem functor_map {I : Type u₁} (F : I → C) {i : Discrete I} (f : i ⟶ i) :
    (Discrete.functor F).map f = 𝟙 (F i.as) 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} (F : I → C) {i : CategoryTheory.Discrete I} (f : i ⟶ i)
Goal: (CategoryTheory.Discrete.functor F).map f = CategoryTheory.CategoryStruct.id (F i.as)
-- CategoryTheory.Discrete.functor_obj_eq_as
@[simp]
theorem functor_obj_eq_as {I : Type u₁} (F : I → C) (X : Discrete I) :
    (Discrete.functor F).obj X = F X.as 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} (F : I → C) (X : CategoryTheory.Discrete I)
Goal: (CategoryTheory.Discrete.functor F).obj X = F X.as
-- CategoryTheory.Discrete.functorComp_hom_app
@[simps!]
def functorComp {I : Type u₁} {J : Type u₁'} (f : J → C) (g : I → J) :
    Discrete.functor (f ∘ g) ≅ Discrete.functor (Discrete.mk ∘ g) ⋙ Discrete.functor f 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} {J : Type u₁'} (f : J → C) (g : I → J) (X : CategoryTheory.Discrete I)
Goal: (CategoryTheory.Discrete.functorComp f g).hom.app X = CategoryTheory.CategoryStruct.id (f (g X.as))
-- CategoryTheory.Discrete.functorComp_inv_app
@[simps!]
def functorComp {I : Type u₁} {J : Type u₁'} (f : J → C) (g : I → J) :
    Discrete.functor (f ∘ g) ≅ Discrete.functor (Discrete.mk ∘ g) ⋙ Discrete.functor f 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} {J : Type u₁'} (f : J → C) (g : I → J) (X : CategoryTheory.Discrete I)
Goal: (CategoryTheory.Discrete.functorComp f g).inv.app X = CategoryTheory.CategoryStruct.id (f (g X.as))
-- CategoryTheory.Discrete.natTrans_app
@[simps]
def natTrans {I : Type u₁} {F G : Discrete I ⥤ C} (f : ∀ i : Discrete I, F.obj i ⟶ G.obj i) :
    F ⟶ G 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} {F G : CategoryTheory.Functor (CategoryTheory.Discrete I) C} (f : (i : CategoryTheory.Discrete I) → F.obj i ⟶ G.obj i) (i : CategoryTheory.Discrete I)
Goal: (CategoryTheory.Discrete.natTrans f).app i = f i
-- CategoryTheory.Discrete.natIso_inv_app
@[simps!]
def natIso {I : Type u₁} {F G : Discrete I ⥤ C} (f : ∀ i : Discrete I, F.obj i ≅ G.obj i) :
    F ≅ G 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} {F G : CategoryTheory.Functor (CategoryTheory.Discrete I) C} (f : (i : CategoryTheory.Discrete I) → F.obj i ≅ G.obj i) (X : CategoryTheory.Discrete I)
Goal: (CategoryTheory.Discrete.natIso f).inv.app X = (f X).inv
-- CategoryTheory.Discrete.natIso_hom_app
@[simps!]
def natIso {I : Type u₁} {F G : Discrete I ⥤ C} (f : ∀ i : Discrete I, F.obj i ≅ G.obj i) :
    F ≅ G 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} {F G : CategoryTheory.Functor (CategoryTheory.Discrete I) C} (f : (i : CategoryTheory.Discrete I) → F.obj i ≅ G.obj i) (X : CategoryTheory.Discrete I)
Goal: (CategoryTheory.Discrete.natIso f).hom.app X = (f X).hom
-- CategoryTheory.Discrete.natIso_app
@[simp]
theorem natIso_app {I : Type u₁} {F G : Discrete I ⥤ C} (f : ∀ i : Discrete I, F.obj i ≅ G.obj i)
    (i : Discrete I) : (Discrete.natIso f).app i = f i 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} {F G : CategoryTheory.Functor (CategoryTheory.Discrete I) C} (f : (i : CategoryTheory.Discrete I) → F.obj i ≅ G.obj i) (i : CategoryTheory.Discrete I)
Goal: (CategoryTheory.Discrete.natIso f).app i = f i
-- CategoryTheory.Discrete.equivalence_functor
@[simps]
def equivalence {I : Type u₁} {J : Type u₂} (e : I ≃ J) : Discrete I ≌ Discrete J 
Arguments: {I : Type u₁} {J : Type u₂} (e : I ≃ J)
Goal: (CategoryTheory.Discrete.equivalence e).functor = CategoryTheory.Discrete.functor (CategoryTheory.Discrete.mk ∘ ⇑e)
-- CategoryTheory.Discrete.equivalence_counitIso
@[simps]
def equivalence {I : Type u₁} {J : Type u₂} (e : I ≃ J) : Discrete I ≌ Discrete J 
Arguments: {I : Type u₁} {J : Type u₂} (e : I ≃ J)
Goal: (CategoryTheory.Discrete.equivalence e).counitIso = CategoryTheory.Discrete.natIso fun j => CategoryTheory.eqToIso ⋯
-- CategoryTheory.Discrete.equivalence_unitIso
@[simps]
def equivalence {I : Type u₁} {J : Type u₂} (e : I ≃ J) : Discrete I ≌ Discrete J 
Arguments: {I : Type u₁} {J : Type u₂} (e : I ≃ J)
Goal: (CategoryTheory.Discrete.equivalence e).unitIso = CategoryTheory.Discrete.natIso fun i => CategoryTheory.eqToIso ⋯
-- CategoryTheory.Discrete.equivalence_inverse
@[simps]
def equivalence {I : Type u₁} {J : Type u₂} (e : I ≃ J) : Discrete I ≌ Discrete J 
Arguments: {I : Type u₁} {J : Type u₂} (e : I ≃ J)
Goal: (CategoryTheory.Discrete.equivalence e).inverse = CategoryTheory.Discrete.functor (CategoryTheory.Discrete.mk ∘ ⇑e.symm)
-- CategoryTheory.Discrete.equivOfEquivalence_symm_apply
@[simps]
def equivOfEquivalence {α : Type u₁} {β : Type u₂} (h : Discrete α ≌ Discrete β) : α ≃ β 
Arguments: {α : Type u₁} {β : Type u₂} (h : CategoryTheory.Discrete α ≌ CategoryTheory.Discrete β)
Goal: ∀ (a : β),
  (CategoryTheory.Discrete.equivOfEquivalence h).symm a =
    (CategoryTheory.Discrete.as ∘ h.inverse.obj ∘ CategoryTheory.Discrete.mk) a
-- CategoryTheory.Discrete.equivOfEquivalence_apply
@[simps]
def equivOfEquivalence {α : Type u₁} {β : Type u₂} (h : Discrete α ≌ Discrete β) : α ≃ β 
Arguments: {α : Type u₁} {β : Type u₂} (h : CategoryTheory.Discrete α ≌ CategoryTheory.Discrete β)
Goal: ∀ (a : α),
  (CategoryTheory.Discrete.equivOfEquivalence h) a =
    (CategoryTheory.Discrete.as ∘ h.functor.obj ∘ CategoryTheory.Discrete.mk) a
-- CategoryTheory.Discrete.opposite_inverse_obj
@[simps! functor_obj_as inverse_obj]
protected def opposite (α : Type u₁) : (Discrete α)ᵒᵖ ≌ Discrete α 
Arguments: (α : Type u₁)
Goal: ∀ (a : CategoryTheory.Discrete α), (CategoryTheory.Discrete.opposite α).inverse.obj a = Opposite.op a
-- CategoryTheory.Discrete.opposite_functor_obj_as
@[simps! functor_obj_as inverse_obj]
protected def opposite (α : Type u₁) : (Discrete α)ᵒᵖ ≌ Discrete α 
Arguments: (α : Type u₁) (X : (CategoryTheory.Discrete α)ᵒᵖ)
Goal: ((CategoryTheory.Discrete.opposite α).functor.obj X).as = (Opposite.unop X).as
-- CategoryTheory.Discrete.functor_map_id
@[simp]
theorem functor_map_id (F : Discrete J ⥤ C) {j : Discrete J} (f : j ⟶ j) :
    F.map f = 𝟙 (F.obj j) 
Arguments: {J : Type v₁} {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] (F : CategoryTheory.Functor (CategoryTheory.Discrete J) C) {j : CategoryTheory.Discrete J} (f : j ⟶ j)
Goal: F.map f = CategoryTheory.CategoryStruct.id (F.obj j)
-- CategoryTheory.piEquivalenceFunctorDiscrete_counitIso
@[simps]
def piEquivalenceFunctorDiscrete (J : Type u₂) (C : Type u₁) [Category.{v₁} C] :
    (J → C) ≌ (Discrete J ⥤ C) 
Arguments: (J : Type u₂) (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: (CategoryTheory.piEquivalenceFunctorDiscrete J C).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun F =>
      CategoryTheory.NatIso.ofComponents
        (fun j =>
          CategoryTheory.Iso.refl
            ((({ obj := fun F j => F.obj { as := j }, map := fun {X Y} f j => f.app { as := j }, map_id := ⋯,
                          map_comp := ⋯ }.comp
                      { obj := fun F => CategoryTheory.Discrete.functor F,
                        map := fun {X Y} f => CategoryTheory.Discrete.natTrans fun j => f j.as, map_id := ⋯,
                        map_comp := ⋯ }).obj
                  F).obj
              j))
        ⋯)
    ⋯
-- CategoryTheory.piEquivalenceFunctorDiscrete_inverse_map
@[simps]
def piEquivalenceFunctorDiscrete (J : Type u₂) (C : Type u₁) [Category.{v₁} C] :
    (J → C) ≌ (Discrete J ⥤ C) 
Arguments: (J : Type u₂) (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : CategoryTheory.Functor (CategoryTheory.Discrete J) C} (f : X ⟶ Y) (j : J),
  (CategoryTheory.piEquivalenceFunctorDiscrete J C).inverse.map f j = f.app { as := j }
-- CategoryTheory.piEquivalenceFunctorDiscrete_functor_map
@[simps]
def piEquivalenceFunctorDiscrete (J : Type u₂) (C : Type u₁) [Category.{v₁} C] :
    (J → C) ≌ (Discrete J ⥤ C) 
Arguments: (J : Type u₂) (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: ∀ {X Y : J → C} (f : X ⟶ Y),
  (CategoryTheory.piEquivalenceFunctorDiscrete J C).functor.map f = CategoryTheory.Discrete.natTrans fun j => f j.as
-- CategoryTheory.piEquivalenceFunctorDiscrete_unitIso
@[simps]
def piEquivalenceFunctorDiscrete (J : Type u₂) (C : Type u₁) [Category.{v₁} C] :
    (J → C) ≌ (Discrete J ⥤ C) 
Arguments: (J : Type u₂) (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C]
Goal: (CategoryTheory.piEquivalenceFunctorDiscrete J C).unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (J → C))
-- CategoryTheory.piEquivalenceFunctorDiscrete_inverse_obj
@[simps]
def piEquivalenceFunctorDiscrete (J : Type u₂) (C : Type u₁) [Category.{v₁} C] :
    (J → C) ≌ (Discrete J ⥤ C) 
Arguments: (J : Type u₂) (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (F : CategoryTheory.Functor (CategoryTheory.Discrete J) C) (j : J)
Goal: (CategoryTheory.piEquivalenceFunctorDiscrete J C).inverse.obj F j = F.obj { as := j }
-- CategoryTheory.piEquivalenceFunctorDiscrete_functor_obj
@[simps]
def piEquivalenceFunctorDiscrete (J : Type u₂) (C : Type u₁) [Category.{v₁} C] :
    (J → C) ≌ (Discrete J ⥤ C) 
Arguments: (J : Type u₂) (C : Type u₁) [CategoryTheory.Category.{v₁, u₁} C] (F : J → C)
Goal: (CategoryTheory.piEquivalenceFunctorDiscrete J C).functor.obj F = CategoryTheory.Discrete.functor F
-- CategoryTheory.MorphismProperty.IsCompatibleWithTriangulation.compatible_with_triangulation
class IsCompatibleWithTriangulation (W : MorphismProperty C)
    extends W.IsCompatibleWithShift ℤ : Prop where
  compatible_with_triangulation (T₁ T₂ : Triangle C)
    (_ : T₁ ∈ distTriang C) (_ : T₂ ∈ distTriang C)
    (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂) (_ : W a) (_ : W b)
    (_ : T₁.mor₁ ≫ b = a ≫ T₂.mor₁) :
      ∃ (c : T₁.obj₃ ⟶ T₂.obj₃) (_ : W c),
        (T₁.mor₂ ≫ c = b ≫ T₂.mor₂) ∧ (T₁.mor₃ ≫ a⟦1⟧' = c ≫ T₂.mor₃)
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] {W : CategoryTheory.MorphismProperty C} [self : W.IsCompatibleWithTriangulation] (T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C)
Goal: T₁ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles →
  T₂ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles →
    ∀ (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂),
      W a →
        W b →
          CategoryTheory.CategoryStruct.comp T₁.mor₁ b = CategoryTheory.CategoryStruct.comp a T₂.mor₁ →
            ∃ c,
              ∃ (_ : W c),
                CategoryTheory.CategoryStruct.comp T₁.mor₂ c = CategoryTheory.CategoryStruct.comp b T₂.mor₂ ∧
                  CategoryTheory.CategoryStruct.comp T₁.mor₃ ((CategoryTheory.shiftFunctor C 1).map a) =
                    CategoryTheory.CategoryStruct.comp c T₂.mor₃
-- CategoryTheory.Functor.essImageDistTriang_mem_of_iso
lemma essImageDistTriang_mem_of_iso {T₁ T₂ : Triangle D} (e : T₂ ≅ T₁)
    (h : T₁ ∈ L.essImageDistTriang) : T₂ ∈ L.essImageDistTriang 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] (L : CategoryTheory.Functor C D) [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.HasShift D ℤ] [L.CommShift ℤ] {T₁ T₂ : CategoryTheory.Pretriangulated.Triangle D} (e : T₂ ≅ T₁) (h : T₁ ∈ L.essImageDistTriang)
Goal: T₂ ∈ L.essImageDistTriang
-- CategoryTheory.Functor.contractible_mem_essImageDistTriang
lemma contractible_mem_essImageDistTriang [EssSurj L] [HasZeroObject D]
    [HasZeroMorphisms D] [L.PreservesZeroMorphisms] (X : D) :
    contractibleTriangle X ∈ L.essImageDistTriang 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] (L : CategoryTheory.Functor C D) [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.HasShift D ℤ] [L.CommShift ℤ] [L.EssSurj] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasZeroMorphisms D] [L.PreservesZeroMorphisms] (X : D)
Goal: CategoryTheory.Pretriangulated.contractibleTriangle X ∈ L.essImageDistTriang
-- CategoryTheory.Functor.rotate_essImageDistTriang
lemma rotate_essImageDistTriang [Preadditive D] [L.Additive]
    [∀ (n : ℤ), (shiftFunctor D n).Additive] (T : Triangle D) :
  T ∈ L.essImageDistTriang ↔ T.rotate ∈ L.essImageDistTriang 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] (L : CategoryTheory.Functor C D) [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.HasShift D ℤ] [L.CommShift ℤ] [CategoryTheory.Preadditive D] [L.Additive] [∀ (n : ℤ), (CategoryTheory.shiftFunctor D n).Additive] (T : CategoryTheory.Pretriangulated.Triangle D)
Goal: T ∈ L.essImageDistTriang ↔ T.rotate ∈ L.essImageDistTriang
-- CategoryTheory.Functor.complete_distinguished_essImageDistTriang_morphism
lemma complete_distinguished_essImageDistTriang_morphism
    (H : ∀ (T₁' T₂' : Triangle C) (_ : T₁' ∈ distTriang C) (_ : T₂' ∈ distTriang C)
      (a : L.obj (T₁'.obj₁) ⟶ L.obj (T₂'.obj₁)) (b : L.obj (T₁'.obj₂) ⟶ L.obj (T₂'.obj₂))
      (_ : L.map T₁'.mor₁ ≫ b = a ≫ L.map T₂'.mor₁),
      ∃ (φ : L.mapTriangle.obj T₁' ⟶ L.mapTriangle.obj T₂'), φ.hom₁ = a ∧ φ.hom₂ = b)
    (T₁ T₂ : Triangle D)
    (hT₁ : T₁ ∈ Functor.essImageDistTriang L) (hT₂ : T₂ ∈ L.essImageDistTriang)
    (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂) (fac : T₁.mor₁ ≫ b = a ≫ T₂.mor₁) :
    ∃ c, T₁.mor₂ ≫ c = b ≫ T₂.mor₂ ∧ T₁.mor₃ ≫ a⟦1⟧' = c ≫ T₂.mor₃ 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] (L : CategoryTheory.Functor C D) [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.HasShift D ℤ] [L.CommShift ℤ] (H :
  ∀ (T₁' T₂' : CategoryTheory.Pretriangulated.Triangle C),
    T₁' ∈ CategoryTheory.Pretriangulated.distinguishedTriangles →
      T₂' ∈ CategoryTheory.Pretriangulated.distinguishedTriangles →
        ∀ (a : L.obj T₁'.obj₁ ⟶ L.obj T₂'.obj₁) (b : L.obj T₁'.obj₂ ⟶ L.obj T₂'.obj₂),
          CategoryTheory.CategoryStruct.comp (L.map T₁'.mor₁) b =
              CategoryTheory.CategoryStruct.comp a (L.map T₂'.mor₁) →
            ∃ φ, φ.hom₁ = a ∧ φ.hom₂ = b) (T₁ T₂ : CategoryTheory.Pretriangulated.Triangle D) (hT₁ : T₁ ∈ L.essImageDistTriang) (hT₂ : T₂ ∈ L.essImageDistTriang) (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂) (fac : CategoryTheory.CategoryStruct.comp T₁.mor₁ b = CategoryTheory.CategoryStruct.comp a T₂.mor₁)
Goal: ∃ c,
  CategoryTheory.CategoryStruct.comp T₁.mor₂ c = CategoryTheory.CategoryStruct.comp b T₂.mor₂ ∧
    CategoryTheory.CategoryStruct.comp T₁.mor₃ ((CategoryTheory.shiftFunctor D 1).map a) =
      CategoryTheory.CategoryStruct.comp c T₂.mor₃
-- CategoryTheory.Triangulated.Localization.distinguished_cocone_triangle
lemma distinguished_cocone_triangle {X Y : D} (f : X ⟶ Y) :
    ∃ (Z : D) (g : Y ⟶ Z) (h : Z ⟶ X⟦(1 : ℤ)⟧),
      Triangle.mk f g h ∈ L.essImageDistTriang 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] (L : CategoryTheory.Functor C D) [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.HasShift D ℤ] [L.CommShift ℤ] (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] {X Y : D} (f : X ⟶ Y)
Goal: ∃ Z g h, CategoryTheory.Pretriangulated.Triangle.mk f g h ∈ L.essImageDistTriang
-- CategoryTheory.Triangulated.Localization.complete_distinguished_triangle_morphism
lemma complete_distinguished_triangle_morphism (T₁ T₂ : Triangle D)
    (hT₁ : T₁ ∈ L.essImageDistTriang) (hT₂ : T₂ ∈ L.essImageDistTriang)
    (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂) (fac : T₁.mor₁ ≫ b = a ≫ T₂.mor₁) :
    ∃ c, T₁.mor₂ ≫ c = b ≫ T₂.mor₂ ∧ T₁.mor₃ ≫ a⟦1⟧' = c ≫ T₂.mor₃ 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] (L : CategoryTheory.Functor C D) [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.HasShift D ℤ] [L.CommShift ℤ] (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.IsCompatibleWithTriangulation] [W.HasLeftCalculusOfFractions] (T₁ T₂ : CategoryTheory.Pretriangulated.Triangle D) (hT₁ : T₁ ∈ L.essImageDistTriang) (hT₂ : T₂ ∈ L.essImageDistTriang) (a : T₁.obj₁ ⟶ T₂.obj₁) (b : T₁.obj₂ ⟶ T₂.obj₂) (fac : CategoryTheory.CategoryStruct.comp T₁.mor₁ b = CategoryTheory.CategoryStruct.comp a T₂.mor₁)
Goal: ∃ c,
  CategoryTheory.CategoryStruct.comp T₁.mor₂ c = CategoryTheory.CategoryStruct.comp b T₂.mor₂ ∧
    CategoryTheory.CategoryStruct.comp T₁.mor₃ ((CategoryTheory.shiftFunctor D 1).map a) =
      CategoryTheory.CategoryStruct.comp c T₂.mor₃
-- CategoryTheory.Triangulated.Localization.isTriangulated
lemma isTriangulated [Pretriangulated D] [L.IsTriangulated] [IsTriangulated C] :
    IsTriangulated D 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] (L : CategoryTheory.Functor C D) [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.HasShift D ℤ] [L.CommShift ℤ] (W : CategoryTheory.MorphismProperty C) [L.IsLocalization W] [W.HasLeftCalculusOfFractions] [CategoryTheory.Preadditive D] [CategoryTheory.Limits.HasZeroObject D] [∀ (n : ℤ), (CategoryTheory.shiftFunctor D n).Additive] [CategoryTheory.Pretriangulated D] [L.IsTriangulated] [CategoryTheory.IsTriangulated C]
Goal: CategoryTheory.IsTriangulated D
-- CategoryTheory.Functor.distTriang_iff
lemma distTriang_iff (T : Triangle D) :
    (T ∈ distTriang D) ↔ T ∈ L.essImageDistTriang 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Category.{u_3, u_2} D] (L : CategoryTheory.Functor C D) [CategoryTheory.HasShift C ℤ] [CategoryTheory.Preadditive C] [CategoryTheory.Limits.HasZeroObject C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [CategoryTheory.Pretriangulated C] [CategoryTheory.HasShift D ℤ] [L.CommShift ℤ] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Preadditive D] [∀ (n : ℤ), (CategoryTheory.shiftFunctor D n).Additive] [CategoryTheory.Pretriangulated D] [L.mapArrow.EssSurj] [L.IsTriangulated] (T : CategoryTheory.Pretriangulated.Triangle D)
Goal: T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles ↔ T ∈ L.essImageDistTriang
-- CategoryTheory.SingleFunctors.shiftIso_zero
structure SingleFunctors where
    functor (a : A) : C ⥤ D
    shiftIso (n a a' : A) (ha' : n + a = a') : functor a' ⋙ shiftFunctor D n ≅ functor a
    shiftIso_zero (a : A) :
    shiftIso 0 a a (zero_add a) = isoWhiskerLeft _ (shiftFunctorZero D A)
    shiftIso_add (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') :
    shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha'']) =
      isoWhiskerLeft _ (shiftFunctorAdd D m n) ≪≫ (Functor.associator _ _ _).symm ≪≫
        isoWhiskerRight (shiftIso m a' a'' ha'') _ ≪≫ shiftIso n a a' ha'
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift D A] (self : CategoryTheory.SingleFunctors C D A) (a : A)
Goal: self.shiftIso 0 a a ⋯ = CategoryTheory.isoWhiskerLeft (self.functor a) (CategoryTheory.shiftFunctorZero D A)
-- CategoryTheory.SingleFunctors.shiftIso_add
structure SingleFunctors where
    functor (a : A) : C ⥤ D
    shiftIso (n a a' : A) (ha' : n + a = a') : functor a' ⋙ shiftFunctor D n ≅ functor a
    shiftIso_zero (a : A) :
    shiftIso 0 a a (zero_add a) = isoWhiskerLeft _ (shiftFunctorZero D A)
    shiftIso_add (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') :
    shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha'']) =
      isoWhiskerLeft _ (shiftFunctorAdd D m n) ≪≫ (Functor.associator _ _ _).symm ≪≫
        isoWhiskerRight (shiftIso m a' a'' ha'') _ ≪≫ shiftIso n a a' ha'
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_6, u_1} C] [CategoryTheory.Category.{u_7, u_2} D] {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift D A] (self : CategoryTheory.SingleFunctors C D A) (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'')
Goal: self.shiftIso (m + n) a a'' ⋯ =
  CategoryTheory.isoWhiskerLeft (self.functor a'') (CategoryTheory.shiftFunctorAdd D m n) ≪≫
    ((self.functor a'').associator (CategoryTheory.shiftFunctor D m) (CategoryTheory.shiftFunctor D n)).symm ≪≫
      CategoryTheory.isoWhiskerRight (self.shiftIso m a' a'' ha'') (CategoryTheory.shiftFunctor D n) ≪≫
        self.shiftIso n a a' ha'
-- CategoryTheory.SingleFunctors.shiftIso_add_hom_app
lemma shiftIso_add_hom_app (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha''])).hom.app X =
      (shiftFunctorAdd D m n).hom.app ((F.functor a'').obj X) ≫
        ((F.shiftIso m a' a'' ha'').hom.app X)⟦n⟧' ≫
        (F.shiftIso n a a' ha').hom.app X 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift D A] (F : CategoryTheory.SingleFunctors C D A) (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') (X : C)
Goal: (F.shiftIso (m + n) a a'' ⋯).hom.app X =
  (CategoryTheory.shiftFunctorAdd D m n).hom.app ((F.functor a'').obj X) ≫
    (CategoryTheory.shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').hom.app X) ≫ (F.shiftIso n a a' ha').hom.app X
-- CategoryTheory.SingleFunctors.shiftIso_add_inv_app
lemma shiftIso_add_inv_app (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') (X : C) :
    (F.shiftIso (m + n) a a'' (by rw [add_assoc, ha', ha''])).inv.app X =
      (F.shiftIso n a a' ha').inv.app X ≫
      ((F.shiftIso m a' a'' ha'').inv.app X)⟦n⟧' ≫
      (shiftFunctorAdd D m n).inv.app ((F.functor a'').obj X) 
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_7, u_1} C] [CategoryTheory.Category.{u_6, u_2} D] {A : Type u_5} [AddMonoid A] [CategoryTheory.HasShift D A] (F : CategoryTheory.SingleFunctors C D A) (n m a a' a'' : A) (ha' : n + a = a') (ha'' : m + a' = a'') (X : C)
Goal: (F.shiftIso (m + n) a a'' ⋯).inv.app X =
  (F.shiftIso n a a' ha').inv.app X ≫
    (CategoryTheory.shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').inv.app X) ≫
      (CategoryTheory.shiftFunctorAdd D m n).inv.app ((F.functor a'').obj X)