topology · SimplicialComplex

38 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.

topology.SimplicialComplex

A finite abstract simplicial complex given by its maximal simplices.

PythonRust

SimplicialComplex(facets: list[list[int]])

noether::topology::SimplicialComplex · Direct Rust declaration

pub struct SimplicialComplex { /* private fields */ }

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: examples/33_simplicial_cohomology_operations.py:10 · examples/33_simplicial_cohomology_operations.py:6 · validation/unit/combinatorics/test_poset.py:11 · validation/unit/combinatorics/test_poset.py:131 · validation/unit/infra/test_discovery.py:121 · validation/unit/infra/test_discovery.py:122

topology.SimplicialComplex.__len__

Return len(self).

PythonRust

(self) -> int

noether::topology::SimplicialComplex · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_filtration_builders.py:109 · validation/unit/topology/test_filtration_builders.py:14

topology.SimplicialComplex.alexander_whitney_diagonal

Alexander--Whitney front/back faces for one simplex.

Detailed contract

Alexander–Whitney front/back faces of one simplex, from split degree zero through its full dimension.

PythonRust

(self, dimension: int, simplex: int) -> list[tuple[list[int], list[int]]]

noether::topology::SimplicialComplex::alexander_whitney_diagonal · Direct Rust declaration

pub fn alexander_whitney_diagonal( &self, dimension: usize, simplex: usize, ) -> Result<Vec<(Simplex, Simplex)>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:154

topology.SimplicialComplex.automorphism_group

Compute the exact automorphism group acting on vertex ids.

Detailed contract

Compute the exact automorphism group acting on the original vertex ids. Missing ids below the largest used label are fixed. Automorphisms are projected from the exact colored incidence-graph group and reverified against the facet set.

PythonRust

(self) -> PermutationGroup

noether::topology::SimplicialComplex::automorphism_group · Direct Rust declaration

pub fn automorphism_group(&self) -> Result<PermutationGroup, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: examples/21_graph_symmetry.py:16 · examples/21_graph_symmetry.py:18 · examples/29_integral_line_configurations.py:10 · validation/unit/category/test_category.py:55 · validation/unit/combin/test_acceptance_workload.py:31 · validation/unit/combin/test_graph_facade.py:91

topology.SimplicialComplex.betti_number

Return one Betti number over Q by default.

Detailed contract

Return one Betti number over an exact field. This invariants-only path constructs and ranks only d_n and d_(n+1). It does not construct the full chain complex or explicit cycle and quotient bases; use Self::homology when those witnesses are needed.

PythonRust

(self, degree: int) -> int
(self, degree: int, *, ring: _FieldContext) -> int

noether::topology::SimplicialComplex::betti_number · Direct Rust declaration

pub fn betti_number<R: Field>( &self, field: R, degree: usize, ) -> Result<usize, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@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

topology.SimplicialComplex.bockstein_reduced_power

Odd-primary beta-reduced-power operation on a checked cocycle.

Detailed contract

The odd-primary operation beta P^power of a checked normalized cocycle over a prime field. A degree-q input produces a degree-q + 2 power (p-1) + 1 cocycle. Here beta is the mod-p Bockstein belonging to the standard Steenrod-algebra convention.

PythonRust

(self, power: int, degree: int, cocycle: Vector[FiniteField]) -> Vector[FiniteField]

noether::topology::SimplicialComplex::bockstein_reduced_power · Direct Rust declaration

pub fn bockstein_reduced_power( &self, power: usize, degree: usize, cocycle: &Vector<FiniteField>, ) -> Result<Vector<FiniteField>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/infra/test_discovery.py:141 · validation/unit/infra/test_discovery.py:149 · validation/unit/topology/test_simplicial_set_facade.py:186 · validation/unit/topology/test_simplicial_set_facade.py:190 · validation/unit/topology/test_simplicial_set_facade.py:191

topology.SimplicialComplex.canonical_form

Canonically relabel the used vertices as a contiguous initial segment.

Detailed contract

Canonically relabel the used vertices as 0,...,n-1. The labeling is induced by exact canonicalization of the colored vertex–facet incidence graph. Vertex and facet nodes have distinct loop colors, so graph isomorphisms are exactly simplicial isomorphisms. This operation and Self::automorphism_group share the same individualization/refinement search.

PythonRust

