Action polynomial rings

gen(A::ActionPolyRing, i::Int, jet::Vector{Int})

Return the jet variable of the action polynomial ring A specified by i and jet. If this jet variable was untracked, it is tracked afterwards. The jet variable may also be specified by a tuple, see Specifying jet variables. Additionally, the jet variable may also be specified by an integer but the corresponding method gen(A::ActionPolyRing, i::Int) slightly differs in its functionality, as it cannot create new jet variables.

Examples

julia> dpr = differential_polynomial_ring(ZZ, [:a, :b, :c], 4)[1]; gen(dpr, 1, [3,1,0,0])
a[3,1,0,0]

julia> gen(dpr, (1, [3,2,0,0]))
a[3,2,0,0]

julia> gens(dpr)
5-element Vector{DifferentialPolyRingElem{ZZRingElem}}:
 a[3,2,0,0]
 a[3,1,0,0]
 a[0,0,0,0]
 b[0,0,0,0]
 c[0,0,0,0]

getindex(A::ActionPolyRing, i::Int, jet::Vector{Int})

Alias for gen(A, i, jet).

gens(A::ActionPolyRing, jet_idxs::Vector{Tuple{Int, Vector{Int}}})

Return the jet variables of the action polynomial ring A specified by the entries of jet_idxs as a vector and track all new jet variables.

Examples

julia> dpr = differential_polynomial_ring(ZZ, [:a, :b, :c], 4)[1]; gens(dpr, [(1, [3,1,0,0]), (1, [3,2,0,0])])
2-element Vector{DifferentialPolyRingElem{ZZRingElem}}:
 a[3,1,0,0]
 a[3,2,0,0]

julia> gens(dpr)
5-element Vector{DifferentialPolyRingElem{ZZRingElem}}:
 a[3,2,0,0]
 a[3,1,0,0]
 a[0,0,0,0]
 b[0,0,0,0]
 c[0,0,0,0]

gen(A::ActionPolyRing, i::Int)

Among the currently tracked jet variables of A, return the i-th largest one.

Examples

julia> dpr = difference_polynomial_ring(ZZ, [:a, :b, :c], 4)[1]; gen(dpr, 2)
b[0,0,0,0]

julia> set_ranking!(dpr; partition = [[0,1,1],[1,0,0]]); gen(dpr, 2)
c[0,0,0,0]

gens(A::ActionPolyRing)

Return the currently tracked jet variables of the action polynomial ring A as a vector. The jet variables are sorted with respect to the ranking of A, leading with the largest jet variable.

Examples

julia> dpr = difference_polynomial_ring(ZZ, [:a, :b, :c], 4)[1]; gens(dpr)
3-element Vector{DifferencePolyRingElem{ZZRingElem}}:
 a[0,0,0,0]
 b[0,0,0,0]
 c[0,0,0,0]

julia> set_ranking!(dpr; partition = [[0,1,1],[1,0,0]]); gens(dpr)
3-element Vector{DifferencePolyRingElem{ZZRingElem}}:
 b[0,0,0,0]
 c[0,0,0,0]
 a[0,0,0,0]

julia> gens(dpr, [(1, [1,1,1,1]), (2, [1,1,1,1])]);

julia> gens(dpr)
5-element Vector{DifferencePolyRingElem{ZZRingElem}}:
 b[1,1,1,1]
 b[0,0,0,0]
 c[0,0,0,0]
 a[1,1,1,1]
 a[0,0,0,0]

is_gen(p::ActionPolyRingElem)

Return true if p is a jet variable in an action polynomial ring.

var_index(p::ActionPolyRingElem)

Return the integer i such that p is the i-th largest currently tracked jet variable. If p is not a jet variable an exception is raised.

vars(p::ActionPolyRingElem; sorted::Bool=true)

Return the jet variables actually occurring in p as a vector. If sorted is true (the default), the jet variables are sorted with respect to the ranking of the action polynomial ring containing p, leading with the largest jet variable.

leader(p::ActionPolyRingElem)

