File: Mathlib/CategoryTheory/DifferentialObject.lean

full_name: CategoryTheory.DifferentialObject.d_squared
code: /-- A differential object in a category with zero morphisms and a shift is
an object `obj` equipped with
a morphism `d : obj ⟶ obj⟦1⟧`, such that `d^2 = 0`. -/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure DifferentialObject where
  /-- The underlying object of a differential object. -/
  obj : C
  /-- The differential of a differential object. -/
  d : obj ⟶ obj⟦(1 : S)⟧
  /-- The differential `d` satisfies that `d² = 0`. -/
  d_squared : d ≫ d⟦(1 : S)⟧' = 0 := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp self.d ((CategoryTheory.shiftFunctor C 1).map self.d) = 0

full_name: CategoryTheory.DifferentialObject
code: /-- A differential object in a category with zero morphisms and a shift is
an object `obj` equipped with
a morphism `d : obj ⟶ obj⟦1⟧`, such that `d^2 = 0`. -/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure DifferentialObject where
  /-- The underlying object of a differential object. -/
  obj : C
  /-- The differential of a differential object. -/
  d : obj ⟶ obj⟦(1 : S)⟧
  /-- The differential `d` satisfies that `d² = 0`. -/
  d_squared : d ≫ d⟦(1 : S)⟧' = 0 := by aesop_cat
goal: Type (max u v)

full_name: CategoryTheory.DifferentialObject.d
code: /-- A differential object in a category with zero morphisms and a shift is
an object `obj` equipped with
a morphism `d : obj ⟶ obj⟦1⟧`, such that `d^2 = 0`. -/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure DifferentialObject where
  /-- The underlying object of a differential object. -/
  obj : C
  /-- The differential of a differential object. -/
  d : obj ⟶ obj⟦(1 : S)⟧
  /-- The differential `d` satisfies that `d² = 0`. -/
  d_squared : d ≫ d⟦(1 : S)⟧' = 0 := by aesop_cat
goal: self.obj ⟶ (CategoryTheory.shiftFunctor C 1).obj self.obj

