category · FiniteOmegaCategory

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

Worked example

The complete checked program Reduce a module element and certify a minimal free resolution uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Reduce a module element and certify a minimal free resolution."""

from noether import Q
from noether.commalg import Degree, MonomialOrder, PolynomialRing
from noether.homalg import (
    FreeModule,
    ModuleElement,
    ModuleHomomorphism,
    ModuleMonomialOrder,
    PresentedModule,
    Submodule,
)
from noether.linalg import Matrix, Vector


def main() -> None:
    ring = PolynomialRing(Q, ["x", "y", "z", "w"])
    x, y, z, w = ring.generators()
    order = ModuleMonomialOrder.term_over_position(MonomialOrder.GREVLEX)

    ambient = FreeModule(ring, 2)
    first = ModuleElement(ambient, Vector.from_values(ring, [x, y]))
    second = ModuleElement(ambient, Vector.from_values(ring, [y, 1]))
    submodule = Submodule.from_generators(ambient, [first, second])
    basis = submodule.groebner_basis(order)
    reduction = basis.reduce(first + second * x)
    basis.verify()
    reduction.verify()
    assert reduction.is_member()

    target = FreeModule(ring, 1, grading_rank=1, degree_shifts=[Degree([0])])
    source = FreeModule(ring, 3, grading_rank=1, degree_shifts=[Degree([-2])] * 3)
    twisted_cubic = PresentedModule(
        ModuleHomomorphism(
            source,
            target,
            Matrix.from_rows(ring, [[x * z - y**2, x * w - y * z, y * w - z**2]]),
        )
    )
    resolution = twisted_cubic.minimal_free_resolution(order)
    resolution.verify()
    betti = resolution.graded_betti_table()
    betti.verify()
    assert betti.entries == [
        (0, Degree([0]), 1),
        (1, Degree([2]), 3),
        (2, Degree([3]), 2),
    ]
    print(f"module member certified; minimal Betti entries={betti.entries}")


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/30_modules_and_resolutions.py.

category.FiniteOmegaCategory

Explicit finite iterated mapping category.

PythonRust

class FiniteOmegaCategory

noether::category::FiniteOmegaCategory · Direct Rust declaration

pub struct FiniteOmegaCategory { /* private fields */ }

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	attached / bounded

Executable usage: validation/unit/infra/test_discovery.py:185 · validation/unit/infra/test_discovery.py:186 · validation/unit/infra/test_discovery.py:187 · validation/unit/infra/test_discovery.py:188 · validation/unit/infra/test_discovery.py:189

category.FiniteOmegaCategory.ambient

Return the ambient recorded by this FiniteOmegaCategory.

Detailed contract

Ambient strong Steiner category.

PythonRust

(self) -> SteinerCategory

noether::category::FiniteOmegaCategory::ambient · Direct Rust declaration

pub fn ambient(&self) -> &SteinerCategory

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	attached / bounded

Executable usage: examples/30_modules_and_resolutions.py:23 · examples/30_modules_and_resolutions.py:24 · examples/30_modules_and_resolutions.py:25 · examples/30_modules_and_resolutions.py:26 · examples/38_exact_linear_systems.py:49 · examples/38_exact_linear_systems.py:53

category.FiniteOmegaCategory.component_poset

Compute component poset for this FiniteOmegaCategory.

Detailed contract

Poset of components, ordered by existence of a morphism.

PythonRust

(self) -> Poset

noether::category::FiniteOmegaCategory::component_poset · Direct Rust declaration

pub fn component_poset(&self) -> Result<Poset, CategoryError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	released

Executable usage: validation/unit/category/test_acceptance_workload.py:28 · validation/unit/infra/test_discovery.py:187

category.FiniteOmegaCategory.depth

Return the depth recorded by this FiniteOmegaCategory.

Detailed contract

Number of mapping iterations used to form this category.

PythonRust

(self) -> int

noether::category::FiniteOmegaCategory::depth · Direct Rust declaration

pub fn depth(&self) -> usize

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	attached / bounded

Executable usage: validation/unit/homalg/test_module_facade.py:505 · validation/parity/combinatorics/test_tree_core_parity.py:17 · validation/parity/combinatorics/test_tree_core_parity.py:189 · validation/parity/combinatorics/test_tree_core_parity.py:194 · validation/parity/combinatorics/test_tree_core_parity.py:210 · validation/parity/combinatorics/test_tree_core_parity.py:265

category.FiniteOmegaCategory.dimension

Return the dimension recorded by this FiniteOmegaCategory.

Detailed contract

Relative nonidentity dimension, or -1 when the mapping category is empty.

PythonRust

(self) -> int

noether::category::FiniteOmegaCategory::dimension · Direct Rust declaration

pub fn dimension(&self) -> Result<i64, CategoryError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	attached / bounded

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

category.FiniteOmegaCategory.exact_cell_counts

Compute exact cell counts for this FiniteOmegaCategory.

Detailed contract

Relative exact-dimensional cell counts through this mapping category’s dimension.

PythonRust

(self) -> list[int]

noether::category::FiniteOmegaCategory::exact_cell_counts · Direct Rust declaration

pub fn exact_cell_counts(&self) -> Result<Vec<usize>, CategoryError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	released

Executable usage: examples/28_steiner_categories.py:15 · examples/28_steiner_categories.py:24 · validation/unit/category/test_acceptance_workload.py:14 · validation/unit/category/test_category.py:54 · validation/unit/infra/test_discovery.py:189

category.FiniteOmegaCategory.exact_cells

Compute exact cells for this FiniteOmegaCategory.

Detailed contract

Relative exact-dimensional nonidentity cells.

PythonRust

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

noether::category::FiniteOmegaCategory::exact_cells · Direct Rust declaration

pub fn exact_cells( &self, relative_dimension: usize, ) -> Result<Vec<SteinerCell>, CategoryError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	released

Executable usage: validation/unit/infra/test_discovery.py:188

category.FiniteOmegaCategory.mapping_category

Compute mapping category for this FiniteOmegaCategory.

Detailed contract

Mapping category between two objects of this mapping category.

PythonRust

(self, source: SteinerCell, target: SteinerCell) -> FiniteOmegaCategory

noether::category::FiniteOmegaCategory::mapping_category · Direct Rust declaration

pub fn mapping_category( &self, source: &SteinerCell, target: &SteinerCell, ) -> Result<Self, CategoryError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	released

Executable usage: validation/unit/category/test_acceptance_workload.py:27 · validation/unit/category/test_category.py:35 · validation/unit/infra/test_discovery.py:186

category.FiniteOmegaCategory.objects

Compute objects for this FiniteOmegaCategory.

Detailed contract

Objects of this mapping category as ambient cells.

PythonRust

(self) -> list[SteinerCell]

noether::category::FiniteOmegaCategory::objects · Direct Rust declaration

pub fn objects(&self) -> Result<Vec<SteinerCell>, CategoryError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	attached / bounded

Executable usage: validation/bench/macaulay2_derived.py:9 · validation/corpus/combin/permutation-cyclic-sieving.py:17 · validation/corpus/combin/permutation-cyclic-sieving.py:19 · validation/corpus/combin/permutation-cyclic-sieving.py:20 · validation/corpus/combin/permutation-cyclic-sieving.py:23 · validation/corpus/combin/permutation-cyclic-sieving.py:28

category.FiniteOmegaCategory.strong_steiner_model

Compute strong steiner model for this FiniteOmegaCategory.

Detailed contract

Recover a strong-Steiner presentation of this mapping category when one is supplied by its indecomposable ambient fillers. Mapping objects form the degree-zero basis. In positive relative degree, the basis consists of fillers with one top-dimensional ambient atom. Construction and exact cell counts are checked. Mapping categories of free strict higher categories need not themselves be free because interchange can identify composites; those return None.

PythonRust

(self) -> SteinerCategory | None

noether::category::FiniteOmegaCategory::strong_steiner_model · Direct Rust declaration

pub fn strong_steiner_model( &self, ) -> Result<Option<SteinerCategory>, CategoryError>

Contract	Value
Guarantee	checked deterministic result
Determinism	deterministic
Availability	default CPU build
Domain implementation crates	noether
GIL	released

Executable usage: validation/unit/category/test_category.py:36 · validation/unit/infra/test_discovery.py:185