(self) -> SimplicialComplex

noether::topology::SimplicialComplex::canonical_form · Direct Rust declaration

pub fn canonical_form(&self) -> Result<Self, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/category/test_category.py:38 · validation/unit/combin/test_acceptance_workload.py:27 · validation/unit/combin/test_acceptance_workload.py:29 · validation/unit/infra/test_discovery.py:122 · validation/unit/infra/test_discovery.py:125 · validation/unit/infra/test_discovery.py:56

topology.SimplicialComplex.chain_complex

Construct the canonical checked chain complex over ring.

Detailed contract

Construct the canonical checked chain complex over ring. A zero-dimensional complex includes d_0: C_0 -> 0, because no adjacent nonzero differential exists from which C_0 could otherwise be inferred.

PythonRust

(self, ring: _CoefficientContext) -> ChainComplex[_CoefficientContext]

noether::topology::SimplicialComplex::chain_complex · Direct Rust declaration

pub fn chain_complex<R: Ring>( &self, ring: R, ) -> Result<ChainComplex<R>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:135 · validation/unit/topology/test_simplicial_set_facade.py:131 · validation/unit/topology/test_simplicial_set_facade.py:54 · validation/corpus/topology/real-projective-plane-integral-homology.py:28 · validation/corpus/topology/simplicialhomology-basic-betti-numbers.py:36 · validation/corpus/topology/simplicialhomology-basic-betti-numbers.py:37

topology.SimplicialComplex.cochain_complex

Construct the canonical signed cochain complex over ring.

Detailed contract

Construct the canonical simplicial cochain complex over ring. Each coboundary is the transpose of the signed boundary in the fixed lexicographic simplex bases.

PythonRust

(self, ring: _CoefficientContext) -> ChainComplex[_CoefficientContext]

noether::topology::SimplicialComplex::cochain_complex · Direct Rust declaration

pub fn cochain_complex<R: Ring>( &self, ring: R, ) -> Result<ChainComplex<R>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/infra/test_discovery.py:134 · validation/unit/infra/test_discovery.py:142 · validation/unit/topology/test_simplicial_complex_facade.py:146 · validation/unit/topology/test_simplicial_set_facade.py:145

topology.SimplicialComplex.cohomology_ring

Complete cohomology algebra over one exact finite field.

Detailed contract

Compute the complete finite-dimensional cohomology algebra over field, including canonical cocycles and every basis product.

PythonRust

(self, field: FiniteField) -> SimplicialCohomologyRing

noether::topology::SimplicialComplex::cohomology_ring · Direct Rust declaration

pub fn cohomology_ring( &self, field: FiniteField, ) -> Result<SimplicialCohomologyRing, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: examples/33_simplicial_cohomology_operations.py:24 · validation/unit/infra/test_discovery.py:121 · validation/unit/infra/test_discovery.py:124 · validation/unit/infra/test_public_api_index.py:186 · validation/unit/topology/test_simplicial_complex_facade.py:186 · validation/unit/topology/test_simplicial_set_facade.py:160

topology.SimplicialComplex.collapse_sequence

Replay and retain a proposed sequence of elementary collapses.

Detailed contract

Replay and retain a checked sequence of elementary collapses.

PythonRust

(self, steps: list[ElementaryCollapse]) -> SimplicialCollapseSequence

noether::topology::SimplicialComplex::collapse_sequence · Direct Rust declaration

pub fn collapse_sequence( &self, steps: Vec<ElementaryCollapse>, ) -> Result<SimplicialCollapseSequence, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:107

topology.SimplicialComplex.count

Number of simplices in one dimension.

Detailed contract

Number of simplices in dimension dimension.

PythonRust

(self, dimension: int) -> int

noether::topology::SimplicialComplex::count · Direct Rust declaration

pub fn count(&self, dimension: usize) -> usize

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: examples/18_finite_field_schemes.py:14 · examples/18_finite_field_schemes.py:16 · examples/18_finite_field_schemes.py:17 · examples/18_finite_field_schemes.py:18 · validation/unit/combin/test_graph_facade.py:34 · validation/unit/combinatorics/test_poset.py:142

topology.SimplicialComplex.cup_i

Medina-Mardones cup-i product on normalized characteristic-two cochains.

Detailed contract

Medina-Mardones cup-i product on normalized characteristic-two cochains.

