Element Operations on Differential Operators

Category and Parent

Category(L): RngDiffOpElt -> RngDiffOpElt

Type(L): RngDiffOpElt -> RngDiffOpElt

The category, or type, of the differential operator \(L\).

Parent(L): RngDiffOpElt -> RngDiffOp

The parent of the differential operator \(L\).

Arithmetic

All the usual arithmetic operations are possible for differential operators. It follows from the multiplication rule for differential operators that the multiplication of differential operators is non–commutative.

s + t: RngDiffOpElt, RngDiffOpElt -> RngDiffOpElt

s + t: RngDiffOpElt, RngElt -> RngDiffOpElt

s + t: RngElt, RngDiffOpElt -> RngDiffOpElt

The sum of the two differential operators \(s\) and \(t\).

- s: RngDiffOpElt -> RngDiffOpElt

The negation of the differential operator \(s\).

s - t: RngDiffOpElt, RngDiffOpElt -> RngDiffOpElt

s - t: RngDiffOpElt, RngElt -> RngDiffOpElt

s - t: RngElt, RngDiffOpElt -> RngDiffOpElt

The difference between the differential operators \(s\) and \(t\).

s * t: RngDiffOpElt, RngDiffOpElt -> RngDiffOpElt

s * t: RngDiffOpElt, RngElt -> RngDiffOpElt

s * t: RngElt, RngDiffOpElt -> RngDiffOpElt

The product of the differential operators \(s\) and \(t\).

s ^ n: RngDiffOpElt, RngIntElt -> RngDiffElt

Given a differential operator \(s\) and an integer \(n\ge 0\), return the \(n\)-th power of \(s\).

Example: Diff Op Arithmetic (ex-a0ba79)

> F<z> := RationalDifferentialField(Rationals());
> R<D> := DifferentialOperatorRing(F);
> (z*D-1)*(D+1);
z*D^2 + (z - 1)*D + -1
> (D+1)*(z*D-1);
z*D^2 + z*D + -1
> (D-1/z)^2;
D^2 + -2/z*D + 2/z^2

Run in calculatorCopy input

Predicates and Booleans

s eq t: RngDiffOpElt, RngDiffOpElt -> BoolElt

Return true iff the differential operators \(s\) and \(t\) are exactly the same.

IsZero(L): RngDiffOpElt -> BoolElt

Return true iff the differential operator \(L\) is the zero element of its parent.

IsOne(L): RngDiffOpElt -> BoolElt

Return true iff the differential operator \(L\) is the unity element of its parent.

IsMonic(L): RngDiffOpElt -> BoolElt

Return true iff the differential operator \(L\) is monic.

IsWeaklyEqual(L, P): RngDiffOpElt, RngDiffOpElt -> BoolElt

Returns true if and only if the differential operator \(L\) is weakly equal to the operator \(P\). This means that the \(i\)-th coefficients of \(L\) and \(P\) should be weakly equal to each other for every \(i \in [0..\max(\deg(L),\deg(P))]\).

IsWeaklyZero(L): RngDiffOpElt -> BoolElt

Returns true if and only if the differential operator \(L\in R\) is weakly equal to \(R ! 0\).

IsWeaklyMonic(L): RngDiffOpElt -> BoolElt

Returns true if and only if the leading coefficient of the differential operator \(L\) is weakly equal to \(1\).

Coefficients and Terms

Differential operators look like univariate polynomials with coefficients in a differential ring. Some of the terminology used for polynomial rings is mimicked for differential operators.

Eltseq(L): RngDiffOpElt -> SeqEnum

Coefficients(L): RngDiffOpElt -> SeqEnum

Given an operator \(L\) with coefficients in \(R\), this function returns the sequence of elements in \(R\), that are the coefficients of \(L\). The sequence is ordered from the constant coefficient to the coefficient of the highest order term of \(L\).

Coefficient(L, i): RngDiffOpElt, RngIntElt -> RngElt

Given an operator \(L\) with coefficients in \(R\), this function returns the coefficient of the monomial of degree \(i\) in \(L\), as an element of \(R\).

LeadingCoefficient(L): RngDiffOpElt -> RngElt

Given an operator \(L\) with coefficients in \(R\), this function returns the coefficient of the highest order term of \(L\).

LeadingTerm(L): RngDiffOpElt -> RngDiffOpElt

The leading term of the differential operator \(L\).

Terms(L): RngDiffOpElt -> SeqEnum

Given an operator \(L\) with coefficients in \(R\), this function returns the sequence of non–zero coefficients of \(L\) as elements of \(R\). The sequence is ordered from the lowest order term to the highest order term in \(L\).

Example: Diff Op Coeff Terms (ex-d50a45)

> F<z> := RationalDifferentialField(Rationals());
> R<D> := DifferentialOperatorRing(F);
> L := D^3  + (-4*z + 5)*D + (3*z - 4);
> L;
D^3 + (-4*z + 5)*D + 3*z - 4
> Eltseq(L);
[ 3*z - 4, -4*z + 5, 0, 1 ]
> LeadingTerm(L);
D^3
> Terms(L);
[
    3*z - 4,
    (-4*z + 5)*D,
    D^3
]

