Documentation

DerivedAlgGeo.Algebra.Homology.DGCategory.Pretriangulated.HomogeneousLift

Homogeneous maps of dg cones #

The degree-zero cone lift in Pretriangulated.Lift is sufficient for the ordinary homotopy category, but not for constructing a dg functor objectwise by cones. A dg functor must map every homogeneous morphism, not only closed degree-zero ones.

For vertical maps a and b of degree p, a homogeneous square carries a degree-p-1 homotopy with boundary

d k = (-1)^p (f₁ ≫ b - a ≫ f₂).

The induced cone map has degree p. Its source-component term is multiplied by (-1)^p; this sign is forced by the diagrammatic Leibniz convention. With it, differentiating the lift of a homogeneous square gives the strict lift of d a and d b (homogeneousLift_d); the homotopy contributes exactly the term that cancels the failure of the square to commute.

This file is the single owner of the cone lift. The degree-zero IsConeOf.lift of Pretriangulated.Lift is homogeneousLift 0, and HomotopySquare there is a HomogeneousSquare of degree zero whose vertical maps are closed.

structure CategoryTheory.DGCategory.HomogeneousSquare {C : Type u} [DGCategory C] {X₁ Y₁ X₂ Y₂ : C} (f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)) (f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)) (p : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) :

A homogeneous homotopy-commutative square between closed degree-zero arrows. No closedness is imposed on the vertical maps: their differentials are needed when the square is used as the value of a dg functor on an arbitrary homogeneous morphism.