full_name: CategoryTheory.DifferentialObject.obj
code: /-- A differential object in a category with zero morphisms and a shift is
an object `obj` equipped with
a morphism `d : obj ⟶ obj⟦1⟧`, such that `d^2 = 0`. -/
-- Porting note(#5171): removed `@[nolint has_nonempty_instance]`
structure DifferentialObject where
  /-- The underlying object of a differential object. -/
  obj : C
  /-- The differential of a differential object. -/
  d : obj ⟶ obj⟦(1 : S)⟧
  /-- The differential `d` satisfies that `d² = 0`. -/
  d_squared : d ≫ d⟦(1 : S)⟧' = 0 := by aesop_cat
goal: C

full_name: CategoryTheory.DifferentialObject.Hom.f
code: /-- A morphism of differential objects is a morphism commuting with the differentials. -/
@[ext] -- Porting note(#5171): removed `nolint has_nonempty_instance`
structure Hom (X Y : DifferentialObject S C) where
  /-- The morphism between underlying objects of the two differentiable objects. -/
  f : X.obj ⟶ Y.obj
  comm : X.d ≫ f⟦1⟧' = f ≫ Y.d := by aesop_cat
goal: X.obj ⟶ Y.obj

full_name: CategoryTheory.DifferentialObject.Hom.comm
code: /-- A morphism of differential objects is a morphism commuting with the differentials. -/
@[ext] -- Porting note(#5171): removed `nolint has_nonempty_instance`
structure Hom (X Y : DifferentialObject S C) where
  /-- The morphism between underlying objects of the two differentiable objects. -/
  f : X.obj ⟶ Y.obj
  comm : X.d ≫ f⟦1⟧' = f ≫ Y.d := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp X.d ((CategoryTheory.shiftFunctor C 1).map self.f) =
  CategoryTheory.CategoryStruct.comp self.f Y.d

full_name: CategoryTheory.DifferentialObject.Hom
code: /-- A morphism of differential objects is a morphism commuting with the differentials. -/
@[ext] -- Porting note(#5171): removed `nolint has_nonempty_instance`
structure Hom (X Y : DifferentialObject S C) where
  /-- The morphism between underlying objects of the two differentiable objects. -/
  f : X.obj ⟶ Y.obj
  comm : X.d ≫ f⟦1⟧' = f ≫ Y.d := by aesop_cat
goal: Type v

full_name: CategoryTheory.DifferentialObject.Hom.id
code: /-- The identity morphism of a differential object. -/
@[simps]
def id (X : DifferentialObject S C) : Hom X X 
goal: X.Hom X

full_name: CategoryTheory.DifferentialObject.Hom.id_f
code: /-- The identity morphism of a differential object. -/
@[simps]
def id (X : DifferentialObject S C) : Hom X X 
goal: (CategoryTheory.DifferentialObject.Hom.id X).f = CategoryTheory.CategoryStruct.id X.obj

full_name: CategoryTheory.DifferentialObject.Hom.comp_f
code: /-- The composition of morphisms of differential objects. -/
@[simps]
def comp {X Y Z : DifferentialObject S C} (f : Hom X Y) (g : Hom Y Z) : Hom X Z 
goal: (f.comp g).f = CategoryTheory.CategoryStruct.comp f.f g.f

full_name: CategoryTheory.DifferentialObject.Hom.comp
code: /-- The composition of morphisms of differential objects. -/
@[simps]
def comp {X Y Z : DifferentialObject S C} (f : Hom X Y) (g : Hom Y Z) : Hom X Z 
goal: X.Hom Z

full_name: CategoryTheory.DifferentialObject.categoryOfDifferentialObjects
code: instance categoryOfDifferentialObjects : Category (DifferentialObject S C) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.DifferentialObject S C)

full_name: CategoryTheory.DifferentialObject.ext
code: @[ext]
theorem ext {A B : DifferentialObject S C} {f g : A ⟶ B} (w : f.f = g.f := by aesop_cat) : f = g 
goal: f = g

full_name: CategoryTheory.DifferentialObject.id_f
code: @[simp]
theorem id_f (X : DifferentialObject S C) : (𝟙 X : X ⟶ X).f = 𝟙 X.obj 
goal: (CategoryTheory.CategoryStruct.id X).f = CategoryTheory.CategoryStruct.id X.obj

full_name: CategoryTheory.DifferentialObject.comp_f
code: @[simp]
theorem comp_f {X Y Z : DifferentialObject S C} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).f = f.f ≫ g.f 
goal: (CategoryTheory.CategoryStruct.comp f g).f = CategoryTheory.CategoryStruct.comp f.f g.f

full_name: CategoryTheory.DifferentialObject.eqToHom_f
code: @[simp]
theorem eqToHom_f {X Y : DifferentialObject S C} (h : X = Y) :
    Hom.f (eqToHom h) = eqToHom (congr_arg _ h) 
goal: (CategoryTheory.eqToHom h).f = CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.DifferentialObject.forget
code: /-- The forgetful functor taking a differential object to its underlying object. -/
def forget : DifferentialObject S C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.DifferentialObject S C) C

full_name: CategoryTheory.DifferentialObject.forget_faithful
code: instance forget_faithful : (forget S C).Faithful 
goal: (CategoryTheory.DifferentialObject.forget S C).Faithful

full_name: CategoryTheory.DifferentialObject.instZeroHom
code: instance {X Y : DifferentialObject S C} : Zero (X ⟶ Y) 
goal: Zero (X ⟶ Y)

full_name: CategoryTheory.DifferentialObject.zero_f
code: @[simp]
theorem zero_f (P Q : DifferentialObject S C) : (0 : P ⟶ Q).f = 0 
goal: CategoryTheory.DifferentialObject.Hom.f 0 = 0

full_name: CategoryTheory.DifferentialObject.hasZeroMorphisms
code: instance hasZeroMorphisms : HasZeroMorphisms (DifferentialObject S C) 
goal: CategoryTheory.Limits.HasZeroMorphisms (CategoryTheory.DifferentialObject S C)

full_name: CategoryTheory.DifferentialObject.isoApp_inv
code: /-- An isomorphism of differential objects gives an isomorphism of the underlying objects. -/
@[simps]
def isoApp {X Y : DifferentialObject S C} (f : X ≅ Y) : X.obj ≅ Y.obj 
goal: (CategoryTheory.DifferentialObject.isoApp f).inv = f.inv.f

full_name: CategoryTheory.DifferentialObject.isoApp_hom
code: /-- An isomorphism of differential objects gives an isomorphism of the underlying objects. -/
@[simps]
def isoApp {X Y : DifferentialObject S C} (f : X ≅ Y) : X.obj ≅ Y.obj 
goal: (CategoryTheory.DifferentialObject.isoApp f).hom = f.hom.f

full_name: CategoryTheory.DifferentialObject.isoApp
code: /-- An isomorphism of differential objects gives an isomorphism of the underlying objects. -/
@[simps]
def isoApp {X Y : DifferentialObject S C} (f : X ≅ Y) : X.obj ≅ Y.obj 
goal: X.obj ≅ Y.obj

full_name: CategoryTheory.DifferentialObject.isoApp_refl
code: @[simp]
theorem isoApp_refl (X : DifferentialObject S C) : isoApp (Iso.refl X) = Iso.refl X.obj 
goal: CategoryTheory.DifferentialObject.isoApp (CategoryTheory.Iso.refl X) = CategoryTheory.Iso.refl X.obj

full_name: CategoryTheory.DifferentialObject.isoApp_symm
code: @[simp]
theorem isoApp_symm {X Y : DifferentialObject S C} (f : X ≅ Y) : isoApp f.symm = (isoApp f).symm 
goal: CategoryTheory.DifferentialObject.isoApp f.symm = (CategoryTheory.DifferentialObject.isoApp f).symm

full_name: CategoryTheory.DifferentialObject.isoApp_trans
code: @[simp]
theorem isoApp_trans {X Y Z : DifferentialObject S C} (f : X ≅ Y) (g : Y ≅ Z) :
    isoApp (f ≪≫ g) = isoApp f ≪≫ isoApp g 
goal: CategoryTheory.DifferentialObject.isoApp (f ≪≫ g) =
  CategoryTheory.DifferentialObject.isoApp f ≪≫ CategoryTheory.DifferentialObject.isoApp g

full_name: CategoryTheory.DifferentialObject.mkIso_inv_f
code: /-- An isomorphism of differential objects can be constructed
from an isomorphism of the underlying objects that commutes with the differentials. -/
@[simps]
def mkIso {X Y : DifferentialObject S C} (f : X.obj ≅ Y.obj) (hf : X.d ≫ f.hom⟦1⟧' = f.hom ≫ Y.d) :
    X ≅ Y 
goal: (CategoryTheory.DifferentialObject.mkIso f hf).inv.f = f.inv

full_name: CategoryTheory.DifferentialObject.mkIso_hom_f
code: /-- An isomorphism of differential objects can be constructed
from an isomorphism of the underlying objects that commutes with the differentials. -/
@[simps]
def mkIso {X Y : DifferentialObject S C} (f : X.obj ≅ Y.obj) (hf : X.d ≫ f.hom⟦1⟧' = f.hom ≫ Y.d) :
    X ≅ Y 
goal: (CategoryTheory.DifferentialObject.mkIso f hf).hom.f = f.hom

full_name: CategoryTheory.DifferentialObject.mkIso
code: /-- An isomorphism of differential objects can be constructed
from an isomorphism of the underlying objects that commutes with the differentials. -/
@[simps]
def mkIso {X Y : DifferentialObject S C} (f : X.obj ≅ Y.obj) (hf : X.d ≫ f.hom⟦1⟧' = f.hom ≫ Y.d) :
    X ≅ Y 
goal: X ≅ Y

full_name: CategoryTheory.Functor.mapDifferentialObject_obj_obj
code: /-- A functor `F : C ⥤ D` which commutes with shift functors on `C` and `D` and preserves zero
morphisms can be lifted to a functor `DifferentialObject S C ⥤ DifferentialObject S D`. -/
@[simps]
def mapDifferentialObject (F : C ⥤ D)
    (η : (shiftFunctor C (1 : S)).comp F ⟶ F.comp (shiftFunctor D (1 : S)))
    (hF : ∀ c c', F.map (0 : c ⟶ c') = 0) : DifferentialObject S C ⥤ DifferentialObject S D 
goal: ((CategoryTheory.Functor.mapDifferentialObject D F η hF).obj X).obj = F.obj X.obj

full_name: CategoryTheory.Functor.mapDifferentialObject_obj_d
code: /-- A functor `F : C ⥤ D` which commutes with shift functors on `C` and `D` and preserves zero
morphisms can be lifted to a functor `DifferentialObject S C ⥤ DifferentialObject S D`. -/
@[simps]
def mapDifferentialObject (F : C ⥤ D)
    (η : (shiftFunctor C (1 : S)).comp F ⟶ F.comp (shiftFunctor D (1 : S)))
    (hF : ∀ c c', F.map (0 : c ⟶ c') = 0) : DifferentialObject S C ⥤ DifferentialObject S D 
goal: ((CategoryTheory.Functor.mapDifferentialObject D F η hF).obj X).d =
  CategoryTheory.CategoryStruct.comp (F.map X.d) (η.app X.obj)

full_name: CategoryTheory.Functor.mapDifferentialObject_map_f
code: /-- A functor `F : C ⥤ D` which commutes with shift functors on `C` and `D` and preserves zero
morphisms can be lifted to a functor `DifferentialObject S C ⥤ DifferentialObject S D`. -/
@[simps]
def mapDifferentialObject (F : C ⥤ D)
    (η : (shiftFunctor C (1 : S)).comp F ⟶ F.comp (shiftFunctor D (1 : S)))
    (hF : ∀ c c', F.map (0 : c ⟶ c') = 0) : DifferentialObject S C ⥤ DifferentialObject S D 
goal: ∀ {X Y : CategoryTheory.DifferentialObject S C} (f : X ⟶ Y),
  ((CategoryTheory.Functor.mapDifferentialObject D F η hF).map f).f = F.map f.f

full_name: CategoryTheory.Functor.mapDifferentialObject
code: /-- A functor `F : C ⥤ D` which commutes with shift functors on `C` and `D` and preserves zero
morphisms can be lifted to a functor `DifferentialObject S C ⥤ DifferentialObject S D`. -/
@[simps]
def mapDifferentialObject (F : C ⥤ D)
    (η : (shiftFunctor C (1 : S)).comp F ⟶ F.comp (shiftFunctor D (1 : S)))
    (hF : ∀ c c', F.map (0 : c ⟶ c') = 0) : DifferentialObject S C ⥤ DifferentialObject S D 
