File: Mathlib/CategoryTheory/Localization/CalculusOfFractions/Preadditive.lean

full_name: CategoryTheory.MorphismProperty.LeftFraction.neg
code: /-- The opposite of a left fraction. -/
abbrev LeftFraction.neg {X Y : C} (φ : W.LeftFraction X Y) :
    W.LeftFraction X Y 
goal: W.LeftFraction X Y

full_name: CategoryTheory.MorphismProperty.LeftFraction₂.add
code: /-- The sum of two left fractions with the same denominator. -/
abbrev add : W.LeftFraction X Y 
goal: W.LeftFraction X Y

full_name: CategoryTheory.MorphismProperty.LeftFraction₂.symm_add
code: @[simp]
lemma symm_add : φ.symm.add = φ.add 
goal: φ.symm.add = φ.add

full_name: CategoryTheory.MorphismProperty.LeftFraction₂.map_add
code: @[simp]
lemma map_add (F : C ⥤ D) (hF : W.IsInvertedBy F) [Preadditive D] [F.Additive] :
    φ.add.map F hF = φ.fst.map F hF + φ.snd.map F hF 
goal: φ.add.map F hF = φ.fst.map F hF + φ.snd.map F hF

full_name: CategoryTheory.Localization.Preadditive.neg'
code: /-- The opposite of a map `L.obj X ⟶ L.obj Y` when `L : C ⥤ D` is a localization
functor, `C` is preadditive and there is a left calculus of fractions. -/
noncomputable def neg' (f : L.obj X ⟶ L.obj Y) : L.obj X ⟶ L.obj Y 
goal: L.obj X ⟶ L.obj Y

full_name: CategoryTheory.Localization.Preadditive.neg'_eq
code: lemma neg'_eq (f : L.obj X ⟶ L.obj Y) (φ : W.LeftFraction X Y)
    (hφ : f = φ.map L (inverts L W)) :
    neg' W f = φ.neg.map L (inverts L W) 
goal: CategoryTheory.Localization.Preadditive.neg' W f = φ.neg.map L ⋯

full_name: CategoryTheory.Localization.Preadditive.add'
code: /-- The addition of two maps `L.obj X ⟶ L.obj Y` when `L : C ⥤ D` is a localization
functor, `C` is preadditive and there is a left calculus of fractions. -/
noncomputable def add' (f₁ f₂ : L.obj X ⟶ L.obj Y) : L.obj X ⟶ L.obj Y 
goal: L.obj X ⟶ L.obj Y

full_name: CategoryTheory.Localization.Preadditive.add'_eq
code: lemma add'_eq (f₁ f₂ : L.obj X ⟶ L.obj Y) (φ : W.LeftFraction₂ X Y)
    (hφ₁ : f₁ = φ.fst.map L (inverts L W))
    (hφ₂ : f₂ = φ.snd.map L (inverts L W)) :
    add' W f₁ f₂ = φ.add.map L (inverts L W) 
goal: CategoryTheory.Localization.Preadditive.add' W f₁ f₂ = φ.add.map L ⋯

full_name: CategoryTheory.Localization.Preadditive.add'_comm
code: lemma add'_comm (f₁ f₂ : L.obj X ⟶ L.obj Y) :
    add' W f₁ f₂ = add' W f₂ f₁ 
goal: CategoryTheory.Localization.Preadditive.add' W f₁ f₂ = CategoryTheory.Localization.Preadditive.add' W f₂ f₁

full_name: CategoryTheory.Localization.Preadditive.add'_zero
code: lemma add'_zero (f : L.obj X ⟶ L.obj Y) :
    add' W f (L.map 0) = f 
goal: CategoryTheory.Localization.Preadditive.add' W f (L.map 0) = f

full_name: CategoryTheory.Localization.Preadditive.zero_add'
code: lemma zero_add' (f : L.obj X ⟶ L.obj Y) :
    add' W (L.map 0) f = f 
goal: CategoryTheory.Localization.Preadditive.add' W (L.map 0) f = f

full_name: CategoryTheory.Localization.Preadditive.add'_left_neg'
code: lemma add'_left_neg' (f : L.obj X ⟶ L.obj Y) :
    add' W (neg' W f) f = L.map 0 
goal: CategoryTheory.Localization.Preadditive.add' W (CategoryTheory.Localization.Preadditive.neg' W f) f = L.map 0

full_name: CategoryTheory.Localization.Preadditive.add'_assoc
code: lemma add'_assoc (f₁ f₂ f₃ : L.obj X ⟶ L.obj Y) :
    add' W (add' W f₁ f₂) f₃ = add' W f₁ (add' W f₂ f₃) 