Return the leader of the polynomial p, that is the largest jet variable with respect to the ranking of parent(p). If p is a nonzero constant, then the multiplicative identity of parent(p) is returned. If p is the zero polynomial, an error is raised.

getindex(var::ActionPolyRingElem, index_shift::Int...)

Given the jet variable var, return the jet variable with jet shifted by index_shift.

Examples

julia> R, u = difference_polynomial_ring(QQ, :u, 2);

julia> u[0,0]
u[0,0]

julia> u_45 = u[4,5]
u[4,5]

julia> u_45[1,0]
u[5,5]

julia> u_45[-3, -2]
u[1,3]

zero(A::ActionPolyRing)

Return the zero element of the action polynomial ring A.

one(A::ActionPolyRing)

Return the multiplicative identity of the action polynomial ring A.

n_action_indeterminates(A::ActionPolyRing) -> Int

Return the number of action indeterminates of the action polynomial ring A.

action_indeterminates(A::ActionPolyRing) -> Vector{Symbol}

Return the action indeterminates of the action polynomial ring A as a vector.

n_action_maps(A::ActionPolyRing) -> Int

Return the number of action indeterminates of the action polynomial ring A.

coefficients(p::ActionPolyRingElem)

Return an iterator for the coefficients of p with respect to the ranking of the parent of p.

Examples

julia> dpr, (a,b,c) = difference_polynomial_ring(ZZ, [:a, :b, :c], 4; partition = [[0,1,1],[1,0,0]]); f = -2*a*b + a*c + 3*b^2;

julia> cf = coefficients(f)
Coefficients iterator of 3*b[0,0,0,0]^2 - 2*a[0,0,0,0]*b[0,0,0,0] + c[0,0,0,0]*a[0,0,0,0]

julia> collect(cf)
3-element Vector{ZZRingElem}:
  3
 -2
  1

exponents(p::ActionPolyRingElem)

Return an iterator for the exponents of p with respect to the ranking of the parent of p.

Examples

julia> dpr, (a,b,c) = difference_polynomial_ring(ZZ, [:a, :b, :c], 4; partition = [[0,1,1],[1,0,0]]); f = -2*a*b + a*c + 3*b^2;

julia> ef = exponents(f)
Exponents iterator of 3*b[0,0,0,0]^2 - 2*a[0,0,0,0]*b[0,0,0,0] + c[0,0,0,0]*a[0,0,0,0]

julia> collect(ef)
3-element Vector{Vector{Int64}}:
 [2, 0, 0]
 [1, 0, 1]
 [0, 1, 1]

monomials(p::ActionPolyRingElem)

Return an iterator for the monomials of p with respect to the ranking of the parent of p.

Examples

julia> dpr, (a,b,c) = difference_polynomial_ring(ZZ, [:a, :b, :c], 4; partition = [[0,1,1],[1,0,0]]); f = -2*a*b + a*c + 3*b^2;

julia> mf = monomials(f)
Monomials iterator of 3*b[0,0,0,0]^2 - 2*a[0,0,0,0]*b[0,0,0,0] + c[0,0,0,0]*a[0,0,0,0]

julia> collect(mf)
3-element Vector{DifferencePolyRingElem{ZZRingElem}}:
 b[0,0,0,0]^2
 a[0,0,0,0]*b[0,0,0,0]
 a[0,0,0,0]*c[0,0,0,0]

terms(p::ActionPolyRingElem)

Return an iterator for the terms of p with respect to the ranking of the parent of p.

Examples

julia> dpr, (a,b,c) = difference_polynomial_ring(ZZ, [:a, :b, :c], 4; partition = [[0,1,1],[1,0,0]]); f = -2*a*b + a*c + 3*b^2;

julia> tf = terms(f)
Terms iterator of 3*b[0,0,0,0]^2 - 2*a[0,0,0,0]*b[0,0,0,0] + c[0,0,0,0]*a[0,0,0,0]

