Commutation Rules in Ore Algebra - Maple Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Mathematics : Algebra : Skew Polynomials : Ore Algebra : Ore_algebra/commutation_rules

Commutation Rules in Ore Algebra

 

Description

Examples

Description

• 

Ore algebras can be defined by mixing predefined commutation types and user-defined commutation types.

• 

Currently available predefined types are introduced by the following syntaxes.

  

Differential operators: diff=Dx,x, euler=Tx,x, loc_diff=Dx,x (followed by localization=u,p).

  

Shift and difference operators: δ=Dx,x, shift=Sx,x.

  

_q_-Calculus operators: qdelta=Dx,qx, qdiff=Dx,x,q, qdilat=Hx,x,q, qdilat=Dx,qx=qx, qshift=Sx,qx, shift+qshift=Sx,qx.

  

Dual types dual_delta, dual_diff, dual_euler, dual_qdelta, dual_qdiff, dual_qdilat, dual_qshift, dual_shift, and `dual_shift+dual_qshift` are also available.

• 

The delta type introduces a finite difference operator Dx that commutes with the operator of multiplication by x as:

Dxx=x+1Dx+1

  

This operator acts on Maple objects as:

Dx.fx=fx+1fx

  

Correspondingly, the dual_delta type is defined by the commutation:

Dxx=x1Dx1

  

This operator acts on Maple objects as:

Dx.fx=fx1fx

• 

The diff type introduces a differential operator Dx that commutes with the operator of multiplication by x as:

Dxx=Dxx+1

  

This operator acts on Maple objects as:

Dx.fx=ⅆⅆxfx

  

Correspondingly, the dual_diff type is defined by the commutation:

Dxx=Dxx1

  

This operator acts on Maple objects as:

Dx.fx=ⅆⅆxfx

• 

The euler type introduces an Eulerian operator, that is, x times the differential operator with respect to x, that commutes with the operator of multiplication by x as:

Txx=Txx+x

  

This operator acts on Maple objects as:

Tx.fx=xⅆⅆxfx

  

Correspondingly, the dual_euler type is defined by the commutation:

Txx=Txxx

  

This operator acts on Maple objects as:

Tx.fx=xⅆⅆxfx

• 

The loc_diff type introduces a differential operator Dx that commutes with the operators x and u of multiplication by x and 1/p, respectively, as:

Dxx=Dxx+1

Dxu=Dxuu2xp

  

This operator acts on Maple objects as:

Dx.fx=ⅆⅆxfx

  

Several loc_diff commutations can appear in the same algebra.  However, they must all be related to the same localization option and there can be at most one such option. Not all indeterminates involved in the inverted polynomial p can appear rationally in the algebra.  At least one of them must be declared polynomial by using the polynom option.

• 

The qdelta type introduces a q-calculus operator Dx that commutes with the operator q^x of multiplication by q^x as:

Dxqx=qqxDx+qqxqx

  

This operator acts on Maple objects as:

Dx.fx=fx+1fx

  

Correspondingly, the dual_qdelta type is defined by the commutation:

Dxqx=qxDxqq1qxq

  

This operator acts on Maple objects as:

Dx.fx=fx1fx

• 

The qdiff type introduces a q-calculus operator Dx that commutes with the operator x of multiplication by x as:

Dxx=Dxqx+1

  

This operator acts on Maple objects as:

Dx.fx=fqxfxq1x

  

Correspondingly, the dual_qdiff type is defined by the commutation:

Dxx=xDxq1

  

This operator acts on Maple objects as:

Dx.fx=qfxqfxq1x

• 

With the syntax qdilat=Hx,x,q, the qdilat type introduces a q-calculus operator Hx that commutes with the operator x of multiplication by q^x as:

Hxx=qxHx

  

This operator acts on Maple objects as:

Hx.fx=fqx

  

With the alternative syntax qdilat=Sx,qx=qx, the qdilat type introduces a q-calculus operator Sx that acts like the operator of the qshift section below, but with a notation for the operator of multiplication by qx that is the name qx instead of the power qx.  This syntax is better suited to calculations with the Groebner package.  The operator Sx commutes with the operator qx as:

Sxqx=qqxSx

  

This operator acts on Maple objects as:

Sx.fx=fqx

  

while the operator qx does as:

qx.fx=qxfx

  

Correspondingly, the dual_qdilat type is defined by the commutation:

Sxqx=qxSxq

  

This operator acts on Maple objects as:

Sx.fx=fxq

  

while the operator qx does as:

qx.fx=qxfx

• 