Instances For
    def CategoryTheory.DGCategory.HomogeneousSquare.strict {C : Type u} [DGCategory C] {X₁ Y₁ X₂ Y₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} {p : ℤ} {a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)} {b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)} (h : ((DGCategoryStruct.dgComp 0 p p ⋯) f₁) b = ((DGCategoryStruct.dgComp p 0 p ⋯) a) f₂) :
    HomogeneousSquare f₁ f₂ p a b

    A strictly commuting homogeneous square, with zero homotopy.

    Equations
    Instances For
      @[simp]
      theorem CategoryTheory.DGCategory.HomogeneousSquare.strict_homotopy {C : Type u} [DGCategory C] {X₁ Y₁ X₂ Y₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} {p : ℤ} {a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)} {b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)} (h : ((DGCategoryStruct.dgComp 0 p p ⋯) f₁) b = ((DGCategoryStruct.dgComp p 0 p ⋯) a) f₂) :
      noncomputable def CategoryTheory.IsConeOf.homogeneousLift {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (k : ↑((DGCategoryStruct.dgHom X₁ Y₂).X (p - 1))) :
      ↑((DGCategoryStruct.dgHom Z₁ Z₂).X p)

      The homogeneous lift of a homotopy-commutative square to its chosen cone objects. The first term has the Koszul sign forced by differentiation.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        theorem CategoryTheory.IsConeOf.inr_comp_homogeneousLift {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (k : ↑((DGCategoryStruct.dgHom X₁ Y₂).X (p - 1))) :
        ((DGCategoryStruct.dgComp 0 p p ⋯) hc₁.inr) (hc₁.homogeneousLift hc₂ p a b k) = ((DGCategoryStruct.dgComp p 0 p ⋯) b) hc₂.inr

        A homogeneous cone lift restricts to b on the target inclusion.

        theorem CategoryTheory.IsConeOf.inr_comp_homogeneousLift_general {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p r : ℤ) (h0p : 0 + p = r) (hp0 : p + 0 = r) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (k : ↑((DGCategoryStruct.dgHom X₁ Y₂).X (p - 1))) :
        ((DGCategoryStruct.dgComp 0 p r h0p) hc₁.inr) (hc₁.homogeneousLift hc₂ p a b k) = ((DGCategoryStruct.dgComp p 0 r hp0) b) hc₂.inr

        inr_comp_homogeneousLift with an arbitrary common result-degree name. This form is convenient in graded naturality statements, whose composition witnesses need not normalize their result index syntactically.

        theorem CategoryTheory.IsConeOf.inl_comp_homogeneousLift_strict {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) :
        ((DGCategoryStruct.dgComp (-1) p (p - 1) ⋯) hc₁.inl) (hc₁.homogeneousLift hc₂ p a b 0) = p.negOnePow • ((DGCategoryStruct.dgComp p (-1) (p - 1) ⋯) a) hc₂.inl

        The shifted source inclusion is graded-natural for strict homogeneous cone lifts. The factor (-1)^p is exactly the Koszul sign later required by the degree--1 natural transformation from the source functor to its cone.

        theorem CategoryTheory.IsConeOf.inl_comp_homogeneousLift_strict_general {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p r : ℤ) (hm1p : -1 + p = r) (hpm1 : p + -1 = r) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) :
        ((DGCategoryStruct.dgComp (-1) p r hm1p) hc₁.inl) (hc₁.homogeneousLift hc₂ p a b 0) = p.negOnePow • ((DGCategoryStruct.dgComp p (-1) r hpm1) a) hc₂.inl

        inl_comp_homogeneousLift_strict with an arbitrary common result-degree name, for direct use in degree--1 graded naturality.

        theorem CategoryTheory.IsConeOf.homogeneousLift_id {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} (hc₁ : IsConeOf f₁ Z₁) :
        @[simp]
        theorem CategoryTheory.IsConeOf.homogeneousLift_zero {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) :
        hc₁.homogeneousLift hc₂ p 0 0 0 = 0

        The homogeneous lift of the zero square is zero.

        theorem CategoryTheory.IsConeOf.homogeneousLift_strict_add {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) (a a' : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b b' : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) :
        hc₁.homogeneousLift hc₂ p (a + a') (b + b') 0 = hc₁.homogeneousLift hc₂ p a b 0 + hc₁.homogeneousLift hc₂ p a' b' 0

        The strict homogeneous lift is additive in the vertical maps.

        theorem CategoryTheory.IsConeOf.homogeneousLift_comp_fst {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (k : ↑((DGCategoryStruct.dgHom X₁ Y₂).X (p - 1))) :
        ((DGCategoryStruct.dgComp p 1 (p + 1) ⋯) (hc₁.homogeneousLift hc₂ p a b k)) hc₂.fst = p.negOnePow • ((DGCategoryStruct.dgComp 1 p (p + 1) ⋯) hc₁.fst) a

        The source projection reads the signed source component of a homogeneous cone lift. The homotopy term dies against inr ≫ fst = 0, so no strictness is needed.

        theorem CategoryTheory.IsConeOf.homogeneousLift_comp_snd {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) :
        ((DGCategoryStruct.dgComp p 0 p ⋯) (hc₁.homogeneousLift hc₂ p a b 0)) hc₂.snd = ((DGCategoryStruct.dgComp 0 p p ⋯) hc₁.snd) b

        The target projection reads the target component of a strict homogeneous cone lift.

        theorem CategoryTheory.IsConeOf.homogeneousLift_comp_fst_general {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p r : ℤ) (hp1 : p + 1 = r) (h1p : 1 + p = r) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (k : ↑((DGCategoryStruct.dgHom X₁ Y₂).X (p - 1))) :
        ((DGCategoryStruct.dgComp p 1 r hp1) (hc₁.homogeneousLift hc₂ p a b k)) hc₂.fst = p.negOnePow • ((DGCategoryStruct.dgComp 1 p r h1p) hc₁.fst) a

        homogeneousLift_comp_fst with an arbitrary common result-degree name. This is the form degree-one graded naturality asks for.

        theorem CategoryTheory.IsConeOf.homogeneousLift_comp_snd_general {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p r : ℤ) (hp0 : p + 0 = r) (h0p : 0 + p = r) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) :
        ((DGCategoryStruct.dgComp p 0 r hp0) (hc₁.homogeneousLift hc₂ p a b 0)) hc₂.snd = ((DGCategoryStruct.dgComp 0 p r h0p) hc₁.snd) b

        homogeneousLift_comp_snd with an arbitrary common result-degree name.

        theorem CategoryTheory.IsConeOf.homogeneous_ext {C : Type u} [DGCategory C] {Z₁ X₂ Y₂ Z₂ : C} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) {u v : ↑((DGCategoryStruct.dgHom Z₁ Z₂).X p)} (hfst : ((DGCategoryStruct.dgComp p 1 (p + 1) ⋯) u) hc₂.fst = ((DGCategoryStruct.dgComp p 1 (p + 1) ⋯) v) hc₂.fst) (hsnd : ((DGCategoryStruct.dgComp p 0 p ⋯) u) hc₂.snd = ((DGCategoryStruct.dgComp p 0 p ⋯) v) hc₂.snd) :
        u = v

        Two homogeneous maps into a cone are equal when their two cone projections agree. This is the all-degree analogue of extensionality for a binary direct sum, derived from the cone's splitting of the identity.

        theorem CategoryTheory.IsConeOf.homogeneousLift_strict_comp {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) {X₃ Y₃ Z₃ : C} {f₃ : ↑((DGCategoryStruct.dgHom X₃ Y₃).X 0)} (hc₃ : IsConeOf f₃ Z₃) (p q : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (c : ↑((DGCategoryStruct.dgHom X₂ X₃).X q)) (d : ↑((DGCategoryStruct.dgHom Y₂ Y₃).X q)) :
        ((DGCategoryStruct.dgComp p q (p + q) ⋯) (hc₁.homogeneousLift hc₂ p a b 0)) (hc₂.homogeneousLift hc₃ q c d 0) = hc₁.homogeneousLift hc₃ (p + q) (((DGCategoryStruct.dgComp p q (p + q) ⋯) a) c) (((DGCategoryStruct.dgComp p q (p + q) ⋯) b) d) 0

        Strict homogeneous cone lifts preserve graded composition.

        This theorem is the multiplicativity law required by the objectwise-cone dg functor. Its proof uses the two projection identities, so the sign is checked once at the canonical cone boundary rather than by re-expanding three cone formulas.

        theorem CategoryTheory.IsConeOf.homogeneousLift_d {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (s : DGCategory.HomogeneousSquare f₁ f₂ p a b) :
        (AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom Z₁ Z₂).d p (p + 1))) (hc₁.homogeneousLift hc₂ p a b s.homotopy) = hc₁.homogeneousLift hc₂ (p + 1) ((AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom X₁ X₂).d p (p + 1))) a) ((AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom Y₁ Y₂).d p (p + 1))) b) 0

        The homogeneous lift of a homotopy-commutative square commutes with the differential. The differential of the degree-p lift is the strict degree-p+1 lift of the differentials of its two vertical maps: the a-term's differential is fst ≫ a ≫ f₂ ≫ inr, the b-term's is -(fst ≫ f₁) ≫ b ≫ inr -- the cone's own correction -- and the boundary of the homotopy is exactly their difference, so the three cancel and only the d a and d b components survive.

        This is the chain-map identity behind every cone functor in the repository; the strict case homogeneousLift_strict_d and the degree-zero IsConeOf.lift_closed are both instances of it.

        theorem CategoryTheory.IsConeOf.homogeneousLift_strict_d {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (hsquare : ((DGCategoryStruct.dgComp 0 p p ⋯) f₁) b = ((DGCategoryStruct.dgComp p 0 p ⋯) a) f₂) :
        (AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom Z₁ Z₂).d p (p + 1))) (hc₁.homogeneousLift hc₂ p a b 0) = hc₁.homogeneousLift hc₂ (p + 1) ((AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom X₁ X₂).d p (p + 1))) a) ((AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom Y₁ Y₂).d p (p + 1))) b) 0

        The strict case of homogeneousLift_d: with a zero homotopy the square commutes on the nose and the lift is a chain map.

        theorem CategoryTheory.IsConeOf.homogeneousLift_strict_map_d {C : Type u} [DGCategory C] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} {f₁ : ↑((DGCategoryStruct.dgHom X₁ Y₁).X 0)} {f₂ : ↑((DGCategoryStruct.dgHom X₂ Y₂).X 0)} (hc₁ : IsConeOf f₁ Z₁) (hc₂ : IsConeOf f₂ Z₂) (p q : ℤ) (a : ↑((DGCategoryStruct.dgHom X₁ X₂).X p)) (b : ↑((DGCategoryStruct.dgHom Y₁ Y₂).X p)) (hsquare : ((DGCategoryStruct.dgComp 0 p p ⋯) f₁) b = ((DGCategoryStruct.dgComp p 0 p ⋯) a) f₂) :
        (AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom Z₁ Z₂).d p q)) (hc₁.homogeneousLift hc₂ p a b 0) = hc₁.homogeneousLift hc₂ q ((AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom X₁ X₂).d p q)) a) ((AddCommGrpCat.Hom.hom ((DGCategoryStruct.dgHom Y₁ Y₂).d p q)) b) 0

        The differential law for a strict homogeneous lift in arbitrary source and target degrees. Off the cochain-complex successor diagonal all three differentials vanish by shape; on the diagonal this is homogeneousLift_strict_d.