This is WeylAlgebras.info, produced by Macaulay2, version 1.26.06

WeylAlgebras -- algorithms for D-modules
****************************************

Description
===========

To begin, read the D-modules tutorial (Dmodules).

How to make Weyl algebras

  * monoid(...,WeylAlgebra=>...) (Macaulay2Doc)
    -- specify
    differential operators in the ring
  * makeWeylAlgebra -- Weyl algebra corresponding to a
    polynomial ring

Basic commands

  * gbw -- compute a Gröbner basis with respect to a weight vector
  * inw -- get the initial term or ideal with respect to a weight
    vector
  * Fourier -- Fourier transform for Weyl algebra
  * Dtransposition -- standard transposition for Weyl
    algebra
  * stafford -- computes 2 generators for a given ideal in the
    Weyl algebra
  * makeCyclic -- finds a cyclic generator of a D-module
  * Dprune -- prunes a D-module

Basic invariants of D-modules

  * Ddim -- dimension of a D-module
  * isHolonomic -- determines whether a D-module (or ideal
    in Weyl algebra) is holonomic
  * holonomicRank -- holonomic rank of a D-module
  * characteristicIdeal -- characteristic ideal of
    a D-module
  * DsingularLocus -- singular locus of a D-module

Programming aids

  * createDpairs -- pairs coordinate and derivation
    variables in a Weyl algebra
  * extractDiffsAlgebra -- underlying polynomial
    ring in the differentials of a Weyl algebra
  * extractVarsAlgebra -- underlying polynomial ring
    in the ordinary variables of a Weyl algebra
  * Dtrace -- set or get the depth of comments made by D-module
    routines

Authors
=======

  * Anton Leykin <leykin@math.gatech.edu>
  * Harrison Tsai

Version
=======

This documentation describes version 1.4.1.1 of WeylAlgebras, released February
2023.

Citation
========

If you have used this package in your research, please cite it as follows:

+---------------------------------------------------------+
|@misc{WeylAlgebrasSource,                                |
|  title = {{WeylAlgebras: D-modules. Version~1.4.1.1}},  |
|  author = {Anton Leykin and Harrison Tsai},             |
|  howpublished = {A \emph{Macaulay2} package available at|
|    "http://people.math.gatech.edu/~aleykin3/Dmodules"}  |
|}                                                        |
|                                                         |
+---------------------------------------------------------+

Exports
=======

  * Functions and commands
      * characteristicIdeal -- characteristic ideal
        of a D-module
      * createDpairs -- pairs coordinate and derivation
        variables in a Weyl algebra
      * Ddim -- dimension of a D-module
      * Dprune -- prunes a D-module
      * DsingularLocus -- singular locus of a D-module
      * Dtrace -- set or get the depth of comments made by
        D-module routines
      * Dtransposition -- standard transposition for
        Weyl algebra
      * extractDiffsAlgebra -- underlying
        polynomial ring in the differentials of a Weyl algebra
      * extractVarsAlgebra -- underlying polynomial
        ring in the ordinary variables of a Weyl algebra
      * factorWeylAlgebra -- factor a Weyl algebra
        element
      * factorWeylAlgebra1 -- give one factorisation
        of a Weyl algebra element
      * Fourier -- Fourier transform for Weyl algebra
      * "FourierInverse" -- see Fourier, -- Fourier transform
        for Weyl algebra
      * gbw -- compute a Gröbner basis with respect to a weight
        vector
      * holonomicRank -- holonomic rank of a D-module
      * inw -- get the initial term or ideal with respect to a
        weight vector
      * isHolonomic -- determines whether a D-module (or
        ideal in Weyl algebra) is holonomic
      * makeCyclic -- finds a cyclic generator of a D-module
      * makeWeylAlgebra -- Weyl algebra corresponding
        to a polynomial ring
      * "getHomSwitch" -- see setHomSwitch, -- toggle the
        use of homogeneous Weyl algebra
      * setHomSwitch -- toggle the use of homogeneous Weyl
        algebra
      * stafford -- computes 2 generators for a given ideal in
        the Weyl algebra
  * Methods
      * "characteristicIdeal(Ideal)" -- see characteristicIdeal,
        -- characteristic ideal of a D-module
      * "characteristicIdeal(Module)" -- see characteristicIdeal,
        -- characteristic ideal of a D-module
      * "createDpairs(PolynomialRing)" -- see createDpairs,
        -- pairs coordinate and derivation variables in a Weyl algebra
      * "Ddim(Ideal)" -- see Ddim, -- dimension of a D-module
      * "Ddim(Module)" -- see Ddim, -- dimension of a D-module
      * "Dprune(Matrix)" -- see Dprune, -- prunes a D-module
      * "Dprune(Module)" -- see Dprune, -- prunes a D-module
      * "DsingularLocus(Ideal)" -- see DsingularLocus, --
        singular locus of a D-module
      * "DsingularLocus(Module)" -- see DsingularLocus,
        -- singular locus of a D-module
      * "Dtrace(Sequence)" -- see Dtrace, -- set or get the depth
        of comments made by D-module routines
      * "Dtrace(ZZ)" -- see Dtrace, -- set or get the depth of
        comments made by D-module routines
      * "Dtransposition(Complex)" -- see Dtransposition,
        -- standard transposition for Weyl algebra
      * "Dtransposition(Ideal)" -- see Dtransposition, --
        standard transposition for Weyl algebra
      * "Dtransposition(Matrix)" -- see Dtransposition,
        -- standard transposition for Weyl algebra
      * "Dtransposition(RingElement)" -- see Dtransposition,
        -- standard transposition for Weyl algebra
      * "extractDiffsAlgebra(PolynomialRing)" -- see extractDiffsAlgebra,
        -- underlying polynomial ring in the differentials
        of a Weyl algebra
      * "extractVarsAlgebra(PolynomialRing)" -- see extractVarsAlgebra,
        -- underlying polynomial ring in the ordinary
        variables of a Weyl algebra
      * "factorWeylAlgebra(RingElement)" -- see factorWeylAlgebra,
        -- factor a Weyl algebra element
      * "Fourier(Complex)" -- see Fourier, -- Fourier transform
        for Weyl algebra
      * "Fourier(Ideal)" -- see Fourier, -- Fourier transform
        for Weyl algebra
      * "Fourier(Matrix)" -- see Fourier, -- Fourier transform
        for Weyl algebra
      * "Fourier(Module)" -- see Fourier, -- Fourier transform
        for Weyl algebra
      * "Fourier(RingElement)" -- see Fourier, -- Fourier
        transform for Weyl algebra
      * "FourierInverse(Complex)" -- see Fourier, -- Fourier
        transform for Weyl algebra
      * "FourierInverse(Ideal)" -- see Fourier, -- Fourier
        transform for Weyl algebra
      * "FourierInverse(Matrix)" -- see Fourier, -- Fourier
        transform for Weyl algebra
      * "FourierInverse(Module)" -- see Fourier, -- Fourier
        transform for Weyl algebra
      * "FourierInverse(RingElement)" -- see Fourier, -- Fourier
        transform for Weyl algebra
      * "gbw(Ideal,List)" -- see gbw, -- compute a Gröbner basis
        with respect to a weight vector
      * "gbw(Matrix,List)" -- see gbw, -- compute a Gröbner basis
        with respect to a weight vector
      * "holonomicRank(Ideal)" -- see holonomicRank, --
        holonomic rank of a D-module
      * "holonomicRank(Module)" -- see holonomicRank, --
        holonomic rank of a D-module
      * "inw(Ideal,List)" -- see inw, -- get the initial term or
        ideal with respect to a weight vector
      * "inw(Matrix,List)" -- see inw, -- get the initial term or
        ideal with respect to a weight vector
      * "inw(RingElement,List)" -- see inw, -- get the initial term
        or ideal with respect to a weight vector
      * "isHolonomic(Ideal)" -- see isHolonomic, --
        determines whether a D-module (or ideal in Weyl algebra) is holonomic
      * "isHolonomic(Module)" -- see isHolonomic, --
        determines whether a D-module (or ideal in Weyl algebra) is holonomic
      * "makeCyclic(Matrix)" -- see makeCyclic, -- finds a
        cyclic generator of a D-module
      * "makeWeylAlgebra(PolynomialRing)" -- see makeWeylAlgebra,
        -- Weyl algebra corresponding to a polynomial ring
      * "setHomSwitch(Boolean)" -- see setHomSwitch, --
        toggle the use of homogeneous Weyl algebra
      * "stafford(Ideal)" -- see stafford, -- computes 2
        generators for a given ideal in the Weyl algebra
  * Symbols
      * "dpairInds" -- see createDpairs, -- pairs
        coordinate and derivation variables in a Weyl algebra
      * "dpairVars" -- see createDpairs, -- pairs
        coordinate and derivation variables in a Weyl algebra
      * "AnnG" -- see makeCyclic, -- finds a cyclic generator
        of a D-module
      * "Generator" -- see makeCyclic, -- finds a cyclic
        generator of a D-module
      * "SetVariables" -- see makeWeylAlgebra, -- Weyl
        algebra corresponding to a polynomial ring
      * StopAfter (missing documentation)

