Skip to content

homalg · FiniteGroupCohomologyCompletePresentation

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

Worked example

The complete checked program Compute in an exterior algebra and induce a linear map on two-forms uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Compute in an exterior algebra and induce a linear map on two-forms."""

from noether import Q
from noether.commalg import PolynomialRing
from noether.homalg import FreeModule, ModuleElement, ModuleHomomorphism
from noether.linalg import Matrix, Vector


def main() -> None:
    ring = PolynomialRing(Q, ["t"])
    module = FreeModule(ring, 3, basis_labels=["e0", "e1", "e2"])
    exterior = module.exterior_algebra()
    e0, e1, e2 = [exterior.generator(position) for position in range(3)]

    volume = e0 * e1 * e2
    assert volume == exterior.alternating_product(
        [
            ModuleElement(module, Vector.from_values(ring, [1, 0, 0])),
            ModuleElement(module, Vector.from_values(ring, [0, 1, 0])),
            ModuleElement(module, Vector.from_values(ring, [0, 0, 1])),
        ]
    )
    assert e1 * e0 == -(e0 * e1)
    assert e0 * e0 == exterior.zero()

    e0_dual = ModuleElement(module.dual(), Vector.from_values(ring, [1, 0, 0]))
    assert volume.contract(e0_dual) == e1 * e2

    linear_map = ModuleHomomorphism(
        module,
        module,
        Matrix.from_rows(ring, [[1, 1, 0], [0, 1, 0], [0, 0, 2]]),
    )
    on_two_forms = linear_map.exterior_power(2)
    on_two_forms.verify()
    assert on_two_forms.apply_exterior(e1 * e2) == 2 * (e0 * e2 + e1 * e2)
    print(
        "Λ² has basis",
        exterior.basis(2),
        "and the induced map sends e1∧e2 to",
        on_two_forms.apply_exterior(e1 * e2).terms,
    )


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/40_exterior_algebra.py.

homalg.FiniteGroupCohomologyCompletePresentation

A complete finite-group cohomology presentation with theorem evidence.

class FiniteGroupCohomologyCompletePresentation

noether::homalg::FiniteGroupCohomologyCompletePresentation · Direct Rust declaration

pub struct FiniteGroupCohomologyCompletePresentation { /* 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/FiniteGroupCohomologyCompletePresentation@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:14 · validation/unit/homalg/test_finite_group_cohomology.py:171 · validation/unit/homalg/test_finite_group_cohomology.py:172

homalg.FiniteGroupCohomologyCompletePresentation.algebra

Exact algebra data promoted by the completion theorem.

(self) -> FiniteGroupCohomologyAlgebraTruncation

noether::homalg::FiniteGroupCohomologyCompletePresentation::algebra · Direct Rust declaration

pub const fn algebra(&self) -> &FiniteGroupCohomologyAlgebraTruncation
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/FiniteGroupCohomologyCompletePresentation@1

Executable usage: examples/40_exterior_algebra.py:3 · examples/distributed/f2_linear_algebra.py:3 · validation/unit/commalg/test_acceptance_workload.py:3 · validation/unit/commalg/test_construction_algebras.py:41 · validation/unit/commalg/test_construction_algebras.py:71 · validation/unit/commalg/test_construction_algebras.py:72

homalg.FiniteGroupCohomologyCompletePresentation.completion_strategy

Stable name of the theorem used to discharge completeness.

Detailed contract

The theorem discharging completeness.

(self) -> Literal['symonds_parameter_criterion', 'symonds_universal_bound']

noether::homalg::FiniteGroupCohomologyCompletePresentation::completion_strategy · Direct Rust declaration

pub const fn completion_strategy( &self, ) -> FiniteGroupCohomologyCompletionStrategy
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/FiniteGroupCohomologyCompletePresentation@1

Executable usage: examples/34_finite_group_cohomology.py:17 · examples/34_finite_group_cohomology.py:21 · validation/unit/homalg/test_finite_group_cohomology.py:113 · validation/unit/homalg/test_finite_group_cohomology.py:175 · validation/unit/homalg/test_finite_group_cohomology.py:210 · validation/unit/homalg/test_finite_group_cohomology.py:38

homalg.FiniteGroupCohomologyCompletePresentation.generator_degree_bound

Universal degree bound for ring generators.

(self) -> int

noether::homalg::FiniteGroupCohomologyCompletePresentation::generator_degree_bound · Direct Rust declaration

pub const fn generator_degree_bound(&self) -> 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/FiniteGroupCohomologyCompletePresentation@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:177

homalg.FiniteGroupCohomologyCompletePresentation.group_order

Exact order of the finite group in the theorem certificate.

Detailed contract

Exact order of the finite group appearing in the certificate.

(self) -> int

noether::homalg::FiniteGroupCohomologyCompletePresentation::group_order · Direct Rust declaration

pub const fn group_order(&self) -> &Integer
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/FiniteGroupCohomologyCompletePresentation@1

Executable usage: validation/unit/groups/test_permutation_group_facade.py:26 · validation/unit/homalg/test_finite_group_cohomology.py:176 · validation/parity/m1_bsgs.py:31 · validation/parity/m1_bsgs.py:330

homalg.FiniteGroupCohomologyCompletePresentation.presentation

Complete graded-commutative quotient presentation.

(self) -> GradedCommutativePresentation

noether::homalg::FiniteGroupCohomologyCompletePresentation::presentation · Direct Rust declaration

pub const fn presentation(&self) -> &GradedCommutativePresentation
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/FiniteGroupCohomologyCompletePresentation@1

Executable usage: examples/34_finite_group_cohomology.py:3 · validation/unit/category/test_category.py:70 · validation/unit/category/test_category.py:71 · validation/unit/category/test_category.py:72 · validation/unit/commalg/test_graded_commutative_facade.py:24 · validation/unit/commalg/test_graded_commutative_facade.py:25

homalg.FiniteGroupCohomologyCompletePresentation.relation_degree_bound

Universal degree bound for defining relations.

(self) -> int

noether::homalg::FiniteGroupCohomologyCompletePresentation::relation_degree_bound · Direct Rust declaration

pub const fn relation_degree_bound(&self) -> 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/FiniteGroupCohomologyCompletePresentation@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:178

homalg.FiniteGroupCohomologyCompletePresentation.symonds_parameter_certificate

Parameter certificate when the parameter criterion was selected.

Detailed contract

Parameter evidence when completion used Symonds’s parameter criterion.

(self) -> FiniteGroupCohomologySymondsParameterCertificate | None

noether::homalg::FiniteGroupCohomologyCompletePresentation::symonds_parameter_certificate · Direct Rust declaration

pub const fn symonds_parameter_certificate( &self, ) -> Option<&FiniteGroupCohomologySymondsParameterCertificate>
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/FiniteGroupCohomologyCompletePresentation@1

Executable usage: validation/unit/homalg/test_finite_group_cohomology.py:211

homalg.FiniteGroupCohomologyCompletePresentation.verify

Recompute the algebra and every completion hypothesis.

Detailed contract

Recompute the algebra and every hypothesis of the completion theorem.

(self) -> None

noether::homalg::FiniteGroupCohomologyCompletePresentation::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 attached / bounded
Semantic ID noether/homalg/FiniteGroupCohomologyCompletePresentation@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