Struct GroebnerBasis 

pub struct GroebnerBasis<D: Domain, O: MonomialOrder> {
    pub basis: Vec<SparseMultivariatePolynomial<D, O>>,
}

A Gröbner basis for a polynomial ideal.

Fields

basis: Vec<SparseMultivariatePolynomial<D, O>>

The polynomials forming the basis.

Implementations

impl<D: Domain, O: MonomialOrder> GroebnerBasis<D, O>

pub fn buchberger(ideal: &[SparseMultivariatePolynomial<D, O>]) -> Self

Compute a Gröbner basis from a set of generators using Buchberger’s algorithm.

Requires that the coefficient domain supports exact division (i.e., is effectively a field). The algorithm will panic if division fails.

Example

use ocas_domain::{RationalDomain, Rational};
use ocas_poly::sparse::Lex;
use ocas_poly::GroebnerBasis;
use ocas_poly::SparseMultivariatePolynomial;

let d = RationalDomain;
// ideal: x + y, x - y
let f1 = SparseMultivariatePolynomial::<_, Lex>::from_terms(d, 2, vec![
    (vec![1, 0], Rational::new(1, 1)),
    (vec![0, 1], Rational::new(1, 1)),
]);
let f2 = SparseMultivariatePolynomial::<_, Lex>::from_terms(d, 2, vec![
    (vec![1, 0], Rational::new(1, 1)),
    (vec![0, 1], Rational::new(-1, 1)),
]);
let gb = GroebnerBasis::buchberger(&[f1, f2]);
assert!(gb.basis.len() >= 2);

pub fn minimize(self) -> Self

Minimize the basis: remove polynomials whose leading monomial is divisible by another element’s leading monomial.

pub fn auto_reduce(self) -> Self

Inter-reduce the basis: reduce each element by the others and make each polynomial monic.

The algorithm processes elements in ascending order of leading monomial. Each element is reduced by all elements with strictly smaller leading monomials (those already in the result set). This ensures the standard reduced Gröbner basis property: no monomial of any basis element is divisible by the leading monomial of any other basis element.

pub fn is_groebner_basis(&self) -> bool

Verify that this is indeed a Gröbner basis by checking that all S-polynomials reduce to zero.

pub fn reorder<O2: MonomialOrder>(&self) -> GroebnerBasis<D, O2>

where D: 'static,

Change the monomial order of this Gröbner basis.

The polynomials are re-interpreted under the target order O2 and the F4 algorithm is re-run. This is the simple reorder path (Symbolica’s reorder::<Order>()). For zero-dimensional ideals, use crate::groebner::fglm::fglm for a much faster conversion.

Example

use ocas_domain::{RationalDomain, Rational};
use ocas_poly::sparse::{Grevlex, Lex};
use ocas_poly::{GroebnerBasis, SparseMultivariatePolynomial, f4};

let d = RationalDomain;
// ideal: x + y, x - y  → basis {y, x} under Lex
let f1 = SparseMultivariatePolynomial::<_, Lex>::from_terms(d, 2, vec![
    (vec![1, 0], Rational::new(1, 1)),
    (vec![0, 1], Rational::new(1, 1)),
]);
let f2 = SparseMultivariatePolynomial::<_, Lex>::from_terms(d, 2, vec![
    (vec![1, 0], Rational::new(1, 1)),
    (vec![0, 1], Rational::new(-1, 1)),
]);
let gb_lex = f4::f4(&[f1, f2]);
let gb_grevlex = gb_lex.reorder::<Grevlex>();
assert!(gb_grevlex.is_groebner_basis());

Trait Implementations

impl<D: Clone + Domain, O: Clone + MonomialOrder> Clone for GroebnerBasis<D, O>

fn clone(&self) -> GroebnerBasis<D, O>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<D: Debug + Domain, O: Debug + MonomialOrder> Debug for GroebnerBasis<D, O>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: Eq + Domain, O: Eq + MonomialOrder> Eq for GroebnerBasis<D, O>

impl<D: PartialEq + Domain, O: PartialEq + MonomialOrder> PartialEq for GroebnerBasis<D, O>

fn eq(&self, other: &GroebnerBasis<D, O>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<D: PartialEq + Domain, O: PartialEq + MonomialOrder> StructuralPartialEq for GroebnerBasis<D, O>