For the programmer
==================

The object WeylAlgebras, is a package (Macaulay2Doc),
defined in WeylAlgebras.m2, with auxiliary files in WeylAlgebras/.

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/main.m2:55:0.

makeWeylAlgebra -- Weyl algebra corresponding to a polynomial ring
******************************************************************

  * Usage:
        makeWeylAlgebra R
        makeWA R
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc), the
        (commutative) polynomial ring
  * Optional inputs (Macaulay2Doc),:
      * SetVariables => a Boolean value (Macaulay2Doc), default
        value true, indicates whether the generators should be assigned to
        global variables
  * Outputs:
      * a polynomial ring (Macaulay2Doc), the
        (non-commutative) Weyl algebra

Description
===========

Given a polynomial ring R with variables x_1,..,x_n, this routine returns a
Weyl algebra with variables x_1,..,x_n and dx_1,..,dx_n.

+-----------------------------------------------+
|i1 : R = QQ[x,y,z]                             |
|                                               |
|o1 = R                                         |
|                                               |
|o1 : PolynomialRing                            |
+-----------------------------------------------+
|i2 : D = makeWeylAlgebra R                     |
|                                               |
|o2 = D                                         |
|                                               |
|o2 : PolynomialRing, 3 differential variable(s)|
+-----------------------------------------------+

To skip naming the ring, use parentheses.

+-----------------------------------------------+
|i3 : makeWA(QQ[x,y,z])                         |
|                                               |
|o3 = QQ[x..z, dx, dy, dz]                      |
|                                               |
|o3 : PolynomialRing, 3 differential variable(s)|
+-----------------------------------------------+

Caveat
======

The polynomial ring R must be commutative.

See also
========

  * monoid(...,WeylAlgebra=>...) (Macaulay2Doc)
    -- specify
    differential operators in the ring

Ways to use makeWeylAlgebra:
============================

  * "makeWeylAlgebra(PolynomialRing)"

For the programmer
==================

The object makeWeylAlgebra, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/general.m2:42:0.

createDpairs -- pairs coordinate and derivation variables in a Weyl algebra
***************************************************************************

  * Usage:
        createDpairs A
  * Inputs:
      * A, the Weyl algebra
  * Consequences:
      * attaches to A a pair of keys to help distinguish the coordinate
        variables from the derivation variables.

Description
===========

Since the Weyl algebra has commutation rules, this routine attaches to the Weyl
algebra two keys to organize the variables.  The first key 'dpairVars' contains
3 lists: a list of the coordinate variables, a list of the derivative
variables, and a list of the central variables.  The second key 'dpairInds'
also contains 3 lists of the corresponding indices to 'dpairVars'.
+----------------------------------------------------+
|i1 : W = QQ[x,y,Dx,Dy, WeylAlgebra => {x=>Dx,y=>Dy}]|
|                                                    |
|o1 = W                                              |
|                                                    |
|o1 : PolynomialRing, 2 differential variable(s)     |
+----------------------------------------------------+
|i2 : createDpairs W                                 |
+----------------------------------------------------+
|i3 : W.dpairVars                                    |
|                                                    |
|o3 = {{x, y}, {Dx, Dy}, {}}                         |
|                                                    |
|o3 : List                                           |
+----------------------------------------------------+
|i4 : W.dpairInds                                    |
|                                                    |
|o4 = {{0, 1}, {2, 3}, {}}                           |
|                                                    |
|o4 : List                                           |
+----------------------------------------------------+

