MultivariatePolynomials

https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/
Admin
MultivariatePolynomials is an implementation-independent Julia library for manipulating multivariate...
Tokens:34,035
Snippets:376
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Examples of Polynomial Antidifferentiation

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/differentiation

Shows examples of antidifferentiating a polynomial `p` with respect to `x`, `x` using `Val{1}()`, and with respect to multiple variables `(x, y)`. The free constant is set to 0.

```julia
p = 3x^2*y + x + 2y + 1
antidifferentiate(p, x) # should return 3x^3* + 1/2*x + 2xy + x
antidifferentiate(p, x, Val{1}()) # equivalent to the above
antidifferentiate(p, (x, y)) # should return [3x^3* + 1/2*x + 2xy + x, 3/2x^2*y^2 + xy + y^2 + y]
```

--------------------------------

### Get Numerator and Denominator of Rational Function

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Retrieve the numerator and denominator polynomials from a rational function using the `numerator` and `denominator` functions.

```julia
numerator(f)
```

```julia
denominator(f)
```

--------------------------------

### Examples of Polynomial Differentiation

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/differentiation

Demonstrates basic differentiation of a polynomial `p` with respect to `x`, `x` with `Val{1}()`, and with respect to multiple variables `(x, y)`. Also shows differentiation of an array of polynomials.

```julia
p = 3x^2*y + x + 2y + 1
differentiate(p, x) # should return 6xy + 1
differentiate(p, x, Val{1}()) # equivalent to the above
differentiate(p, (x, y)) # should return [6xy+1, 3x^2+1]
differentiate( [x^2+y, z^2+4x], [x, y, z]) # should return [2x 1 0; 4 0 2z]
```

--------------------------------

### Generate Monomial Exponents with Graded Lex Order (2 Variables)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Example of using `ExponentsIterator` to generate all monomial exponents for 2 variables up to degree 2, using `Graded{LexOrder}`.

```julia
collect(ExponentsIterator{Graded{LexOrder}}((0, 0), maxdegree = 2))
```

--------------------------------

### Generate Monomial Exponents with Graded Lex Order (3 Variables)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Example of using `ExponentsIterator` to generate monomial exponents for 3 variables between degree 2 and 2, using `Graded{LexOrder}` and `ntuple`.

```julia
collect(ExponentsIterator{Graded{LexOrder}}(ntuple(zero, 3), mindegree = 2, maxdegree = 2))
```

--------------------------------

### Calculate Pseudo Divisor and Remainder

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Use `pseudo_divrem` for pseudo-division of polynomial `f` by `g`, returning a pseudo quotient and remainder. This method is useful when coefficients do not form a field, as demonstrated by the example of dividing `3x + 1` by `2x + 1` over integers.

```julia
pseudo_divrem(f::_APL{S}, g::_APL{T}, algo) where {S,T}
```

--------------------------------

### Get Exponents of a Term

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the exponents corresponding to the variables in a term's monomial. For example, exponents(x^2*y) returns (2, 1).

```julia
exponents(t::AbstractTermLike)
```

--------------------------------

### Get Monomial of a Term

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the monomial part of a given term.

```julia
monomial(t::AbstractTermLike)

```

--------------------------------

### Get Extremal Total Degrees of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns a tuple containing the minimal and maximal total degrees of the monomials in a polynomial. Provides a range of degrees present.

```julia
extdegree(p::Union{AbstractPolynomialLike, AbstractVector{<:AbstractPolynomialLike}})
```

--------------------------------

### Get Variables of a Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Retrieves the tuple of variables in a polynomial, sorted in decreasing order. May include variables with zero degree.

```julia
variables(p::AbstractPolynomialLike)
```

--------------------------------

### Get Variable Name and Indices

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the name of a variable along with its associated indices. This is useful for understanding the structure of indexed variables.

```julia
name_base_indices(v::AbstractVariable)
```

--------------------------------

### Get Minimum Total Degree of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the minimal total degree of the monomials of a polynomial. Use when you need the smallest degree present in the polynomial.

```julia
mindegree(p::Union{AbstractPolynomialLike, AbstractVector{<:AbstractPolynomialLike}}, v::AbstractVariable)
```

--------------------------------

### Get Polynomial Coefficients

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns an iterator over the coefficients of the nonzero terms, sorted by decreasing monomial order. An overload allows specifying coefficients for a given set of monomials.

```julia
coefficients(p::AbstractPolynomialLike)
```

```julia
coefficients(p::AbstractPolynomialLike, X::AbstractVector)
```

--------------------------------

### Get Polynomial Monomials

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns an iterator over the monomials of the nonzero terms, sorted in decreasing order. Another form constructs monomials based on variables, degrees, and a filter.

```julia
monomials(p::AbstractPolynomialLike)
```

```julia
monomials(vars::Union{Vector{<:AbstractVariable},Tuple}, degs::AbstractVector{Int}, filter::Function = m -> true)
```

--------------------------------

### Get Total Degree of a Term

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Calculates the sum of the exponents of the variables in a term's monomial. For example, degree(x^2*y) returns 3.

