Differential polynomial rings

action_derivation(R::Ring)

Construct the zero derivation on the ring R.

action_derivation(m::Map{D, D}) where {D <: Ring}

Wrap the map m into an ActionDerivation. This does not check whether m is actually a derivation.

differential_polynomial_ring(R::Ring, action_indeterminates::Union{Vector{Symbol}, Int}, n_action_maps::Int) -> Tuple{DifferentialPolyRing, Vector{DifferentialPolyRingElem}}

Construct the differential polynomial ring over the coefficient ring R with the given action indeterminates and n_action_maps-many zero derivations.

• If action_indeterminates is a vector of symbols, those names are used.
• If it is an integer m, the symbols u1, …, um are generated automatically.

In both cases, the jet variables that are initially available are those with jet [0,…,0], one for each action indeterminate.

This method returns a tuple (dpr, gens) where dpr is the resulting differential polynomial ring and gens is the vector of initial jet variables.

This constructor also accepts all keyword arguments of set_ranking! to control the ranking.

Examples

julia> R, variablesR = differential_polynomial_ring(QQ, 3, 4)
(Differential polynomial ring in 3 action indeterminates over QQ, DifferentialPolyRingElem{QQFieldElem}[u1[0,0,0,0], u2[0,0,0,0], u3[0,0,0,0]])

julia> R
Differential polynomial ring in 3 action indeterminates u1, u2, u3
with 4 commuting derivations
  over rational field

julia> variablesR
3-element Vector{DifferentialPolyRingElem{QQFieldElem}}:
 u1[0,0,0,0]
 u2[0,0,0,0]
 u3[0,0,0,0]

julia> S, variablesS = differential_polynomial_ring(QQ, [:a, :b, :c], 4)
(Differential polynomial ring in 3 action indeterminates over QQ, DifferentialPolyRingElem{QQFieldElem}[a[0,0,0,0], b[0,0,0,0], c[0,0,0,0]])

julia> S
Differential polynomial ring in 3 action indeterminates a, b, c
with 4 commuting derivations
  over rational field

julia> variablesS
3-element Vector{DifferentialPolyRingElem{QQFieldElem}}:
 a[0,0,0,0]
 b[0,0,0,0]
 c[0,0,0,0]

differential_polynomial_ring(R::Ring, x::Symbol, n_action_maps::Int) -> Tuple{DifferentialPolyRing, DifferentialPolyRingElem}

This constructor behaves exactly like differential_polynomial_ring but only allows for one action indeterminate x instead of a vector of these. Consequently, this method returns the tuple (dpr, x[0,…,0]) where dpr is the resulting differential polynomial ring.

Examples

This constructor is preferred when one only wants to have one action indeterminate:

julia> R, x = differential_polynomial_ring(ZZ, :x, 2)
(Differential polynomial ring in 1 action indeterminates over ZZ, x[0,0])

julia> x
x[0,0]

If we instead construct this ring by passing the single action indeterminate as a vector, the variable x does not behave as intended:

julia> R, x = differential_polynomial_ring(ZZ, [:x], 2)
(Differential polynomial ring in 1 action indeterminates over ZZ, DifferentialPolyRingElem{ZZRingElem}[x[0,0]])

julia> x
1-element Vector{DifferentialPolyRingElem{ZZRingElem}}:
 x[0,0]

differential_polynomial_ring(R::Ring, action_indeterminates::Union{Vector{Symbol}, Int}, action_maps::Vector{<:ActionDerivation}; kwargs...) -> Tuple{DifferentialPolyRing, Vector{DifferentialPolyRingElem}}

This constructor behaves exactly like and comes with the same features as differential_polynomial_ring but additionally allows the user to pass a custom vector of derivations action_maps. In particular, this constructor allows for nontrivial derivations.

Examples

julia> S, (x, y) = polynomial_ring(QQ, [:x, :y]);

julia> nontrivial_derivations = action_derivation.([map_from_func(S, S, p -> derivative(p, x)), map_from_func(S, S, p -> derivative(p, y))])
2-element Vector{Oscar.NontrivialActionDerivation{QQMPolyRing}}:
 Derivation on S
 Derivation on S

julia> dpr, (u, v) = differential_polynomial_ring(S, [:u, :v], nontrivial_derivations)
(Differential polynomial ring in 2 action indeterminates over S, DifferentialPolyRingElem{QQMPolyRingElem}[u[0,0], v[0,0]])

differential_polynomial_ring(R::Ring, action_indeterminate::Symbol, action_maps::Vector{<:ActionDerivation}; kwargs...) -> Tuple{DifferentialPolyRing, DifferentialPolyRingElem}

This constructor behaves exactly like differential_polynomial_ring in that only a single action indeterminate is passed as a symbol but additionally allows the user to pass a custom vector of derivations action_maps. In particular, this constructor allows for nontrivial derivations.

apply_action(p::DifferentialPolyRingElem, i::Int)

Apply the i-th derivation to the differential polynomial p.

Examples

julia> dpr, (a,b,c) = differential_polynomial_ring(ZZ, [:a, :b, :c], 2); f = -2*a*b + 3*a*b^2;

julia> apply_action(3*a, 1)
3*a[1,0]

julia> apply_action(3*a, 2)
3*a[0,1]

julia> apply_action(f, 1)
(3*b[0,0]^2 - 2*b[0,0])*a[1,0] + 6*b[1,0]*a[0,0]*b[0,0] - 2*b[1,0]*a[0,0]

julia> apply_action(f, 2)
(3*b[0,0]^2 - 2*b[0,0])*a[0,1] + 6*b[0,1]*a[0,0]*b[0,0] - 2*b[0,1]*a[0,0]

apply_action(p::DifferentialPolyRingElem, d::Vector{Int})

Successively apply the i-th derivation d[i]-times to the differential polynomial p, where $i = 1, \ldots, \mathrm{length}(d)$.