julia> collect(tf)
3-element Vector{DifferencePolyRingElem{ZZRingElem}}:
 3*b[0,0,0,0]^2
 -2*a[0,0,0,0]*b[0,0,0,0]
 a[0,0,0,0]*c[0,0,0,0]

coeff(p::ActionPolyRingElem, i::Int)

Return coefficient of the i-th term of p.

exponent_vector(p::ActionPolyRingElem, i::Int)

Return the exponent vector of the i-th term of p.

monomial(p::ActionPolyRingElem, i::Int)

Return the i-th monomial of p.

term(p::ActionPolyRingElem, i::Int)

Return the i-th term of p.

leading_coefficient(p::ActionPolyRingElem{T}) -> T

Return the leading coefficient of the polynomial p, i.e. the coefficient of the first (with respect to the ranking of the action polynomial ring containing it) nonzero term.

leading_monomial(p::ActionPolyRingElem)

Return the leading monomial of the polynomial p with respect to the ranking of the action polynomial ring containing it.

leading_term(p::ActionPolyRingElem)

Return the leading term of the polynomial p with respect to the ranking of the action polynomial ring containing it.

trailing_coefficient(p::MPolyRingElem)

Return the trailing coefficient of the polynomial $p$, i.e. the coefficient of the last nonzero term.

trailing_coefficient(p::ActionPolyRingElem{T}) -> T

Return the trailing coefficient of the polynomial p, i.e. the coefficient of the last (with respect to the ranking of the action polynomial ring containing it) nonzero term, or zero if the polynomial is zero.

trailing_monomial(p::ActionPolyRingElem)

Return the trailing monomial of the polynomial p with respect to the ranking of the action polynomial ring containing it.

trailing_term(p::ActionPolyRingElem)

Return the leading term of the polynomial p with respect to the ranking of the action polynomial ring containing it.

is_monomial(p::ActionPolyRingElem)

Return true if p is a monomial and false otherwise.

is_term(p::ActionPolyRingElem)

Return true if p is a term, i.e. a non-zero multiple of a monomial, and false otherwise.

initial(p::ActionPolyRingElem)

Return the initial of the polynomial p, i.e. the leading coefficient of p regarded as a univariate polynomial in its leader. If p is a nonzero constant, p itself is returned. If p is the zero polynomial, an error is raised.

length(p::ActionPolyRingElem) -> Int

Return the length of p, i.e. the number of terms of p.

tail(p::ActionPolyRingElem)

Return the tail of p, i.e. p, i.e. return p without its leading term with respect to the ranking of the action polynomial ring containing it.

is_constant(p::ActionPolyRingElem)

Return true if p is a degree zero polynomial or the zero polynomial, i.e. a constant polynomial.

constant_coefficient(p::ActionPolyRingElem{T}) -> T

Return the constant coefficient of p. Does not throw an error for the zero polynomial like trailing_coefficient.

degree(p::ActionPolyRingElem, i::Int, jet::Vector{Int}) -> Int

Return the degree of the polynomial p in the jet variable specified by i and jet. If this jet variable is valid but still untracked, return $0$.

This method allows all versions described in Specifying jet variables; see the online documentation.

degrees(p::ActionPolyRingElem)

Return an array of the degrees of the polynomial p in terms of each jet variable. The jet variables are sorted with respect to the ranking of the action polynomial ring containing p, leading with the largest variable.

total_degree(p::ActionPolyRingElem) -> Int

Return the total degree of p.

derivative(p::ActionPolyRing, i::Int, jet::Vector{Int})

Return the derivative of p with respect to the jet variable specified by i and jet.

This method allows all versions described in Specifying jet variables; see the online documentation.

discriminant(p::ActionPolyRingElem)

Return the discriminant of p.

resultant(f::ActionPolyRingElem, g::ActionPolyRingElem, i::Int, jet::Vector{Int})

Return the resultant of f and g regarded as univariate polynomials in the jet variable specified by i and jet.

This method allows all versions described in Specifying jet variables; see the online documentation.

evaluate(a::ActionPolyRingElem{T}, vals::Vector{V}) where {T <: RingElement, V <: Ringelement}