```julia
degree(t::AbstractTermLike)
```

--------------------------------

### Get Degree and Number of Leading Terms

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the maximum degree of a polynomial with respect to a variable and the count of terms that have this maximum degree. Useful for understanding the structure of the highest degree terms.

```julia
deg_num_leading_terms(p::AbstractPolynomialLike, var)
```

--------------------------------

### Get Powers of a Term's Monomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns an iterator over the variable-exponent pairs in a term's monomial. For example, powers(3x^4*y) returns ((x, 4), (y, 1)).

```julia
powers(t::AbstractTermLike)
```

--------------------------------

### Get Degree of a Term with Respect to a Variable

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the exponent of a specific variable within a term's monomial. For example, degree(x^2*y, x) returns 2.

```julia
degree(t::AbstractTermLike, v::AbstractVariable)
```

--------------------------------

### Iterate Monomial Exponents with LexOrder

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Demonstrates iterating through monomial exponents using LexOrder and collecting them into a Vector. Specify mindegree and maxdegree for the iteration range.

```julia
julia> collect(ExponentsIterator{LexOrder}(zeros(Int, 2), mindegree = 2, maxdegree = 3))
7-element Vector{Vector{Int64}}:
 [0, 2]
 [0, 3]
 [1, 1]
 [1, 2]
 [2, 0]
 [2, 1]
 [3, 0]
```

--------------------------------

### Construct Rational Polynomial Function

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Rational polynomial functions can be constructed using the `/` operator. Common arithmetic operations are supported.

```julia
p / q
```

--------------------------------

### AbstractMonomialLike Type

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Abstract type for values that can act like monomials. An AbstractVariable is an example.

```julia
AbstractMonomialLike
```

--------------------------------

### @similar_variable

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Macro to create a similar variable and bind it to a name.

```APIDOC
## Macro

`MultivariatePolynomials.@similar_variable` — Macro

```
@similar_variable(p::AbstractPolynomialLike, variable)
```

Calls `similar_variable(p, Val{variable})` and binds the result to a variable with the same name.

**Examples**
Calling `@similar_variable typedpoly x` on a polynomial created with `TypedPolynomials` binds `TypedPolynomials.Variable{:x}` to the variable `x`.
```

--------------------------------

### promote_variables

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Return two polynomials over the same variables.

```APIDOC
## Function `MultivariatePolynomials.promote_variables`

```
promote_variables(p::AbstractPolynomialLike, q::AbstractPolynomialLike)
```

Return two polynomials over the same variables.
```

--------------------------------

### Define AbstractPolynomialLike Type

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Abstract type for values that can act like polynomials. An AbstractTerm is an example.

```julia
AbstractPolynomialLike{T}
```

--------------------------------

### compare(a, b, order::Type{<:AbstractMonomialOrdering})

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Compares two elements `a` and `b` according to the specified monomial ordering. Deprecated, use `cmp(order(), a, b)` instead.

```APIDOC
## Function: compare(a, b, order::Type{<:AbstractMonomialOrdering})

### Description
Returns a negative number if `a < b`, a positive number if `a > b` and zero if `a == b`. The comparison is done according to `order`.

### Warning
This is deprecated, use `cmp(order(), a, b)` instead.

### Signature
`compare(a, b, order::Type{<:AbstractMonomialOrdering})`
```

--------------------------------

### Get Type of Monomial Vector

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the return type of the `monomial_vector` function for a given input vector of monomials.

```julia
monomial_vector_type(X::AbstractVector{MT}) where {MT<:AbstractMonomialLike}
```

--------------------------------

### Get Polynomial Type

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the type that a polynomial-like object would have if converted to a polynomial. Can specify the coefficient type.

```julia
polynomial_type(p::AbstractPolynomialLike)
```

```julia
polynomial_type(::Type{PT}) where PT<:AbstractPolynomialLike
```

```julia
polynomial_type(p::AbstractPolynomialLike, ::Type{T}) where T
```

```julia
polynomial_type(::Type{PT}, ::Type{T}) where {PT<:AbstractPolynomialLike, T}
```

--------------------------------

### Get Coefficient Type of a Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the coefficient type of a polynomial. Overloads are provided for polynomial instances and types.

```julia
coefficient_type(p::AbstractPolynomialLike)

```

```julia
coefficient_type(::Type{PT}) where PT

```

--------------------------------

### antidifferentiate(p::AbstractPolynomialLike, vs, deg::Union{Int, Val}=1)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/differentiation

Antidifferentiate `deg` times the polynomial `p` by the variables in `vs` and return an array of antidifferences.

```APIDOC
## Function Signature
antidifferentiate(p::AbstractPolynomialLike, vs, deg::Union{Int, Val}=1)

### Description
Antidifferentiate `deg` times the polynomial `p` by the variables of the vector or tuple of variable `vs` and return an array of dimension `deg`. It is recommended to pass `deg` as a `Val` instance when the degree is known at compile time, e.g. `antidifferentiate(p, v, Val{2}())` instead of `antidifferentiate(p, x, 2)`, as this will help the compiler infer the return type.

### Parameters
- **p** (AbstractPolynomialLike) - The polynomial to antidifferentiate.
- **vs** (Vector or Tuple of AbstractVariable) - The variables with respect to which to antidifferentiate.
- **deg** (Int or Val) - The number of times to antidifferentiate. Defaults to 1.

### Examples
```julia
p = 3x^2*y + x + 2y + 1
antidifferentiate(p, (x, y)) # should return [3x^3* + 1/2*x + 2xy + x, 3/2x^2*y^2 + xy + y^2 + y]
```
```

