Documentation

Mathlib.Algebra.Homology.HomologicalComplex

Homological complexes. #

A HomologicalComplex V c with a "shape" controlled by c : ComplexShape ι has chain groups X i (objects in V) indexed by i : ι, and a differential d i j whenever c.Rel i j.

We in fact ask for differentials d i j for all i j : ι, but have a field shape requiring that these are zero when not allowed by c. This avoids a lot of dependent type theory hell!

The composite of any two differentials d i j ≫ d j k must be zero.

We provide ChainComplex V α for α-indexed chain complexes in which d i j ≠ 0 only if j + 1 = i, and similarly CochainComplex V α, with i = j + 1.

There is a category structure, where morphisms are chain maps.

For C : HomologicalComplex V c, we define C.xNext i, which is either C.X j for some arbitrarily chosen j such that c.r i j, or C.X i if there is no such j. Similarly we have C.xPrev j. Defined in terms of these we have C.dFrom i : C.X i ⟶ C.xNext i and C.dTo j : C.xPrev j ⟶ C.X j, which are either defined as C.d i j, or zero, as needed.

A HomologicalComplex V c with a "shape" controlled by c : ComplexShape ι has chain groups X i (objects in V) indexed by i : ι, and a differential d i j whenever c.Rel i j.

We in fact ask for differentials d i j for all i j : ι, but have a field shape requiring that these are zero when not allowed by c. This avoids a lot of dependent type theory hell!

The composite of any two differentials d i j ≫ d j k must be zero.

  • X : ιV
  • d : (i j : ι) → self.X i self.X j
  • shape : ∀ (i j : ι), ¬c.Rel i jself.d i j = 0
  • d_comp_d' : ∀ (i j k : ι), c.Rel i jc.Rel j kCategoryTheory.CategoryStruct.comp (self.d i j) (self.d j k) = 0
