mathhook-core 0.2.0

Core mathematical engine for MathHook - expressions, algebra, and solving
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Groebner Basis Computation
//!
//! Provides Groebner basis algorithms for polynomial ideals.
//! This module re-exports from `algebra::groebner` while providing
//! a unified interface through the polynomial module.
//!
//! # Overview
//!
//! Groebner bases are a fundamental tool in computational algebraic geometry
//! and polynomial system solving. They provide canonical generators for
//! polynomial ideals, enabling:
//!
//! - Ideal membership testing
//! - Polynomial system solving
//! - Elimination of variables
//! - Geometric theorem proving
//!
//! # Algorithms
//!
//! - **Buchberger's Algorithm**: Classic algorithm for Groebner basis computation
//! - **Efficient Buchberger**: Optimized variant with pair selection strategies
//!
//! # Example
//!
//! ```rust
//! use mathhook_core::core::polynomial::groebner::{GroebnerBasis, MonomialOrder};
//! use mathhook_core::core::Expression;
//! use mathhook_core::symbol;
//!
//! let x = symbol!(x);
//! let y = symbol!(y);
//!
//! // f1 = x - y
//! let f1 = Expression::add(vec![
//!     Expression::symbol(x.clone()),
//!     Expression::mul(vec![Expression::integer(-1), Expression::symbol(y.clone())]),
//! ]);
//! // f2 = y^2 - 1
//! let f2 = Expression::add(vec![
//!     Expression::pow(Expression::symbol(y.clone()), Expression::integer(2)),
//!     Expression::integer(-1),
//! ]);
//!
//! let mut gb = GroebnerBasis::new(
//!     vec![f1, f2],
//!     vec![x.clone(), y.clone()],
//!     MonomialOrder::Lex
//! );
//! gb.compute();
//!
//! // The basis should have at least 2 polynomials
//! assert!(gb.basis.len() >= 2);
//! ```

pub use crate::algebra::groebner::{
    buchberger_algorithm, efficient_buchberger_algorithm, expression_to_sparse_polynomial,
    poly_reduce, poly_reduce_completely, s_polynomial, sparse_polynomial_to_expression,
    GroebnerBasis, Monomial, MonomialOrder, MonomialOrdering, SparsePolynomial,
};

#[cfg(test)]
mod tests {
    use super::*;
    use crate::core::Expression;
    use crate::symbol;

    #[test]
    fn test_monomial_order_export() {
        let _lex = MonomialOrder::Lex;
        let _grlex = MonomialOrder::Grlex;
        let _grevlex = MonomialOrder::Grevlex;
    }

    #[test]
    fn test_sparse_polynomial_creation() {
        let mono = Monomial::new(vec![1, 2]);
        assert_eq!(mono.degree(), 3);
    }

    #[test]
    fn test_groebner_basis_creation() {
        let x = symbol!(x);
        let y = symbol!(y);

        let f1 = Expression::add(vec![
            Expression::pow(Expression::symbol(x.clone()), Expression::integer(2)),
            Expression::integer(-1),
        ]);

        let gb = GroebnerBasis::new(vec![f1], vec![x, y], MonomialOrder::Lex);

        assert_eq!(gb.basis.len(), 1);
        assert_eq!(gb.variables.len(), 2);
    }

    #[test]
    fn test_groebner_basis_simple() {
        let x = symbol!(x);
        let y = symbol!(y);

        let f1 = Expression::symbol(x.clone()) - Expression::symbol(y.clone());
        let f2 = Expression::pow(Expression::symbol(y.clone()), Expression::integer(2))
            - Expression::integer(1);

        let mut gb =
            GroebnerBasis::new(vec![f1, f2], vec![x.clone(), y.clone()], MonomialOrder::Lex);

        gb.compute();

        assert!(!gb.basis.is_empty());
        assert!(gb.basis.len() >= 2);
    }

    #[test]
    fn test_expression_conversion_exists() {
        let x = symbol!(x);
        let y = symbol!(y);

        let poly = Expression::add(vec![
            Expression::pow(Expression::symbol(x.clone()), Expression::integer(2)),
            Expression::symbol(y.clone()),
        ]);

        let vars = vec![x, y];
        let sparse = expression_to_sparse_polynomial(&poly, &vars);

        assert!(sparse.is_some());
    }
}