See also
========

  * monoid(...,WeylAlgebra=>...) (Macaulay2Doc)
    -- specify
    differential operators in the ring

Ways to use createDpairs:
=========================

  * "createDpairs(PolynomialRing)"

For the programmer
==================

The object createDpairs, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/general.m2:90:0.

extractDiffsAlgebra -- underlying polynomial ring in the differentials of a Weyl algebra
****************************************************************************************

  * Usage:
        extractDiffsAlgebra D
  * Inputs:
      * D, a polynomial ring (Macaulay2Doc), a Weyl
        algebra
  * Outputs:
      * a polynomial ring (Macaulay2Doc),

Description
===========

Extracts from a Weyl algebra the polynomial ring in its differentials only.

+-----------------------------------------------+
|i1 : D = makeWA(QQ[x,y])                       |
|                                               |
|o1 = D                                         |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : S = extractDiffsAlgebra D                 |
|                                               |
|o2 = S                                         |
|                                               |
|o2 : PolynomialRing                            |
+-----------------------------------------------+
|i3 : describe S                                |
|                                               |
|o3 = QQ[dx, dy, Degrees => {2:1}, Heft => {1}] |
+-----------------------------------------------+

See also
========

  * extractVarsAlgebra -- underlying polynomial ring
    in the ordinary variables of a Weyl algebra

Ways to use extractDiffsAlgebra:
================================

  * "extractDiffsAlgebra(PolynomialRing)"

For the programmer
==================

The object extractDiffsAlgebra, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/general.m2:138:0.

extractVarsAlgebra -- underlying polynomial ring in the ordinary variables of a Weyl algebra
********************************************************************************************

  * Usage:
        extractVarsAlgebra D
  * Inputs:
      * D, a polynomial ring (Macaulay2Doc), a Weyl
        algebra
  * Outputs:
      * a polynomial ring (Macaulay2Doc),

Description
===========

Extracts from a Weyl algebra the polynomial ring in its ordinary variables.

+-----------------------------------------------+
|i1 : D = makeWA(QQ[x,y])                       |
|                                               |
|o1 = D                                         |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : R = extractVarsAlgebra D                  |
|                                               |
|o2 = R                                         |
|                                               |
|o2 : PolynomialRing                            |
+-----------------------------------------------+
|i3 : describe R                                |
|                                               |
|o3 = QQ[x..y, Degrees => {2:1}, Heft => {1}]   |
+-----------------------------------------------+

See also
========

  * extractDiffsAlgebra -- underlying polynomial
    ring in the differentials of a Weyl algebra

Ways to use extractVarsAlgebra:
===============================

  * "extractVarsAlgebra(PolynomialRing)"

For the programmer
==================

The object extractVarsAlgebra, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/general.m2:114:0.

gbw -- compute a Gröbner basis with respect to a weight vector
**************************************************************

  * Usage:
        gbI = gbw(I, w)
        gbM = gbw(M, w)
  * Inputs:
      * I, an ideal (Macaulay2Doc), in the Weyl algebra
      * M, a matrix (Macaulay2Doc), with entries in the Weyl
        algebra
      * w, a list (Macaulay2Doc), of weights
  * Optional inputs (Macaulay2Doc),:
      * Strategy => a thing (Macaulay2Doc), default value null, if
        set to homogenize the input is homogenized in the homogeneous Weyl
        algebra
  * Outputs:
      * gbI, an ideal (Macaulay2Doc), with the generators forming
        a Gröbner basis of the ideal with respect to the weight vector
      * gbM, a matrix (Macaulay2Doc), with the columns forming a
        Gröbner basis of the submodule generated by the columns of the matrix
        with respect to the weight vector

Description
===========

This routine computes a Gröbner basis of a left ideal I of the Weyl algebra
with respect to a weight vector w = (u,v) where  u+v >= 0. In the case where
u_i+v_i > 0 for all i, the ordinary Buchberger algorithm works for any term
order refining the weight order. If there exists i so that u_i+v_i = 0 the
Buchberger algorithm needs to be adapted to  guarantee termination. There are
two strategies for doing this. One is to homogenize to an ideal of the
homogeneous Weyl algebra.

+-----------------------------------------------+
|i1 : makeWA(QQ[x,y])                           |
|                                               |
|o1 = QQ[x..y, dx, dy]                          |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : I = ideal (x*dx+2*y*dy-3, dx^2-dy)        |
|                                               |
|                                2              |
|o2 = ideal (x*dx + 2y*dy - 3, dx  - dy)        |
|                                               |
|o2 : Ideal of QQ[x..y, dx, dy]                 |
+-----------------------------------------------+
|i3 : gbw(I, {-1,-3,1,3})                       |
|                                               |
|                                  2            |
|o3 = ideal (x*dx + 2y*dy - 3, - dx  + dy)      |
|                                               |
|o3 : Ideal of QQ[x..y, dx, dy]                 |
+-----------------------------------------------+

The other is to homogenize with respect to the weight vector w. More details
can be found in [SST (see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf
), Sections 1.1 and 1.2].

+-----------------------------------------------------------------------------+
|i4 : gbw(I, {1,3,3,-1})                                                      |
|                                                                             |
|                                2                                2  2    2   |
|o4 = ideal (x*dx + 2y*dy - 3, dx  - dy, 2y*dx*dy + x*dy - 2dx, 4y dy  - x dy |
|     ------------------------------------------------------------------------|
|     + 2x*dx - 2y*dy)                                                        |
|                                                                             |
|o4 : Ideal of QQ[x..y, dx, dy]                                               |
+-----------------------------------------------------------------------------+