--------------------------------

### Generalized Euclidean Algorithm Type (Julia)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Represents an algorithm for computing the GCD of univariate polynomials using a generalized Euclidean algorithm. Options include making intermediate remainders primitive for better handling of unique factorization domains.

```julia
struct GeneralizedEuclideanAlgorithm <: AbstractUnivariateGCDAlgorithm
    primitive_rem::Bool
    skip_last::Bool
end
```

--------------------------------

### Get Variable Name

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Retrieves the name of a variable as a string. This is a fundamental operation for identifying variables within polynomials.

```julia
name(v::AbstractVariable)::AbstractString
```

--------------------------------

### ordering(p::AbstractPolynomialLike)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the AbstractMonomialOrdering type used for comparing exponent vectors of a polynomial.

```APIDOC
## Function: ordering(p::AbstractPolynomialLike)

### Description
Returns the `AbstractMonomialOrdering` type to be used to compare exponent vectors for the monomials of `p`.

### Signature
`ordering(p::AbstractPolynomialLike)::Type{<:AbstractMonomialOrdering}`
```

--------------------------------

### MultivariatePolynomials.pair_zip

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/internal

Zips two tuples into a tuple of pairs. For example, pair_zip((a, b), (c, d)) results in (a=>c, b=>d).

```APIDOC
## Function: MultivariatePolynomials.pair_zip

### Description
Zips two tuples into a tuple of pairs.

### Parameters
- `(a, b)`: The first tuple.
- `(c, d)`: The second tuple.

### Returns
A tuple of pairs, e.g., `(a=>c, b=>d)`.
```

--------------------------------

### Get Effective Variables of a Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns a sorted vector of variables that have a non-zero degree in at least one term of the polynomial.

```julia
effective_variables(p::AbstractPolynomialLike)
```

--------------------------------

### Map Coefficients to an Output Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Applies a function to each coefficient of an input polynomial `p` and stores the result in the `output` polynomial. Terms resulting in zero are omitted. If the function is known to never return zero for non-zero inputs, `nonzero` can be set to `true` for a performance improvement.

```julia
map_coefficients_to!(output::AbstractPolynomialLike, f::Function, p::AbstractPolynomialLike, nonzero = false)
```

--------------------------------

### differentiate(p::AbstractPolynomialLike, vs, deg::Union{Int, Val}=1)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/differentiation

Differentiate `deg` times the polynomial `p` by the variables in `vs` and return an array of derivatives.

```APIDOC
## Function Signature
differentiate(p::AbstractPolynomialLike, vs, deg::Union{Int, Val}=1)

### Description
Differentiate `deg` times the polynomial `p` by the variables of the vector or tuple of variable `vs` and return an array of dimension `deg`. It is recommended to pass `deg` as a `Val` instance when the degree is known at compile time, e.g. `differentiate(p, v, Val{2}())` instead of `differentiate(p, x, 2)`, as this will help the compiler infer the return type.

### Parameters
- **p** (AbstractPolynomialLike) - The polynomial to differentiate.
- **vs** (Vector or Tuple of AbstractVariable) - The variables with respect to which to differentiate.
- **deg** (Int or Val) - The number of times to differentiate. Defaults to 1.

### Examples
```julia
p = 3x^2*y + x + 2y + 1
differentiate(p, (x, y)) # should return [6xy+1, 3x^2+1]
```
```

--------------------------------

### Get Leading Monomial of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the monomial part of the leading term of a polynomial. This is equivalent to the last monomial when terms are ordered.

```julia
leading_monomial(p::AbstractPolynomialLike)
```

--------------------------------

### Get Leading Coefficient of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the coefficient of the leading term of a polynomial. Handles the case of a zero polynomial by returning 0.

```julia
leading_coefficient(p::AbstractPolynomialLike)
```

--------------------------------

### monic

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns a monic version of the polynomial.

```APIDOC
## monic

### Description
Returns `p / leading_coefficient(p)` where the leading coefficient of the returned polynomials is made sure to be exactly one to avoid rounding error.

### Parameters
- `p` (AbstractPolynomialLike): The polynomial.
```

--------------------------------

### Get Minimum Degree of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the minimum degree of a polynomial or a vector of polynomials. This is useful for analyzing the structure of polynomial expressions.

```julia
mindegree(p::Union{AbstractPolynomialLike, AbstractVector{<:AbstractPolynomialLike}})
```

--------------------------------

### Reverse{O<:AbstractMonomialOrdering}

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Represents a Reverse monomial ordering, reversing the order of another ordering.