Run in calculatorCopy input

Order and Degree

Order(L): RngDiffOpElt -> RngIntElt

Degree(L): RngDiffOpElt -> RngIntElt

Returns the order of the differential operator \(L\). In the case that \(L\) is identically \(0\), the order is defined to be \(-1\).

WeakOrder(L): RngDiffOpElt -> RngIntElt

WeakDegree(L): RngDiffOpElt -> RngIntElt

If the differential operator \(L\) is defined over a differential series ring, then the exponent of the highest coefficient of \(L\) that is not weakly \(0\) is returned.

Example Booleans Degrees Diff Ops (ex-873e6e)

> S<t> := DifferentialLaurentSeriesRing(Rationals());
> R<D> := DifferentialOperatorRing(S);
> L := D^2 + 2*t;
> P := O(t)*D^3 + (1+O(t))*D^2  + 2*t;
> Order(L);
2
> Degree(P);
3
> L eq P;
false
> IsWeaklyEqual(L,P);
true
> WeakOrder(P);
2

Run in calculatorCopy input

Related Differential Operators

MonicDifferentialOperator(L): RngDiffOpElt -> RngDiffOpElt

Given the differential operator \(L\), this function returns the monic differential operator \(1/c\cdot L\), where c is the leading coefficient of \(L\).

Adjoint(L): RngDiffOpElt -> RngDiffOpElt

Returns the formal adjoint of the differential operator \(L\). The formal adjoint of \(L=\sum_{i=0}^n a_iD^i\) in the differential operator ring \(R=F[D]\) over \(F\), is the differential operator \(L^*:=\sum_{i=0}^n (-1)^iD^i*a_i\in R\). It follows from the definition that the orders of \(L\) and \(L^*\) are the same and that the leading coefficient of \(L^*\) is \((-1)^n a_n\).

Translation(L, e): RngDiffOpElt, RngElt -> RngDiffOpElt, Map

If \(R\) is the parent of the differential operator \(L\) and \(e\) is a suitable ring element, then the operator in \(R\) obtained by replacing \(R.1\) by \(R.1+e\) in \(L\) is returned. The second argument returned is the translation map on \(R\) by \(e\).

TruncateCoefficients(L): RngDiffOpElt -> RngDiffOpElt

If \(L\) is defined over a differential series ring, then returned is the operator whose coefficients are the truncations of the coefficients of \(L\).

Example: Related Diff Op (ex-978632)

> F<z> := RationalDifferentialField(Rationals());
> R<D> := DifferentialOperatorRing(F);
> L := z*D^3  + (-4*z + 5)*D + (3*z - 4);
> Order(L);
3
> MonicDifferentialOperator(L);
D^3 + (-4*z + 5)/z*D + (3*z - 4)/z
> Adjoint(L);
-z*D^3 + -3*D^2 + (4*z - 5)*D + 3*z
> trans, mp := Translation(L, 2);
> trans;
z*D^3 + 6*z*D^2 + (8*z + 5)*D + 3*z + 6

Run in calculatorCopy input

Example: Related Diff Op Truncate Coefficients (ex-32cf07)

> S<t> := DifferentialLaurentSeriesRing(Rationals());
> RS<DS> := DifferentialOperatorRing(S);
> L := (5-O(t))*DS^3+(2*t^-1+t^2+O(t^4))*DS - t^-2+t+O(t^3);
> L;
(5 + O(t))*DS^3 + (2*t^-1 + t^2 + O(t^4))*DS + -t^-2 + t + O(t^3)
> TruncateCoefficients(L);
5*DS^3 + (2*t^-1 + t^2)*DS + -t^-2 + t
> L -TruncateCoefficients(L);
O(t)*DS^3 + O(t^4)*DS + O(t^3)

Run in calculatorCopy input

Application of Operators

As pointed out in the introduction a differential operator \(L=a_nD^n+a_{n-1}D^{n-1}+\cdots+a_1D+a_0\) in \(F[D]\) leads to the differential equation \(L(y)=0\) given by

\[L(y)=a_n \delta_F^n(y)+a_{n-1} \delta_F^{n-1}(y)+ \cdots+a_1 \delta_F(y)+a_0 y\]

This notation is formal, but also defines an action of \(L\) on any element \(y\in F\). The function Apply returns the ring element obtained by this action.

Apply(L, f): RngDiffOpElt, RngElt -> RngElt

L(f): RngElt, RngDiffOpElt -> RngElt

f @ L: RngElt, RngDiffOpElt -> RngElt

Given a differential operator \(L\) and a ring element \(f\), return the ring element obtained after applying \(L\) to \(f\), as an element of the base ring of \(L\). The element \(f\) must be coercible into the base ring of \(L\).

Example Apply (ex-1a4536)

> F<z> := RationalDifferentialField(Rationals());
> R<D> := DifferentialOperatorRing(F);
> L := D^2-2/z^2;
> Apply(L, z);
-2/z
> L(z);
-2/z
> Apply(L, z^2);
0

Run in calculatorCopy input