Chain-level cup-i product on normalized cochains in characteristic 2. This uses the subset formula of Medina-Mardones. Inputs need not be cocycles. The output has degree left_degree + right_degree - i.

PythonRust

(self, cup_index: int, left_degree: int, left: Vector[FiniteField], right_degree: int, right: Vector[FiniteField]) -> Vector[FiniteField]

noether::topology::SimplicialComplex::cup_i · Direct Rust declaration

pub fn cup_i( &self, cup_index: usize, left_degree: usize, left: &Vector<FiniteField>, right_degree: usize, right: &Vector<FiniteField>, ) -> Result<Vector<FiniteField>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/infra/test_discovery.py:138 · validation/unit/infra/test_discovery.py:146 · validation/unit/topology/test_simplicial_complex_facade.py:167 · validation/unit/topology/test_simplicial_complex_facade.py:170 · validation/unit/topology/test_simplicial_complex_facade.py:175 · validation/unit/topology/test_simplicial_set_facade.py:148

topology.SimplicialComplex.cup_product

Exact Alexander--Whitney cup product in the fixed simplex bases.

Detailed contract

Alexander–Whitney cup product of two simplicial cochains. Inputs and output use the same lexicographic simplex bases as the boundary and cochain complexes. This is a chain-level operation: inputs need not be cocycles.

PythonRust

(self, left_degree: int, left: Vector[_CoefficientContext], right_degree: int, right: Vector[_CoefficientContext]) -> Vector[_CoefficientContext]

noether::topology::SimplicialComplex::cup_product · Direct Rust declaration

pub fn cup_product<R: Ring>( &self, left_degree: usize, left: &Vector<R>, right_degree: usize, right: &Vector<R>, ) -> Result<Vector<R>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/infra/test_discovery.py:137 · validation/unit/infra/test_discovery.py:145 · validation/unit/topology/test_simplicial_complex_facade.py:152 · validation/unit/topology/test_simplicial_complex_facade.py:153 · validation/unit/topology/test_simplicial_complex_facade.py:159 · validation/unit/topology/test_simplicial_complex_facade.py:167

topology.SimplicialComplex.dimension

Top dimension; the empty complex has dimension -1.

Detailed contract

Top dimension, with the empty complex assigned dimension -1.

PythonRust

(self) -> int

noether::topology::SimplicialComplex::dimension · Direct Rust declaration

pub fn dimension(&self) -> i64

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: examples/03_exact_linear_systems.py:15 · examples/03_exact_linear_systems.py:16 · examples/15_groebner_twisted_cubic.py:14 · examples/15_groebner_twisted_cubic.py:28 · examples/27_weight_characters.py:25 · examples/34_finite_group_cohomology.py:13

topology.SimplicialComplex.dominated_vertices

Dominated vertices with their least-label dominators.

Detailed contract

Every currently dominated vertex, with its least-label dominator. A vertex v is dominated by w precisely when every maximal simplex containing v also contains w.

PythonRust

(self) -> list[DominatedVertex]

noether::topology::SimplicialComplex::dominated_vertices · Direct Rust declaration

pub fn dominated_vertices(&self) -> Vec<DominatedVertex>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

topology.SimplicialComplex.elementary_collapse

Replay one verified elementary free-face collapse.

Detailed contract

Replay one proposed elementary collapse after verifying freeness.

PythonRust

(self, step: ElementaryCollapse) -> SimplicialComplex

noether::topology::SimplicialComplex::elementary_collapse · Direct Rust declaration

pub fn elementary_collapse( &self, step: &ElementaryCollapse, ) -> Result<Self, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:101 · validation/unit/topology/test_simplicial_complex_facade.py:113

topology.SimplicialComplex.elementary_collapses

Every elementary free-face collapse available in this complex.

Detailed contract

All elementary free-face collapses available in this complex.

PythonRust

(self) -> list[ElementaryCollapse]

noether::topology::SimplicialComplex::elementary_collapses · Direct Rust declaration

pub fn elementary_collapses(&self) -> Vec<ElementaryCollapse>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:118 · validation/unit/topology/test_simplicial_complex_facade.py:97

topology.SimplicialComplex.euler_characteristic

Euler characteristic computed independently from cell counts.

Detailed contract

Euler characteristic from cell counts. This is independent of homology and therefore provides a useful cross-check against the alternating sum of field-homology dimensions.