goal: CategoryTheory.Functor (CategoryTheory.DifferentialObject S C) (CategoryTheory.DifferentialObject S D)

full_name: CategoryTheory.DifferentialObject.hasZeroObject
code: instance hasZeroObject : HasZeroObject (DifferentialObject S C) 
goal: CategoryTheory.Limits.HasZeroObject (CategoryTheory.DifferentialObject S C)

full_name: CategoryTheory.DifferentialObject.concreteCategoryOfDifferentialObjects
code: instance concreteCategoryOfDifferentialObjects : ConcreteCategory (DifferentialObject S C) 
goal: CategoryTheory.ConcreteCategory (CategoryTheory.DifferentialObject S C)

full_name: CategoryTheory.DifferentialObject.instHasForget₂
code: instance : HasForget₂ (DifferentialObject S C) C 
goal: CategoryTheory.HasForget₂ (CategoryTheory.DifferentialObject S C) C

full_name: CategoryTheory.DifferentialObject.shiftFunctor
code: /-- The shift functor on `DifferentialObject S C`. -/
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C 
goal: CategoryTheory.Functor (CategoryTheory.DifferentialObject S C) (CategoryTheory.DifferentialObject S C)

full_name: CategoryTheory.DifferentialObject.shiftFunctor_obj_d
code: /-- The shift functor on `DifferentialObject S C`. -/
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C 
goal: ((CategoryTheory.DifferentialObject.shiftFunctor C n).obj X).d =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.shiftFunctor C n).map X.d)
    (CategoryTheory.shiftComm X.obj 1 n).hom

