Action polynomial rings

An action polynomial ring over the commutative ring $R$ is a polynomial ring

\[S = R[\, (u_i)_J \mid i \in \lbrace 1, \ldots, m \rbrace, J \in \mathbb{Z}_{\geq 0}^n ]\]

in the countably infinitely many jet variables $(u_i)_J$, equipped with $n$ commuting $R$-linear action maps $\sigma_1, \ldots, \sigma_n$, where $m$ and $n$ are positive integers. The symbols $u_1, \ldots, u_m$ are called elementary symbols, the multiindices $J \in \mathbb{Z}_{\geq 0}^n$ are called jets.

The $j$-th action map has the property that, when applied to a jet variable, it increments the $j$-th entry of its jet by one. Depending on the setting it also has further properties, e.g. it is multiplicative for difference polynomial rings and it is a derivation for differential polynomial rings.

In Oscar we provide the action polynomial interface via the abstract types ActionPolyRing{T} <: Ring and ActionPolyRingElem{T} <: RingElem. The type parameter T is the element type of the coefficient ring. All concrete subtypes use the functionality of universal polynomials from the AbstractAlgebra package for polynomial arithmetic, as well as maintaining variables and adding new ones on demand. Any action polynomial ring maintains a sorted list of currently tracked jet variables, that can be accessed and extended by a number of methods, see, e.g., Element Constructors. The jet variables are sorted with respect to a user-defined ranking.

Tracked jet variables

The set of valid jet variables of an action polynomial ring depend only on the integers $m$ and $n$ and are thus known at the time of construction. For reasons of efficiency, we keep the list of tracked jet variables as short as possible and track jet variables only, if necessary. The list of currently tracked jet variables is obtained using gens.

Currently, there are two concrete subtypes available, namely DifferencePolyRing{T} and DifferentialPolyRing{T} with element types DifferencePolyRingElem{T} and DifferentialPolyRingElem{T}. See difference polynomial rings and differential polynomial rings for their unique functionality.

Specifying jet variables

Recall that a jet variable is of the form $(u_i)_J$ with $i \in \lbrace 1, \ldots, m \rbrace$ and $J \in \mathbb{Z}_{\geq 0}^n$. There are four ways in which jet variables can be specified as an input for methods, which can be found below. The first two do not require the jet variable in question to be tracked, the last two do.

By a tuple consisting of the index i and the jet J.
By passing the tuple as separate arguments, starting with the index.
By passing the index of the jet variable in the list of the currently tracked jet variables.
By immediately passing the jet variable as an element of an action polynomial ring.

Note

For many methods, e.g. degree or derivative we provide all the above versions, but only record one in this documentation for readability. Usually, we choose the second version from the above list.

Element Constructors

(A::ActionPolyRing)() returns the zero polynomial of the action polynomial ring A. (A::ActionPolyRing)(a::T) where {T<:RingElement} returns a as an element of A, if possible. This can be used for creating constant polynomials.

Warning

The next three methods take input arguments specifying a jet variable or a vector of jet variables. After calling one of them, the provided action polynomial ring A will track all jet variables specified.

gen — Method

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]

Experimental

This function is part of the experimental code in Oscar. Please read here for more details.