```APIDOC
## Type: Reverse{O<:AbstractMonomialOrdering}

### Description
Monomial ordering defined by `cmp(o::Reverse, a, b) where {O} = cmp(o.reverse_order, b, a)`.
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}}`.

### References
[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**.

### Signature
`struct Reverse{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
    reverse_order::O
end`
```

--------------------------------

### Division with Multiple Divisors

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Finds a quotient vector and a remainder for division by multiple divisors.

```APIDOC
## div(p, d)

### Description
Given a polynomial `p` and a vector of divisors `d = [d1, ..., dn]`, returns a vector `[q1, ..., qn]` such that `p = q1*d1 + ... + qn*dn + r`, and none of the leading terms of `q1, ..., qn` divide the leading term of `r`.

### Method
`div(p, d)`

### Parameters
- `p`: The dividend polynomial.
- `d`: A vector of divisor polynomials `[d1, ..., dn]`.

### Returns
A vector `[q1, ..., qn]` of quotient polynomials.

## rem(p, d)

### Description
Given a polynomial `p` and a vector of divisors `d = [d1, ..., dn]`, returns the remainder `r` such that `p = q1*d1 + ... + qn*dn + r`.

### Method
`rem(p, d)`

### Parameters
- `p`: The dividend polynomial.
- `d`: A vector of divisor polynomials `[d1, ..., dn]`.

### Returns
The remainder polynomial `r`.

## divrem(p, d)

### Description
Given a polynomial `p` and a vector of divisors `d = [d1, ..., dn]`, returns a tuple `(q, r)` where `q` is the vector of quotient polynomials `[q1, ..., qn]` and `r` is the remainder polynomial.

### Method
`divrem(p, d)`

### Parameters
- `p`: The dividend polynomial.
- `d`: A vector of divisor polynomials `[d1, ..., dn]`.

### Returns
A tuple `(q, r)` where `q` is the vector of quotient polynomials and `r` is the remainder polynomial.
```

--------------------------------

### Get Term Type of a Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the type of the terms of a polynomial. Overloads are provided for polynomial types and for specifying a coefficient type.

```julia
term_type(p::AbstractPolynomialLike)

```

```julia
term_type(::Type{PT}) where PT<:AbstractPolynomialLike

```

```julia
term_type(p::AbstractPolynomialLike, ::Type{T}) where T

```

```julia
term_type(::Type{PT}, ::Type{T}) where {PT<:AbstractPolynomialLike, T}

```

--------------------------------

### Get Monomial Ordering Type for a Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the AbstractMonomialOrdering type used for comparing exponent vectors of a polynomial's monomials.

```julia
ordering(p::AbstractPolynomialLike)::Type{<:AbstractMonomialOrdering}
```

--------------------------------

### GCD of Polynomials (Julia)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Provides the function signature for computing the greatest common divisor of two polynomials. The implementation uses a generalized Euclidean algorithm to handle potential non-termination issues with standard Euclidean division for multivariate polynomials.

```julia
function gcd(p1::AbstractPolynomialLike{T}, p2::AbstractPolynomialLike{S}) where {T, S}
```

--------------------------------

### Constant and Zero Terms

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Functions for creating constant and zero terms.

```APIDOC
## Function: constant_term

`constant_term(α, p::AbstractPolynomialLike)`

Creates a constant term with coefficient α and the same variables as p.

`constant_term(α, ::Type{PT} where {PT<:AbstractPolynomialLike}`

Creates a constant term of the term type of a polynomial of type `PT`.
```

```APIDOC
## Function: zero_term

`zero_term(p::AbstractPolynomialLike{T}) where T`

Equivalent to `constant_term(zero(T), p)`.

`zero_term(α, ::Type{PT} where {T, PT<:AbstractPolynomialLike{T}}`

Equivalent to `constant_term(zero(T), PT)`.
```

--------------------------------

### Get Monomial Type of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the type of monomials for a given polynomial or polynomial type. Useful for ensuring type consistency.

```julia
monomial_type(p::AbstractPolynomialLike)
```

```julia
monomial_type(::Type{PT}) where PT<:AbstractPolynomialLike
```

--------------------------------

### differentiate(p::AbstractArray{<:AbstractPolynomialLike, N}, vs, deg::Union{Int, Val}=1) where N

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/differentiation

Differentiate polynomials in an array `p` by variables in `vs` and return an array of derivatives.

```APIDOC
## Function Signature
differentiate(p::AbstractArray{<:AbstractPolynomialLike, N}, vs, deg::Union{Int, Val}=1) where N

### Description
Differentiate the polynomials in `p` by the variables of the vector or tuple of variable `vs` and return an array of dimension `N+deg`. If `p` is an `AbstractVector` this returns the Jacobian of `p` where the i-th row containts the partial derivaties of `p[i]`.

### Parameters
- **p** (AbstractArray{<:AbstractPolynomialLike, N}) - An array of polynomials to differentiate.
- **vs** (Vector or Tuple of AbstractVariable) - The variables with respect to which to differentiate.
- **deg** (Int or Val) - The number of times to differentiate. Defaults to 1.

### Examples
```julia
differentiate( [x^2+y, z^2+4x], [x, y, z]) # should return [2x 1 0; 4 0 2z]
```
```

--------------------------------

### name

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the name of a variable.

```APIDOC
## Function

`MultivariatePolynomials.name` — Function

```
name(v::AbstractVariable)::AbstractString
```

Returns the name of a variable.
```

--------------------------------

### Macro for Similar Variable Creation

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

A macro that simplifies creating a similar variable and binding it to a variable name. It calls `similar_variable` with `Val{variable}`.

```julia
@similar_variable(p::AbstractPolynomialLike, variable)
```

--------------------------------

### Get Coefficient of a Term or Monomial in a Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the coefficient of a term or a specific monomial within a polynomial. If the monomial is not present, it returns 0.

```julia
coefficient(t::AbstractTermLike)

```

```julia
coefficient(p::AbstractPolynomialLike, m::AbstractMonomialLike)

```

--------------------------------

### Get Leading Term of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the leading term of a polynomial, which is the last term when terms are ordered. This is often used in polynomial reduction algorithms.

```julia
leading_term(p::AbstractPolynomialLike)
```

--------------------------------

### ExponentsIterator

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

An iterator for generating monomial exponents based on a specified monomial ordering.

```APIDOC
## Type: ExponentsIterator{M}

### Description
An iterator for generating monomial exponents for monomial ordering `M`. The type of the vector of exponents is the type of `object` and is length (i.e., the number of variables) is `length(object)`.
Note that `object` does not have to be zero, it just needs to implement `copy` and `setindex!` methods (except for `Tuple` which we handle with a special case).
See also `monomials`.

### Examples
The following example shows how to generate all exponents of monomials of 2 variables up to degree 2.
```julia
collect(ExponentsIterator{Graded{LexOrder}}((0, 0), maxdegree = 2))
```

Note that you can easily generate the tuple of exponents of arbitrary length using `ntuple` as follows:
```julia
collect(ExponentsIterator{Graded{LexOrder}}(ntuple(zero, 3), mindegree = 2, maxdegree = 2))
```

### Signature
```julia
struct ExponentsIterator{M}(
    object;
    mindegree::Int = 0,
    maxdegree::Union{Nothing,Int} = nothing,
    inline::Bool = false,
)
```
```

--------------------------------

### Get Maximum Total Degree of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the maximal total degree of the monomials of a polynomial. Use when you need the largest degree present in the polynomial.

```julia
maxdegree(p::Union{AbstractPolynomialLike, AbstractVector{<:AbstractTermLike}})
```

--------------------------------

### Extract Primitive Part and Content of Polynomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Efficiently returns both the primitive part and the content of a polynomial over a unique factorization domain. This is more efficient than calling `primitive_part` and `content` separately.

```julia
primitive_part_content(poly::AbstractPolynomialLike{T}, algo::AbstractUnivariateGCDAlgorithm) where {T}
```

--------------------------------

### Pseudo Divisor and Remainder

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Calculates the pseudo quotient and remainder of polynomial division, useful when coefficients are not fields.

```APIDOC
## pseudo_divrem(f, g, algo)

### Description
Returns the pseudo quotient and remainder of polynomial `f` modulo polynomial `g` as defined in Knuth's 'Art of Computer Programming', Volume 2, Algorithm R, p. 425. This operation is defined as `l*f = q*g + r`, where `l` is a power of the leading coefficient of `g`.

### Method
`pseudo_divrem(f::_APL{S}, g::_APL{T}, algo) where {S,T}`

### Parameters
- `f`: The dividend polynomial.
- `g`: The divisor polynomial.
- `algo`: The algorithm to use.

### Returns
A tuple `(q, r)` where `q` is the pseudo quotient and `r` is the pseudo remainder.
```

--------------------------------

### Compute GCD of Primitive Polynomials

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Computes the GCD of primitive polynomials p and q using a specified algorithm. The function may modify the input polynomials.

```julia
primitive_univariate_gcd!(p::_APL, q::_APL, algo::AbstractUnivariateGCDAlgorithm)
```

--------------------------------

### Define Reverse Monomial Ordering

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Defines a reverse monomial ordering by reversing the comparison of a specified underlying ordering. For example, `Reverse{InverseLexOrder}` yields 'rinvlex'.

```julia
struct Reverse{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
    reverse_order::O
end
```

--------------------------------

### Polynomial Division and Remainder

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Calculates the quotient and remainder of polynomial division. For polynomials `p` and `d`, finds `q` and `r` such that `p = qd + r`, where the leading term of `d` does not divide the leading term of `r`.

```APIDOC
## div(p, d)

### Description
Returns the quotient `q` of the division of polynomial `p` by polynomial `d`.

### Method
`div(p, d)`

### Parameters
- `p`: The dividend polynomial.
- `d`: The divisor polynomial.

### Returns
The quotient polynomial `q`.

## rem(p, d)

### Description
Returns the remainder `r` of the division of polynomial `p` by polynomial `d`.

### Method
`rem(p, d)`

### Parameters
- `p`: The dividend polynomial.
- `d`: The divisor polynomial.

### Returns
The remainder polynomial `r`.

## divrem(p, d)

### Description
Returns a tuple `(q, r)` containing the quotient `q` and remainder `r` of the division of polynomial `p` by polynomial `d`.

### Method
`divrem(p, d)`

### Parameters
- `p`: The dividend polynomial.
- `d`: The divisor polynomial.

### Returns
A tuple `(q, r)` where `q` is the quotient and `r` is the remainder.
```

--------------------------------

### Create Monomial from Variables and Exponents

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Constructs a monomial by multiplying variables raised to specified exponents. Usage differs slightly between DynamicPolynomials and TypedPolynomials.

```julia
monomial(variables, exponents)

```

--------------------------------

### Get Coefficient of a Monomial

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the coefficient of a specific monomial within a polynomial, considering a given set of variables. Useful for isolating specific term coefficients.

```julia
coefficient(p::AbstractPolynomialLike, m::AbstractMonomialLike, vars)::AbstractPolynomialLike
```

--------------------------------

### AbstractMonomialOrdering

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Abstract type for monomial ordering. Defines comparison logic for exponent vectors.

```APIDOC
## Type: AbstractMonomialOrdering

### Description
Abstract type for monomial ordering as defined in [CLO13, Definition 2.2.1, p. 55].
Given an ordering `ordering::AbstractMonomialOrdering` and vector of exponents `e1` and `e2`, `cmp(ordering, e1, e2)` returns a negative number if `e1` is before `e2` in the ordering, a positive number if `e2` is before `e1` and 0 if they are equal. For convenience, `ordering(e1, e2)` returns a `Bool` indicating whether `cmp(ordering, e1, e2)` is negative.

### References
[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**.
```

--------------------------------

### Conditional Remainder Calculation

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Use `rem_or_pseudo_rem` to get the remainder of `f` modulo `g`. It returns `rem` if the coefficient type is a field, otherwise it returns `pseudo_rem`.

```julia
rem_or_pseudo_rem(f::_APL, g::_APL, algo)
```

--------------------------------

### Create Similar Variable (Symbol)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Creates a new variable based on a source polynomial and a symbol. Note that this can lead to type instabilities.

```julia
similar_variable(p::AbstractPolynomialLike, v::Symbol)
```

--------------------------------

### content

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Returns the content of a polynomial, which is the GCD of its coefficients over a unique factorization domain.

```APIDOC
## content

### Description
Return the _content_ of the polynomial `poly` over a unique factorization domain `S` as defined in [Knu14, (3) p. 423]. That is, return the `gcd` of the coefficients of `poly`. See also `primitive_part_content`.
The output can be mutated without affecting `poly` if `mutability` is `MA.IsNotMutable`.
[Knu14] Knuth, D.E., 2014. _Art of computer programming, volume 2: Seminumerical algorithms._ Addison-Wesley Professional. Third edition.

### Function Signature
```julia
content(poly::AbstractPolynomialLike{T}, algo::AbstractUnivariateGCDAlgorithm, mutability::MA.MutableTrait) where {T}
```
```

--------------------------------

### Compare Polynomials by Monomial Ordering

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Compares two elements based on a specified monomial ordering. Deprecated; use `cmp(order(), a, b)` instead.

```julia
compare(a, b, order::Type{<:AbstractMonomialOrdering})
```

--------------------------------

### Get Maximum Degree in a Variable

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the maximal degree of the monomials of a polynomial with respect to a specific variable. Useful for analyzing the polynomial's behavior along a single dimension.

```julia
maxdegree(p::Union{AbstractPolynomialLike, AbstractVector{<:AbstractTermLike}}, v::AbstractVariable)
```

--------------------------------

### Term Creation and Manipulation

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Functions for creating and converting terms.

```APIDOC
## Function: term

`term(coef, mono::AbstractMonomialLike)`

Returns a term with coefficient `coef` and monomial `mono`. There are two key difference between this and `coef * mono`:
  * `term(coef, mono)` does not copy `coef` and `mono` so modifying this term with MutableArithmetics may modifying the input of this function. To avoid this, call `term(MA.copy_if_mutable(coef), MA.copy_if_mutable(mono))` where `MA = MutableArithmetics`.
  * Suppose that `coef = (x + 1)` and `mono = x^2`, `coef * mono` gives the polynomial with integer coefficients `x^3 + x^2` which `term(x + 1, x^2)` gives a term with polynomial coefficient `x + 1`.

`term(p::AbstractPolynomialLike)`

Converts the polynomial `p` to a term. When applied on a polynomial, it throws an `InexactError` if it has more than one term. When applied to a term, it is the identity and does not copy it. When applied to a monomial, it create a term of type `AbstractTerm{Int}`.
```

--------------------------------

### terms

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns an iterator over the nonzero terms of a polynomial, sorted in decreasing monomial order.

```APIDOC
## terms

### Description
Returns an iterator over the nonzero terms of the polynomial `p` sorted in the decreasing monomial order.

### Signature
```julia
terms(p::AbstractPolynomialLike)
```

### Example
Calling `terms` on 4x2y+xy+2x4x^2y + xy + 2x4x2y+xy+2x should return an iterator of [x2y,xy,x].
```

--------------------------------

### Create Monomial Vector with Coefficients

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Generates a sorted vector of unique monomials and a corresponding vector of coefficients. Coefficients of duplicate monomials are summed.

```julia
monomial_vector(a, X::AbstractVector{MT}) where {MT<:AbstractMonomialLike}
```

--------------------------------

### primitive_part_content

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Efficiently computes both the primitive part and the content of a polynomial.

```APIDOC
## primitive_part_content

### Description
Return the _primitive part_ and _content_ of the polynomial `poly` over a unique factorization domain `S` as defined in [Knu14, (3) p. 423]. This is more efficient to call this function rather than calling `primitive_part` and `content` separately since computing the primitive part requires computing the content first and this function avoid computing the content twice.
[Knu14] Knuth, D.E., 2014. _Art of computer programming, volume 2: Seminumerical algorithms._ Addison-Wesley Professional. Third edition.

### Function Signature
```julia
primitive_part_content(poly::AbstractPolynomialLike{T}, algo::AbstractUnivariateGCDAlgorithm) where {T}
```
```

--------------------------------

### Get Extremal Degrees in a Variable

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns a tuple containing the minimal and maximal degrees of the monomials in a polynomial with respect to a specific variable. Useful for analyzing the degree range along a single dimension.

```julia
extdegree(p::Union{AbstractPolynomialLike, AbstractVector{<:AbstractPolynomialLike}}, v::AbstractVariable)
```

--------------------------------

### Caution with partial evaluation syntax

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/substitution

Avoid using the evaluation syntax `p(variable => value)` when only substituting some variables, as it can lead to incorrect results with `DynamicPolynomials` by assuming a full evaluation and thus an `Int` return type.

```julia
p(y => 2) # Do not do that, this works fine with TypedPolynomials but it will not return a correct result with DynamicPolynomials since it thinks that the return type is `Int`.
```

--------------------------------

### Get Original Variable

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Given a transformed variable (conjugate, real part, or imaginary part), this function returns the original user-defined variable. It is the inverse of transformations like `conj`, `real`, and `imag`.

```julia
ordinary_variable(x::Union{AbstractVariable, AbstractVector{<:AbstractVariable}})
```

--------------------------------

### map_exponents

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

If m1=∏xαim1 = ∏xαi and m2=∏xβim2 = ∏xβi then it returns the monomial m=∏xf(αi,βi)m = ∏xf(αi,βi).

```APIDOC
## Function `MultivariatePolynomials.map_exponents`

```
map_exponents(f, m1::AbstractMonomialLike, m2::AbstractMonomialLike)
```

If m1=∏xαim1 = \prod x^{\alpha_i}m1 = ∏xαi and m2=∏xβim2 = \prod x^{\beta_i}m2 = ∏xβi then it returns the monomial m=∏xf(αi,βi)m = \prod x^{f(\alpha_i, \beta_i)}m = ∏xf(αi,βi).

**Examples**
The multiplication `m1 * m2` is equivalent to `map_exponents(+, m1, m2)`, the unsafe division `div_multiple(m1, m2)` is equivalent to `map_exponents(-, m1, m2)`, `gcd(m1, m2)` is equivalent to `map_exponents(min, m1, m2)`, `lcm(m1, m2)` is equivalent to `map_exponents(max, m1, m2)`.
```

--------------------------------

### differentiate(p::AbstractPolynomialLike, v::AbstractVariable, deg::Union{Int, Val}=1)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/differentiation

Differentiate `deg` times the polynomial `p` by the variable `v`.

```APIDOC
## Function Signature
differentiate(p::AbstractPolynomialLike, v::AbstractVariable, deg::Union{Int, Val}=1)

### Description
Differentiate `deg` times the polynomial `p` by the variable `v`.

### Parameters
- **p** (AbstractPolynomialLike) - The polynomial to differentiate.
- **v** (AbstractVariable) - The variable with respect to which to differentiate.
- **deg** (Int or Val) - The number of times to differentiate. Defaults to 1.

### Examples
```julia
p = 3x^2*y + x + 2y + 1
differentiate(p, x) # should return 6xy + 1
differentiate(p, x, Val{1}()) # equivalent to the above
```
```

--------------------------------

### similar_variable

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Creates a new variable based on a source polynomial and a variable identifier.

```APIDOC
## Function

`MultivariatePolynomials.similar_variable` — Function

```
similar_variable(p::AbstractPolynomialLike, variable::Type{Val{V}})
```

Creates a new variable `V` based upon the the given source polynomial.

```
similar_variable(p::AbstractPolynomialLike, v::Symbol)
```

Creates a new variable based upon the given source polynomial and the given symbol `v`. Note that this can lead to type instabilities.

**Examples**
Calling `similar_variable(typedpoly, Val{:x})` on a polynomial created with `TypedPolynomials` results in `TypedPolynomials.Variable{:x}`.
```

--------------------------------

### MultivariatePolynomials.subs

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/substitution

Applies substitutions to a polynomial. Use p(s...) if all variables are substituted.

```APIDOC
## Function: MultivariatePolynomials.subs

### Description
Applies a set of substitutions to a given polynomial.

### Syntax
```julia
subs(p, s::AbstractSubstitution...)
```

### Parameters
- `p`: The polynomial to perform substitution on.
- `s`: One or more substitution rules.

### Substitution Rules
- `v => poly`: Replace variable `v` with polynomial `poly`.
- `(vars) => (polys)`: Replace a tuple/vector of variables `vars` with a tuple/vector of polynomials `polys`. Note: Direct tuple/vector substitution is not recommended due to potential ordering issues. Use `p(variables(p) => (1, 2))` for guaranteed order if needed.

### Examples
```julia
# Example polynomial
p = 3x^2*y + x + 2y + 1

# Full evaluation (all variables substituted)
subs(p, x => 2, y => 1) # Returns an Int

# Partial substitution
subs(p, y => x*y^2 + 1)

# Substitution with tuple of variables and polynomials (equivalent to individual substitutions)
subs(polynomial, (x, y)=>(1, 2))
subs(polynomial, (x=>1, y=>2))
```
```

--------------------------------

### promote_variables_with_maps

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Given two sorted variable collections `a` and `b`, this function returns a tuple containing the merged sorted variable set and mapping information for each input collection.

```APIDOC
## promote_variables_with_maps

### Description
Given two sorted variable collections `a` and `b`, return `((all_vars, map_a), (all_vars, map_b))` where `all_vars` is the merged sorted variable set and `map_a` (resp. `map_b`) is an `ExponentMap` that maps exponents from `a` (resp. `b`) to exponents in `all_vars`, or `nothing` if no mapping is needed.

### Function Signature
`promote_variables_with_maps(a, b)`
```

--------------------------------

### real

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Returns the real part of a vector of monomials.

```APIDOC
## real

### Description
Return the real part of `x` by applying `real` to all monomials; for this purpose, every complex-valued variable is decomposed into its real- and imaginary parts. Note that the result will no longer be a monomial vector.

### Signature
```julia
real(x::AbstractVector{<:AbstractMonomial})
```

### See Also
`imag`
```

--------------------------------

### map_coefficients_to!

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Mutates a target polynomial by applying a function to each coefficient of a source polynomial. Similar to `map_coefficients!`, terms with zero coefficients are dropped, and a `nonzero` flag can optimize performance. The function returns the mutated target polynomial.

```APIDOC
## map_coefficients_to!

### Description
Mutate `output` by replacing each coefficient `α` of `p` by `f(α)`. The function may return zero in which case the term is dropped. If the function is known to never returns zero for a nonzero input, `nonzero` can be set to `true` to get a small speedup. The function returns `output`, which is identically equal to the first argument.

### Method
`map_coefficients_to!(output::AbstractPolynomialLike, f::Function, p::AbstractPolynomialLike, nonzero = false)`

### See also
`map_coefficients!` and `map_coefficients`.
```

--------------------------------

### lcm(m1::AbstractMonomialLike, m2::AbstractMonomialLike)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Return the smallest monomial `m` such that both `divides(m1, m)` and `divides(m2, m)` are true.

```APIDOC
## lcm(m1::AbstractMonomialLike, m2::AbstractMonomialLike)

### Description
Return the smallest monomial `m` such that both `divides(m1, m)` and `divides(m2, m)` are true.

### Example
```julia
@polyvar x y z;
lcm(x^2*y^7*z^3, x^4*y^5*z^2)
```

### Response
```
x^4*y^7*z^3
```
```

--------------------------------

### gcd(m1::AbstractMonomialLike, m2::AbstractMonomialLike)

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/division

Returns the largest monomial `m` such that both `divides(m, m1)` and `divides(m, m2)` are true.

```APIDOC
## gcd(m1::AbstractMonomialLike, m2::AbstractMonomialLike)

### Description
Returns the largest monomial `m` such that both `divides(m, m1)` and `divides(m, m2)` are true.

### Example
```julia
@polyvar x y z;
gcd(x^2*y^7*z^3, x^4*y^5*z^2)
```

### Response
```
x²y⁵z²
```
```

--------------------------------

### Graded{O<:AbstractMonomialOrdering}

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Represents a Graded monomial ordering, where degree is the primary sorting criterion.

```APIDOC
## Type: Graded{O<:AbstractMonomialOrdering}

### Description
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)`.

### Signature
`struct Graded{O<:AbstractMonomialOrdering} <: AbstractMonomialOrdering
    same_degree_ordering::O
end`
```

--------------------------------

### Create Zero Term

Source: https://juliaalgebra.github.io/MultivariatePolynomials.jl/stable/types

Generates a zero term, equivalent to `constant_term(zero(T), p)` or `constant_term(zero(T), PT)`. T is the coefficient type and PT is the polynomial type.

```julia
zero_term(p::AbstractPolynomialLike{T}) where T

```

```julia
zero_term(α, ::Type{PT} where {T, PT<:AbstractPolynomialLike{T}})

```
Tokens:
Raw