PythonRust

(self) -> int

noether::topology::SimplicialComplex::euler_characteristic · Direct Rust declaration

pub fn euler_characteristic(&self) -> i64

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/combinatorics/test_poset.py:143 · validation/unit/topology/test_simplicial_complex_facade.py:62 · validation/unit/topology/test_simplicial_set_facade.py:262 · validation/unit/topology/test_simplicial_set_facade.py:53 · validation/corpus/topology/bowtie-complex-homology.py:15 · validation/corpus/topology/bowtie-complex-homology.py:25

topology.SimplicialComplex.facets

Maximal simplices in canonical lexicographic order.

Detailed contract

Maximal simplices in lexicographic order.

PythonRust

(self) -> list[list[int]]

noether::topology::SimplicialComplex::facets · Direct Rust declaration

pub fn facets(&self) -> Vec<&Simplex>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/combinatorics/test_poset.py:132 · validation/unit/geometry/test_acceptance_workload.py:60 · validation/unit/geometry/test_acceptance_workload.py:79 · validation/unit/geometry/test_polytope_facade.py:39 · validation/unit/geometry/test_polytope_facade.py:82 · validation/unit/topology/test_simplicial_complex_facade.py:59

topology.SimplicialComplex.from_json

Deserialize and revalidate a SimplicialComplex from typed JSON.

Detailed contract

Deserialize and normalize a typed facet presentation.

PythonRust

(cls, value: str) -> SimplicialComplex

noether::topology::SimplicialComplex::from_json · Direct Rust declaration

pub fn from_json(value: &str) -> Result<Self, NoetherError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/category/test_category.py:14 · validation/unit/combin/test_acceptance_workload.py:65 · validation/unit/combin/test_acceptance_workload.py:86 · validation/unit/combin/test_graph_facade.py:106 · validation/unit/combin/test_graph_facade.py:25 · validation/unit/combinatorics/test_kashiwara_crystal.py:32

topology.SimplicialComplex.graded_homology

Compute checked homology in every chain degree, over Z by default.

Detailed contract

Compute field homology in every nonzero chain degree.

PythonRust

(self) -> GradedHomology[IntegerRing]
(self, *, ring: _CoefficientContext) -> GradedHomology[_CoefficientContext]

noether::topology::SimplicialComplex::graded_homology · Direct Rust declaration

pub fn graded_homology<R: Field>( &self, field: R, ) -> Result<GradedHomology<R>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1
Contexts	Z, exact fields
Evidence	GradedHomology.verify

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

Example

from noether.topology import SimplicialComplex
circle = SimplicialComplex([[0, 1], [1, 2], [0, 2]])
result = circle.graded_homology()
assert result.get(1).free_rank == 1
result.verify()

topology.SimplicialComplex.graded_homology_invariants

Compute lean integral homology invariants in every chain degree.

Detailed contract

Compute lean integral homology invariants in every chain degree. Each sparse boundary is constructed and Smith-reduced exactly once. The returned vector is indexed by homological degree and retains no boundary matrices or cycle representatives. The empty complex returns an empty vector.

PythonRust

(self) -> list[FinitelyGeneratedAbelianGroup]

noether::topology::SimplicialComplex::graded_homology_invariants · Direct Rust declaration

pub fn graded_homology_invariants( &self, ) -> Result<Vec<FinitelyGeneratedAbelianGroup>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@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

topology.SimplicialComplex.greedy_collapse_reduction

Deterministically collapse until no free-face pair remains.

Detailed contract

Deterministically collapse the least available free-face pair until no elementary collapse remains. Unlike a strong-homotopy core, this terminal target need not be unique up to isomorphism. The returned sequence is the mathematical evidence; callers must not treat the target as a canonical simple-homotopy type.

PythonRust

(self) -> SimplicialCollapseSequence

noether::topology::SimplicialComplex::greedy_collapse_reduction · Direct Rust declaration

pub fn greedy_collapse_reduction( &self, ) -> Result<SimplicialCollapseSequence, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:102

topology.SimplicialComplex.homology

Compute one checked homology group, over Z by default.

Detailed contract

Compute one field-homology group through the canonical chain complex.

PythonRust

(self, degree: int) -> HomologyGroup[IntegerRing]
(self, degree: int, *, ring: _CoefficientContext) -> HomologyGroup[_CoefficientContext]