Instances For
    @[simp]
    theorem HomologicalComplex.shape {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (self : HomologicalComplex V c) (i : ι) (j : ι) :
    ¬c.Rel i jself.d i j = 0
    theorem HomologicalComplex.d_comp_d' {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (self : HomologicalComplex V c) (i : ι) (j : ι) (k : ι) :
    c.Rel i jc.Rel j kCategoryTheory.CategoryStruct.comp (self.d i j) (self.d j k) = 0
    @[simp]
    theorem HomologicalComplex.d_comp_d {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) (i : ι) (j : ι) (k : ι) :
    theorem HomologicalComplex.ext {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (h_X : C₁.X = C₂.X) (h_d : ∀ (i j : ι), c.Rel i jCategoryTheory.CategoryStruct.comp (C₁.d i j) (CategoryTheory.eqToHom ) = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ) (C₂.d i j)) :
    C₁ = C₂
    def HomologicalComplex.XIsoOfEq {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p : ι} {q : ι} (h : p = q) :
    K.X p K.X q

    The obvious isomorphism K.X p ≅ K.X q when p = q.

    Equations
    Instances For
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_hom_comp_XIsoOfEq_hom_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} {p₃ : ι} (h₁₂ : p₁ = p₂) (h₂₃ : p₂ = p₃) {Z : V} (h : K.X p₃ Z) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₁₂).hom (CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₂₃).hom h) = CategoryTheory.CategoryStruct.comp (K.XIsoOfEq ).hom h
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_hom_comp_XIsoOfEq_hom {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} {p₃ : ι} (h₁₂ : p₁ = p₂) (h₂₃ : p₂ = p₃) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₁₂).hom (K.XIsoOfEq h₂₃).hom = (K.XIsoOfEq ).hom
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_hom_comp_XIsoOfEq_inv_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} {p₃ : ι} (h₁₂ : p₁ = p₂) (h₃₂ : p₃ = p₂) {Z : V} (h : K.X p₃ Z) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₁₂).hom (CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₃₂).inv h) = CategoryTheory.CategoryStruct.comp (K.XIsoOfEq ).hom h
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_hom_comp_XIsoOfEq_inv {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} {p₃ : ι} (h₁₂ : p₁ = p₂) (h₃₂ : p₃ = p₂) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₁₂).hom (K.XIsoOfEq h₃₂).inv = (K.XIsoOfEq ).hom
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_inv_comp_XIsoOfEq_hom_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} {p₃ : ι} (h₂₁ : p₂ = p₁) (h₂₃ : p₂ = p₃) {Z : V} (h : K.X p₃ Z) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₂₁).inv (CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₂₃).hom h) = CategoryTheory.CategoryStruct.comp (K.XIsoOfEq ).hom h
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_inv_comp_XIsoOfEq_hom {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} {p₃ : ι} (h₂₁ : p₂ = p₁) (h₂₃ : p₂ = p₃) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₂₁).inv (K.XIsoOfEq h₂₃).hom = (K.XIsoOfEq ).hom
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_inv_comp_XIsoOfEq_inv_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} {p₃ : ι} (h₂₁ : p₂ = p₁) (h₃₂ : p₃ = p₂) {Z : V} (h : K.X p₃ Z) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₂₁).inv (CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₃₂).inv h) = CategoryTheory.CategoryStruct.comp (K.XIsoOfEq ).hom h
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_inv_comp_XIsoOfEq_inv {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} {p₃ : ι} (h₂₁ : p₂ = p₁) (h₃₂ : p₃ = p₂) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h₂₁).inv (K.XIsoOfEq h₃₂).inv = (K.XIsoOfEq ).hom
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_hom_comp_d_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} (h : p₁ = p₂) (p₃ : ι) {Z : V} (h : K.X p₃ Z) :
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_hom_comp_d {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₁ : ι} {p₂ : ι} (h : p₁ = p₂) (p₃ : ι) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h).hom (K.d p₂ p₃) = K.d p₁ p₃
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_inv_comp_d_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₂ : ι} {p₁ : ι} (h : p₂ = p₁) (p₃ : ι) {Z : V} (h : K.X p₃ Z) :
      @[simp]
      theorem HomologicalComplex.XIsoOfEq_inv_comp_d {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₂ : ι} {p₁ : ι} (h : p₂ = p₁) (p₃ : ι) :
      CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h).inv (K.d p₂ p₃) = K.d p₁ p₃
      @[simp]
      theorem HomologicalComplex.d_comp_XIsoOfEq_hom_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₂ : ι} {p₃ : ι} (h : p₂ = p₃) (p₁ : ι) {Z : V} (h : K.X p₃ Z) :
      @[simp]
      theorem HomologicalComplex.d_comp_XIsoOfEq_hom {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₂ : ι} {p₃ : ι} (h : p₂ = p₃) (p₁ : ι) :
      CategoryTheory.CategoryStruct.comp (K.d p₁ p₂) (K.XIsoOfEq h).hom = K.d p₁ p₃
      @[simp]
      theorem HomologicalComplex.d_comp_XIsoOfEq_inv_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₂ : ι} {p₃ : ι} (h : p₃ = p₂) (p₁ : ι) {Z : V} (h : K.X p₃ Z) :
      @[simp]
      theorem HomologicalComplex.d_comp_XIsoOfEq_inv {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (K : HomologicalComplex V c) {p₂ : ι} {p₃ : ι} (h : p₃ = p₂) (p₁ : ι) :
      CategoryTheory.CategoryStruct.comp (K.d p₁ p₂) (K.XIsoOfEq h).inv = K.d p₁ p₃
      @[reducible, inline]

      An α-indexed chain complex is a HomologicalComplex in which d i j ≠ 0 only if j + 1 = i.

      Equations
      Instances For
        @[reducible, inline]

        An α-indexed cochain complex is a HomologicalComplex in which d i j ≠ 0 only if i + 1 = j.

        Equations
        Instances For
          @[simp]
          theorem ChainComplex.prev (α : Type u_2) [AddRightCancelSemigroup α] [One α] (i : α) :
          (ComplexShape.down α).prev i = i + 1
          @[simp]
          theorem ChainComplex.next (α : Type u_2) [AddGroup α] [One α] (i : α) :
          (ComplexShape.down α).next i = i - 1
          @[simp]
          theorem ChainComplex.next_nat_succ (i : ) :
          (ComplexShape.down ).next (i + 1) = i
          @[simp]
          theorem CochainComplex.prev (α : Type u_2) [AddGroup α] [One α] (i : α) :
          (ComplexShape.up α).prev i = i - 1
          @[simp]
          theorem CochainComplex.next (α : Type u_2) [AddRightCancelSemigroup α] [One α] (i : α) :
          (ComplexShape.up α).next i = i + 1
          @[simp]
          theorem CochainComplex.prev_nat_succ (i : ) :
          (ComplexShape.up ).prev (i + 1) = i
          theorem HomologicalComplex.Hom.ext_iff {ι : Type u_1} {V : Type u} :
          ∀ {inst : CategoryTheory.Category.{v, u} V} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms V} {c : ComplexShape ι} {A B : HomologicalComplex V c} (x y : A.Hom B), x = y x.f = y.f
          theorem HomologicalComplex.Hom.ext {ι : Type u_1} {V : Type u} :
          ∀ {inst : CategoryTheory.Category.{v, u} V} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms V} {c : ComplexShape ι} {A B : HomologicalComplex V c} (x y : A.Hom B), x.f = y.fx = y

          A morphism of homological complexes consists of maps between the chain groups, commuting with the differentials.

          Instances For
            theorem HomologicalComplex.Hom.comm' {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {A : HomologicalComplex V c} {B : HomologicalComplex V c} (self : A.Hom B) (i : ι) (j : ι) :
            c.Rel i jCategoryTheory.CategoryStruct.comp (self.f i) (B.d i j) = CategoryTheory.CategoryStruct.comp (A.d i j) (self.f j)
            @[simp]
            Equations
            • A.instInhabitedHom B = { default := { f := fun (i : ι) => 0, comm' := } }

            Identity chain map.

            Equations
            Instances For
              def HomologicalComplex.comp {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (A : HomologicalComplex V c) (B : HomologicalComplex V c) (C : HomologicalComplex V c) (φ : A.Hom B) (ψ : B.Hom C) :
              A.Hom C

              Composition of chain maps.

              Equations
              Instances For
                theorem HomologicalComplex.hom_ext {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C : HomologicalComplex V c} {D : HomologicalComplex V c} (f : C D) (g : C D) (h : ∀ (i : ι), f.f i = g.f i) :
                f = g
                @[simp]
                theorem HomologicalComplex.comp_f {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} {C₃ : HomologicalComplex V c} (f : C₁ C₂) (g : C₂ C₃) (i : ι) :
                Equations
                • X.instZeroHom Y = { zero := { f := fun (i : ι) => 0, comm' := } }

                The zero complex

                Equations
                • HomologicalComplex.zero = { X := fun (x : ι) => 0, d := fun (x x_1 : ι) => 0, shape := , d_comp_d' := }
                Instances For
                  Equations
                  • HomologicalComplex.instInhabitedOfHasZeroObject = { default := HomologicalComplex.zero }
                  theorem HomologicalComplex.congr_hom {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C : HomologicalComplex V c} {D : HomologicalComplex V c} {f : C D} {g : C D} (w : f = g) (i : ι) :
                  f.f i = g.f i
                  @[simp]
                  theorem HomologicalComplex.eval_map {ι : Type u_1} (V : Type u) [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (c : ComplexShape ι) (i : ι) :
                  ∀ {X Y : HomologicalComplex V c} (f : X Y), (HomologicalComplex.eval V c i).map f = f.f i

                  The functor picking out the i-th object of a complex.

                  Equations
                  Instances For
                    @[simp]
                    theorem HomologicalComplex.forget_map {ι : Type u_1} (V : Type u) [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (c : ComplexShape ι) :
                    ∀ {X Y : HomologicalComplex V c} (f : X Y) (i : ι), (HomologicalComplex.forget V c).map f i = f.f i

                    The functor forgetting the differential in a complex, obtaining a graded object.

                    Equations
                    Instances For

                      Forgetting the differentials than picking out the i-th object is the same as just picking out the i-th object.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        theorem HomologicalComplex.XIsoOfEq_hom_naturality_assoc {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {K : HomologicalComplex V c} {L : HomologicalComplex V c} (φ : K L) {n : ι} {n' : ι} (h : n = n') {Z : V} (h : L.X n' Z) :
                        theorem HomologicalComplex.XIsoOfEq_hom_naturality {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {K : HomologicalComplex V c} {L : HomologicalComplex V c} (φ : K L) {n : ι} {n' : ι} (h : n = n') :
                        CategoryTheory.CategoryStruct.comp (φ.f n) (L.XIsoOfEq h).hom = CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h).hom (φ.f n')
                        theorem HomologicalComplex.XIsoOfEq_inv_naturality {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {K : HomologicalComplex V c} {L : HomologicalComplex V c} (φ : K L) {n : ι} {n' : ι} (h : n = n') :
                        CategoryTheory.CategoryStruct.comp (φ.f n') (L.XIsoOfEq h).inv = CategoryTheory.CategoryStruct.comp (K.XIsoOfEq h).inv (φ.f n)
                        theorem HomologicalComplex.d_comp_eqToHom {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} {j : ι} {j' : ι} (rij : c.Rel i j) (rij' : c.Rel i j') :

                        If C.d i j and C.d i j' are both allowed, then we must have j = j', and so the differentials only differ by an eqToHom.

                        theorem HomologicalComplex.eqToHom_comp_d {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} {i' : ι} {j : ι} (rij : c.Rel i j) (rij' : c.Rel i' j) :

                        If C.d i j and C.d i' j are both allowed, then we must have i = i', and so the differentials only differ by an eqToHom.

                        @[reducible, inline]

                        Either C.X i, if there is some i with c.Rel i j, or C.X j.

                        Equations
                        • C.xPrev j = C.X (c.prev j)
                        Instances For
                          def HomologicalComplex.xPrevIso {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} {j : ι} (r : c.Rel i j) :
                          C.xPrev j C.X i

                          If c.Rel i j, then C.xPrev j is isomorphic to C.X i.

                          Equations
                          Instances For
                            def HomologicalComplex.xPrevIsoSelf {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {j : ι} (h : ¬c.Rel (c.prev j) j) :
                            C.xPrev j C.X j

                            If there is no i so c.Rel i j, then C.xPrev j is isomorphic to C.X j.

                            Equations
                            Instances For
                              @[reducible, inline]

                              Either C.X j, if there is some j with c.rel i j, or C.X i.

                              Equations
                              • C.xNext i = C.X (c.next i)
                              Instances For
                                def HomologicalComplex.xNextIso {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} {j : ι} (r : c.Rel i j) :
                                C.xNext i C.X j

                                If c.Rel i j, then C.xNext i is isomorphic to C.X j.

                                Equations
                                Instances For
                                  def HomologicalComplex.xNextIsoSelf {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} (h : ¬c.Rel i (c.next i)) :
                                  C.xNext i C.X i

                                  If there is no j so c.Rel i j, then C.xNext i is isomorphic to C.X i.

                                  Equations
                                  Instances For
                                    @[reducible, inline]

                                    The differential mapping into C.X j, or zero if there isn't one.

                                    Equations
                                    • C.dTo j = C.d (c.prev j) j
                                    Instances For
                                      @[reducible, inline]

                                      The differential mapping out of C.X i, or zero if there isn't one.

                                      Equations
                                      • C.dFrom i = C.d i (c.next i)
                                      Instances For
                                        theorem HomologicalComplex.dTo_eq {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} {j : ι} (r : c.Rel i j) :
                                        C.dTo j = CategoryTheory.CategoryStruct.comp (C.xPrevIso r).hom (C.d i j)
                                        @[simp]
                                        theorem HomologicalComplex.dTo_eq_zero {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {j : ι} (h : ¬c.Rel (c.prev j) j) :
                                        C.dTo j = 0
                                        theorem HomologicalComplex.dFrom_eq {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} {j : ι} (r : c.Rel i j) :
                                        C.dFrom i = CategoryTheory.CategoryStruct.comp (C.d i j) (C.xNextIso r).inv
                                        @[simp]
                                        theorem HomologicalComplex.dFrom_eq_zero {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} (h : ¬c.Rel i (c.next i)) :
                                        C.dFrom i = 0
                                        @[simp]
                                        @[simp]
                                        theorem HomologicalComplex.xPrevIso_comp_dTo {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} {j : ι} (r : c.Rel i j) :
                                        CategoryTheory.CategoryStruct.comp (C.xPrevIso r).inv (C.dTo j) = C.d i j
                                        @[simp]
                                        theorem HomologicalComplex.xPrevIsoSelf_comp_dTo {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {j : ι} (h : ¬c.Rel (c.prev j) j) :
                                        CategoryTheory.CategoryStruct.comp (C.xPrevIsoSelf h).inv (C.dTo j) = 0
                                        @[simp]
                                        @[simp]
                                        theorem HomologicalComplex.dFrom_comp_xNextIso {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} {j : ι} (r : c.Rel i j) :
                                        CategoryTheory.CategoryStruct.comp (C.dFrom i) (C.xNextIso r).hom = C.d i j
                                        @[simp]
                                        theorem HomologicalComplex.dFrom_comp_xNextIsoSelf {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i : ι} (h : ¬c.Rel i (c.next i)) :
                                        CategoryTheory.CategoryStruct.comp (C.dFrom i) (C.xNextIsoSelf h).hom = 0
                                        @[simp]
                                        @[simp]
                                        def HomologicalComplex.Hom.isoApp {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁ C₂) (i : ι) :
                                        C₁.X i C₂.X i

                                        The i-th component of an isomorphism of chain complexes.

                                        Equations
                                        Instances For
                                          @[simp]
                                          theorem HomologicalComplex.Hom.isoOfComponents_inv_f {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : (i : ι) → C₁.X i C₂.X i) (hf : autoParam (∀ (i j : ι), c.Rel i jCategoryTheory.CategoryStruct.comp (f i).hom (C₂.d i j) = CategoryTheory.CategoryStruct.comp (C₁.d i j) (f j).hom) _auto✝) (i : ι) :
                                          (HomologicalComplex.Hom.isoOfComponents f hf).inv.f i = (f i).inv
                                          @[simp]
                                          theorem HomologicalComplex.Hom.isoOfComponents_hom_f {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : (i : ι) → C₁.X i C₂.X i) (hf : autoParam (∀ (i j : ι), c.Rel i jCategoryTheory.CategoryStruct.comp (f i).hom (C₂.d i j) = CategoryTheory.CategoryStruct.comp (C₁.d i j) (f j).hom) _auto✝) (i : ι) :
                                          (HomologicalComplex.Hom.isoOfComponents f hf).hom.f i = (f i).hom
                                          def HomologicalComplex.Hom.isoOfComponents {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : (i : ι) → C₁.X i C₂.X i) (hf : autoParam (∀ (i j : ι), c.Rel i jCategoryTheory.CategoryStruct.comp (f i).hom (C₂.d i j) = CategoryTheory.CategoryStruct.comp (C₁.d i j) (f j).hom) _auto✝) :
                                          C₁ C₂

                                          Construct an isomorphism of chain complexes from isomorphism of the objects which commute with the differentials.

                                          Equations
                                          • HomologicalComplex.Hom.isoOfComponents f hf = { hom := { f := fun (i : ι) => (f i).hom, comm' := hf }, inv := { f := fun (i : ι) => (f i).inv, comm' := }, hom_inv_id := , inv_hom_id := }
                                          Instances For
                                            @[simp]
                                            theorem HomologicalComplex.Hom.isoOfComponents_app {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : (i : ι) → C₁.X i C₂.X i) (hf : ∀ (i j : ι), c.Rel i jCategoryTheory.CategoryStruct.comp (f i).hom (C₂.d i j) = CategoryTheory.CategoryStruct.comp (C₁.d i j) (f j).hom) (i : ι) :

                                            Lemmas relating chain maps and dTo/dFrom.

                                            @[reducible, inline]
                                            abbrev HomologicalComplex.Hom.prev {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (j : ι) :
                                            C₁.xPrev j C₂.xPrev j

                                            f.prev j is f.f i if there is some r i j, and f.f j otherwise.

                                            Equations
                                            • f.prev j = f.f (c.prev j)
                                            Instances For
                                              theorem HomologicalComplex.Hom.prev_eq {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) {i : ι} {j : ι} (w : c.Rel i j) :
                                              f.prev j = CategoryTheory.CategoryStruct.comp (C₁.xPrevIso w).hom (CategoryTheory.CategoryStruct.comp (f.f i) (C₂.xPrevIso w).inv)
                                              @[reducible, inline]
                                              abbrev HomologicalComplex.Hom.next {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (i : ι) :
                                              C₁.xNext i C₂.xNext i

                                              f.next i is f.f j if there is some r i j, and f.f j otherwise.

                                              Equations
                                              • f.next i = f.f (c.next i)
                                              Instances For
                                                theorem HomologicalComplex.Hom.next_eq {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) {i : ι} {j : ι} (w : c.Rel i j) :
                                                f.next i = CategoryTheory.CategoryStruct.comp (C₁.xNextIso w).hom (CategoryTheory.CategoryStruct.comp (f.f j) (C₂.xNextIso w).inv)
                                                @[simp]
                                                @[simp]
                                                theorem HomologicalComplex.Hom.comm_from_apply {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (i : ι) [inst : CategoryTheory.ConcreteCategory V] (x : (CategoryTheory.forget V).obj (C₁.X i)) :
                                                (C₂.dFrom i) ((f.f i) x) = (f.next i) ((C₁.dFrom i) x)
                                                theorem HomologicalComplex.Hom.comm_from {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (i : ι) :
                                                CategoryTheory.CategoryStruct.comp (f.f i) (C₂.dFrom i) = CategoryTheory.CategoryStruct.comp (C₁.dFrom i) (f.next i)
                                                @[simp]
                                                theorem HomologicalComplex.Hom.comm_to_apply {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (j : ι) [inst : CategoryTheory.ConcreteCategory V] (x : (CategoryTheory.forget V).obj (C₁.xPrev j)) :
                                                (C₂.dTo j) ((f.prev j) x) = (f.f j) ((C₁.dTo j) x)
                                                theorem HomologicalComplex.Hom.comm_to {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (j : ι) :
                                                CategoryTheory.CategoryStruct.comp (f.prev j) (C₂.dTo j) = CategoryTheory.CategoryStruct.comp (C₁.dTo j) (f.f j)
                                                def HomologicalComplex.Hom.sqFrom {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (i : ι) :

                                                A morphism of chain complexes induces a morphism of arrows of the differentials out of each object.

                                                Equations
                                                Instances For
                                                  @[simp]
                                                  theorem HomologicalComplex.Hom.sqFrom_left {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (i : ι) :
                                                  (f.sqFrom i).left = f.f i
                                                  @[simp]
                                                  theorem HomologicalComplex.Hom.sqFrom_right {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (i : ι) :
                                                  (f.sqFrom i).right = f.next i

                                                  A morphism of chain complexes induces a morphism of arrows of the differentials into each object.

                                                  Equations
                                                  Instances For
                                                    @[simp]
                                                    theorem HomologicalComplex.Hom.sqTo_left {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (j : ι) :
                                                    (f.sqTo j).left = f.prev j
                                                    @[simp]
                                                    theorem HomologicalComplex.Hom.sqTo_right {ι : Type u_1} {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ : HomologicalComplex V c} {C₂ : HomologicalComplex V c} (f : C₁.Hom C₂) (j : ι) :
                                                    (f.sqTo j).right = f.f j
                                                    def ChainComplex.of {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d : (n : α) → X (n + 1) X n) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (d n) = 0) :

                                                    Construct an α-indexed chain complex from a dependently-typed differential.

                                                    Equations
                                                    Instances For
                                                      @[simp]
                                                      theorem ChainComplex.of_x {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d : (n : α) → X (n + 1) X n) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (d n) = 0) (n : α) :
                                                      (ChainComplex.of X d sq).X n = X n
                                                      @[simp]
                                                      theorem ChainComplex.of_d {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d : (n : α) → X (n + 1) X n) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (d n) = 0) (j : α) :
                                                      (ChainComplex.of X d sq).d (j + 1) j = d j
                                                      theorem ChainComplex.of_d_ne {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d : (n : α) → X (n + 1) X n) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (d n) = 0) {i : α} {j : α} (h : i j + 1) :
                                                      (ChainComplex.of X d sq).d i j = 0
                                                      @[simp]
                                                      theorem ChainComplex.ofHom_f {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d_X : (n : α) → X (n + 1) X n) (sq_X : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_X (n + 1)) (d_X n) = 0) (Y : αV) (d_Y : (n : α) → Y (n + 1) Y n) (sq_Y : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_Y (n + 1)) (d_Y n) = 0) (f : (i : α) → X i Y i) (comm : ∀ (i : α), CategoryTheory.CategoryStruct.comp (f (i + 1)) (d_Y i) = CategoryTheory.CategoryStruct.comp (d_X i) (f i)) (i : α) :
                                                      (ChainComplex.ofHom X d_X sq_X Y d_Y sq_Y f comm).f i = f i
                                                      def ChainComplex.ofHom {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d_X : (n : α) → X (n + 1) X n) (sq_X : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_X (n + 1)) (d_X n) = 0) (Y : αV) (d_Y : (n : α) → Y (n + 1) Y n) (sq_Y : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_Y (n + 1)) (d_Y n) = 0) (f : (i : α) → X i Y i) (comm : ∀ (i : α), CategoryTheory.CategoryStruct.comp (f (i + 1)) (d_Y i) = CategoryTheory.CategoryStruct.comp (d_X i) (f i)) :
                                                      ChainComplex.of X d_X sq_X ChainComplex.of Y d_Y sq_Y

                                                      A constructor for chain maps between α-indexed chain complexes built using ChainComplex.of, from a dependently typed collection of morphisms.

                                                      Equations
                                                      Instances For
                                                        def ChainComplex.mkAux {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₁ X₀) (d₁ : X₂ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ S.X₁) ×' CategoryTheory.CategoryStruct.comp d₂ S.f = 0) :

                                                        Auxiliary definition for mk.

                                                        Equations
                                                        Instances For
                                                          def ChainComplex.mk {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₁ X₀) (d₁ : X₂ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ S.X₁) ×' CategoryTheory.CategoryStruct.comp d₂ S.f = 0) :

                                                          An inductive constructor for -indexed chain complexes.

                                                          You provide explicitly the first two differentials, then a function which takes two differentials and the fact they compose to zero, and returns the next object, its differential, and the fact it composes appropriately to zero.

                                                          See also mk', which only sees the previous differential in the inductive step.

                                                          Equations
                                                          Instances For
                                                            @[simp]
                                                            theorem ChainComplex.mk_X_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₁ X₀) (d₁ : X₂ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ S.X₁) ×' CategoryTheory.CategoryStruct.comp d₂ S.f = 0) :
                                                            (ChainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).X 0 = X₀
                                                            @[simp]
                                                            theorem ChainComplex.mk_X_1 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₁ X₀) (d₁ : X₂ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ S.X₁) ×' CategoryTheory.CategoryStruct.comp d₂ S.f = 0) :
                                                            (ChainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).X 1 = X₁
                                                            @[simp]
                                                            theorem ChainComplex.mk_X_2 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₁ X₀) (d₁ : X₂ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ S.X₁) ×' CategoryTheory.CategoryStruct.comp d₂ S.f = 0) :
                                                            (ChainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).X 2 = X₂
                                                            @[simp]
                                                            theorem ChainComplex.mk_d_1_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₁ X₀) (d₁ : X₂ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ S.X₁) ×' CategoryTheory.CategoryStruct.comp d₂ S.f = 0) :
                                                            (ChainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).d 1 0 = d₀
                                                            @[simp]
                                                            theorem ChainComplex.mk_d_2_1 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₁ X₀) (d₁ : X₂ X₁) (s : CategoryTheory.CategoryStruct.comp d₁ d₀ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₃ : V) ×' (d₂ : X₃ S.X₁) ×' CategoryTheory.CategoryStruct.comp d₂ S.f = 0) :
                                                            (ChainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).d 2 1 = d₁
                                                            def ChainComplex.mk' {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (d : X₁ X₀) (succ' : {X₀ X₁ : V} → (f : X₁ X₀) → (X₂ : V) ×' (d : X₂ X₁) ×' CategoryTheory.CategoryStruct.comp d f = 0) :

                                                            A simpler inductive constructor for -indexed chain complexes.

                                                            You provide explicitly the first differential, then a function which takes a differential, and returns the next object, its differential, and the fact it composes appropriately to zero.

                                                            Equations
                                                            Instances For
                                                              @[simp]
                                                              theorem ChainComplex.mk'_X_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (d₀ : X₁ X₀) (succ' : {X₀ X₁ : V} → (f : X₁ X₀) → (X₂ : V) ×' (d : X₂ X₁) ×' CategoryTheory.CategoryStruct.comp d f = 0) :
                                                              (ChainComplex.mk' X₀ X₁ d₀ fun {X₀ X₁ : V} => succ').X 0 = X₀
                                                              @[simp]
                                                              theorem ChainComplex.mk'_X_1 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (d₀ : X₁ X₀) (succ' : {X₀ X₁ : V} → (f : X₁ X₀) → (X₂ : V) ×' (d : X₂ X₁) ×' CategoryTheory.CategoryStruct.comp d f = 0) :
                                                              (ChainComplex.mk' X₀ X₁ d₀ fun {X₀ X₁ : V} => succ').X 1 = X₁
                                                              @[simp]
                                                              theorem ChainComplex.mk'_d_1_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (d₀ : X₁ X₀) (succ' : {X₀ X₁ : V} → (f : X₁ X₀) → (X₂ : V) ×' (d : X₂ X₁) ×' CategoryTheory.CategoryStruct.comp d f = 0) :
                                                              (ChainComplex.mk' X₀ X₁ d₀ fun {X₀ X₁ : V} => succ').d 1 0 = d₀
                                                              def ChainComplex.mkHomAux {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : ChainComplex V ) (Q : ChainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp one (Q.d 1 0) = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f' (Q.d (n + 1) n) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f) → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp f'' (Q.d (n + 2) (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) p.snd.fst) (n : ) :
                                                              (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f' (Q.d (n + 1) n) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f

                                                              An auxiliary construction for mkHom.

                                                              Here we build by induction a family of commutative squares, but don't require at the type level that these successive commutative squares actually agree. They do in fact agree, and we then capture that at the type level (i.e. by constructing a chain map) in mkHom.

                                                              Equations
                                                              • P.mkHomAux Q zero one one_zero_comm succ 0 = zero, one, one_zero_comm
                                                              • P.mkHomAux Q zero one one_zero_comm succ n.succ = (P.mkHomAux Q zero one one_zero_comm succ n).snd.fst, (succ n (P.mkHomAux Q zero one one_zero_comm succ n)).fst,
                                                              Instances For
                                                                def ChainComplex.mkHom {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : ChainComplex V ) (Q : ChainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp one (Q.d 1 0) = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f' (Q.d (n + 1) n) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f) → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp f'' (Q.d (n + 2) (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) p.snd.fst) :
                                                                P Q

                                                                A constructor for chain maps between -indexed chain complexes, working by induction on commutative squares.

                                                                You need to provide the components of the chain map in degrees 0 and 1, show that these form a commutative square, and then give a construction of each component, and the fact that it forms a commutative square with the previous component, using as an inductive hypothesis the data (and commutativity) of the previous two components.

                                                                Equations
                                                                • P.mkHom Q zero one one_zero_comm succ = { f := fun (n : ) => (P.mkHomAux Q zero one one_zero_comm succ n).fst, comm' := }
                                                                Instances For
                                                                  @[simp]
                                                                  theorem ChainComplex.mkHom_f_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : ChainComplex V ) (Q : ChainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp one (Q.d 1 0) = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f' (Q.d (n + 1) n) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f) → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp f'' (Q.d (n + 2) (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) p.snd.fst) :
                                                                  (P.mkHom Q zero one one_zero_comm succ).f 0 = zero
                                                                  @[simp]
                                                                  theorem ChainComplex.mkHom_f_1 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : ChainComplex V ) (Q : ChainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp one (Q.d 1 0) = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f' (Q.d (n + 1) n) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f) → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp f'' (Q.d (n + 2) (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) p.snd.fst) :
                                                                  (P.mkHom Q zero one one_zero_comm succ).f 1 = one
                                                                  @[simp]
                                                                  theorem ChainComplex.mkHom_f_succ_succ {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : ChainComplex V ) (Q : ChainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp one (Q.d 1 0) = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f' (Q.d (n + 1) n) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) n) f) → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp f'' (Q.d (n + 2) (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d (n + 2) (n + 1)) p.snd.fst) (n : ) :
                                                                  (P.mkHom Q zero one one_zero_comm succ).f (n + 2) = (succ n (P.mkHom Q zero one one_zero_comm succ).f n, (P.mkHom Q zero one one_zero_comm succ).f (n + 1), ).fst
                                                                  def CochainComplex.of {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d : (n : α) → X n X (n + 1)) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d n) (d (n + 1)) = 0) :

                                                                  Construct an α-indexed cochain complex from a dependently-typed differential.

                                                                  Equations
                                                                  • One or more equations did not get rendered due to their size.
                                                                  Instances For
                                                                    @[simp]
                                                                    theorem CochainComplex.of_x {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d : (n : α) → X n X (n + 1)) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d n) (d (n + 1)) = 0) (n : α) :
                                                                    (CochainComplex.of X d sq).X n = X n
                                                                    @[simp]
                                                                    theorem CochainComplex.of_d {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d : (n : α) → X n X (n + 1)) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d n) (d (n + 1)) = 0) (j : α) :
                                                                    (CochainComplex.of X d sq).d j (j + 1) = d j
                                                                    theorem CochainComplex.of_d_ne {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d : (n : α) → X n X (n + 1)) (sq : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d n) (d (n + 1)) = 0) {i : α} {j : α} (h : i + 1 j) :
                                                                    (CochainComplex.of X d sq).d i j = 0
                                                                    @[simp]
                                                                    theorem CochainComplex.ofHom_f {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d_X : (n : α) → X n X (n + 1)) (sq_X : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_X n) (d_X (n + 1)) = 0) (Y : αV) (d_Y : (n : α) → Y n Y (n + 1)) (sq_Y : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_Y n) (d_Y (n + 1)) = 0) (f : (i : α) → X i Y i) (comm : ∀ (i : α), CategoryTheory.CategoryStruct.comp (f i) (d_Y i) = CategoryTheory.CategoryStruct.comp (d_X i) (f (i + 1))) (i : α) :
                                                                    (CochainComplex.ofHom X d_X sq_X Y d_Y sq_Y f comm).f i = f i
                                                                    def CochainComplex.ofHom {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] {α : Type u_2} [AddRightCancelSemigroup α] [One α] [DecidableEq α] (X : αV) (d_X : (n : α) → X n X (n + 1)) (sq_X : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_X n) (d_X (n + 1)) = 0) (Y : αV) (d_Y : (n : α) → Y n Y (n + 1)) (sq_Y : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_Y n) (d_Y (n + 1)) = 0) (f : (i : α) → X i Y i) (comm : ∀ (i : α), CategoryTheory.CategoryStruct.comp (f i) (d_Y i) = CategoryTheory.CategoryStruct.comp (d_X i) (f (i + 1))) :

                                                                    A constructor for chain maps between α-indexed cochain complexes built using CochainComplex.of, from a dependently typed collection of morphisms.

                                                                    Equations
                                                                    Instances For
                                                                      def CochainComplex.mkAux {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₀ X₁) (d₁ : X₁ X₂) (s : CategoryTheory.CategoryStruct.comp d₀ d₁ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ X₄) ×' CategoryTheory.CategoryStruct.comp S.g d₂ = 0) :

                                                                      Auxiliary definition for mk.

                                                                      Equations
                                                                      Instances For
                                                                        def CochainComplex.mk {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₀ X₁) (d₁ : X₁ X₂) (s : CategoryTheory.CategoryStruct.comp d₀ d₁ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ X₄) ×' CategoryTheory.CategoryStruct.comp S.g d₂ = 0) :

                                                                        An inductive constructor for -indexed cochain complexes.

                                                                        You provide explicitly the first two differentials, then a function which takes two differentials and the fact they compose to zero, and returns the next object, its differential, and the fact it composes appropriately to zero.

                                                                        See also mk', which only sees the previous differential in the inductive step.

                                                                        Equations
                                                                        • One or more equations did not get rendered due to their size.
                                                                        Instances For
                                                                          @[simp]
                                                                          theorem CochainComplex.mk_X_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₀ X₁) (d₁ : X₁ X₂) (s : CategoryTheory.CategoryStruct.comp d₀ d₁ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ X₄) ×' CategoryTheory.CategoryStruct.comp S.g d₂ = 0) :
                                                                          (CochainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).X 0 = X₀
                                                                          @[simp]
                                                                          theorem CochainComplex.mk_X_1 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₀ X₁) (d₁ : X₁ X₂) (s : CategoryTheory.CategoryStruct.comp d₀ d₁ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ X₄) ×' CategoryTheory.CategoryStruct.comp S.g d₂ = 0) :
                                                                          (CochainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).X 1 = X₁
                                                                          @[simp]
                                                                          theorem CochainComplex.mk_X_2 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₀ X₁) (d₁ : X₁ X₂) (s : CategoryTheory.CategoryStruct.comp d₀ d₁ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ X₄) ×' CategoryTheory.CategoryStruct.comp S.g d₂ = 0) :
                                                                          (CochainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).X 2 = X₂
                                                                          @[simp]
                                                                          theorem CochainComplex.mk_d_1_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₀ X₁) (d₁ : X₁ X₂) (s : CategoryTheory.CategoryStruct.comp d₀ d₁ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ X₄) ×' CategoryTheory.CategoryStruct.comp S.g d₂ = 0) :
                                                                          (CochainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).d 0 1 = d₀
                                                                          @[simp]
                                                                          theorem CochainComplex.mk_d_2_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (X₂ : V) (d₀ : X₀ X₁) (d₁ : X₁ X₂) (s : CategoryTheory.CategoryStruct.comp d₀ d₁ = 0) (succ : (S : CategoryTheory.ShortComplex V) → (X₄ : V) ×' (d₂ : S.X₃ X₄) ×' CategoryTheory.CategoryStruct.comp S.g d₂ = 0) :
                                                                          (CochainComplex.mk X₀ X₁ X₂ d₀ d₁ s succ).d 1 2 = d₁
                                                                          def CochainComplex.mk' {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (d : X₀ X₁) (succ' : {X₀ X₁ : V} → (f : X₀ X₁) → (X₂ : V) ×' (d : X₁ X₂) ×' CategoryTheory.CategoryStruct.comp f d = 0) :

                                                                          A simpler inductive constructor for -indexed cochain complexes.

                                                                          You provide explicitly the first differential, then a function which takes a differential, and returns the next object, its differential, and the fact it composes appropriately to zero.

                                                                          Equations
                                                                          Instances For
                                                                            @[simp]
                                                                            theorem CochainComplex.mk'_X_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (d₀ : X₀ X₁) (succ' : {X₀ X₁ : V} → (f : X₀ X₁) → (X₂ : V) ×' (d : X₁ X₂) ×' CategoryTheory.CategoryStruct.comp f d = 0) :
                                                                            (CochainComplex.mk' X₀ X₁ d₀ fun {X₀ X₁ : V} => succ').X 0 = X₀
                                                                            @[simp]
                                                                            theorem CochainComplex.mk'_X_1 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (d₀ : X₀ X₁) (succ' : {X₀ X₁ : V} → (f : X₀ X₁) → (X₂ : V) ×' (d : X₁ X₂) ×' CategoryTheory.CategoryStruct.comp f d = 0) :
                                                                            (CochainComplex.mk' X₀ X₁ d₀ fun {X₀ X₁ : V} => succ').X 1 = X₁
                                                                            @[simp]
                                                                            theorem CochainComplex.mk'_d_1_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (X₀ : V) (X₁ : V) (d₀ : X₀ X₁) (succ' : {X₀ X₁ : V} → (f : X₀ X₁) → (X₂ : V) ×' (d : X₁ X₂) ×' CategoryTheory.CategoryStruct.comp f d = 0) :
                                                                            (CochainComplex.mk' X₀ X₁ d₀ fun {X₀ X₁ : V} => succ').d 0 1 = d₀
                                                                            def CochainComplex.mkHomAux {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : CochainComplex V ) (Q : CochainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'') (n : ) :
                                                                            (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f'

                                                                            An auxiliary construction for mkHom.

                                                                            Here we build by induction a family of commutative squares, but don't require at the type level that these successive commutative squares actually agree. They do in fact agree, and we then capture that at the type level (i.e. by constructing a chain map) in mkHom.

                                                                            Equations
                                                                            • P.mkHomAux Q zero one one_zero_comm succ 0 = zero, one, one_zero_comm
                                                                            • P.mkHomAux Q zero one one_zero_comm succ n.succ = (P.mkHomAux Q zero one one_zero_comm succ n).snd.fst, (succ n (P.mkHomAux Q zero one one_zero_comm succ n)).fst,
                                                                            Instances For
                                                                              def CochainComplex.mkHom {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : CochainComplex V ) (Q : CochainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'') :
                                                                              P Q

                                                                              A constructor for chain maps between -indexed cochain complexes, working by induction on commutative squares.

                                                                              You need to provide the components of the chain map in degrees 0 and 1, show that these form a commutative square, and then give a construction of each component, and the fact that it forms a commutative square with the previous component, using as an inductive hypothesis the data (and commutativity) of the previous two components.

                                                                              Equations
                                                                              • P.mkHom Q zero one one_zero_comm succ = { f := fun (n : ) => (P.mkHomAux Q zero one one_zero_comm succ n).fst, comm' := }
                                                                              Instances For
                                                                                @[simp]
                                                                                theorem CochainComplex.mkHom_f_0 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : CochainComplex V ) (Q : CochainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'') :
                                                                                (P.mkHom Q zero one one_zero_comm succ).f 0 = zero
                                                                                @[simp]
                                                                                theorem CochainComplex.mkHom_f_1 {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : CochainComplex V ) (Q : CochainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'') :
                                                                                (P.mkHom Q zero one one_zero_comm succ).f 1 = one
                                                                                @[simp]
                                                                                theorem CochainComplex.mkHom_f_succ_succ {V : Type u} [CategoryTheory.Category.{v, u} V] [CategoryTheory.Limits.HasZeroMorphisms V] (P : CochainComplex V ) (Q : CochainComplex V ) (zero : P.X 0 Q.X 0) (one : P.X 1 Q.X 1) (one_zero_comm : CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one) (succ : (n : ) → (p : (f : P.X n Q.X n) ×' (f' : P.X (n + 1) Q.X (n + 1)) ×' CategoryTheory.CategoryStruct.comp f (Q.d n (n + 1)) = CategoryTheory.CategoryStruct.comp (P.d n (n + 1)) f') → (f'' : P.X (n + 2) Q.X (n + 2)) ×' CategoryTheory.CategoryStruct.comp p.snd.fst (Q.d (n + 1) (n + 2)) = CategoryTheory.CategoryStruct.comp (P.d (n + 1) (n + 2)) f'') (n : ) :
                                                                                (P.mkHom Q zero one one_zero_comm succ).f (n + 2) = (succ n (P.mkHom Q zero one one_zero_comm succ).f n, (P.mkHom Q zero one one_zero_comm succ).f (n + 1), ).fst