Skip to content

commalg · ProjectiveCompleteIntersection

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

Worked example

The complete checked program Compute characteristic numbers of a smooth complete intersection uses this API directly.

# SPDX-License-Identifier: MIT
# Copyright (c) 2026 Benjamin Antieau and Deven Manam
"""Compute characteristic numbers of a smooth complete intersection."""

from fractions import Fraction

from noether.commalg import ChowRing, ProjectiveCompleteIntersection


def main() -> None:
    # The Chow ring of P^1 x P^2 is Z[h1,h2]/(h1^2,h2^3).
    chow = ChowRing([1, 2])
    h1, h2 = chow.generators()
    assert chow.integrate(h1 * h2**2) == 1

    # A smooth (1,1),(1,2) complete intersection is a curve. Smoothness is an
    # explicit hypothesis here.
    variety = ProjectiveCompleteIntersection.assuming_smooth(chow, [[1, 1], [1, 2]])
    assert variety.dimension == 1
    assert variety.integrate_restriction(h1) == 2
    assert variety.integrate_restriction(h2) == 3

    euler = variety.line_bundle_euler_characteristic([2, -1])
    euler.verify()
    assert euler.hrr_integral == Fraction(euler.koszul_value)
    print(
        f"smooth (1,1),(1,2) curve in P^1 x P^2: chi(O(2,-1))={euler.value}; HRR and Koszul agree"
    )


if __name__ == "__main__":
    main()

Run it with .venv/bin/python examples/37_complete_intersection_theory.py.

commalg.ProjectiveCompleteIntersection

A multidegree complete intersection with explicit geometric hypotheses.

class ProjectiveCompleteIntersection

noether::commalg::ProjectiveCompleteIntersection · Direct Rust declaration

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

Executable usage: examples/37_complete_intersection_theory.py:18 · examples/37_complete_intersection_theory.py:7 · validation/unit/commalg/test_intersection_theory.py:101 · validation/unit/commalg/test_intersection_theory.py:103 · validation/unit/commalg/test_intersection_theory.py:15 · validation/unit/commalg/test_intersection_theory.py:45

commalg.ProjectiveCompleteIntersection.__eq__

Test mathematical equality with another value.

(self, other: object) -> bool

noether::commalg::ProjectiveCompleteIntersection · 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, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ProjectiveCompleteIntersection@1

commalg.ProjectiveCompleteIntersection.assuming_regular_sequence

Construct a ProjectiveCompleteIntersection using assuming regular sequence.

Detailed contract

Construct a complete-intersection type, explicitly assuming regularity.

(cls, ring: ChowRing, multidegrees: Sequence[Sequence[int]]) -> ProjectiveCompleteIntersection

noether::commalg::ProjectiveCompleteIntersection::assuming_regular_sequence · Direct Rust declaration

pub fn assuming_regular_sequence( ring: ChowRing, multidegrees: impl Into<Vec<Vec<u64>>>, ) -> Result<Self, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: validation/unit/commalg/test_intersection_theory.py:78

commalg.ProjectiveCompleteIntersection.assuming_smooth

Construct a projective complete intersection under an explicit smoothness hypothesis.

Detailed contract

Construct a complete-intersection type, explicitly assuming smoothness.

(cls, ring: ChowRing, multidegrees: Sequence[Sequence[int]]) -> ProjectiveCompleteIntersection

noether::commalg::ProjectiveCompleteIntersection::assuming_smooth · Direct Rust declaration

pub fn assuming_smooth( ring: ChowRing, multidegrees: impl Into<Vec<Vec<u64>>>, ) -> Result<Self, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: examples/37_complete_intersection_theory.py:18 · validation/unit/commalg/test_intersection_theory.py:101 · validation/unit/commalg/test_intersection_theory.py:103 · validation/unit/commalg/test_intersection_theory.py:45 · validation/unit/commalg/test_intersection_theory.py:68 · validation/unit/commalg/test_intersection_theory.py:99

commalg.ProjectiveCompleteIntersection.codimension

Return the codimension recorded by this ProjectiveCompleteIntersection.

Detailed contract

Codimension, equal to the length of the assumed regular sequence.

(self) -> int

noether::commalg::ProjectiveCompleteIntersection::codimension · Direct Rust declaration

pub fn codimension(&self) -> usize
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/ProjectiveCompleteIntersection@1

Executable usage: examples/39_kahler_differentials.py:29 · validation/unit/commalg/test_intersection_theory.py:31 · validation/unit/commalg/test_intersection_theory.py:32 · validation/unit/commalg/test_intersection_theory.py:50 · validation/unit/commalg/test_kahler_differentials.py:100 · validation/unit/commalg/test_kahler_differentials.py:121

commalg.ProjectiveCompleteIntersection.dimension

Return the dimension recorded by this ProjectiveCompleteIntersection.

Detailed contract

Expected dimension.

(self) -> int

noether::commalg::ProjectiveCompleteIntersection::dimension · Direct Rust declaration

