Skip to content

commalg · ConormalSequenceEvidence

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

commalg.ConormalSequenceEvidence

Replayable conormal presentation I/I² -> A^n with its exact Jacobian.

class ConormalSequenceEvidence

noether::commalg::ConormalSequenceEvidence · Direct Rust declaration

pub struct ConormalSequenceEvidence<C: Field> { /* private fields */ }
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ConormalSequenceEvidence@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:14 · validation/unit/commalg/test_kahler_differentials.py:63

commalg.ConormalSequenceEvidence.algebra

The affine algebra A = k[x_1,...,x_n]/I.

Detailed contract

Affine algebra A in the conormal sequence.

(self) -> QuotientRing[D]

noether::commalg::ConormalSequenceEvidence::algebra · Direct Rust declaration

pub fn algebra(&self) -> &QuotientRing<PolynomialRing<C>>
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ConormalSequenceEvidence@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

commalg.ConormalSequenceEvidence.ambient_differentials

The free ambient module with basis dx_1,...,dx_n.

Detailed contract

Relation-free module Omega_{C[x]/C} tensor A with basis dx_i.

(self) -> PresentedModule[QuotientRing[RationalField]] | PresentedModule[QuotientRing[FiniteField]]

noether::commalg::ConormalSequenceEvidence::ambient_differentials · Direct Rust declaration

pub fn ambient_differentials( &self, ) -> &PresentedModule<QuotientRing<PolynomialRing<C>>>
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ConormalSequenceEvidence@1

commalg.ConormalSequenceEvidence.chosen_generators

The exact chosen generators of I, including redundancies.

Detailed contract

Ordered equations whose exact syzygies present I/I^2.

(self) -> list[Polynomial[D]]

noether::commalg::ConormalSequenceEvidence::chosen_generators · Direct Rust declaration

pub fn chosen_generators(&self) -> &[Polynomial<C>]
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ConormalSequenceEvidence@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:118 · validation/unit/commalg/test_kahler_differentials.py:64

commalg.ConormalSequenceEvidence.conormal_map

The conormal map sending each equation to its exact differential.

Detailed contract

Checked conormal map I/I^2 -> Omega_{C[x]/C} tensor A.

(self) -> PresentedModuleHomomorphism[QuotientRing[RationalField]] | PresentedModuleHomomorphism[QuotientRing[FiniteField]]

noether::commalg::ConormalSequenceEvidence::conormal_map · Direct Rust declaration

pub fn conormal_map( &self, ) -> &PresentedModuleHomomorphism<QuotientRing<PolynomialRing<C>>>
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ConormalSequenceEvidence@1

commalg.ConormalSequenceEvidence.conormal_module

A presentation of I/I^2 over A for the chosen generators.

Detailed contract

Exact presented A-module I/I^2.

(self) -> PresentedModule[QuotientRing[RationalField]] | PresentedModule[QuotientRing[FiniteField]]

noether::commalg::ConormalSequenceEvidence::conormal_module · Direct Rust declaration

pub fn conormal_module( &self, ) -> &PresentedModule<QuotientRing<PolynomialRing<C>>>
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ConormalSequenceEvidence@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:119 · validation/unit/commalg/test_kahler_differentials.py:66

commalg.ConormalSequenceEvidence.from_json

Deserialize and independently verify conormal evidence.

Detailed contract

Deserialize and exactly reconstruct the conormal evidence.

(cls, value: str) -> ConormalSequenceEvidence[RationalField] | ConormalSequenceEvidence[FiniteField]

noether::commalg::ConormalSequenceEvidence::from_json · Direct Rust declaration

pub fn from_json(value: &str) -> Result<Self, NoetherError>where C: for<'de> Deserialize<'de>, C::Element: for<'de> Deserialize<'de>,
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL released
Semantic ID noether/commalg/ConormalSequenceEvidence@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

commalg.ConormalSequenceEvidence.jacobian

The exact Jacobian matrix over A for the chosen generators.

Detailed contract

Jacobian with one row per chosen equation and one column per variable.

(self) -> Matrix[QuotientRing[D]]

noether::commalg::ConormalSequenceEvidence::jacobian · Direct Rust declaration

pub fn jacobian(&self) -> &Matrix<QuotientRing<PolynomialRing<C>>>
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ConormalSequenceEvidence@1

Executable usage: validation/unit/commalg/test_kahler_differentials.py:114 · validation/unit/commalg/test_kahler_differentials.py:65 · validation/bench/macaulay2_decomposition.py:493 · validation/corpus/homalg/line-arrangement-jacobian-syzygies.py:15 · validation/corpus/homalg/line-arrangement-jacobian-syzygies.py:19 · validation/corpus/linalg/restricted-grassmannian-secant-rank.py:24

commalg.ConormalSequenceEvidence.to_json

Serialize the replayable evidence as canonical typed JSON.

Detailed contract

Serialize the algebra and chosen equations; deserialization rebuilds and exactly reverifies all derived evidence.

(self) -> str

noether::commalg::ConormalSequenceEvidence::to_json · Direct Rust declaration

pub fn to_json(&self) -> Result<String, NoetherError>where C: Serialize, C::Element: Serialize,
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ConormalSequenceEvidence@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

commalg.ConormalSequenceEvidence.verify

Replay the ideal, I/I^2, Jacobian, and conormal-map calculations.

Detailed contract

Recompute the syzygy presentation and Jacobian and compare every map.

(self) -> None

noether::commalg::ConormalSequenceEvidence::verify · Direct Rust declaration

pub fn verify(&self) -> Result<(), KahlerDifferentialError>
Contract Value
Guarantee checked deterministic result
Determinism deterministic
Availability default CPU build
Domain implementation crates noether, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL released
Semantic ID noether/commalg/ConormalSequenceEvidence@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