Changing Related Structures

It may happen that certain intrinsics only work for differential operator rings whose derivations are of a specific form, or whose constant fields have to be large enough. Some of the functions available for changing settings of the differential rings or fields can be used to change the desired related structure on the operator ring directly. To alter some of the settings of a differential operator ring, the following functions are available.

ChangeDerivation(R, f): RngDiffOp, RngElt -> RngDiffOp, Map

Returns a differential operator ring isomorphic to \(R\), but whose derivation is given by \(f *\) Derivation(R). The ring element \(f\) must be non–zero. The isomorphism of \(R\) to the new differential ring is also returned. The base ring of the new differential operator ring is isomorphic to the one of \(R\), but it has derivation ChangeDerivation(BaseRing(R)).

ChangeDifferential(R, df): RngDiffOp, DiffFunElt -> RngDiffOp, Map

Returns the differential operator ring with differential \(df\), and whose underlying ring of its basefield coincides with the one of \(R\). The map returned is the bijective map of \(R\) into the new operator ring. The base ring of the new differential operator ring is isomorphic to the one of \(R\). However, the returned inclusion map and taking derivatives may not be commutative.

Example Diff Op Ring Changing Differential (ex-29b98d)

> F<z> := RationalDifferentialField(Rationals());
> R<D> := DifferentialOperatorRing(F);
> df := Differential(z^3+5);
> RM<DM>, mp := ChangeDifferential(R,df);
> Domain(mp) eq R and Codomain(mp) eq RM;
true
> M<u> := BaseRing(RM);
> IsDifferentialOperatorRing(RM) and IsAlgebraicDifferentialField(M);
true
> mp(RM!z);
u
> mp(D);
3*u^2*DM
> D*z, mp(D*z);
u*D + 1
3*u^3*DM + 1
> DM*u;
u*DM + 1/3/u^2
> Differential(RM);
(3*u^2) d(u)

Run in calculatorCopy input

ConstantFieldExtension(R, C): RngDiffOp, Fld -> RngDiffOp, Map

Returns the ring of differential operators with base ring isomorphic to that of the differential operator ring \(R\), but whose constant field is \(C\). The derivation is extended over the new constant field. The second argument returned is the map from \(R\) to the new operator ring.

PurelyRamifiedExtension(R, f): RngDiffOp, RngUPolElt -> RngDiffOp, Map

When \(R\) is a differential operator ring over a differential ring \(F\), this function returns an operator ring over the purely ramified extension of \(F\), as induced by the polynomial \(f\). The polynomial \(f\) is of the form \(X^n-a\cdot(F.1)\) for some constant element \(a\) in \(F\) and positive integer \(n\).

Example: Diff Op Ring Purely Ramified Extension DLSR (ex-43ec30)

> S<t> := DifferentialLaurentSeriesRing(Rationals());
> R<D> := DifferentialOperatorRing(S);
> _<T> := PolynomialRing(S);
> Rext<Dext>, mp := PurelyRamifiedExtension(R, T^7-3*t);
> Sext<text> := BaseRing(Rext);
> Domain(mp) eq R and Codomain(mp) eq Rext;
true
> IsDifferentialLaurentSeriesRing(Sext);
true
> BaseRing(Sext) eq S;
true
> RelativePrecision(Sext) eq 7*RelativePrecision(S);
true
> D*t;
t*D + t
> mp(D);
Dext
> mp(R!t) eq Rext!(1/3*text^7);
true
> Dext*text;
text*Dext + 1/7*text

Run in calculatorCopy input

Completion(R, p): RngDiffOp, PlcFunElt -> RngDiffOp, Map

Precision: RngIntElt                    Default: Infinity()

Returns the operator ring \(\tilde{R}\), whose base ring is the completion of the base ring of the operator ring \(R\) w.r.t. the place \(p\). The second return value is the natural embedding of \(R\) into \(\tilde{R}\). The precision of the base ring of \(\tilde{R}\) can be set by setting Precision upon creation. If no precision is set, a default value for the precision is taken.

Localization(R, p): RngDiffOp, PlcFunElt -> RngDiffOp, Map, PlcFunElt

Returns the operator ring whose differential has valuation \(-1\) at \(p\), with derivation \(t\cdot d/dt\), where \(t\) is the uniformizing element at the place \(p\). The natural map between the operator rings, and the induced image of \(p\) are also returned.

Localization(L, p): RngDiffOpElt, PlcFunElt -> RngDiffOpElt, Map, PlcFunElt

Given the differential operator \(L\) over an algebraic differential field, returns the localized operator of \(L\) at the place \(p\). The embedding map between the parents as well as the induced image of the place are also returned.

Localization(R): RngDiffOp -> RngDiffOp, Map

Given a differential operator ring \(R\) over the differential Laurent series ring \(C((t))\), returns the operator ring whose derivation is of the form \(t\cdot d/dt\), and the natural map between the operator rings.

Localization(L): RngDiffOpElt -> RngDiffOpElt, Map

Given the differential operator \(L\) over a differential series ring, returns the localized operator of \(L\) and the embedding map between the parents.

Example Diff Op Ring Changing Attributes DLSR (ex-7675d6)

> S<t>:=DifferentialLaurentSeriesRing(Rationals());
> R<D> := DifferentialOperatorRing(S);
> D*t;
t*D + t
> Rprime<Dprime>, mp := ChangeDerivation(R,t^2);
> Fprime<tprime> := BaseRing(Rprime);
> mp;
Mapping from: RngDiffOp: R to RngDiffOp: Rprime given by a rule
> Dprime*tprime;
tprime*Dprime + tprime^3
> P<T> := PolynomialRing(Rationals());
> Cext := ext<Rationals()|T^2+1>;
> Rext<Dext>, mp := ConstantFieldExtension(R,Cext);
> Cext eq ConstantRing(BaseRing(Rext));
true
> mp(D);
Dext

Run in calculatorCopy input

Example Diff Op Ring Completion (ex-397606)

This examples illustrates how to use Completion on operator rings.

> F<z> := RationalDifferentialField(Rationals());
> R<D> := DifferentialOperatorRing(F);
> pl := Zeros(z)[1];
> Rcompl<Dcompl>, mp := Completion(R,pl);
> IsDifferentialOperatorRing(Rcompl);
true
> S<t> := BaseRing(Rcompl);
> IsDifferentialLaurentSeriesRing(S);
true
> mp(D);
Dcompl
> Dcompl*t;
t*Dcompl + 1

Run in calculatorCopy input

Example Diff Op Ring Localization (ex-885bd3)

> F<z> := RationalDifferentialField(Rationals());
> R<D> := DifferentialOperatorRing(F);
> pl := Zeros(z-1)[1];
> Rloc<Dloc>, mp, place:=  Localization(R,pl);
> Domain(mp) eq R, Codomain(mp) eq Rloc;
true true
> place;
(z - 1)
> Differential(BaseRing(Rloc));
(1/(z - 1)) d(z)
> mp(D);
1/(z - 1)*Dloc
> Dloc*(z-1);
(z - 1)*Dloc + z - 1
> L := D + z;
> Lloc, mp, place := Localization(L,Zeros(z)[1]);
> Lloc;
1/z*$.1 + z

Run in calculatorCopy input