pub fn dimension(&self) -> usize
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/ProjectiveCompleteIntersection@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

commalg.ProjectiveCompleteIntersection.from_json

Deserialize and revalidate a ProjectiveCompleteIntersection from typed JSON.

Detailed contract

Deserialize and verify a canonical complete-intersection type.

(cls, value: str) -> ProjectiveCompleteIntersection

noether::commalg::ProjectiveCompleteIntersection::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, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL released
Semantic ID noether/commalg/ProjectiveCompleteIntersection@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.ProjectiveCompleteIntersection.fundamental_class

Compute fundamental class for this ProjectiveCompleteIntersection.

Detailed contract

Ambient fundamental class prod_j D_j.

(self) -> ChowClass

noether::commalg::ProjectiveCompleteIntersection::fundamental_class · Direct Rust declaration

pub fn fundamental_class(&self) -> Result<ChowClass, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: validation/unit/commalg/test_intersection_theory.py:51 · validation/unit/commalg/test_intersection_theory.py:84 · validation/parity/commalg/test_intersection_theory_sage_parity.py:58

commalg.ProjectiveCompleteIntersection.hypotheses

Return the hypotheses recorded by this ProjectiveCompleteIntersection.

Detailed contract

Explicit hypothesis under which formulas are interpreted.

(self) -> CompleteIntersectionHypotheses

noether::commalg::ProjectiveCompleteIntersection::hypotheses · Direct Rust declaration

pub fn hypotheses(&self) -> CompleteIntersectionHypotheses
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/ProjectiveCompleteIntersection@1

Executable usage: validation/unit/commalg/test_intersection_theory.py:47 · validation/unit/commalg/test_intersection_theory.py:82

commalg.ProjectiveCompleteIntersection.integrate_restriction

Compute integrate restriction for this ProjectiveCompleteIntersection.

Detailed contract

Integrate an integral class restricted from the ambient product.

(self, value: ChowClass) -> int

noether::commalg::ProjectiveCompleteIntersection::integrate_restriction · Direct Rust declaration

pub fn integrate_restriction( &self, class: &ChowClass, ) -> Result<Integer, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: examples/37_complete_intersection_theory.py:20 · examples/37_complete_intersection_theory.py:21 · validation/unit/commalg/test_intersection_theory.py:52 · validation/unit/commalg/test_intersection_theory.py:70 · validation/unit/commalg/test_intersection_theory.py:71

commalg.ProjectiveCompleteIntersection.line_bundle_chern_character

Compute line bundle chern character for this ProjectiveCompleteIntersection.

Detailed contract

Ambient representative of the Chern character of O(a_1, ..., a_r)|_X. The result is truncated through the dimension of X and does not claim to model the full Chow ring of X.

(self, multidegree: Sequence[int]) -> RationalChowClass

noether::commalg::ProjectiveCompleteIntersection::line_bundle_chern_character · Direct Rust declaration

pub fn line_bundle_chern_character( &self, multidegree: &[i64], ) -> Result<RationalChowClass, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

commalg.ProjectiveCompleteIntersection.line_bundle_euler_characteristic

Compute line bundle euler characteristic for this ProjectiveCompleteIntersection.

Detailed contract

Euler characteristic of O(a_1, ..., a_r) by HRR with independent replay.

(self, multidegree: Sequence[int]) -> HirzebruchRiemannRochResult

noether::commalg::ProjectiveCompleteIntersection::line_bundle_euler_characteristic · Direct Rust declaration

pub fn line_bundle_euler_characteristic( &self, multidegree: impl Into<Vec<i64>>, ) -> Result<HirzebruchRiemannRochResult, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: examples/37_complete_intersection_theory.py:23 · validation/unit/commalg/test_intersection_theory.py:55 · validation/unit/commalg/test_intersection_theory.py:56 · validation/unit/commalg/test_intersection_theory.py:72 · validation/unit/commalg/test_intersection_theory.py:73 · validation/unit/commalg/test_intersection_theory.py:90

commalg.ProjectiveCompleteIntersection.line_bundle_euler_characteristic_koszul

Compute line bundle euler characteristic koszul for this ProjectiveCompleteIntersection.

Detailed contract

Euler characteristic of O(a_1, ..., a_r)|_X from the Koszul resolution. This exact lane needs only the declared regular-sequence hypothesis and is therefore available even when smoothness was not assumed.

(self, multidegree: Sequence[int]) -> int

noether::commalg::ProjectiveCompleteIntersection::line_bundle_euler_characteristic_koszul · Direct Rust declaration

pub fn line_bundle_euler_characteristic_koszul( &self, multidegree: impl Into<Vec<i64>>, ) -> Result<Integer, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: validation/unit/commalg/test_intersection_theory.py:86

commalg.ProjectiveCompleteIntersection.multidegrees

Return the multidegrees recorded by this ProjectiveCompleteIntersection.

Detailed contract

Equation multidegrees.

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