Evaluate the polynomial expression by substituting in the supplied values in the array vals for each of the tracked jet variables. The evaluation will succeed if multiplication is defined between elements of the coefficient ring of a and elements of vals.

evaluate(a::ActionPolyRingElem{T}, vars::Vector{Int}, vals::Vector{V}) where {T <: RingElement, V <: Ringelement}

Evaluate the polynomial expression by substituting in the supplied values in the array vals for the corresponding jet variables specified by the indices given by the array vars; see Specifying jet variables. The evaluation will succeed if multiplication is defined between elements of the coefficient ring of a and elements of vals.

evaluate(a::ActionPolyRingElem, vars::Vector{ActionPolyRingElem}, vals::Vector{V}) where {V <: Ringelement}

Evaluate the polynomial expression by substituting in the supplied values in the array vals for the corresponding jet variables from the vector vars; see Specifying jet variables. The evaluation will succeed if multiplication is defined between elements of the coefficient ring of a and elements of vals.

is_univariate(p::ActionPolyRingElem)

Return true if p is a polynomial in a single jet variable and false otherwise.

to_univariate(R::PolyRing{T}, p::ActionPolyRingElem{T}) where {T <: RingElement}

Assuming the polynomial p is actually a univariate polynomial, convert the polynomial to a univariate polynomial in the given univariate polynomial ring R. An exception is raised if the polynomial p involves more than one jet variable.

to_univariate(p::ActionPolyRingElem)

Assuming the polynomial p is actually a univariate polynomial in the jet variable x, convert the polynomial to a univariate polynomial in a univariate polynomial ring over the same coefficient ring in the variable x. If p is constant, it is considered to be a polynomial in the largest tracked jet variable of its parent. An exception is raised if the polynomial p involves more than one jet variable.

univariate_coefficients(p::ActionPolyRingElem, i::Int, jet::Vector{Int})

Return the coefficient vector of p regarded as a univariate polynomial in the jet variable specified by i and jet, leading with the constant coefficient.

This method allows all versions described in Specifying jet variables; see the online documentation.

univariate_leading_coefficient(p::ActionPolyRingElem, i::Int, jet::Vector{Int})

Return the leading coefficient of p regarded as a univariate polynomial in the jet variable specified by i and jet. Note that in case where the jet variable coincides with the leader of p, this result is just the initial of p; see initial.

This method allows all versions described in Specifying jet variables; see the online documentation.

pseudorem(p::PolyT, q::PolyT, i::Int, jet::Vector{Int}) where {PolyT <: ActionPolyRingElem} -> PolyT

Return the algebraic pseudo-remainder of p divided by q with respect to the jet variable specified by i and jet. If no jet variable is specified then division is performed with respect to the leader of q, even allowing q to be a nonzero constant. This method performs division by using a lazy pre-multiplication by the initial of q at each step, only multiplying the remainder when necessary.

This method allows all versions described in Specifying jet variables; see the online documentation.

Examples

julia> dpr, (x, y) = differential_polynomial_ring(QQ, [:x, :y], 1); p, q = (x^2 + y, y*x + 1)
(x[0]^2 + y[0], y[0]*x[0] + 1)

julia> pseudorem(p, q, x)
y[0]^3 + 1

julia> pseudorem(p, q, y)
x[0]^3 - 1

Note that in this example, the leader of q is x, so it need not be specified for pseudo-division with respect to x:

julia> leader(q) == x
true

julia> pseudorem(p, q)
y[0]^3 + 1

Finally, the pseudoremainder of any polynomial with respect to a non-zero constant is always zero.

julia> pseudorem(p, dpr(1))
0

pseudodivrem(p::PolyT, q::PolyT, i::Int, jet::Vector{Int}) where {PolyT <: ActionPolyRingElem} -> Tuple{PolyT, PolyT}