noether::topology::SimplicialComplex::homology · Direct Rust declaration

pub fn homology<R: Field>( &self, field: R, degree: usize, ) -> Result<HomologyGroup<R>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@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

topology.SimplicialComplex.homology_invariants

Compute lean integral homology invariants without retaining boundaries.

Detailed contract

Compute integral homology as a lean finitely generated abelian group. Only sparse ranks and Smith invariant factors are retained. Use Self::integral_homology when the result must carry adjacent dense boundary matrices for an independent later verification.

PythonRust

(self, degree: int) -> FinitelyGeneratedAbelianGroup

noether::topology::SimplicialComplex::homology_invariants · Direct Rust declaration

pub fn homology_invariants( &self, degree: usize, ) -> Result<FinitelyGeneratedAbelianGroup, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

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

topology.SimplicialComplex.is_empty

Whether this complex contains no nonempty simplices.

Detailed contract

Whether the complex has no simplices.

PythonRust

(self) -> bool

noether::topology::SimplicialComplex::is_empty · Direct Rust declaration

pub fn is_empty(&self) -> bool

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/combinatorics/test_poset.py:113 · validation/unit/topology/test_filtration_builders.py:119 · validation/unit/topology/test_persistence_facade.py:45 · validation/unit/topology/test_persistence_facade.py:47 · validation/unit/topology/test_simplicial_complex_facade.py:47 · validation/unit/topology/test_simplicial_complex_facade.py:49

topology.SimplicialComplex.morse_chain_complex

Construct only the critical-cell chain complex over ring.

Detailed contract

Construct only the chain complex carried by the critical cells.

PythonRust

(self, ring: _CoefficientContext) -> ChainComplex[_CoefficientContext]

noether::topology::SimplicialComplex::morse_chain_complex · Direct Rust declaration

pub fn morse_chain_complex<R: Ring>( &self, ring: R, ) -> Result<ChainComplex<R>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/infra/test_discovery.py:136 · validation/unit/topology/test_simplicial_complex_facade.py:213

topology.SimplicialComplex.morse_reduction

Construct a verified critical-cell chain model over ring.

Detailed contract

Construct a smaller chain model through verified discrete Morse theory. Matching uses only elementary free-face collapses, interspersed with deterministic critical-cell choices. The resulting signed Morse boundary is valid over every coefficient ring.

PythonRust

(self, ring: _CoefficientContext) -> SimplicialMorseReduction[_CoefficientContext]

noether::topology::SimplicialComplex::morse_reduction · Direct Rust declaration

pub fn morse_reduction<R: Ring>( &self, ring: R, ) -> Result<SimplicialMorseReduction<R>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: examples/32_poset_core_and_morse.py:16 · validation/unit/infra/test_discovery.py:135 · validation/unit/topology/test_simplicial_complex_facade.py:206

topology.SimplicialComplex.simple_homotopy_zigzag

Replay and retain a proposed simple-homotopy zigzag.

Detailed contract

Replay and retain a checked zigzag of elementary expansions and collapses beginning at this complex.

PythonRust

(self, moves: list[SimplicialSimpleHomotopyMove]) -> SimplicialSimpleHomotopyZigzag

noether::topology::SimplicialComplex::simple_homotopy_zigzag · Direct Rust declaration

pub fn simple_homotopy_zigzag( &self, moves: Vec<SimplicialSimpleHomotopyMove>, ) -> Result<SimplicialSimpleHomotopyZigzag, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:119

topology.SimplicialComplex.simplices

Simplices in one dimension, in canonical boundary-matrix order.

Detailed contract

Simplices of one dimension, in canonical index order.

PythonRust

(self, dimension: int) -> list[list[int]]

noether::topology::SimplicialComplex::simplices · Direct Rust declaration

pub fn simplices(&self, dimension: usize) -> &[Simplex]

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: examples/28_steiner_categories.py:25 · validation/unit/geometry/test_acceptance_workload.py:42 · validation/unit/geometry/test_geometry_facade.py:60 · validation/unit/geometry/test_geometry_facade.py:64 · validation/unit/geometry/test_geometry_facade.py:82 · validation/unit/topology/test_persistence_facade.py:60

topology.SimplicialComplex.steenrod_reduced_power

