homalg · ChainComplex

29 accepted declarations. Python and Rust forms, contracts, evidence, failure boundaries, and checked usages are kept together below.

Worked example

The complete checked program Compute the mod-two cohomology ring of RP2 and its Steenrod square uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Compute the mod-two cohomology ring of RP2 and its Steenrod square."""

from noether.numthy import FiniteField
from noether.topology import AdmissibleCohomologyOperation, SimplicialComplex


def main() -> None:
    projective_plane = SimplicialComplex(
        [
            [0, 1, 2],
            [0, 1, 4],
            [0, 2, 3],
            [0, 3, 5],
            [0, 4, 5],
            [1, 2, 5],
            [1, 3, 4],
            [1, 3, 5],
            [2, 3, 4],
            [2, 4, 5],
        ]
    )
    cohomology = projective_plane.cohomology_ring(FiniteField.prime(2))
    cohomology.verify()
    assert [basis.degree for basis in cohomology.basis] == [0, 1, 2]
    assert cohomology.product(1, 1)[0].basis == 2

    square = AdmissibleCohomologyOperation.steenrod_square(1)
    image = cohomology.apply_operation(square, 1)
    assert image[0].basis == 2 and int(image[0].coefficient) == 1
    print(f"H*(RP2; F2) degrees={[basis.degree for basis in cohomology.basis]}; Sq^1(h)=h^2")


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/33_simplicial_cohomology_operations.py.

homalg.ChainComplex

One checked chain-complex type for boundary and coboundary presentations.

PythonRust

class ChainComplex

noether::homalg::ChainComplex · Direct Rust declaration

pub struct ChainComplex<R: Ring> { /* private fields */ }

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_acceptance_workload.py:16 · validation/unit/homalg/test_acceptance_workload.py:33 · validation/unit/homalg/test_acceptance_workload.py:51 · validation/unit/homalg/test_acceptance_workload.py:52 · validation/unit/homalg/test_acceptance_workload.py:54 · validation/unit/homalg/test_acceptance_workload.py:55

homalg.ChainComplex.algebraic_morse_reduction

Cancel every 1 and -1 pivot and return replayable evidence.

Detailed contract

Cancel 1 and -1 entries until no universal-unit pivot remains. This is algebraic discrete Morse reduction for an arbitrary based complex of finite free modules. Candidate pivots are chosen deterministically by predicted fill-in, then degree, row, and column.

PythonRust

(self) -> ChainReduction[R]

noether::homalg::ChainComplex::algebraic_morse_reduction · Direct Rust declaration

pub fn algebraic_morse_reduction( &self, ) -> Result<ChainReduction<R>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_chain_complex.py:190 · validation/unit/homalg/test_chain_complex.py:75 · validation/unit/homalg/test_padic_homology_facade.py:231 · validation/unit/homalg/test_padic_homology_facade.py:269 · validation/unit/infra/test_concurrency.py:162 · validation/unit/infra/test_discovery.py:131

homalg.ChainComplex.betti_number

Return the Betti number without constructing cycle or quotient bases.

Detailed contract

Return the Betti number in one displayed degree. This is the invariants-only path: it computes dim(C_n) - rank(d_n) - rank(d_(n+1)) without constructing cycle, boundary, or quotient bases. For a boundary presentation it is the dimension of homology; for a coboundary presentation it is the dimension of cohomology.

PythonRust

(self: ChainComplex[_FieldContext], degree: int) -> int

noether::homalg::ChainComplex::betti_number · Direct Rust declaration

pub fn betti_number(&self, degree: i32) -> Result<usize, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_chain_complex.py:105 · validation/unit/homalg/test_chain_complex.py:106 · validation/unit/homalg/test_chain_complex.py:141 · validation/unit/homalg/test_chain_complex.py:32 · validation/unit/homalg/test_chain_complex.py:33 · validation/unit/homalg/test_chain_complex.py:34

homalg.ChainComplex.cohomology

Compute one checked cohomology group.

Detailed contract

Compute H^n = ker(delta^n) / im(delta^(n-1)) over an exact field. Compute integral cohomology from a coboundary presentation.

PythonRust

(self, degree: int) -> HomologyGroup[R]

noether::homalg::ChainComplex::cohomology · Direct Rust declaration

pub fn cohomology(&self, degree: i32) -> Result<HomologyGroup<R>, HomologyError>
pub fn cohomology( &self, degree: i32, ) -> Result<HomologyGroup<IntegerRing>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: examples/33_simplicial_cohomology_operations.py:24 · examples/33_simplicial_cohomology_operations.py:25 · examples/33_simplicial_cohomology_operations.py:26 · examples/33_simplicial_cohomology_operations.py:27 · examples/33_simplicial_cohomology_operations.py:3 · examples/33_simplicial_cohomology_operations.py:30

homalg.ChainComplex.cohomology_invariants

Return lean integral or precision-aware p-adic cohomology invariants.

Detailed contract

Compute one p-adic cohomology invariant summary. Compute only the canonical finitely generated abelian group underlying integral cohomology, without retaining adjacent coboundaries.

PythonRust

(self: ChainComplex[IntegerRing], degree: int) -> FinitelyGeneratedAbelianGroup
(self: ChainComplex[PadicRing], degree: int) -> PadicModuleInvariants

noether::homalg::ChainComplex::cohomology_invariants · Direct Rust declaration

pub fn cohomology_invariants( &self, degree: i32, ) -> Result<PadicModuleInvariants, HomologyError>
pub fn cohomology_invariants( &self, degree: i32, ) -> Result<FinitelyGeneratedAbelianGroup, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_acceptance_workload.py:34 · validation/unit/homalg/test_padic_homology_facade.py:131 · validation/unit/homalg/test_padic_homology_facade.py:222

homalg.ChainComplex.cohomology_invariants_with_integer_lift

Certify p-adic cohomology using an exact integral cochain lift.

Detailed contract

Compute cohomology from an exact integral cochain complex lift. The adjacent integral maps are retained so unconditional validity can be replayed after serialization.

PythonRust

(self: ChainComplex[PadicRing], degree: int, integer_lift: ChainComplex[IntegerRing]) -> PadicModuleInvariants

noether::homalg::ChainComplex::cohomology_invariants_with_integer_lift · Direct Rust declaration

pub fn cohomology_invariants_with_integer_lift( &self, degree: i32, integer_lift: &ChainComplex<IntegerRing>, ) -> Result<PadicModuleInvariants, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:184

homalg.ChainComplex.cohomology_invariants_with_ranks

Resolve p-adic cohomology under caller-supplied exact Q_p-rank assumptions.

Detailed contract

Compute cohomology under caller-supplied exact adjacent Q_p-rank assumptions. outgoing_rank is the rank of delta^degree and incoming_rank is the rank of delta^(degree-1).

PythonRust

(self: ChainComplex[PadicRing], degree: int, outgoing_rank: int, incoming_rank: int) -> PadicModuleInvariants

noether::homalg::ChainComplex::cohomology_invariants_with_ranks · Direct Rust declaration

pub fn cohomology_invariants_with_ranks( &self, degree: i32, outgoing_rank: usize, incoming_rank: usize, ) -> Result<PadicModuleInvariants, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:133

homalg.ChainComplex.degrees

Displayed degrees carrying an inferred free module.

Detailed contract

Degrees carrying a nonzero explicitly inferred free module, in order. Cohomological presentations are returned in their displayed degrees.

PythonRust

(self) -> list[int]

noether::homalg::ChainComplex::degrees · Direct Rust declaration

pub fn degrees(&self) -> Vec<i32>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: examples/14_weighted_polynomials.py:18 · examples/33_simplicial_cohomology_operations.py:32 · validation/unit/homalg/test_chain_complex.py:102 · validation/unit/homalg/test_chain_complex.py:26 · validation/unit/homalg/test_exterior_algebra.py:91 · validation/unit/homalg/test_padic_homology_facade.py:237

homalg.ChainComplex.differential

Differential supplied at one displayed degree, if present.

Detailed contract

Differential supplied at one displayed degree. For a homological presentation this is d_degree; for a cohomological presentation it is delta^degree. Missing degrees return None, including degrees represented only by an inferred free module. Sparse storage is materialized only when this inspection method is called; algorithms continue to operate on the retained layout.

PythonRust

(self, degree: int) -> Matrix[R] | None

noether::homalg::ChainComplex::differential · Direct Rust declaration

pub fn differential(&self, degree: i32) -> Option<Matrix<R>>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:142 · validation/unit/commalg/test_kahler_differentials.py:143 · validation/unit/homalg/test_chain_complex.py:27 · validation/unit/homalg/test_chain_complex.py:28 · validation/unit/homalg/test_module_facade.py:425 · validation/unit/homalg/test_module_facade.py:426

homalg.ChainComplex.differential_layout

Retained storage layout of one represented differential.

Detailed contract

Storage layout of a represented differential in the displayed degree.

PythonRust

(self, degree: int) -> Literal['dense', 'sparse'] | None

noether::homalg::ChainComplex::differential_layout · Direct Rust declaration

pub fn differential_layout(&self, degree: i32) -> Option<&'static str>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_chain_complex.py:188 · validation/unit/homalg/test_chain_complex.py:191 · validation/unit/homalg/test_padic_homology_facade.py:197 · validation/unit/homalg/test_padic_homology_facade.py:198 · validation/unit/homalg/test_padic_homology_facade.py:199 · validation/unit/homalg/test_padic_homology_facade.py:200

homalg.ChainComplex.from_boundaries

Construct from d_n: C_n -> C_(n-1) matrices keyed by n.

Detailed contract

Construct from lowering maps d_n: C_n -> C_(n-1).

PythonRust

(cls, ring: _CoefficientContext, boundaries: Mapping[int, Matrix[_CoefficientContext] | SparseMatrix[_CoefficientContext]]) -> ChainComplex[_CoefficientContext]

noether::homalg::ChainComplex::from_boundaries · Direct Rust declaration

pub fn from_boundaries( ring: R, boundaries: BTreeMap<i32, Matrix<R>>, ) -> Result<Self, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/ChainComplex@1
Contexts	Z, exact fields
Evidence	GradedHomology.verify

Executable usage: validation/unit/homalg/test_acceptance_workload.py:51 · validation/unit/homalg/test_acceptance_workload.py:60 · validation/unit/homalg/test_acceptance_workload.py:64 · validation/unit/homalg/test_chain_complex.py:110 · validation/unit/homalg/test_chain_complex.py:117 · validation/unit/homalg/test_chain_complex.py:128

Example

from noether import Q
from noether.homalg import ChainComplex
from noether.linalg import Matrix
complex_ = ChainComplex.from_boundaries(Q, {1: Matrix.from_rows(Q, [[0]])})
result = complex_.graded_homology()
result.verify()

homalg.ChainComplex.from_coboundaries

Construct from delta^n: C^n -> C^(n+1) matrices keyed by n.

Detailed contract

Construct from raising maps delta^n: C^n -> C^(n+1). Degree negation turns these into the same internal lowering form used by Self::from_boundaries.

PythonRust

(cls, ring: _CoefficientContext, coboundaries: Mapping[int, Matrix[_CoefficientContext] | SparseMatrix[_CoefficientContext]]) -> ChainComplex[_CoefficientContext]

noether::homalg::ChainComplex::from_coboundaries · Direct Rust declaration

pub fn from_coboundaries( ring: R, coboundaries: BTreeMap<i32, Matrix<R>>, ) -> Result<Self, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_acceptance_workload.py:16 · validation/unit/homalg/test_acceptance_workload.py:33 · validation/unit/homalg/test_acceptance_workload.py:52 · validation/unit/homalg/test_acceptance_workload.py:58 · validation/unit/homalg/test_chain_complex.py:100 · validation/unit/homalg/test_chain_complex.py:168

homalg.ChainComplex.graded_cohomology

Compute every explicitly represented cohomological degree.

Detailed contract

Compute cohomology in every explicitly inferred cochain degree. Compute integral cohomology in every nonzero cochain degree.

PythonRust

(self) -> GradedHomology[R]

noether::homalg::ChainComplex::graded_cohomology · Direct Rust declaration

pub fn graded_cohomology(&self) -> Result<GradedHomology<R>, HomologyError>
pub fn graded_cohomology( &self, ) -> Result<GradedHomology<IntegerRing>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_acceptance_workload.py:18 · validation/unit/homalg/test_acceptance_workload.py:35 · validation/unit/homalg/test_acceptance_workload.py:57 · validation/unit/homalg/test_acceptance_workload.py:59 · validation/unit/homalg/test_chain_complex.py:169 · validation/unit/homalg/test_chain_complex.py:170

homalg.ChainComplex.graded_cohomology_invariants

Return lean integral or p-adic cohomology invariants keyed by degree.

Detailed contract

Compute every p-adic cohomology summary, reducing each coboundary once. Compute lean integral cohomology invariants in every nonzero degree. Each stored coboundary is Smith-reduced exactly once. The result is keyed by displayed cohomological degree.

PythonRust

(self: ChainComplex[IntegerRing]) -> dict[int, FinitelyGeneratedAbelianGroup]
(self: ChainComplex[PadicRing]) -> dict[int, PadicModuleInvariants]

noether::homalg::ChainComplex::graded_cohomology_invariants · Direct Rust declaration

pub fn graded_cohomology_invariants( &self, ) -> Result<BTreeMap<i32, PadicModuleInvariants>, HomologyError>
pub fn graded_cohomology_invariants( &self, ) -> Result<BTreeMap<i32, FinitelyGeneratedAbelianGroup>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_chain_complex.py:169 · validation/unit/homalg/test_padic_homology_facade.py:132

homalg.ChainComplex.graded_cohomology_invariants_with_integer_lift

Certify graded p-adic cohomology using an exact integral cochain lift.

Detailed contract

Compute graded cohomology from an exact integral cochain complex lift.

PythonRust

(self: ChainComplex[PadicRing], integer_lift: ChainComplex[IntegerRing]) -> dict[int, PadicModuleInvariants]

noether::homalg::ChainComplex::graded_cohomology_invariants_with_integer_lift · Direct Rust declaration

pub fn graded_cohomology_invariants_with_integer_lift( &self, integer_lift: &ChainComplex<IntegerRing>, ) -> Result<BTreeMap<i32, PadicModuleInvariants>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:187

homalg.ChainComplex.graded_cohomology_invariants_with_ranks

Resolve graded p-adic cohomology with ranks keyed by coboundary degree.

Detailed contract

Compute graded cohomology under one exact-rank assumption per coboundary degree.

PythonRust

(self: ChainComplex[PadicRing], differential_ranks: Mapping[int, int]) -> dict[int, PadicModuleInvariants]

noether::homalg::ChainComplex::graded_cohomology_invariants_with_ranks · Direct Rust declaration

pub fn graded_cohomology_invariants_with_ranks( &self, differential_ranks: &BTreeMap<i32, usize>, ) -> Result<BTreeMap<i32, PadicModuleInvariants>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:134

homalg.ChainComplex.graded_homology

Compute every explicitly represented homological degree.

Detailed contract

Compute homology in every nonzero explicitly inferred degree. Compute integral homology in every nonzero chain degree.

PythonRust

(self) -> GradedHomology[R]

noether::homalg::ChainComplex::graded_homology · Direct Rust declaration

pub fn graded_homology(&self) -> Result<GradedHomology<R>, HomologyError>
pub fn graded_homology( &self, ) -> Result<GradedHomology<IntegerRing>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_acceptance_workload.py:56 · validation/unit/homalg/test_acceptance_workload.py:61 · validation/unit/homalg/test_chain_complex.py:64 · validation/unit/infra/test_discovery.py:63 · validation/unit/topology/test_simplicial_complex_facade.py:256 · validation/unit/topology/test_simplicial_set_facade.py:212

homalg.ChainComplex.graded_homology_invariants

Return lean integral or p-adic homology invariants keyed by degree.

Detailed contract

Compute every p-adic homology summary, reducing each differential once. Compute lean integral homology invariants in every nonzero chain degree. Each differential is Smith-reduced exactly once. The result is keyed by homological degree and retains neither differentials nor lattice witnesses. Use Self::graded_homology when independently verifiable source-retaining groups are required.

PythonRust

(self: ChainComplex[IntegerRing]) -> dict[int, FinitelyGeneratedAbelianGroup]
(self: ChainComplex[PadicRing]) -> dict[int, PadicModuleInvariants]

noether::homalg::ChainComplex::graded_homology_invariants · Direct Rust declaration

pub fn graded_homology_invariants( &self, ) -> Result<BTreeMap<i32, PadicModuleInvariants>, HomologyError>
pub fn graded_homology_invariants( &self, ) -> Result<BTreeMap<i32, FinitelyGeneratedAbelianGroup>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/combinatorics/test_poset.py:107 · validation/unit/combinatorics/test_poset.py:108 · validation/unit/homalg/test_chain_complex.py:162 · validation/unit/homalg/test_chain_complex.py:179 · validation/unit/homalg/test_padic_homology_facade.py:106 · validation/unit/homalg/test_padic_homology_facade.py:202

homalg.ChainComplex.graded_homology_invariants_with_integer_lift

Certify graded p-adic homology using an exact integral complex lift.

Detailed contract

Compute graded homology from an exact integral complex lift.

PythonRust

(self: ChainComplex[PadicRing], integer_lift: ChainComplex[IntegerRing]) -> dict[int, PadicModuleInvariants]

noether::homalg::ChainComplex::graded_homology_invariants_with_integer_lift · Direct Rust declaration

pub fn graded_homology_invariants_with_integer_lift( &self, integer_lift: &ChainComplex<IntegerRing>, ) -> Result<BTreeMap<i32, PadicModuleInvariants>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:170

homalg.ChainComplex.graded_homology_invariants_with_ranks

Resolve graded p-adic homology with ranks keyed by boundary degree.

Detailed contract

Compute graded homology under one exact-rank assumption per boundary degree.

PythonRust

(self: ChainComplex[PadicRing], differential_ranks: Mapping[int, int]) -> dict[int, PadicModuleInvariants]

noether::homalg::ChainComplex::graded_homology_invariants_with_ranks · Direct Rust declaration

pub fn graded_homology_invariants_with_ranks( &self, differential_ranks: &BTreeMap<i32, usize>, ) -> Result<BTreeMap<i32, PadicModuleInvariants>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:118 · validation/unit/homalg/test_padic_homology_facade.py:122 · validation/unit/homalg/test_padic_homology_facade.py:124

homalg.ChainComplex.homology

Compute one checked homology group.

Detailed contract

Compute H_n = ker(d_n) / im(d_(n+1)) over an exact field. Compute H_n = ker(d_n) / im(d_(n+1)) as a finitely generated abelian group. This uses the fast Smith forms without transformation matrices. For a chain complex of free abelian groups, the free rank follows from the two adjacent ranks, while the torsion subgroup is the torsion subgroup of coker(d_(n+1)) because im(d_n) is free.

PythonRust

(self, degree: int) -> HomologyGroup[R]

noether::homalg::ChainComplex::homology · Direct Rust declaration

pub fn homology(&self, degree: i32) -> Result<HomologyGroup<R>, HomologyError>
pub fn homology( &self, degree: i32, ) -> Result<HomologyGroup<IntegerRing>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: examples/28_steiner_categories.py:3 · examples/35_eilenberg_maclane_spaces.py:12 · examples/35_eilenberg_maclane_spaces.py:13 · examples/35_eilenberg_maclane_spaces.py:14 · examples/35_eilenberg_maclane_spaces.py:21 · validation/unit/homalg/test_chain_complex.py:111

homalg.ChainComplex.homology_invariants

Return lean integral or precision-aware p-adic homology invariants.

Detailed contract

Compute invariants shared by compatible finite free Z_p complex lifts. Compute only the canonical finitely generated abelian group underlying H_n, without retaining adjacent differentials or lattice witnesses. This is the lean integral analogue of ChainComplex::betti_number. It computes the two adjacent Smith ranks and the incoming invariant factors, then returns only the decomposition of the resulting group.

PythonRust

(self: ChainComplex[IntegerRing], degree: int) -> FinitelyGeneratedAbelianGroup
(self: ChainComplex[PadicRing], degree: int) -> PadicModuleInvariants

noether::homalg::ChainComplex::homology_invariants · Direct Rust declaration

pub fn homology_invariants( &self, degree: i32, ) -> Result<PadicModuleInvariants, HomologyError>
pub fn homology_invariants( &self, degree: i32, ) -> Result<FinitelyGeneratedAbelianGroup, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Dispatch / backing	flint, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1
Contexts	Z, fixed-precision p-adic integers
Evidence	integer: canonical invariants only; use graded_homology for source-retaining evidence, p-adic: PadicModuleInvariants.verify
Failures	cochain grading, incompatible differential contexts

Executable usage: examples/32_poset_core_and_morse.py:19 · validation/unit/combinatorics/test_poset.py:144 · validation/unit/homalg/test_chain_complex.py:148 · validation/unit/homalg/test_chain_complex.py:175 · validation/unit/homalg/test_chain_complex.py:189 · validation/unit/homalg/test_padic_homology_facade.py:105

homalg.ChainComplex.homology_invariants_with_integer_lift

Certify p-adic homology using an exact integral complex lift.

Detailed contract

Compute homology from an exact integral complex reducing to this one. The adjacent integral maps are retained so unconditional validity can be replayed after serialization.

PythonRust

(self: ChainComplex[PadicRing], degree: int, integer_lift: ChainComplex[IntegerRing]) -> PadicModuleInvariants

noether::homalg::ChainComplex::homology_invariants_with_integer_lift · Direct Rust declaration

pub fn homology_invariants_with_integer_lift( &self, degree: i32, integer_lift: &ChainComplex<IntegerRing>, ) -> Result<PadicModuleInvariants, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:154 · validation/unit/homalg/test_padic_homology_facade.py:165 · validation/unit/homalg/test_padic_homology_facade.py:180

homalg.ChainComplex.homology_invariants_with_ranks

Resolve p-adic homology under caller-supplied exact Q_p-rank assumptions.

Detailed contract

Compute homology under caller-supplied exact adjacent Q_p-rank assumptions. outgoing_rank is the rank of d_degree and incoming_rank is the rank of d_(degree+1). Both are checked against the capped Smith bounds and the chain inequality before they resolve the free-rank interval.

PythonRust

(self: ChainComplex[PadicRing], degree: int, outgoing_rank: int, incoming_rank: int) -> PadicModuleInvariants

noether::homalg::ChainComplex::homology_invariants_with_ranks · Direct Rust declaration

pub fn homology_invariants_with_ranks( &self, degree: i32, outgoing_rank: usize, incoming_rank: usize, ) -> Result<PadicModuleInvariants, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:61 · validation/unit/homalg/test_padic_homology_facade.py:64 · validation/unit/homalg/test_padic_homology_facade.py:73 · validation/unit/homalg/test_padic_homology_facade.py:92

homalg.ChainComplex.module_dimension

Rank of the free module in one displayed degree.

Detailed contract

Dimension of the free module in a displayed degree.

PythonRust

(self, degree: int) -> int

noether::homalg::ChainComplex::module_dimension · Direct Rust declaration

pub fn module_dimension(&self, degree: i32) -> usize

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_chain_complex.py:103 · validation/unit/homalg/test_chain_complex.py:104 · validation/unit/homalg/test_chain_complex.py:29 · validation/unit/homalg/test_chain_complex.py:30 · validation/unit/homalg/test_chain_complex.py:31 · validation/unit/homalg/test_chain_complex.py:80

homalg.ChainComplex.padic_unit_morse_reduction

Cancel every valuation-zero p-adic pivot with replayable evidence.

Detailed contract

Cancel every valuation-zero p-adic pivot with replayable evidence. A coefficient that is a unit modulo p^N is a unit in every compatible Z_p lift, so these cancellations preserve the compatible-lift homology problem as well as the finite-ring complex.

PythonRust

(self: ChainComplex[PadicRing]) -> PadicChainReduction

noether::homalg::ChainComplex::padic_unit_morse_reduction · Direct Rust declaration

pub fn padic_unit_morse_reduction( &self, ) -> Result<PadicChainReduction, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_padic_homology_facade.py:233 · validation/unit/homalg/test_padic_homology_facade.py:253 · validation/unit/homalg/test_padic_homology_facade.py:261 · validation/unit/infra/test_discovery.py:132

homalg.ChainComplex.reduction_from_cancellations

Replay externally stored universal-unit cancellation evidence.

Detailed contract

Replay a proposed universal-unit cancellation log. A result is returned only after every pivot has been checked in the current basis and the resulting complex has passed the chain-identity verifier. This is the reconstruction entry point for serialized reduction witnesses retained by an external caller.

PythonRust

(self, cancellations: list[ChainCancellation]) -> ChainReduction[R]

noether::homalg::ChainComplex::reduction_from_cancellations · Direct Rust declaration

pub fn reduction_from_cancellations( &self, cancellations: &[ChainCancellation], ) -> Result<ChainReduction<R>, HomologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: validation/unit/homalg/test_chain_complex.py:91 · validation/unit/homalg/test_padic_homology_facade.py:270 · validation/unit/infra/test_discovery.py:133 · validation/unit/topology/test_simplicial_set_facade.py:136

homalg.ChainComplex.ring

Exact coefficient ring.

Detailed contract

Exact coefficient context.

PythonRust

(self) -> R

noether::homalg::ChainComplex::ring · Direct Rust declaration

pub fn ring(&self) -> &R

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	attached / bounded
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: examples/11_qadic_witt_vectors.py:3 · examples/13_chinese_remainder_theorem.py:10 · examples/13_chinese_remainder_theorem.py:12 · examples/13_chinese_remainder_theorem.py:9 · examples/14_weighted_polynomials.py:10 · examples/14_weighted_polynomials.py:11

homalg.ChainComplex.verify

Recheck coefficient contexts, matrix shapes, and d^2 = 0.

Detailed contract

Recheck contexts, adjacent shapes, and d^2 = 0.

PythonRust

(self) -> None

noether::homalg::ChainComplex::verify · Direct Rust declaration

pub fn verify(&self) -> Result<(), VerificationError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, flint-core, groebner-kernel, m4rst, m4rste, module-core, resolution-kernel, sparla
GIL	released
Semantic ID	noether/homalg/ChainComplex@1

Executable usage: examples/01_bezout_certificates.py:10 · examples/01_bezout_certificates.py:3 · examples/03_exact_linear_systems.py:13 · examples/03_exact_linear_systems.py:3 · examples/04_smith_normal_form.py:12 · examples/06_shortest_lattice_vectors.py:12