noether::commalg::ProjectiveCompleteIntersection::multidegrees · Direct Rust declaration

pub fn multidegrees(&self) -> &[Vec<u64>]
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/ProjectiveCompleteIntersection@1

commalg.ProjectiveCompleteIntersection.normal_total_chern_class

Compute normal total chern class for this ProjectiveCompleteIntersection.

Detailed contract

Ambient-ring representative of the restricted normal-bundle Chern class. This is a polynomial in the ambient hyperplane classes, truncated through the dimension of X; it does not claim to model the full Chow ring of X.

(self) -> ChowClass

noether::commalg::ProjectiveCompleteIntersection::normal_total_chern_class · Direct Rust declaration

pub fn normal_total_chern_class( &self, ) -> Result<ChowClass, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: validation/unit/commalg/test_intersection_theory.py:85 · validation/parity/commalg/test_intersection_theory_sage_parity.py:59

commalg.ProjectiveCompleteIntersection.pushforward_restriction

Compute pushforward restriction for this ProjectiveCompleteIntersection.

Detailed contract

Push forward a class restricted from the ambient product.

(self, value: ChowClass) -> ChowClass

noether::commalg::ProjectiveCompleteIntersection::pushforward_restriction · Direct Rust declaration

pub fn pushforward_restriction( &self, class: &ChowClass, ) -> Result<ChowClass, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

commalg.ProjectiveCompleteIntersection.ring

Return the ring recorded by this ProjectiveCompleteIntersection.

Detailed contract

Ambient Chow ring.

(self) -> ChowRing

noether::commalg::ProjectiveCompleteIntersection::ring · Direct Rust declaration

pub fn ring(&self) -> &ChowRing
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/ProjectiveCompleteIntersection@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

commalg.ProjectiveCompleteIntersection.tangent_total_chern_class

Compute tangent total chern class for this ProjectiveCompleteIntersection.

Detailed contract

Ambient-ring representative of the restricted tangent-bundle Chern class. This is a polynomial in the ambient hyperplane classes, truncated through the dimension of X; it does not claim to model the full Chow ring of X.

(self) -> ChowClass

noether::commalg::ProjectiveCompleteIntersection::tangent_total_chern_class · Direct Rust declaration

pub fn tangent_total_chern_class( &self, ) -> Result<ChowClass, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: validation/unit/commalg/test_intersection_theory.py:53 · validation/unit/commalg/test_intersection_theory.py:88 · validation/parity/commalg/test_intersection_theory_sage_parity.py:60

commalg.ProjectiveCompleteIntersection.to_json

Serialize this ProjectiveCompleteIntersection to its canonical typed JSON representation.

Detailed contract

Serialize this object to canonical typed JSON.

(self) -> str

noether::commalg::ProjectiveCompleteIntersection::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, flint-core, groebner-kernel, module-core, poly-core, resolution-kernel
GIL attached / bounded
Semantic ID noether/commalg/ProjectiveCompleteIntersection@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.ProjectiveCompleteIntersection.todd_class

Compute todd class for this ProjectiveCompleteIntersection.

Detailed contract

Ambient-ring representative of the restricted tangent-bundle Todd class. This is a polynomial in the ambient hyperplane classes, truncated through the dimension of X; it does not claim to model the full Chow ring of X.

(self) -> RationalChowClass

noether::commalg::ProjectiveCompleteIntersection::todd_class · Direct Rust declaration

pub fn todd_class(&self) -> Result<RationalChowClass, IntersectionTheoryError>
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/ProjectiveCompleteIntersection@1

Executable usage: validation/parity/commalg/test_intersection_theory_sage_parity.py:61

commalg.ProjectiveCompleteIntersection.validity

Return the validity recorded by this ProjectiveCompleteIntersection.

Detailed contract

Logical validity of formulas derived from the declared hypothesis.

(self) -> MathematicalValidity

noether::commalg::ProjectiveCompleteIntersection::validity · Direct Rust declaration

pub fn validity(&self) -> MathematicalValidity
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/ProjectiveCompleteIntersection@1

Executable usage: validation/unit/commalg/test_intersection_theory.py:48 · validation/unit/commalg/test_intersection_theory.py:83 · validation/unit/homalg/test_chain_complex.py:42 · validation/unit/homalg/test_padic_homology_facade.py:157 · validation/unit/homalg/test_padic_homology_facade.py:168 · validation/unit/homalg/test_padic_homology_facade.py:172

commalg.ProjectiveCompleteIntersection.verify

Replay and verify the mathematical evidence carried by this ProjectiveCompleteIntersection.

Detailed contract

Recheck representation invariants while preserving declared hypotheses. Numerical multidegrees cannot prove regularity or smoothness. Verification revalidates the bounded nonempty complete-intersection representation and retains, but does not upgrade, its conditional validity.

(self) -> None

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

pub fn verify(&self) -> Result<(), IntersectionTheoryError>
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/ProjectiveCompleteIntersection@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