full_name: CategoryTheory.DifferentialObject.shiftFunctor_obj_obj
code: /-- The shift functor on `DifferentialObject S C`. -/
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C 
goal: ((CategoryTheory.DifferentialObject.shiftFunctor C n).obj X).obj = (CategoryTheory.shiftFunctor C n).obj X.obj

full_name: CategoryTheory.DifferentialObject.shiftFunctor_map_f
code: /-- The shift functor on `DifferentialObject S C`. -/
@[simps]
def shiftFunctor (n : S) : DifferentialObject S C ⥤ DifferentialObject S C 
goal: ∀ {X Y : CategoryTheory.DifferentialObject S C} (f : X ⟶ Y),
  ((CategoryTheory.DifferentialObject.shiftFunctor C n).map f).f = (CategoryTheory.shiftFunctor C n).map f.f

full_name: CategoryTheory.DifferentialObject.shiftFunctorAdd_hom_app_f
code: /-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n 
goal: ((CategoryTheory.DifferentialObject.shiftFunctorAdd C m n).hom.app X).f =
  (CategoryTheory.shiftFunctorAdd C m n).hom.app X.obj

full_name: CategoryTheory.DifferentialObject.shiftFunctorAdd
code: /-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n 
goal: CategoryTheory.DifferentialObject.shiftFunctor C (m + n) ≅
  (CategoryTheory.DifferentialObject.shiftFunctor C m).comp (CategoryTheory.DifferentialObject.shiftFunctor C n)