goal: CategoryTheory.Localization.Preadditive.add' W (CategoryTheory.Localization.Preadditive.add' W f₁ f₂) f₃ =
  CategoryTheory.Localization.Preadditive.add' W f₁ (CategoryTheory.Localization.Preadditive.add' W f₂ f₃)

full_name: CategoryTheory.Localization.Preadditive.add'_comp
code: @[reassoc (attr := simp)]
lemma add'_comp (f₁ f₂ : L.obj X ⟶ L.obj Y) (g : L.obj Y ⟶ L.obj Z) :
    add' W f₁ f₂ ≫ g = add' W (f₁ ≫ g) (f₂ ≫ g) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.Preadditive.add' W f₁ f₂) g =
  CategoryTheory.Localization.Preadditive.add' W (CategoryTheory.CategoryStruct.comp f₁ g)
    (CategoryTheory.CategoryStruct.comp f₂ g)

full_name: CategoryTheory.Localization.Preadditive.comp_add'
code: @[reassoc (attr := simp)]
lemma comp_add' (f : L.obj X ⟶ L.obj Y) (g₁ g₂ : L.obj Y ⟶ L.obj Z) :
    f ≫ add' W g₁ g₂ = add' W (f ≫ g₁) (f ≫ g₂) 
goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.Localization.Preadditive.add' W g₁ g₂) =
  CategoryTheory.Localization.Preadditive.add' W (CategoryTheory.CategoryStruct.comp f g₁)
    (CategoryTheory.CategoryStruct.comp f g₂)

full_name: CategoryTheory.Localization.Preadditive.add'_map
code: @[simp]
lemma add'_map (f₁ f₂ : X ⟶ Y) :
    add' W (L.map f₁) (L.map f₂) = L.map (f₁ + f₂) 
goal: CategoryTheory.Localization.Preadditive.add' W (L.map f₁) (L.map f₂) = L.map (f₁ + f₂)

full_name: CategoryTheory.Localization.Preadditive.addCommGroup'
code: /-- The abelian group structure on `L.obj X ⟶ L.obj Y` when `L : C ⥤ D` is a localization
functor, `C` is preadditive and there is a left calculus of fractions. -/
noncomputable def addCommGroup' : AddCommGroup (L.obj X ⟶ L.obj Y) 
goal: AddCommGroup (L.obj X ⟶ L.obj Y)

full_name: CategoryTheory.Localization.Preadditive.homEquiv
code: /-- The bijection `(X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y)` induced by isomorphisms
`eX : L.obj X ≅ X'` and `eY : L.obj Y ≅ Y'`. -/
@[simps]
def homEquiv : (X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y) 
goal: (X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y)

full_name: CategoryTheory.Localization.Preadditive.homEquiv_apply
code: /-- The bijection `(X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y)` induced by isomorphisms
`eX : L.obj X ≅ X'` and `eY : L.obj Y ≅ Y'`. -/
@[simps]
def homEquiv : (X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y) 
goal: (CategoryTheory.Localization.Preadditive.homEquiv eX eY) f =
  CategoryTheory.CategoryStruct.comp eX.hom (CategoryTheory.CategoryStruct.comp f eY.inv)

full_name: CategoryTheory.Localization.Preadditive.homEquiv_symm_apply
code: /-- The bijection `(X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y)` induced by isomorphisms
`eX : L.obj X ≅ X'` and `eY : L.obj Y ≅ Y'`. -/
@[simps]
def homEquiv : (X' ⟶ Y') ≃ (L.obj X ⟶ L.obj Y) 
goal: (CategoryTheory.Localization.Preadditive.homEquiv eX eY).symm g =
  CategoryTheory.CategoryStruct.comp eX.inv (CategoryTheory.CategoryStruct.comp g eY.hom)

full_name: CategoryTheory.Localization.Preadditive.add
code: /-- The addition of morphisms in `D`, when `L : C ⥤ D` is a localization
functor, `C` is preadditive and there is a left calculus of fractions. -/
noncomputable def add (f₁ f₂ : X' ⟶ Y') : X' ⟶ Y' 
goal: X' ⟶ Y'

full_name: CategoryTheory.Localization.Preadditive.add_comp
code: @[reassoc]
lemma add_comp (f₁ f₂ : X' ⟶ Y') (g : Y' ⟶ Z') :
    add W eX eY f₁ f₂ ≫ g = add W eX eZ (f₁ ≫ g) (f₂ ≫ g) 
goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.Preadditive.add W eX eY f₁ f₂) g =
  CategoryTheory.Localization.Preadditive.add W eX eZ (CategoryTheory.CategoryStruct.comp f₁ g)
    (CategoryTheory.CategoryStruct.comp f₂ g)

full_name: CategoryTheory.Localization.Preadditive.comp_add
code: @[reassoc]
lemma comp_add (f : X' ⟶ Y') (g₁ g₂ : Y' ⟶ Z') :
    f ≫ add W eY eZ g₁ g₂ = add W eX eZ (f ≫ g₁) (f ≫ g₂) 
goal: CategoryTheory.CategoryStruct.comp f (CategoryTheory.Localization.Preadditive.add W eY eZ g₁ g₂) =
  CategoryTheory.Localization.Preadditive.add W eX eZ (CategoryTheory.CategoryStruct.comp f g₁)
    (CategoryTheory.CategoryStruct.comp f g₂)

full_name: CategoryTheory.Localization.Preadditive.add_eq_add
code: lemma add_eq_add {X'' Y'' : C} (eX' : L.obj X'' ≅ X') (eY' : L.obj Y'' ≅ Y')
    (f₁ f₂ : X' ⟶ Y') :
    add W eX eY f₁ f₂ = add W eX' eY' f₁ f₂ 
goal: CategoryTheory.Localization.Preadditive.add W eX eY f₁ f₂ = CategoryTheory.Localization.Preadditive.add W eX' eY' f₁ f₂

full_name: CategoryTheory.Localization.Preadditive.addCommGroup
code: /-- The abelian group structure on morphisms in `D`, when `L : C ⥤ D` is a localization
functor, `C` is preadditive and there is a left calculus of fractions. -/
noncomputable def addCommGroup : AddCommGroup (X' ⟶ Y') 
goal: AddCommGroup (X' ⟶ Y')

full_name: CategoryTheory.Localization.Preadditive.add_eq
code: lemma add_eq (f₁ f₂ : X' ⟶ Y') :
    letI := addCommGroup L W X' Y'
    f₁ + f₂ = add W eX eY f₁ f₂ 
goal: f₁ + f₂ = CategoryTheory.Localization.Preadditive.add W eX eY f₁ f₂

full_name: CategoryTheory.Localization.Preadditive.map_add
code: lemma map_add (f₁ f₂ : X ⟶ Y) :
    letI := addCommGroup L W (L.obj X) (L.obj Y)
    L.map (f₁ + f₂) = L.map f₁ + L.map f₂ 
goal: L.map (f₁ + f₂) = L.map f₁ + L.map f₂

full_name: CategoryTheory.Localization.preadditive
code: /-- The preadditive structure on `D`, when `L : C ⥤ D` is a localization
functor, `C` is preadditive and there is a left calculus of fractions. -/
noncomputable def preadditive : Preadditive D 
goal: CategoryTheory.Preadditive D

full_name: CategoryTheory.Localization.functor_additive
code: lemma functor_additive :
    letI := preadditive L W
    L.Additive 
goal: L.Additive

full_name: CategoryTheory.Localization.functor_additive_iff
code: lemma functor_additive_iff {E : Type*} [Category E] [Preadditive E] [Preadditive D] [L.Additive]
    (G : D ⥤ E) :
    G.Additive ↔ (L ⋙ G).Additive 
goal: G.Additive ↔ (L.comp G).Additive

full_name: CategoryTheory.Localization.instPreadditiveLocalization
code: noncomputable instance : Preadditive W.Localization 
goal: CategoryTheory.Preadditive W.Localization

full_name: CategoryTheory.Localization.instAdditiveLocalizationQ
code: instance : W.Q.Additive 
goal: W.Q.Additive

full_name: CategoryTheory.Localization.instHasZeroObjectLocalization
code: instance [HasZeroObject C] : HasZeroObject W.Localization 
goal: CategoryTheory.Limits.HasZeroObject W.Localization

full_name: CategoryTheory.Localization.instPreadditiveLocalization'
code: noncomputable instance : Preadditive W.Localization' 
goal: CategoryTheory.Preadditive W.Localization'

full_name: CategoryTheory.Localization.instAdditiveLocalization'Q'
code: instance : W.Q'.Additive 
goal: W.Q'.Additive

full_name: CategoryTheory.Localization.instHasZeroObjectLocalization'
code: instance [HasZeroObject C] : HasZeroObject W.Localization' 
goal: CategoryTheory.Limits.HasZeroObject W.Localization'