Caveat
======

The weight vector w = (u,v) must have u+v>=0.

See also
========

  * inw -- get the initial term or ideal with respect to a weight
    vector

Ways to use gbw:
================

  * "gbw(Ideal,List)"
  * "gbw(Matrix,List)"

For the programmer
==================

The object gbw, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:51:0.

setHomSwitch -- toggle the use of homogeneous Weyl algebra
**********************************************************

  * Usage:
        setHomSwitch n
        getHomSwitch()
  * Inputs:
      * n, a Boolean value (Macaulay2Doc), new value
  * Outputs:
      * a Boolean value (Macaulay2Doc), old value

Ways to use setHomSwitch:
=========================

  * "setHomSwitch(Boolean)"

For the programmer
==================

The object setHomSwitch, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:110:0.

inw -- get the initial term or ideal with respect to a weight vector
********************************************************************

  * Usage:
        inF = inw(F, w)
        inI = inw(I, w)
        inM = inw(M, w)
  * Inputs:
      * F, a ring element (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
      * M, a matrix (Macaulay2Doc),
      * w, a list (Macaulay2Doc), of weights
  * Outputs:
      * inF, a ring element (Macaulay2Doc), the initial form
        of F with respect to the weight vector
      * inI, an ideal (Macaulay2Doc), the initial ideal of I with
        respect to the weight vector
      * inM, a matrix (Macaulay2Doc), with the columns generating
        the initial module of the image of M with respect to the weight vector

Description
===========

This routine computes the initial ideal of a left ideal I of the Weyl algebra
with respect to a weight vector w = (u,v) where u+v >= 0. In the case where u+v
> 0, then the ideal lives in the associated graded ring which is a commutative
ring. In the case where u+v = 0, then the ideal lives in the associated graded
ring which is again the Weyl algebra. In the general case u+v >= 0 the
associated graded ring is somewhere between. There are two strategies to
compute the initial ideal. One is to homogenize to an ideal of the homogeneous
Weyl algebra. The other is to homogenize with respect to the weight vector w.
For more details, see [SST (see
https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Sections 1.1 and 1.2].

+------------------------------------------------+
|i1 : makeWA(QQ[x,y])                            |
|                                                |
|o1 = QQ[x..y, dx, dy]                           |
|                                                |
|o1 : PolynomialRing, 2 differential variable(s) |
+------------------------------------------------+
|i2 : I = ideal (x*dx+2*y*dy-3, dx^2-dy)         |
|                                                |
|                                2               |
|o2 = ideal (x*dx + 2y*dy - 3, dx  - dy)         |
|                                                |
|o2 : Ideal of QQ[x..y, dx, dy]                  |
+------------------------------------------------+
|i3 : inw(I, {1,3,3,-1})                         |
|                                                |
|                    2              2  2         |
|o3 = ideal (x*dx, dx , 2y*dx*dy, 4y dy  + 2x*dx)|
|                                                |
|o3 : Ideal of QQ[x..y, dx, dy]                  |
+------------------------------------------------+
|i4 : inw(I, {-1,-3,1,3})                        |
|                                                |
|o4 = ideal (x*dx + 2y*dy - 3, dy)               |
|                                                |
|o4 : Ideal of QQ[x..y, dx, dy]                  |
+------------------------------------------------+

Caveat
======

The weight vector w = (u,v) must have u+v>=0.

See also
========

  * gbw -- compute a Gröbner basis with respect to a weight vector
  * setHomSwitch -- toggle the use of homogeneous Weyl
    algebra

Ways to use inw:
================

  * "inw(Ideal,List)"
  * "inw(Matrix,List)"
  * "inw(RingElement,List)"

For the programmer
==================

The object inw, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:102:0.

Fourier -- Fourier transform for Weyl algebra
*********************************************

  * Usage:
        Fourier A
        FourierInverse A
  * Inputs:
      * A, a matrix (Macaulay2Doc), a ring element (Macaulay2Doc),
        an ideal (Macaulay2Doc), or a
        complex (Complexes), over the Weyl algebra
  * Outputs:
      * a matrix (Macaulay2Doc), a ring element (Macaulay2Doc),
        an ideal (Macaulay2Doc), or a
        complex (Complexes), the Fourier transform of A as a
        matrix, function, ideal, or chain complex over the Weyl algebra

Description
===========

The Fourier transform is the automorphism of the Weyl algebra that sends x  to
                                                                          i
-D  and D  to x . In order to compute the Fourier transform of the finitely
  i      i     i
generated module M, we compute the Fourier transform of the matrix A of which M
is the cokernel.

+-------------------------------------------------------+
|i1 : makeWA(QQ[x,y])                                   |
|                                                       |
|o1 = QQ[x..y, dx, dy]                                  |
|                                                       |
|o1 : PolynomialRing, 2 differential variable(s)        |
+-------------------------------------------------------+
|i2 : A = matrix{{2*x^2+1,y*dy},{9*x*dx, x*y*dx^2}}     |
|                                                       |
|o2 = | 2x2+1 ydy    |                                  |
|     | 9xdx  xydx^2 |                                  |
|                                                       |
|                              2                       2|
|o2 : Matrix (QQ[x..y, dx, dy])  <-- (QQ[x..y, dx, dy]) |
+-------------------------------------------------------+
|i3 : Fourier A                                         |
|                                                       |
|o3 = | 2dx^2+1 -ydy-1      |                           |
|     | -9xdx-9 x2dxdy+2xdy |                           |
|                                                       |
|                              2                       2|
|o3 : Matrix (QQ[x..y, dx, dy])  <-- (QQ[x..y, dx, dy]) |
+-------------------------------------------------------+
|i4 : L = x^2*dy + y*dy^2 + 3*dx^5*dy                   |
|                                                       |
|        5      2         2                             |
|o4 = 3dx dy + x dy + y*dy                              |
|                                                       |
|o4 : QQ[x..y, dx, dy]                                  |
+-------------------------------------------------------+
|i5 : Fourier L                                         |
|                                                       |
|       5        2    2                                 |
|o5 = 3x y + y*dx  - y dy - 2y                          |
|                                                       |
|o5 : QQ[x..y, dx, dy]                                  |
+-------------------------------------------------------+
|i6 : I = ideal(8*x*y*dy^3+y^5, dx^7+5)                 |
|                                                       |
|             5          3    7                         |
|o6 = ideal (y  + 8x*y*dy , dx  + 5)                    |
|                                                       |
|o6 : Ideal of QQ[x..y, dx, dy]                         |
+-------------------------------------------------------+
|i7 : Fourier I                                         |
|                                                       |
|              3          5      2     7                |
|o7 = ideal (8y dx*dy - dy  + 24y dx, x  + 5)           |
|                                                       |
|o7 : Ideal of QQ[x..y, dx, dy]                         |
+-------------------------------------------------------+

See also
========

  * WeylAlgebra (Macaulay2Doc)
    -- specify differential operators in the ring

Ways to use Fourier:
====================

  * "Fourier(Complex)"
  * "Fourier(Ideal)"
  * "Fourier(Matrix)"
  * "Fourier(Module)"
  * "Fourier(RingElement)"

For the programmer
==================

The object Fourier, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:156:0.

Dtransposition -- standard transposition for Weyl algebra
*********************************************************

  * Usage:
        Dtransposition A
  * Inputs:
      * A, a matrix (Macaulay2Doc), a matrix (between free
        modules), function, ideal, or chain complex of free modules over the
        Weyl algebra
  * Outputs:
      * a matrix (Macaulay2Doc), the standard transpose of A as a
        matrix, function, ideal, or chain complex over the Weyl algebra

Description
===========

The standard transposition is the involution of the Weyl algebra which sends
 a b        b a
x d  to (-d) x . It provides the equivalence in the Weyl algebra between left
and right D-modules.

+-----------------------------------------------+
|i1 : makeWeylAlgebra(QQ[x,y])                  |
|                                               |
|o1 = QQ[x..y, dx, dy]                          |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : L = x^2*dy + y*dy^2 + 3*dx^5*dy           |
|                                               |
|        5      2         2                     |
|o2 = 3dx dy + x dy + y*dy                      |
|                                               |
|o2 : QQ[x..y, dx, dy]                          |
+-----------------------------------------------+
|i3 : Dtransposition L                          |
|                                               |
|        5      2         2                     |
|o3 = 3dx dy - x dy + y*dy  + 2dy               |
|                                               |
|o3 : QQ[x..y, dx, dy]                          |
+-----------------------------------------------+

Caveat
======

The standard transposition of a left ideal should be a right ideal, however M2
currently doesn't support right modules. Thus the output is left ideal
generated by the transposition of the previous generators.

See also
========

  * WeylAlgebra (Macaulay2Doc)
    -- specify differential operators in the ring

Ways to use Dtransposition:
===========================

  * "Dtransposition(Complex)"
  * "Dtransposition(Ideal)"
  * "Dtransposition(Matrix)"
  * "Dtransposition(RingElement)"

For the programmer
==================

The object Dtransposition, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:215:0.

stafford -- computes 2 generators for a given ideal in the Weyl algebra
***********************************************************************

  * Usage:
        stafford I
  * Inputs:
      * I, an ideal (Macaulay2Doc), of the Weyl algebra
  * Outputs:
      * an ideal (Macaulay2Doc), with 2 generators (that has the
        same extension as I in $k(x)\langle dx\rangle)$

Description
===========

A theorem of Stafford says that every ideal in the Weyl algebra can be
 The current implementation provides a weaker result: the 2 generators
generated by 2 elements. This routine is the implementation of the effective
produced are guaranteed to generate only the extension of the ideal I in the
version of this theorem following the constructive proof in A.Leykin,
Weyl algebra with rational-function coefficients.
`Algorithmic proofs of two theorems of Stafford', Journal of Symbolic
Computation, 38(6):1535-1550, 2004.

+---------------------------------------------------------+
|i1 : makeWA(QQ[x_1..x_4])                                |
|                                                         |
|o1 = QQ[x ..x , dx ..dx ]                                |
|         1   4    1    4                                 |
|                                                         |
|o1 : PolynomialRing, 4 differential variable(s)          |
+---------------------------------------------------------+
|i2 : stafford ideal (dx_1,dx_2,dx_3,dx_4)                |
|                                                         |
|                  4         2         3                  |
|o2 = ideal (dx , x x dx  + x x dx  + x dx  + x dx  + dx )|
|              1   1 4  4    1 3  3    1  4    1  3     2 |
|                                                         |
|o2 : Ideal of QQ[x ..x , dx ..dx ]                       |
|                  1   4    1    4                        |
+---------------------------------------------------------+

Caveat
======

The input should be generated by at least 2 generators. The output and input
ideals are not equal necessarily.

See also
========

  * makeCyclic -- finds a cyclic generator of a D-module

Ways to use stafford:
=====================

  * "stafford(Ideal)"

For the programmer
==================

The object stafford, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:280:0.

makeCyclic -- finds a cyclic generator of a D-module
****************************************************

  * Usage:
        makeCyclic M
  * Inputs:
      * M, a matrix (Macaulay2Doc), that specifies a map such
        that coker M is a holonomic D-module
  * Outputs:
      * H, a hash table (Macaulay2Doc), where H.Generator is a
        cyclic generator and H.AnnG is the annihilator ideal of this generator

Description
===========

It is known that every holonomic module is cyclic and there is an algorithm for
computing a cyclic generator.

+-----------------------------------------------------------------+
|i1 : makeWA(QQ[x])                                               |
|                                                                 |
|o1 = QQ[x, dx]                                                   |
|                                                                 |
|o1 : PolynomialRing, 1 differential variable(s)                  |
+-----------------------------------------------------------------+
|i2 : M = matrix {{dx,0,0},{0,dx,0},{0,0,dx}} -- coker M = QQ[x]^3|
|                                                                 |
|o2 = | dx 0  0  |                                                |
|     | 0  dx 0  |                                                |
|     | 0  0  dx |                                                |
|                                                                 |
|                       3                3                        |
|o2 : Matrix (QQ[x, dx])  <-- (QQ[x, dx])                         |
+-----------------------------------------------------------------+
|i3 : h = makeCyclic M                                            |
|                                                                 |
|                               3                                 |
|o3 = HashTable{AnnG => ideal dx   }                              |
|               Generator => | x2 |                               |
|                            | x  |                               |
|                            | 1  |                               |
|                                                                 |
|o3 : HashTable                                                   |
+-----------------------------------------------------------------+

Caveat
======

The module M must be holonomic.

See also
========

  * isHolonomic -- determines whether a D-module (or ideal
    in Weyl algebra) is holonomic

Ways to use makeCyclic:
=======================

  * "makeCyclic(Matrix)"

For the programmer
==================

The object makeCyclic, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:246:0.

Dprune -- prunes a D-module
***************************

  * Usage:
        Dprune M
  * Inputs:
      * M, a matrix (Macaulay2Doc), or a module (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * MinimalGenerators => a Boolean value (Macaulay2Doc),
        default value true, indicates whether a Gröbner basis should be
        computed
  * Outputs:
      * a matrix (Macaulay2Doc), or a module (Macaulay2Doc),
        of the same type as M

Description
===========

Finds another (possibly smaller) representation of a D-module. If given a
matrix, prunes its cokernel; the result is a matrix whose cokernel is
isomorphic.
+-----------------------------------------------+
|i1 : W = makeWA(QQ[x,y])                       |
|                                               |
|o1 = W                                         |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : M = matrix{{x,dx},{1,1}}                  |
|                                               |
|o2 = | x dx |                                  |
|     | 1 1  |                                  |
|                                               |
|             2      2                          |
|o2 : Matrix W  <-- W                           |
+-----------------------------------------------+
|i3 : Dprune M                                  |
|                                               |
|o3 = | x-dx |                                  |
|                                               |
|             1      1                          |
|o3 : Matrix W  <-- W                           |
+-----------------------------------------------+
|i4 : Dprune coker M                            |
|                                               |
|o4 = cokernel | x-dx |                         |
|                                               |
|                            1                  |
|o4 : W-module, quotient of W                   |
+-----------------------------------------------+
|i5 : M = matrix{{x,dx},{x,y}}                  |
|                                               |
|o5 = | x dx |                                  |
|     | x y  |                                  |
|                                               |
|             2      2                          |
|o5 : Matrix W  <-- W                           |
+-----------------------------------------------+
|i6 : Dprune M                                  |
|                                               |
|o6 = | dx x xy-xdx |                           |
|     | y  x 0      |                           |
|                                               |
|             2      3                          |
|o6 : Matrix W  <-- W                           |
+-----------------------------------------------+

Ways to use Dprune:
===================

  * "Dprune(Matrix)"
  * "Dprune(Module)"

For the programmer
==================

The object Dprune, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:182:0.

Ddim -- dimension of a D-module
*******************************

  * Usage:
        Ddim M
        Ddim I
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra $D$
      * I, an ideal (Macaulay2Doc), which represents the module
        $M=D/I$
  * Outputs:
      * an integer (Macaulay2Doc), the dimension of $M$

Description
===========

The dimension of $M$ is equal to the dimension of the associated graded module
with respect to the Bernstein filtration. If $D$ is the Weyl algebra over $\CC$
with generators $x_1,\dots,x_n$ and $\partial_1,\dots,\partial_n$, then the
Bernstein filtration corresponds to the weight vector $(1,...,1,1,...,1)$.

+-----------------------------------------------+
|i1 : makeWA(QQ[x,y])                           |
|                                               |
|o1 = QQ[x..y, dx, dy]                          |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : I = ideal (x*dx+2*y*dy-3, dx^2-dy)        |
|                                               |
|                                2              |
|o2 = ideal (x*dx + 2y*dy - 3, dx  - dy)        |
|                                               |
|o2 : Ideal of QQ[x..y, dx, dy]                 |
+-----------------------------------------------+
|i3 : Ddim I                                    |
|                                               |
|o3 = 2                                         |
+-----------------------------------------------+

See also
========

  * characteristicIdeal -- characteristic ideal of
    a D-module
  * holonomicRank -- holonomic rank of a D-module
  * DsingularLocus -- singular locus of a D-module

Ways to use Ddim:
=================

  * "Ddim(Ideal)"
  * "Ddim(Module)"

For the programmer
==================

The object Ddim, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:499:0.

isHolonomic -- determines whether a D-module (or ideal in Weyl algebra) is holonomic
************************************************************************************

  * Usage:
        isHolonomic M
        isHolonomic I
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
  * Outputs:
      * a Boolean value (Macaulay2Doc),

Description
===========

Let $D$ be the Weyl algebra with generators $x_1,\dots,x_n$ and
$\partial_1,\dots,\partial_n$. over a field. A $D$-module is holonomic if it
has dimension $n$. For more details see [SST (see
https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Section 1.4].

+-----------------------------------------------+
|i1 : D = makeWA(QQ[x_1..x_3])                  |
|                                               |
|o1 = D                                         |
|                                               |
|o1 : PolynomialRing, 3 differential variable(s)|
+-----------------------------------------------+
|i2 : A = matrix{{1,1,1},{0,1,2}}               |
|                                               |
|o2 = | 1 1 1 |                                 |
|     | 0 1 2 |                                 |
|                                               |
|              2       3                        |
|o2 : Matrix ZZ  <-- ZZ                         |
+-----------------------------------------------+
|i3 : b = {3,4}                                 |
|                                               |
|o3 = {3, 4}                                    |
|                                               |
|o3 : List                                      |
+-----------------------------------------------+

See also
========

  * Ddim -- dimension of a D-module
  * holonomicRank -- holonomic rank of a D-module

Ways to use isHolonomic:
========================

  * "isHolonomic(Ideal)"
  * "isHolonomic(Module)"

For the programmer
==================

The object isHolonomic, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:317:0.

holonomicRank -- holonomic rank of a D-module
*********************************************

  * Usage:
        holonomicRank M
        holonomicRank I
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
  * Outputs:
      * an integer (Macaulay2Doc), the rank of M
  * Consequences:
      * if the system has finite holonomic rank, a basis for differential
        operators modulo the system is cached under M.cache#"standard
        monomials" or (comodule I).cache#"standard monomials".

Description
===========

The holonomic rank of a D-module M = D^r/N provides analytic information about
the system of PDE's given by N. By the Cauchy-Kovalevskii-Kashiwara Theorem,
the dimension of the space of germs of holomorphic solutions to N in a
neighborhood of a nonsingular point is equal to the holonomic rank of M.

The holonomic rank of a D-module is defined algebraically as follows. Let $D$
be the Weyl algebra with generators $x_1,\dots,x_n$ and
$\partial_1,\dots,\partial_n$ over $\CC$. and let $R$ denote the ring of
differential operators $\CC(x_1,\dots,x_n)\langle\partial_1,\dots,\partial_n\
rangle$ with rational function coefficients. Then the holonomic rank of $M =
D^r/N$ is equal to the dimension of $R^r/RN$ as a vector space over
$\CC[x_1,\dots,x_n]$.

+-----------------------------------------------+
|i1 : makeWA(QQ[x,y])                           |
|                                               |
|o1 = QQ[x..y, dx, dy]                          |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : I = ideal (x*dx+2*y*dy-3, dx^2-dy)        |
|                                               |
|                                2              |
|o2 = ideal (x*dx + 2y*dy - 3, dx  - dy)        |
|                                               |
|o2 : Ideal of QQ[x..y, dx, dy]                 |
+-----------------------------------------------+
|i3 : holonomicRank I                           |
|                                               |
|o3 = 2                                         |
+-----------------------------------------------+

The holonomic rank is also determined by the number of standard monomials
$\{\partial^\alpha\}$ with respect to a Gröbner basis of $I$ for any term order
on $R$. For convenience, these standard monomials, which form a basis for
differential operators modulo the system, are cached.

+-------------------------------------------------------+
|i4 : (comodule I).cache#"standard monomials"           |
|                                                       |
|o4 = | 1 dy |                                          |
|                                                       |
|                              1                       2|
|o4 : Matrix (QQ[x..y, dx, dy])  <-- (QQ[x..y, dx, dy]) |
+-------------------------------------------------------+

References
==========

See [SST (see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ),
Algorithm 1.4.17] for more details.

See also
========

  * characteristicIdeal -- characteristic ideal of
    a D-module
  * DsingularLocus -- singular locus of a D-module
  * Ddim -- dimension of a D-module

Ways to use holonomicRank:
==========================

  * "holonomicRank(Ideal)"
  * "holonomicRank(Module)"

For the programmer
==================

The object holonomicRank, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:463:0.

characteristicIdeal -- characteristic ideal of a D-module
*********************************************************

  * Usage:
        characteristicIdeal M, characteristicIdeal I
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
  * Outputs:
      * an ideal (Macaulay2Doc), the characteristic ideal of M

Description
===========

The characteristic ideal of M is the annihilator of gr(M) under a good
filtration with respect to the order filtration. If $D$ is the Weyl algebra
over $\CC$ with generators $x_1,\dots,x_n$ and $\partial_1,\dots,\partial_n$,
then the order filtration corresponds to the weight vector $(0,...,0,1,...,1)$.
The characteristic ideal lives in the associated graded ring of $D$ with
respect to the order filtration, and this is a commutative polynomial ring
$\CC[x_1,\dots,x_n,\xi_1,\dots,\xi_n]$. Here the $\xi_i$ is the principal
symbol of $\partial_i$, that is, the image of $\partial_i$ in the associated
graded ring. The zero locus of the characteristic ideal is equal to the
characteristic variety of D/I which is an invariant of a D-module.

The algorithm to compute the characteristic ideal consists of computing the
initial ideal of I with respect to the weight vector $(0,...,0,1...,1)$. More
details can be found in [SST (see
https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Section 1.4].

+-----------------------------------------------+
|i1 : makeWA(QQ[x,y])                           |
|                                               |
|o1 = QQ[x..y, dx, dy]                          |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : I = ideal (x*dx+2*y*dy-3, dx^2-dy)        |
|                                               |
|                                2              |
|o2 = ideal (x*dx + 2y*dy - 3, dx  - dy)        |
|                                               |
|o2 : Ideal of QQ[x..y, dx, dy]                 |
+-----------------------------------------------+
|i3 : characteristicIdeal I                     |
|                                               |
|              2                                |
|o3 = ideal (dx , x*dx + 2y*dy)                 |
|                                               |
|o3 : Ideal of QQ[x..y, dx, dy]                 |
+-----------------------------------------------+

See also
========

  * Ddim -- dimension of a D-module
  * DsingularLocus -- singular locus of a D-module
  * holonomicRank -- holonomic rank of a D-module

Ways to use characteristicIdeal:
================================

  * "characteristicIdeal(Ideal)"
  * "characteristicIdeal(Module)"

For the programmer
==================

The object characteristicIdeal, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:406:0.

DsingularLocus -- singular locus of a D-module
**********************************************

  * Usage:
        DsingularLocus M
        DsingularLocus I
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
  * Outputs:
      * an ideal (Macaulay2Doc), the singular locus of M

Description
===========

The singular locus of the system of PDE's given by I generalizes the notion of
 More details can be found in [SST (see https://mathscinet.ams.org/mathscinet/
 singular point of an ODE. Geometrically, the singular locus of a D-module M
pdf/1734566.pdf ), Section 1.4].
equals the projection of the characteristic variety of M minus the zero section
of the cotangent bundle to the base affine space C ^n.

+-----------------------------------------------+
|i1 : makeWA(QQ[x,y])                           |
|                                               |
|o1 = QQ[x..y, dx, dy]                          |
|                                               |
|o1 : PolynomialRing, 2 differential variable(s)|
+-----------------------------------------------+
|i2 : I = ideal (x*dx+2*y*dy-3, dx^2-dy)        |
|                                               |
|                                2              |
|o2 = ideal (x*dx + 2y*dy - 3, dx  - dy)        |
|                                               |
|o2 : Ideal of QQ[x..y, dx, dy]                 |
+-----------------------------------------------+
|i3 : DsingularLocus I                          |
|                                               |
|o3 = ideal y                                   |
|                                               |
|o3 : Ideal of QQ[x..y, dx, dy]                 |
+-----------------------------------------------+

See also
========

  * characteristicIdeal -- characteristic ideal of
    a D-module
  * holonomicRank -- holonomic rank of a D-module
  * Ddim -- dimension of a D-module

Ways to use DsingularLocus:
===========================

  * "DsingularLocus(Ideal)"
  * "DsingularLocus(Module)"

For the programmer
==================

The object DsingularLocus, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/basics.m2:356:0.

Dtrace -- set or get the depth of comments made by D-module routines
********************************************************************

  * Usage:
        Dtrace n
        Dtrace()
  * Inputs:
      * n, an integer (Macaulay2Doc), new level
  * Outputs:
      * an integer (Macaulay2Doc), old level

Ways to use Dtrace:
===================

  * "Dtrace(Sequence)"
  * "Dtrace(ZZ)"

For the programmer
==================

The object Dtrace, is a method function with a single argument (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/DOC/main.m2:94:0.

factorWeylAlgebra -- factor a Weyl algebra element
**************************************************

  * Usage:
        factorWeylAlgebra r
  * Inputs:
      * r, the ring element
  * Optional inputs (Macaulay2Doc),:
      * StopAfter => a number (Macaulay2Doc), default value
        infinity, indicates how many factorisations should be computed, default
        infinity
  * Outputs:
      * a list (Macaulay2Doc), a list of factorisations

Description
===========

Produces all the factorisations of the element r of a Weyl algebra (unless
StopAfter is set to a finite value, in which case the algorithm stops after
that many factorisations).

+-----------------------------------------------------------------------------+
|i1 : R = makeWA(QQ[x])                                                       |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing, 1 differential variable(s)                              |
+-----------------------------------------------------------------------------+
|i2 : factorWA(x^5*dx^2+7*x^4*dx+8*x^3-x*dx^2+dx)                             |
|                                                                             |
|        3       2                  2             3                2          |
|o2 = {(x dx + 3x  - x*dx + 1)(dx)(x  + 1), (dx)(x dx - x*dx + 2)(x  + 1),    |
|     ------------------------------------------------------------------------|
|       3       2                                      3                      |
|     (x dx + 3x  + x*dx - 1)(dx)(x - 1)(x + 1), (dx)(x dx + x*dx - 2)(x -    |
|     ------------------------------------------------------------------------|
|                                              2                              |
|     1)(x + 1), (x*dx - 1)(dx)(x - 1)(x + 1)(x  + 1)}                        |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

To reduce their number, two factorisations are considered equivalent if they
can be related by (1)      switching commuting irreducible factors or (2)
switching monomials and degree 0 factors; a normal order is chosen where
commuting factors are sorted, and monomials are pushed to the right/left if
they're differential/not.

factorWeylAlgebra uses a variety of factorisation strategies, including the one
in ``Factoring linear partial differential operators in n variables'', Mark
Giesbrecht, Albert Heinle and Viktor Levandovskyy, Journal of Symbolic
Computation Volume 75, July–August 2016, Pages 127-148.

Caveat
======

The ring of r must have variables in the same order as those created by
makeWeylAlgebra.

See also
========

  * factorWeylAlgebra1 -- give one factorisation of
    a Weyl algebra element

Ways to use factorWeylAlgebra:
==============================

  * "factorWeylAlgebra(RingElement)"

For the programmer
==================

The object factorWeylAlgebra, is a method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/factorWA.m2:499:0.

factorWeylAlgebra1 -- give one factorisation of a Weyl algebra element
**********************************************************************

  * Usage:
        factorWeylAlgebra1 r
  * Inputs:
      * r, the ring element

Description
===========

Produces one possible factorisation of the element r of a Weyl algebra. This is
a shortcut for factorWeylAlgebra, with optional
argument StopAfter=>1. Note that alternate strategies are used if only a finite
number of factorisation is required, so it may take much less time to compute,
as on this example:

+-----------------------------------------------------------------------------+
|i1 : R = makeWA(QQ[x,y])                                                     |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing, 2 differential variable(s)                              |
+-----------------------------------------------------------------------------+
|i2 : u=dx^3+x^2-8; v=1/2*dx; U=u^2+4*v; V=u^3+3*(u*v+v*u);  -- V^2==U^3+8    |
+-----------------------------------------------------------------------------+
|i6 : factorWA1(U*V)                                                          |
|                                                                             |
|        6     2  3    4        2       3      2               9     2  6     |
|o6 = (dx  + 2x dx  + x  + 6x*dx  - 16dx  - 16x  + 8dx + 64)(dx  + 3x dx  +   |
|                                                                             |
|o6 : Expression of class Product                                             |
|-----------------------------------------------------------------------------|
|  4  3    6         5       6      3  2      2  3      4       4      2      |
|3x dx  + x  + 18x*dx  - 24dx  + 18x dx  - 48x dx  - 24x  + 39dx  + 45x dx -  |
|-----------------------------------------------------------------------------|
|       2        3       2                                                    |
|144x*dx  + 192dx  + 192x  + 27x - 168dx - 512)                               |
+-----------------------------------------------------------------------------+

See also
========

  * factorWeylAlgebra -- factor a Weyl algebra
    element

For the programmer
==================

The object factorWeylAlgebra1, is a function closure (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in WeylAlgebras/factorWA.m2:499:0.

StopAfter
*********

Functions with optional argument named StopAfter:
=================================================

  * "factorWeylAlgebra(...,StopAfter=>...)" -- see factorWeylAlgebra,
    -- factor a Weyl algebra element

For the programmer
==================

The object StopAfter (missing documentation) is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in currentString:1:378.