Return the pair (s, r) where s is the pseudo-quotient and r is the pseudo-remainder of p by q with respect to the jet variable specified by i and jet. If no jet variable is specified then division is performed with respect to the leader of q, even allowing q to be a nonzero constant. The number of pre-multiplications by the leading coefficient of q in this jet variable is minimised, i.e. we have lc(q)^k * p = s * q + r where the integer k >= 0 is minimal and lc(q) is the above mentioned leading coefficient.

This method allows all versions described in Specifying jet variables; see the online documentation.

Examples

julia> dpr, (x, y) = differential_polynomial_ring(QQ, [:x, :y], 1); p, q = (x^2 + y, y*x + 1)
(x[0]^2 + y[0], y[0]*x[0] + 1)

julia> pseudodivrem(p, q, x)
(y[0]*x[0] - 1, y[0]^3 + 1)

julia> y^2 * p == (y*x - 1) * q + (y^3 + 1)
true

julia> pseudodivrem(p, q, y)
(1, x[0]^3 - 1)

julia> x * p == 1 * q + (x^3 - 1)
true

Note that in this example, the leader of q is x, so it need not be specified for pseudo-division with respect to x:

julia> leader(q) == x
true

julia> pseudodivrem(p, q)
(y[0]*x[0] - 1, y[0]^3 + 1)

Finally, if the second argument is a non-zero constant, then it depends on the first argument being divisible by said constant, whether the pseudo-quotient is the first argument divided by the second one or just the first argument. The pseudo-remainder is always equal to zero in this case.

julia> pseudodivrem(p, dpr(2))
(1//2*x[0]^2 + 1//2*y[0], 0)

is_partially_reduced(p::ActionPolyRingElem, q::ActionPolyRingElem)

Return true if the action polynomial p is partially reduced with respect to the nonzero action polynomial q.

is_reduced(p::ActionPolyRingElem, q::ActionPolyRingElem)

Return true if the polynomial p is fully reduced with respect to the non-constant polynomial q. This means p is partially reduced with respect to q, and the degree of p in the leader of q is strictly less than the degree of q in its leader.

partially_reduce(p::ActionPolyRingElem, q::ActionPolyRingElem)

Return the partial remainder of p with respect to the non-zero polynomial q, by performing successive pseudo-divisions of p by proper derivatives (or shifts) of q. This means that the returned polynomial has strictly smaller degree in each jet variable that is a proper derivative (or shift) of the leader of q. If q is a non-zero constant then the zero polynomial is returned.

reduce(p::ActionPolyRingElem, q::ActionPolyRingElem)

Return the full remainder of p with respect to the nonzero polynomial q. This remainder is reduced with respect to q in the sense that the degree of p in each derivative (or shift) of the leader of q is strictly smaller than the degree of the respective derivative (or shift) of q in that same jet variable. If q is a nonzero constant then the zero polynomial is returned.

is_partially_reduced(p::ActionPolyRingElem, S::Vector{<:ActionPolyRingElem})

Return true if p is partially reduced with respect to every element in the set S.

is_reduced(p::ActionPolyRingElem, S::Vector{<:ActionPolyRingElem})

Return true if p is fully reduced with respect to every element in the set S.

is_autoreduced(S::Vector{<:ActionPolyRingElem})

Return true if S is an autoreduced set. A set is autoreduced if every polynomial in the set is fully reduced with respect to all other polynomials in the set, and the set is sorted by Ritt ordering.

partially_reduce(p::ActionPolyRingElem, S::Vector{ActionPolyRingElem})

Partially reduce the action polynomial p with respect to the vector S. This is done by pre-sorting S with respect to Ritt ordering and then performing top-down partial reductions of p by the remaining elements of S until no further reductions are possible.

reduce(p::ActionPolyRingElem, S::Vector{ActionPolyRingElem})

Reduce the action polynomial p with respect to the vector S. This is done by pre-sorting S with respect to Ritt ordering and then performing top-down reductions of p by the elements of S until no further reductions are possible.

autoreduce(S::Vector{ActionPolyRingElem})

Compute an autoreduced set from the vector of action polynomials S. If at any point in the reduction process a nonzero constant is discovered, the vector containing just this constant is returned.