full_name: CategoryTheory.DifferentialObject.shiftFunctorAdd_inv_app_f
code: /-- The shift functor on `DifferentialObject S C` is additive. -/
@[simps!]
nonrec def shiftFunctorAdd (m n : S) :
    shiftFunctor C (m + n) ≅ shiftFunctor C m ⋙ shiftFunctor C n 
goal: ((CategoryTheory.DifferentialObject.shiftFunctorAdd C m n).inv.app X).f =
  (CategoryTheory.shiftFunctorAdd C m n).inv.app X.obj

full_name: CategoryTheory.DifferentialObject.shiftZero
code: /-- The shift by zero is naturally isomorphic to the identity. -/
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) 
goal: CategoryTheory.DifferentialObject.shiftFunctor C 0 ≅ CategoryTheory.Functor.id (CategoryTheory.DifferentialObject S C)

full_name: CategoryTheory.DifferentialObject.shiftZero_hom_app_f
code: /-- The shift by zero is naturally isomorphic to the identity. -/
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) 
goal: ((CategoryTheory.DifferentialObject.shiftZero C).hom.app X).f = (CategoryTheory.shiftFunctorZero C S).hom.app X.obj

full_name: CategoryTheory.DifferentialObject.shiftZero_inv_app_f
code: /-- The shift by zero is naturally isomorphic to the identity. -/
@[simps!]
def shiftZero : shiftFunctor C (0 : S) ≅ 𝟭 (DifferentialObject S C) 
goal: ((CategoryTheory.DifferentialObject.shiftZero C).inv.app X).f = (CategoryTheory.shiftFunctorZero C S).inv.app X.obj

full_name: CategoryTheory.DifferentialObject.instHasShift
code: instance : HasShift (DifferentialObject S C) S 
goal: CategoryTheory.HasShift (CategoryTheory.DifferentialObject S C) S