Odd-primary Steenrod reduced power of a checked cocycle.

Detailed contract

The odd-primary Steenrod reduced power P^power of a checked normalized cocycle over a prime field. A degree-q input produces a degree-q + 2 power (p-1) cocycle. The implementation uses the effective May–Steenrod structure on normalized simplicial cochains.

PythonRust

(self, power: int, degree: int, cocycle: Vector[FiniteField]) -> Vector[FiniteField]

noether::topology::SimplicialComplex::steenrod_reduced_power · Direct Rust declaration

pub fn steenrod_reduced_power( &self, power: usize, degree: usize, cocycle: &Vector<FiniteField>, ) -> Result<Vector<FiniteField>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/infra/test_discovery.py:140 · validation/unit/infra/test_discovery.py:148 · validation/unit/topology/test_simplicial_set_facade.py:185 · validation/unit/topology/test_simplicial_set_facade.py:189

topology.SimplicialComplex.steenrod_square

Steenrod square of a checked characteristic-two cocycle.

Detailed contract

Steenrod square of a checked normalized cocycle over a field of characteristic 2.

PythonRust

(self, square: int, degree: int, cocycle: Vector[FiniteField]) -> Vector[FiniteField]

noether::topology::SimplicialComplex::steenrod_square · Direct Rust declaration

pub fn steenrod_square( &self, square: usize, degree: usize, cocycle: &Vector<FiniteField>, ) -> Result<Vector<FiniteField>, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: examples/33_simplicial_cohomology_operations.py:29 · validation/unit/infra/test_discovery.py:139 · validation/unit/infra/test_discovery.py:147 · validation/unit/topology/test_simplicial_complex_facade.py:171 · validation/unit/topology/test_simplicial_complex_facade.py:192 · validation/unit/topology/test_simplicial_complex_facade.py:193

topology.SimplicialComplex.strong_collapse

Replay one verified dominated-vertex deletion.

Detailed contract

Delete a currently dominated vertex and verify the supplied dominator.

PythonRust

(self, step: DominatedVertex) -> SimplicialComplex

noether::topology::SimplicialComplex::strong_collapse · Direct Rust declaration

pub fn strong_collapse( &self, step: DominatedVertex, ) -> Result<Self, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:92

topology.SimplicialComplex.strong_core

Canonically relabeled strong-homotopy core.

Detailed contract

Canonical representative of the strong-homotopy core.

PythonRust

(self) -> SimplicialComplex

noether::topology::SimplicialComplex::strong_core · Direct Rust declaration

pub fn strong_core(&self) -> Result<Self, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/infra/test_discovery.py:123 · validation/unit/topology/test_simplicial_complex_facade.py:86

topology.SimplicialComplex.strong_core_reduction

Construct a replayable reduction to the strong-homotopy core.

Detailed contract

Deterministically delete dominated vertices until none remain. The replayed reduced complex retains surviving labels. The published core is its exact canonical form, so isomorphic inputs have equal core values even when their deterministic deletion sequences differ.

PythonRust

(self) -> StrongCoreReduction

noether::topology::SimplicialComplex::strong_core_reduction · Direct Rust declaration

pub fn strong_core_reduction( &self, ) -> Result<StrongCoreReduction, TopologyError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	released
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/topology/test_simplicial_complex_facade.py:80

topology.SimplicialComplex.to_json

Serialize this SimplicialComplex to its canonical typed JSON representation.

Detailed contract

Serialize the canonical facet presentation as typed JSON.

PythonRust

(self) -> str

noether::topology::SimplicialComplex::to_json · Direct Rust declaration

pub fn to_json(&self) -> Result<String, NoetherError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@1

Executable usage: validation/unit/category/test_category.py:14 · validation/unit/category/test_category.py:15 · validation/unit/combin/test_acceptance_workload.py:30 · validation/unit/combin/test_acceptance_workload.py:65 · validation/unit/combin/test_acceptance_workload.py:86 · validation/unit/combin/test_graph_facade.py:106

topology.SimplicialComplex.verify

Recheck signed boundary construction and d^2 = 0 over the integers.

PythonRust

(self) -> None

noether::topology::SimplicialComplex · Python projection

Python projection convenience over this Rust mathematical type

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether, geom-core, m4rst, m4rste
GIL	attached / bounded
Semantic ID	noether/topology/SimplicialComplex@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