Add monomial order (#231)

* Abstract monomial ordering

* MA term

* DP#bl/order

Author: blegat

.github/workflows/ci.yml

@@ -51,7 +51,7 @@ jobs:
         shell: julia --project=@. {0}
         run: |
           using Pkg
-          Pkg.add(PackageSpec(name="DynamicPolynomials", rev="bl/coefficient_type"))
+          Pkg.add(PackageSpec(name="DynamicPolynomials", rev="bl/order"))
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
         with:

src/default_term.jl

@@ -86,3 +86,33 @@ function MA.mutability(::Type{Term{C,M}}) where {C,M}
         return MA.IsNotMutable()
     end
 end
+
+function MA.mutable_copy(t::Term)
+    return Term(
+        MA.copy_if_mutable(coefficient(t)),
+        MA.copy_if_mutable(monomial(t)),
+    )
+end
+
+function MA.operate_to!(
+    t::Term,
+    ::typeof(*),
+    t1::AbstractTermLike,
+    t2::AbstractTermLike,
+)
+    MA.operate_to!(t.coefficient, *, coefficient(t1), coefficient(t2))
+    MA.operate_to!(t.monomial, *, monomial(t1), monomial(t2))
+    return t
+end
+
+function MA.operate!(::typeof(*), t1::Term, t2::AbstractTermLike)
+    MA.operate!(*, t1.coefficient, coefficient(t2))
+    MA.operate!(*, t1.monomial, monomial(t2))
+    return t1
+end
+
+function MA.operate!(::typeof(one), t::Term)
+    MA.operate!(one, t.coefficient)
+    MA.operate!(constant_monomial, t.monomial)
+    return t
+end

src/monomial_vector.jl

@@ -4,6 +4,106 @@ export monomial_vector,
     sort_monomial_vector,
     merge_monomial_vectors
 
+export LexOrder, InverseLexOrder, Reverse, Graded
+
+"""
+    abstract type AbstractMonomialOrdering end
+
+Abstract type for monomial ordering as defined in [CLO13, Definition 2.2.1, p. 55]
+
+[CLO13] Cox, D., Little, J., & OShea, D.
+*Ideals, varieties, and algorithms: an introduction to computational algebraic geometry and commutative algebra*.
+Springer Science & Business Media, **2013**.
+"""
+abstract type AbstractMonomialOrdering end
+
+"""
+    compare(a, b, order::AbstractMonomialOrdering)
+
+Returns a negative number if `a < b`, a positive number if `a > b` and zero if `a == b`.
+"""
+function compare end
+
+"""
+    struct LexOrder <: AbstractMonomialOrdering end
+
+Lexicographic (Lex for short) Order often abbreviated as *lex* order as defined in [CLO13, Definition 2.2.3, p. 56]
+
+The [`Graded`](@ref) version is often abbreviated as *grlex* order and is defined in [CLO13, Definition 2.2.5, p. 58]
+
+[CLO13] Cox, D., Little, J., & OShea, D.
+*Ideals, varieties, and algorithms: an introduction to computational algebraic geometry and commutative algebra*.
+Springer Science & Business Media, **2013**.
+"""
+struct LexOrder <: AbstractMonomialOrdering end
+
+"""
+    struct InverseLexOrder <: AbstractMonomialOrdering end
+
+Inverse Lex Order defined in [CLO13, Exercise 2.2.6, p. 61] where it is abbreviated as *invlex*.
+It corresponds to [`LexOrder`](@ref) but with the variables in reverse order.
+
+The [`Graded`](@ref) version can be abbreviated as *grinvlex* order.
+It is defined in [BDD13, Definition 2.1] where it is called *Graded xel order*.
+
+[CLO13] Cox, D., Little, J., & OShea, D.
+*Ideals, varieties, and algorithms: an introduction to computational algebraic geometry and commutative algebra*.
+Springer Science & Business Media, **2013**.
+[BDD13] Batselier, K., Dreesen, P., & De Moor, B.
+*The geometry of multivariate polynomial division and elimination*.
+SIAM Journal on Matrix Analysis and Applications, 34(1), 102-125, *2013*.
+"""
+struct InverseLexOrder <: AbstractMonomialOrdering end
+
+"""
+    struct Graded{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
+        same_degree_ordering::O
+    end
+
+Monomial ordering defined by:
+* `degree(a) == degree(b)` then the ordering is determined by `same_degree_ordering`,
+* otherwise, it is the ordering between the integers `degree(a)` and `degree(b)`.
+"""
+struct Graded{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
+    same_degree_ordering::O
+end
+
+_deg(exponents) = sum(exponents)
+_deg(mono::AbstractMonomial) = degree(mono)
+
+function compare(a, b, ordering::Graded)
+    deg_a = _deg(a)
+    deg_b = _deg(b)
+    if deg_a == deg_b
+        return compare(a, b, ordering.same_degree_ordering)
+    else
+        return deg_a - deg_b
+    end
+end
+
+"""
+    struct Reverse{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
+        reverse_order::O
+    end
+
+Monomial ordering defined by `compare(a, b, order) = compare(b, a, order.reverse_order)`..
+
+Reverse Lex Order defined in [CLO13, Exercise 2.2.9, p. 61] where it is abbreviated as *rinvlex*.
+can be obtained as `Reverse(InverseLexOrder())`.
+
+The Graded Reverse Lex Order often abbreviated as *grevlex* order defined in [CLO13, Definition 2.2.6, p. 58]
+can be obtained as `Graded(Reverse(InverseLexOrder()))`.
+
+[CLO13] Cox, D., Little, J., & OShea, D.
+*Ideals, varieties, and algorithms: an introduction to computational algebraic geometry and commutative algebra*.
+Springer Science & Business Media, **2013**.
+"""
+struct Reverse{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
+    reverse_ordering::O
+end
+
+compare(a, b, ordering::Reverse) = compare(b, a, ordering.reverse_ordering)
+
 function monomials(v::AbstractVariable, degree, args...)
     return monomials((v,), degree, args...)
 end

src/variable.jl

@@ -13,9 +13,9 @@ be the type of `p` but the supertype of all variables that could be created.
 
 For `TypedPolynomials`, a variable of name `x` has type `Variable{:x}` so
 `variable_union_type` should return `Variable`.
-For `DynamicPolynomials`, all variables have the same type `PolyVar{C}` where
+For `DynamicPolynomials`, all variables have the same type `Variable{C}` where
 `C` is `true` for commutative variables and `false` for non-commutative ones so
-`variable_union_type` should return `PolyVar{C}`.
+`variable_union_type` should return `Variable{C}`.
 """
 function variable_union_type end
 function variable_union_type(::Type{MT}) where {MT<:AbstractMonomialLike}

test/variable.jl

@@ -9,7 +9,7 @@ import MultivariatePolynomials:
         @test length(z) == 2
         @test x[1] > x[2] > x[3] > y > z[1] > z[2]
     end
-    @testset "PolyVar" begin
+    @testset "Variable" begin
         Mod.@polyvar x
         alloc_test(() -> convert(typeof(x), x), 0)
         alloc_test(() -> convert(variable_union_type(x), x), 0)