The qshift type introduces a q-calculus operator Sx that commutes with the operator q^x of multiplication by q^x as:

Sxqx=qqxSx

  

This operator acts on Maple objects as:

Sx.fx=fx+1

  

Correspondingly, the dual_qshift type is defined by the commutation:

Sxqx=qxSxq

  

This operator acts on Maple objects as:

Sx.fx=fx1

• 

The shift type introduces a shift operator Sx=Dx+1 that commutes with the operator of multiplication by x as:

Sxx=x+1Sx

  

This operator acts on Maple objects as:

Sx.fx=fx+1

  

Correspondingly, the dual_shift type is defined by the commutation:

Sxx=x1Sx

  

This operator acts on Maple objects as:

Sx.fx=fx1

  

The related type `shift+dual_shift` introduces both operators above, namely the forward shift operator Sx and the backward shift operator Tx, which commute with the operator of multiplication by x as:

Sxx=x+1Sx,

Txx=x1Tx

  

These operators acts on Maple objects as:

Sx.fx=fx+1,

Tx.fx=fx1

  

Note: In the current implementation, the rules SxTx=1 and SxTx=1 are not recognized.

• 

The `shift+qshift` type introduces a q-calculus operator Sx that commutes with the operators x and q^x of multiplication by x and q^x respectively as:

Sxx=x+1SxandSxqx=qqxSx

  

This operator acts on Maple objects as:

Sx.fx,qx=fx+1,qqx

  

Correspondingly, the `dual_shift+dual_qshift` type is defined by the commutations:

Sxx=x1SxandSxqx=qxSxq

  

This operator acts on Maple objects as:

Sx.fx,qx=fx1,qxq

• 

User-defined types are introduced by the syntax.

user=d,x,σ,δ

  

where d is the pseudo-differentiation operator, x is the operator of multiplication by x, and sigma and delta are functions over polynomials in x.  See examples below.  No action on Maple objects is predefined.

• 

Not all combinations of commutations are supported. More specifically, the indeterminates x_i and d_i must appear in a single list l_j only, except from the parameters q used for q-calculus.

Examples

Dual commutations

Here are possible declarations of a shift operator, next of a inverse shift operator.

withOre_algebra:

Askew_algebrashift=Sn,n:

skew_productSn,n,A

n+1Sn

(1)

applyoprSn,un,A

un+1

(2)

Askew_algebradual_shift=Sn,n:

skew_productSn,n,A

n1Sn

(3)

applyoprSn,un,A

un1

(4)

Localization

The following call introduces the algebra of linear differential operators with polynomial coefficients in x and y and an inverse u for the polynomial p=x2y2+1.

p1x2y2:

Askew_algebraloc_diff=Dx,x,loc_diff=Dy,y,polynom=x,y,localization=u,p:

skew_productDx,x,A

Dxx+1

(5)

skew_productDx,u,A

2u2x+Dxu

(6)

skew_productDx,ux,A

2u2x2+Dxux+u

(7)

skew_productDy,y,A

Dyy+1

(8)

skew_productDy,u,A

2u2y+Dyu

(9)

skew_productDy,uy,A

2u2y2+Dyuy+u

(10)

mapapplyopr,x,y,u,Dx,Dy,fx,y,A

xfx,y,yfx,y,fx,yx2y2+1,xfx,y,yfx,y

(11)

User-defined commutations

Define an algebra of operators where Dx and y are interpreted as the differentiation operator with respect to x and as the multiplication operator by ⅇx respectively.  The commutation rule reads: ⅇxfx'=ⅇxfx+ⅇxf'x.

A:=skew_algebra(user=[Dx,y,p->p,
    proc(p,n) local q;
        q:=p; to n do q:=y*diff(q,y) end do; q
    end proc]):

skew_productDx,y,A

Dxy+y

(12)

skew_productDx3,y,A

Dx3y+3Dx2y+3Dxy+y

(13)

skew_productDx,y5,A

Dxy5+5y5

(14)

Define the Mahlerian operator of order p=2.  The commutation rule reads: Mfx=fx2.

A:=skew_algebra(user=[M,x,proc(p,n) subs(x=x^(2^n),p) end proc,
    proc(p,n) `if`(n=0,p,0) end proc]):

skew_productM,x,A

x2M

(15)

skew_productM5,x,A

x32M5

(16)

skew_productM,5x3+x,A

5x6+x2M

(17)

See Also

Ore_algebra

Ore_algebra/skew_algebra

Ore_algebra/skew_product

Ore_algebra/Weyl_algebra

 


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam