File: Mathlib/CategoryTheory/Linear/LinearFunctor.lean

full_name: CategoryTheory.Functor.Linear.map_smul
code: /-- An additive functor `F` is `R`-linear provided `F.map` is an `R`-module morphism. -/
class Functor.Linear {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
  [Linear R C] [Linear R D] (F : C ⥤ D) [F.Additive] : Prop where
  /-- the functor induces a linear map on morphisms -/
  map_smul : ∀ {X Y : C} (f : X ⟶ Y) (r : R), F.map (r • f) = r • F.map f := by aesop_cat
goal: F.map (r • f) = r • F.map f

full_name: CategoryTheory.Functor.Linear
code: /-- An additive functor `F` is `R`-linear provided `F.map` is an `R`-module morphism. -/
class Functor.Linear {C D : Type*} [Category C] [Category D] [Preadditive C] [Preadditive D]
  [Linear R C] [Linear R D] (F : C ⥤ D) [F.Additive] : Prop where
  /-- the functor induces a linear map on morphisms -/
  map_smul : ∀ {X Y : C} (f : X ⟶ Y) (r : R), F.map (r • f) = r • F.map f := by aesop_cat
goal: Prop

full_name: CategoryTheory.Functor.map_smul
code: @[simp]
theorem map_smul {X Y : C} (r : R) (f : X ⟶ Y) : F.map (r • f) = r • F.map f 
goal: F.map (r • f) = r • F.map f

full_name: CategoryTheory.Functor.map_units_smul
code: @[simp]
theorem map_units_smul {X Y : C} (r : Rˣ) (f : X ⟶ Y) : F.map (r • f) = r • F.map f 
goal: F.map (r • f) = r • F.map f

full_name: CategoryTheory.Functor.instLinearId
code: instance : Linear R (𝟭 C) 
goal: CategoryTheory.Functor.Linear R (CategoryTheory.Functor.id C)

full_name: CategoryTheory.Functor.instLinearComp
code: instance {E : Type*} [Category E] [Preadditive E] [CategoryTheory.Linear R E] (G : D ⥤ E)
    [Additive G] [Linear R G] : Linear R (F ⋙ G) 
goal: CategoryTheory.Functor.Linear R (F.comp G)

full_name: CategoryTheory.Functor.mapLinearMap
code: /-- `F.mapLinearMap` is an `R`-linear map whose underlying function is `F.map`. -/
@[simps]
def mapLinearMap {X Y : C} : (X ⟶ Y) →ₗ[R] F.obj X ⟶ F.obj Y 
goal: (X ⟶ Y) →ₗ[R] F.obj X ⟶ F.obj Y

full_name: CategoryTheory.Functor.mapLinearMap_apply
code: /-- `F.mapLinearMap` is an `R`-linear map whose underlying function is `F.map`. -/
@[simps]
def mapLinearMap {X Y : C} : (X ⟶ Y) →ₗ[R] F.obj X ⟶ F.obj Y 
goal: ∀ (a : X ⟶ Y), (CategoryTheory.Functor.mapLinearMap R F) a = (↑F.mapAddHom).toFun a

full_name: CategoryTheory.Functor.coe_mapLinearMap
code: theorem coe_mapLinearMap {X Y : C} : ⇑(F.mapLinearMap R : (X ⟶ Y) →ₗ[R] _) = F.map 
goal: ⇑(CategoryTheory.Functor.mapLinearMap R F) = F.map

full_name: CategoryTheory.Functor.inducedFunctorLinear
code: instance inducedFunctorLinear : Functor.Linear R (inducedFunctor F) 
goal: CategoryTheory.Functor.Linear R (CategoryTheory.inducedFunctor F)

full_name: CategoryTheory.Functor.fullSubcategoryInclusionLinear
code: instance fullSubcategoryInclusionLinear {C : Type*} [Category C] [Preadditive C]
    [CategoryTheory.Linear R C] (Z : C → Prop) : (fullSubcategoryInclusion Z).Linear R 
goal: CategoryTheory.Functor.Linear R (CategoryTheory.fullSubcategoryInclusion Z)

full_name: CategoryTheory.Functor.natLinear
code: instance natLinear : F.Linear ℕ 
goal: CategoryTheory.Functor.Linear ℕ F

full_name: CategoryTheory.Functor.intLinear
code: instance intLinear : F.Linear ℤ 
goal: CategoryTheory.Functor.Linear ℤ F

full_name: CategoryTheory.Functor.ratLinear
code: instance ratLinear : F.Linear ℚ 
goal: CategoryTheory.Functor.Linear ℚ F

full_name: CategoryTheory.Equivalence.inverseLinear
code: instance inverseLinear (e : C ≌ D) [e.functor.Additive] [e.functor.Linear R] :
  e.inverse.Linear R 
goal: CategoryTheory.Functor.Linear R e.inverse