This is Dmodules.info, produced by Macaulay2, version 1.21

Dmodules -- algorithms for D-modules
************************************

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

To begin, read the D-modules tutorial.

How to make Weyl algebras:
--------------------------

  * WeylAlgebra (Macaulay2Doc) -- an optional argument
  * makeWeylAlgebra -- Weyl algebra corresponding to a
    polynomial ring

Basic commands:
---------------

  * gbw -- Groebner bases w.r.t. a weight
  * inw -- initial form/ideal w.r.t. a weight
  * Fourier -- Fourier transform for Weyl algebra
  * Dtransposition -- standard transposition for Weyl
    algebra
  * makeCyclic -- finds a cyclic generator of a D-module
  * stafford -- computes 2 generators for a given ideal in the
    Weyl algebra

Some examples of D-modules:
---------------------------

  * gkz -- The A-hypergeometric systems of Gelfand, Kapranov and
    Zelevinsky (GKZ)
  * AppellF1 -- Appell F1 system of PDE's
  * PolyAnn -- annihilator of a polynomial in the Weyl algebra
  * RatAnn -- annihilator of a rational function in Weyl algebra

Basic invariants of D-modules:
------------------------------

  * Ddim -- dimension of a D-module
  * holonomicRank -- rank of a D-module
  * charIdeal -- characteristic ideal of a D-module
  * singLocus -- singular locus of a D-module

B-functions:
------------

  * bFunction -- b-function
  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * globalB -- compute global
    b-function and b-operator for a D-module and a polynomial
  * globalBoperator -- compute a
    b-operator of a polynomial
  * generalB -- global generalized
    Bernstein-Sato polynomial
  * localBFunction -- local
    b-function (a.k.a. the local Bernstein-Sato polynomial)
  * paramBpoly -- compute the list
    of all possible Bernstein-Sato polynomials for a polynomial with parametric
    coefficients
  * factorBFunction -- factorization
    of a b-function
  * bFunctionRoots -- get roots of a
    b-function
  * getIntRoots -- get integer roots of a
    b-function
                                                 s
  * AnnFs -- annihilator ideal of f
                                                                             s
  * AnnIFs -- annihilator ideal  of f
    for an arbitrary D-module

Resolutions and Functors:
-------------------------

  * Dresolution -- resolution of a D-module
  * Dlocalize -- localization of a D-module
  * WeylClosure -- Weyl closure of an ideal
  * Ddual -- holonomic dual of a D-module
  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module
  * DHom -- D-homomorphisms between holonomic D-modules
  * DExt -- Ext groups between holonomic modules
  * PolyExt -- Ext groups between a holonomic module and a
    polynomial ring
  * RatExt -- Ext(holonomic D-module, polynomial ring localized
    at the singular locus)

Applications:
-------------

  * localCohom -- local cohomology
  * deRham -- deRham cohomology groups for the complement of a
    hypersurface
  * PolySols -- polynomial solutions of a holonomic system
  * RatSols -- rational solutions of a holonomic system
  * diffOps -- differential operators of up to the given order
    for a quotient polynomial ring
  * populateCechComplexCC,
    pruneCechComplexCC, --
    characteristic cycles of local cohomology
  * logCohomology -- logarithmic
    cohomology groups in two variables
  * lct -- compute the log canonical threshold for an
    ideal
  * multiplierIdeal,
    isInMultiplierIdeal,
    jumpingCoefficients, -- multiplier
    ideals
  * hasRationalSing -- check if a complete
    intersection has at most rational singularities

Canonical Series:
-----------------

  * distraction -- the image in the thetaRing of a
    torus-fixed ideal in a Weyl algebra
  * genToDistractionGens -- the image in the
    thetaRing of a torus-fixed element in a Weyl algebra
  * cssExpts -- the exponents of the canonical series
    solutions of I in the direction of a weight vector
  * cssExptsMult -- the exponents (and multiplicities) of
    the canonical series solutions of I in the direction of a weight vector
  * isTorusFixed -- checks if an ideal in a Weyl algebra
    is torus-fixed
  * Canonical Series Tutorial -- Computing
    series solutions to regular holonomic systems

Programming aids:
-----------------

  * createDpairs -- pairs up the
    variables in Weyl algebra
  * Dtrace -- set the depth of comments made by D-module
    routines
  * setHomSwitch -- toggles the use of
    homogeneous Weyl algebra

Authors
=======

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

Version
=======

This documentation describes version 1.4.0.1 of Dmodules.

Source code
===========

The source code from which this documentation is derived is in the file
Dmodules.m2 (see common/share/Macaulay2/Dmodules.m2 ). The auxiliary files
accompanying it are in the directory Dmodules/ (see
common/share/Macaulay2/Dmodules/ ).

Exports
=======

  * Functions and commands
      * AnnFs -- the annihilating ideal of f^s
      * "AnnIFs" -- see AnnIFs(Ideal,RingElement),
        -- the annihilating ideal of f^s for
        an arbitrary D-module
      * AppellF1 -- Appell F1 system of PDE's
      * bFunction -- b-function
      * "bFunctionRoots" -- see bFunctionRoots(RingElement),
        -- get roots of a b-function
      * BMM -- the characteristic cycle of the localized $D$-module
      * charIdeal -- characteristic ideal of a D-module
      * "createDpairs" -- see createDpairs(PolynomialRing),
        -- pairs up the variables in Weyl
        algebra
      * cssExpts -- the exponents of the canonical series
        solutions of I in the direction of a weight vector
      * cssExptsMult -- the exponents (and multiplicities)
        of the canonical series solutions of I in the direction of a weight
        vector
      * Ddim -- dimension of a D-module
      * Ddual -- holonomic dual of a D-module
      * deRham -- deRham cohomology groups for the complement of
        a hypersurface
      * "deRhamAll" -- see deRhamAll(RingElement),
        -- deRham complex for the complement of a
        hypersurface
      * DExt -- Ext groups between holonomic modules
      * DHom -- D-homomorphisms between holonomic D-modules
      * diffOps -- differential operators of up to the given
        order for a quotient polynomial ring
      * Dintegrate -- Dintegrate* is an (OBSOLETE)
        abbreviation for Dintegration*
      * "DintegrateAll" -- see Dintegrate, -- Dintegrate* is
        an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateClasses" -- see Dintegrate, -- Dintegrate*
        is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateComplex" -- see Dintegrate, -- Dintegrate*
        is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateIdeal" -- see Dintegrate, -- Dintegrate*
        is an (OBSOLETE) abbreviation for Dintegration*
      * Dintegration -- integration modules of a D-module
      * DintegrationAll -- integration modules of a
        D-module (extended version)
      * DintegrationClasses -- integration classes
        of a D-module
      * DintegrationComplex -- derived integration
        complex of a D-module
      * DintegrationIdeal -- integration ideal of a
        D-module
      * distraction -- the image in the thetaRing of a
        torus-fixed ideal in a Weyl algebra
      * Dlocalization -- Dlocalization* is an OBSOLETE
        name for Dlocalize*
      * "DlocalizationAll" -- see Dlocalization, --
        Dlocalization* is an OBSOLETE name for Dlocalize*
      * "DlocalizationMap" -- see Dlocalization, --
        Dlocalization* is an OBSOLETE name for Dlocalize*
      * Dlocalize -- localization of a D-module
      * DlocalizeAll -- localization of a D-module
        (extended version)
      * DlocalizeMap -- localization map from a D-module
        to its localization
      * Dprune -- prunes a D-module
      * Dres -- abbreviation for Dresolution
      * Dresolution -- resolution of a D-module
      * Drestrict -- an (OBSOLETE) abbreviation for
        Drestriction
      * "DrestrictAll" -- see Drestrict, -- an (OBSOLETE)
        abbreviation for Drestriction
      * "DrestrictClasses" -- see Drestrict, -- an (OBSOLETE)
        abbreviation for Drestriction
      * "DrestrictComplex" -- see Drestrict, -- an (OBSOLETE)
        abbreviation for Drestriction
      * "DrestrictIdeal" -- see Drestrict, -- an (OBSOLETE)
        abbreviation for Drestriction
      * Drestriction -- restriction modules of a D-module
      * DrestrictionAll -- restriction modules of a
        D-module (extended version)
      * DrestrictionClasses -- restriction classes
        of a D-module
      * DrestrictionComplex -- derived restriction
        complex of a D-module
      * DrestrictionIdeal -- restriction ideal of a
        D-module
      * "Dtrace" -- see Dtrace(ZZ), -- set the depth of
        comments made by D-module routines
      * Dtransposition -- standard transposition for
        Weyl algebra
      * eulerOperators (missing documentation)
      * ExternalProduct -- external product of modules
        or complexes
      * extractDiffsAlgebra -- underlying
        polynomial ring in the differentials of a Weyl algebra
      * extractVarsAlgebra -- underlying polynomial
        ring in the ordinary variables of a Weyl algebra
      * "factorBFunction" -- see factorBFunction(RingElement),
        -- factorization of a b-function
      * Fourier -- Fourier transform for Weyl algebra
      * FourierInverse -- Inverse Fourier map
        (D-modules)
      * gbw -- Groebner bases w.r.t. a weight
      * "generalB" -- see generalB(List,RingElement),
        -- global generalized Bernstein-Sato
        polynomial
      * genToDistractionGens -- the image in the
        thetaRing of a torus-fixed element in a Weyl algebra
      * getDtrace -- (internal) -- get the INFOLEVEL switch
      * getHomSwitch -- (internal) -- get the
        HOMOGENIZATION switch
      * "getIntRoots" -- see getIntRoots(RingElement),
        -- get integer roots of a b-function
      * gkz -- The A-hypergeometric systems of Gelfand, Kapranov
        and Zelevinsky (GKZ)
      * "globalB" -- see globalB(Ideal,RingElement),
        -- compute global b-function and
        b-operator for a D-module and a polynomial
      * "globalBFunction" -- see globalBFunction(RingElement),
        -- global b-function (else known as
        the Bernstein-Sato polynomial)
      * "globalBoperator" -- see globalBoperator(RingElement),
        -- compute a b-operator of a
        polynomial
      * "hasRationalSing" -- see hasRationalSing(List),
        -- check if a complete intersection has at
        most rational singularities
      * holonomicRank -- rank of a D-module
      * ICcohom (missing documentation)
      * ICmodule (missing documentation)
      * indicialIdeal -- the image in the thetaRing of an
        indicial ideal in a Weyl algebra
      * inw -- initial form/ideal w.r.t. a weight
      * isHolonomic -- determines whether a D-module (or
        ideal in Weyl algebra) is holonomic
      * "isInMultiplierIdeal" -- see
        isInMultiplierIdeal(RingElement,Ideal,QQ),
        -- multiplier ideal
        membership test
      * isTorusFixed -- checks if an ideal in a Weyl
        algebra is torus-fixed
      * "jumpingCoefficients" -- see jumpingCoefficients(Ideal),
        -- jumping coefficients and
        corresponding multiplier ideals
      * kappaAnnF1PlanarCurve -- D-annihilator of
        1/f for a planar curve
      * kOrderAnnFa -- k-th order D-annihilator of a power
        of a polynomial
      * "kOrderAnnFs" -- see kOrderAnnFa, -- k-th order
        D-annihilator of a power of a polynomial
      * "lct" -- see lct(Ideal), -- compute the log
        canonical threshold for an ideal
      * "localBFunction" -- see localBFunction(RingElement,Ideal),
        -- local b-function (a.k.a.
        the local Bernstein-Sato polynomial)
      * localCohom -- local cohomology
      * "logCohomology" -- see logCohomology(RingElement),
        -- logarithmic cohomology groups in two
        variables
      * makeCyclic -- finds a cyclic generator of a D-module
      * makeWeylAlgebra -- Weyl algebra corresponding
        to a polynomial ring
      * "multiplierIdeal" -- see multiplierIdeal(Ideal,QQ),
        -- multiplier ideal
      * "paramBpoly" -- see paramBpoly(RingElement,String),
        -- compute the list of all
        possible Bernstein-Sato polynomials for a polynomial with parametric
        coefficients
      * pInfo -- prints tracing info
      * PolyAnn -- annihilator of a polynomial in the Weyl
        algebra
      * PolyExt -- Ext groups between a holonomic module and a
        polynomial ring
      * PolySols -- polynomial solutions of a holonomic system
      * "populateCechComplexCC" -- see populateCechComplexCC(Ideal,List),
        -- Cech complex skeleton for
        the computation of the characteristic cycles of local cohomology
        modules
      * "pruneCechComplexCC" -- see pruneCechComplexCC(MutableHashTable),
        -- reduction of the Cech
        complex that produces characteristic cycles of local cohomology modules
      * "pruneLocalCohom" -- see pruneLocalCohom(HashTable),
        -- prunes local cohomology modules
      * "putWeylAlgebra" -- see putWeylAlgebra(HashTable),
        -- transforms output of diffOps into
        elements of Weyl algebra
      * RatAnn -- annihilator of a rational function in Weyl
        algebra
      * RatExt -- Ext(holonomic D-module, polynomial ring
        localized at the singular locus)
      * RatSols -- rational solutions of a holonomic system
      * reiffen -- Reiffen's curve
      * "setHomSwitch" -- see setHomSwitch(Boolean),
        -- toggles the use of homogeneous Weyl
        algebra
      * singLocus -- singular locus of a D-module
      * solveFrobeniusIdeal -- solving Frobenius
        ideals
      * stafford -- computes 2 generators for a given ideal in
        the Weyl algebra
      * toricIdealPartials -- image of a monomial
        map
      * WeylClosure -- Weyl closure of an ideal
  * Methods
      * AnnFs(List) -- the annihilating ideal of
        f_1^{s_1}...f_r^{s_r}
      * AnnFs(RingElement) -- the annihilating
        ideal of f^s
      * AnnIFs(Ideal,RingElement), --
        the annihilating ideal of f^s for an arbitrary D-module
      * "AppellF1(List)" -- see AppellF1, -- Appell F1 system
        of PDE's
      * bFunction(Ideal,List) -- b-function
        of an ideal
      * bFunction(Module,List,List),
        -- b-function of a holonomic D-module
      * bFunctionRoots(RingElement), --
        get roots of a b-function
      * "BMM(Ideal,RingElement)" -- see BMM, -- the characteristic
        cycle of the localized $D$-module
      * "BMM(List,RingElement)" -- see BMM, -- the characteristic
        cycle of the localized $D$-module
      * "charIdeal(Ideal)" -- see charIdeal, -- characteristic
        ideal of a D-module
      * "charIdeal(Module)" -- see charIdeal, --
        characteristic ideal of a D-module
      * createDpairs(PolynomialRing),
        -- pairs up the variables in Weyl algebra
      * "cssExpts(Ideal,List)" -- see cssExpts, -- the
        exponents of the canonical series solutions of I in the direction of a
        weight vector
      * "cssExptsMult(Ideal,List)" -- see cssExptsMult, --
        the exponents (and multiplicities) of the canonical series solutions of
        I in the direction of a weight vector
      * "Ddim(Ideal)" -- see Ddim, -- dimension of a D-module
      * "Ddim(Module)" -- see Ddim, -- dimension of a D-module
      * "Ddual(Ideal)" -- see Ddual, -- holonomic dual of a
        D-module
      * "Ddual(Module)" -- see Ddual, -- holonomic dual of a
        D-module
      * "deRham(RingElement)" -- see deRham, -- deRham cohomology
        groups for the complement of a hypersurface
      * "deRham(ZZ,RingElement)" -- see deRham, -- deRham
        cohomology groups for the complement of a hypersurface
      * deRhamAll(RingElement) -- deRham
        complex for the complement of a hypersurface
      * "DExt(Module,Module)" -- see DExt, -- Ext groups between
        holonomic modules
      * "DExt(Module,Module,List)" -- see DExt, -- Ext groups
        between holonomic modules
      * "DHom(Ideal,Ideal)" -- see DHom, -- D-homomorphisms between
        holonomic D-modules
      * "DHom(Module,Module)" -- see DHom, -- D-homomorphisms
        between holonomic D-modules
      * "DHom(Module,Module,List)" -- see DHom, -- D-homomorphisms
        between holonomic D-modules
      * "diffOps(Ideal,ZZ)" -- see diffOps, -- differential
        operators of up to the given order for a quotient polynomial ring
      * "diffOps(RingElement,ZZ)" -- see diffOps, --
        differential operators of up to the given order for a quotient
        polynomial ring
      * "Dintegrate(Ideal,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "Dintegrate(Module,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "Dintegrate(ZZ,Ideal,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "Dintegrate(ZZ,Module,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateAll(Ideal,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateAll(Module,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateClasses(Ideal,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateClasses(Module,List)" -- see Dintegrate,
        -- Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateClasses(ZZ,Ideal,List)" -- see Dintegrate,
        -- Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateClasses(ZZ,Module,List)" -- see Dintegrate,
        -- Dintegrate* is an (OBSOLETE) abbreviation for
        Dintegration*
      * "DintegrateComplex(Ideal,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateComplex(Module,List)" -- see Dintegrate,
        -- Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "DintegrateIdeal(Ideal,List)" -- see Dintegrate, --
        Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
      * "Dintegration(Ideal,List)" -- see Dintegration, --
        integration modules of a D-module
      * "Dintegration(Module,List)" -- see Dintegration, --
        integration modules of a D-module
      * "Dintegration(ZZ,Ideal,List)" -- see Dintegration,
        -- integration modules of a D-module
      * "Dintegration(ZZ,Module,List)" -- see Dintegration,
        -- integration modules of a D-module
      * "DintegrationAll(Ideal,List)" -- see DintegrationAll,
        -- integration modules of a D-module (extended
        version)
      * "DintegrationAll(Module,List)" -- see DintegrationAll,
        -- integration modules of a D-module (extended
        version)
      * "DintegrationClasses(Ideal,List)" -- see DintegrationClasses,
        -- integration classes of a D-module
      * "DintegrationClasses(Module,List)" -- see DintegrationClasses,
        -- integration classes of a D-module
      * "DintegrationClasses(ZZ,Ideal,List)" -- see DintegrationClasses,
        -- integration classes of a D-module
      * "DintegrationClasses(ZZ,Module,List)" -- see DintegrationClasses,
        -- integration classes of a D-module
      * "DintegrationComplex(Ideal,List)" -- see DintegrationComplex,
        -- derived integration complex of a D-module
      * "DintegrationComplex(Module,List)" -- see DintegrationComplex,
        -- derived integration complex of a D-module
      * "DintegrationIdeal(Ideal,List)" -- see DintegrationIdeal,
        -- integration ideal of a D-module
      * "distraction(Ideal,Ring)" -- see distraction, -- the
        image in the thetaRing of a torus-fixed ideal in a Weyl algebra
      * "Dlocalization(Ideal,RingElement)" -- see Dlocalization,
        -- Dlocalization* is an OBSOLETE name for Dlocalize*
      * "Dlocalization(Module,RingElement)" -- see Dlocalization,
        -- Dlocalization* is an OBSOLETE name for Dlocalize*
      * "DlocalizationAll(Ideal,RingElement)" -- see Dlocalization,
        -- Dlocalization* is an OBSOLETE name for Dlocalize*
      * "DlocalizationAll(Module,RingElement)" -- see Dlocalization,
        -- Dlocalization* is an OBSOLETE name for Dlocalize*
      * "DlocalizationMap(Ideal,RingElement)" -- see Dlocalization,
        -- Dlocalization* is an OBSOLETE name for Dlocalize*
      * "DlocalizationMap(Module,RingElement)" -- see Dlocalization,
        -- Dlocalization* is an OBSOLETE name for Dlocalize*
      * "Dlocalize(Ideal,RingElement)" -- see Dlocalize, --
        localization of a D-module
      * "Dlocalize(Module,RingElement)" -- see Dlocalize, --
        localization of a D-module
      * "DlocalizeAll(Ideal,RingElement)" -- see DlocalizeAll,
        -- localization of a D-module (extended version)
      * "DlocalizeAll(Module,RingElement)" -- see DlocalizeAll,
        -- localization of a D-module (extended version)
      * "DlocalizeMap(Ideal,RingElement)" -- see DlocalizeMap,
        -- localization map from a D-module to its localization
      * "DlocalizeMap(Module,RingElement)" -- see DlocalizeMap,
        -- localization map from a D-module to its localization
      * "Dprune(Matrix)" -- see Dprune, -- prunes a D-module
      * "Dprune(Module)" -- see Dprune, -- prunes a D-module
      * "Dres(Ideal)" -- see Dres, -- abbreviation for Dresolution
      * "Dres(Ideal,List)" -- see Dres, -- abbreviation for
        Dresolution
      * "Dres(Module)" -- see Dres, -- abbreviation for Dresolution
      * "Dres(Module,List)" -- see Dres, -- abbreviation for
        Dresolution
      * "Dresolution(Ideal)" -- see Dresolution, --
        resolution of a D-module
      * "Dresolution(Ideal,List)" -- see Dresolution, --
        resolution of a D-module
      * "Dresolution(Module)" -- see Dresolution, --
        resolution of a D-module
      * "Dresolution(Module,List)" -- see Dresolution, --
        resolution of a D-module
      * "Drestrict(Ideal,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "Drestrict(Module,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "Drestrict(ZZ,Ideal,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "Drestrict(ZZ,Module,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "DrestrictAll(Ideal,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "DrestrictAll(Module,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "DrestrictClasses(Ideal,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "DrestrictClasses(Ideal,List,ZZ)" -- see Drestrict, --
        an (OBSOLETE) abbreviation for Drestriction
      * "DrestrictClasses(Module,List)" -- see Drestrict, --
        an (OBSOLETE) abbreviation for Drestriction
      * "DrestrictClasses(Module,List,ZZ)" -- see Drestrict,
        -- an (OBSOLETE) abbreviation for Drestriction
      * "DrestrictComplex(Ideal,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "DrestrictComplex(Ideal,List,ZZ)" -- see Drestrict, --
        an (OBSOLETE) abbreviation for Drestriction
      * "DrestrictComplex(Module,List)" -- see Drestrict, --
        an (OBSOLETE) abbreviation for Drestriction
      * "DrestrictComplex(Module,List,ZZ)" -- see Drestrict,
        -- an (OBSOLETE) abbreviation for Drestriction
      * "DrestrictIdeal(Ideal,List)" -- see Drestrict, -- an
        (OBSOLETE) abbreviation for Drestriction
      * "Drestriction(Ideal,List)" -- see Drestriction, --
        restriction modules of a D-module
      * "Drestriction(Module,List)" -- see Drestriction, --
        restriction modules of a D-module
      * "Drestriction(ZZ,Ideal,List)" -- see Drestriction,
        -- restriction modules of a D-module
      * "Drestriction(ZZ,Module,List)" -- see Drestriction,
        -- restriction modules of a D-module
      * "DrestrictionAll(Ideal,List)" -- see DrestrictionAll,
        -- restriction modules of a D-module (extended
        version)
      * "DrestrictionAll(Module,List)" -- see DrestrictionAll,
        -- restriction modules of a D-module (extended
        version)
      * "DrestrictionClasses(Ideal,List)" -- see DrestrictionClasses,
        -- restriction classes of a D-module
      * "DrestrictionClasses(Module,List)" -- see DrestrictionClasses,
        -- restriction classes of a D-module
      * "DrestrictionClasses(ZZ,Ideal,List)" -- see DrestrictionClasses,
        -- restriction classes of a D-module
      * "DrestrictionClasses(ZZ,Module,List)" -- see DrestrictionClasses,
        -- restriction classes of a D-module
      * "DrestrictionComplex(Ideal,List)" -- see DrestrictionComplex,
        -- derived restriction complex of a D-module
      * "DrestrictionComplex(Module,List)" -- see DrestrictionComplex,
        -- derived restriction complex of a D-module
      * "DrestrictionIdeal(Ideal,List)" -- see DrestrictionIdeal,
        -- restriction ideal of a D-module
      * Dtrace(ZZ) -- set the depth of comments made by
        D-module routines
      * "Dtransposition(ChainComplex)" -- 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
      * "ExternalProduct(ChainComplex,ChainComplex)" -- see
        ExternalProduct, -- external product of modules or
        complexes
      * "ExternalProduct(Module,Module)" -- see ExternalProduct,
        -- external product of modules or complexes
      * "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
      * factorBFunction(RingElement),
        -- factorization of a b-function
      * "Fourier(Ideal)" -- see Fourier, -- Fourier transform
        for Weyl algebra
      * "Fourier(Matrix)" -- see Fourier, -- Fourier transform
        for Weyl algebra
      * "Fourier(RingElement)" -- see Fourier, -- Fourier
        transform for Weyl algebra
      * "FourierInverse(ChainComplex)" -- see FourierInverse,
        -- Inverse Fourier map (D-modules)
      * "FourierInverse(Ideal)" -- see FourierInverse, --
        Inverse Fourier map (D-modules)
      * "FourierInverse(Matrix)" -- see FourierInverse,
        -- Inverse Fourier map (D-modules)
      * "FourierInverse(Module)" -- see FourierInverse,
        -- Inverse Fourier map (D-modules)
      * "FourierInverse(RingElement)" -- see FourierInverse,
        -- Inverse Fourier map (D-modules)
      * "gbw(Ideal,List)" -- see gbw, -- Groebner bases w.r.t. a
        weight
      * "gbw(Matrix,List)" -- see gbw, -- Groebner bases w.r.t. a
        weight
      * "generalB(List)" -- see generalB(List,RingElement),
        -- global generalized Bernstein-Sato
        polynomial
      * generalB(List,RingElement), --
        global generalized Bernstein-Sato polynomial
      * "genToDistractionGens(RingElement,Ring)" -- see
        genToDistractionGens, -- the image in the
        thetaRing of a torus-fixed element in a Weyl algebra
      * getIntRoots(RingElement) -- get
        integer roots of a b-function
      * "gkz(Matrix,List)" -- see gkz, -- The A-hypergeometric
        systems of Gelfand, Kapranov and Zelevinsky (GKZ)
      * "gkz(Matrix,List,PolynomialRing)" -- see gkz, -- The
        A-hypergeometric systems of Gelfand, Kapranov and Zelevinsky (GKZ)
      * globalB(Ideal,RingElement), --
        compute global b-function and b-operator for a D-module and a
        polynomial
      * globalBFunction(RingElement),
        -- global b-function (else known as the Bernstein-Sato polynomial)
      * globalBoperator(RingElement),
        -- compute a b-operator of a polynomial
      * hasRationalSing(List) -- check if a
        complete intersection has at most rational singularities
      * "holonomicRank(Ideal)" -- see holonomicRank, --
        rank of a D-module
      * "holonomicRank(Module)" -- see holonomicRank, --
        rank of a D-module
      * "indicialIdeal(Ideal,List)" -- see indicialIdeal,
        -- the image in the thetaRing of an indicial ideal in a Weyl algebra
      * "inw(Ideal,List)" -- see inw, -- initial form/ideal w.r.t. a
        weight
      * "inw(Matrix,List)" -- see inw, -- initial form/ideal w.r.t.
        a weight
      * "inw(RingElement,List)" -- see inw, -- initial form/ideal
        w.r.t. a weight
      * "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
      * isInMultiplierIdeal(RingElement,Ideal,QQ)
        -- multiplier ideal
        membership test
      * "isTorusFixed(Ideal)" -- see isTorusFixed, --
        checks if an ideal in a Weyl algebra is torus-fixed
      * jumpingCoefficients(Ideal), --
        jumping coefficients and corresponding multiplier ideals
      * "jumpingCoefficients(Ideal,QQ,QQ)" -- see
        jumpingCoefficients(Ideal), -- jumping
        coefficients and corresponding multiplier ideals
      * "jumpingCoefficients(Ideal,QQ,ZZ)" -- see
        jumpingCoefficients(Ideal), -- jumping
        coefficients and corresponding multiplier ideals
      * "jumpingCoefficients(Ideal,ZZ,QQ)" -- see
        jumpingCoefficients(Ideal), -- jumping
        coefficients and corresponding multiplier ideals
      * "jumpingCoefficients(Ideal,ZZ,ZZ)" -- see
        jumpingCoefficients(Ideal), -- jumping
        coefficients and corresponding multiplier ideals
      * "kappaAnnF1PlanarCurve(RingElement)" -- see
        kappaAnnF1PlanarCurve, -- D-annihilator of 1/f
        for a planar curve
      * "kOrderAnnFa(ZZ,RingElement,ZZ)" -- see kOrderAnnFa,
        -- k-th order D-annihilator of a power of a polynomial
      * "kOrderAnnFs(ZZ,RingElement)" -- see kOrderAnnFa, --
        k-th order D-annihilator of a power of a polynomial
      * lct(Ideal) -- compute the log canonical
        threshold for an ideal
      * localBFunction(RingElement,Ideal)
        -- local b-function (a.k.a.
        the local Bernstein-Sato polynomial)
      * localCohom(Ideal) -- local cohomology of
        a polynomial ring
      * localCohom(Ideal,Module), --
        local cohomology of a D-module
      * localCohom(List,Ideal) -- local
        cohomology of a polynomial ring
      * localCohom(List,Ideal,Module)
        -- local cohomology of a
        D-module
      * localCohom(ZZ,Ideal) -- local
        cohomology of a polynomial ring
      * localCohom(ZZ,Ideal,Module),
        -- local cohomology of a D-module
      * logCohomology(RingElement), --
        logarithmic cohomology groups in two variables
      * "makeCyclic(Matrix)" -- see makeCyclic, -- finds a
        cyclic generator of a D-module
      * "makeWeylAlgebra(PolynomialRing)" -- see makeWeylAlgebra,
        -- Weyl algebra corresponding to a polynomial ring
      * "multiplierIdeal(Ideal,List)" -- see multiplierIdeal(Ideal,QQ),
        -- multiplier ideal
      * multiplierIdeal(Ideal,QQ), --
        multiplier ideal
      * "multiplierIdeal(Ideal,ZZ)" -- see multiplierIdeal(Ideal,QQ),
        -- multiplier ideal
      * paramBpoly(RingElement,String)
        -- compute the list of all
        possible Bernstein-Sato polynomials for a polynomial with parametric
        coefficients
      * "pInfo(ZZ,List)" -- see pInfo, -- prints tracing info
      * "pInfo(ZZ,Thing)" -- see pInfo, -- prints tracing info
      * "PolyAnn(RingElement)" -- see PolyAnn, -- annihilator of
        a polynomial in the Weyl algebra
      * "PolyExt(Ideal)" -- see PolyExt, -- Ext groups between a
        holonomic module and a polynomial ring
      * "PolyExt(Module)" -- see PolyExt, -- Ext groups between
        a holonomic module and a polynomial ring
      * "PolyExt(ZZ,Ideal)" -- see PolyExt, -- Ext groups
        between a holonomic module and a polynomial ring
      * "PolyExt(ZZ,Module)" -- see PolyExt, -- Ext groups
        between a holonomic module and a polynomial ring
      * "PolySols(Ideal)" -- see PolySols, -- polynomial
        solutions of a holonomic system
      * "PolySols(Ideal,List)" -- see PolySols, -- polynomial
        solutions of a holonomic system
      * "PolySols(Module)" -- see PolySols, -- polynomial
        solutions of a holonomic system
      * "PolySols(Module,List)" -- see PolySols, -- polynomial
        solutions of a holonomic system
      * populateCechComplexCC(Ideal,List)
        -- Cech complex skeleton for
        the computation of the characteristic cycles of local cohomology
        modules
      * pruneCechComplexCC(MutableHashTable)
        -- reduction of the Cech
        complex that produces characteristic cycles of local cohomology modules
      * pruneLocalCohom(HashTable), --
        prunes local cohomology modules
      * putWeylAlgebra(HashTable), --
        transforms output of diffOps into elements of Weyl algebra
      * "RatAnn(RingElement)" -- see RatAnn, -- annihilator of a
        rational function in Weyl algebra
      * "RatAnn(RingElement,RingElement)" -- see RatAnn, --
        annihilator of a rational function in Weyl algebra
      * "RatExt(Ideal)" -- see RatExt, -- Ext(holonomic D-module,
        polynomial ring localized at the singular locus)
      * "RatExt(Ideal,RingElement)" -- see RatExt, --
        Ext(holonomic D-module, polynomial ring localized at the singular
        locus)
      * "RatExt(Module)" -- see RatExt, -- Ext(holonomic
        D-module, polynomial ring localized at the singular locus)
      * "RatExt(Module,RingElement)" -- see RatExt, --
        Ext(holonomic D-module, polynomial ring localized at the singular
        locus)
      * "RatExt(ZZ,Ideal)" -- see RatExt, -- Ext(holonomic
        D-module, polynomial ring localized at the singular locus)
      * "RatExt(ZZ,Ideal,RingElement)" -- see RatExt, --
        Ext(holonomic D-module, polynomial ring localized at the singular
        locus)
      * "RatExt(ZZ,Module)" -- see RatExt, -- Ext(holonomic
        D-module, polynomial ring localized at the singular locus)
      * "RatExt(ZZ,Module,RingElement)" -- see RatExt, --
        Ext(holonomic D-module, polynomial ring localized at the singular
        locus)
      * "RatSols(Ideal)" -- see RatSols, -- rational solutions
        of a holonomic system
      * "RatSols(Ideal,List)" -- see RatSols, -- rational
        solutions of a holonomic system
      * "RatSols(Ideal,List,List)" -- see RatSols, -- rational
        solutions of a holonomic system
      * "RatSols(Ideal,RingElement)" -- see RatSols, -- rational
        solutions of a holonomic system
      * "RatSols(Ideal,RingElement,List)" -- see RatSols, --
        rational solutions of a holonomic system
      * "reiffen(ZZ,ZZ)" -- see reiffen, -- Reiffen's curve
      * setHomSwitch(Boolean) -- toggles the
        use of homogeneous Weyl algebra
      * "singLocus(Ideal)" -- see singLocus, -- singular locus
        of a D-module
      * "singLocus(Module)" -- see singLocus, -- singular
        locus of a D-module
      * "solveFrobeniusIdeal(Ideal)" -- see solveFrobeniusIdeal,
        -- solving Frobenius ideals
      * "stafford(Ideal)" -- see stafford, -- computes 2
        generators for a given ideal in the Weyl algebra
      * "toricIdealPartials(Matrix,PolynomialRing)" -- see
        toricIdealPartials, -- image of a monomial map
      * "WeylClosure(Ideal)" -- see WeylClosure, -- Weyl
        closure of an ideal
      * "WeylClosure(Ideal,RingElement)" -- see WeylClosure,
        -- Weyl closure of an ideal
  * Symbols
      * Alg
      * annFS -- a key created by Dlocalize
      * AnnG -- a key created by makeCyclic
      * BasisElts -- a key of the hashtable generated by
        diffOps
      * BFunction -- a key in the hashtable created by
        Drestriction/Dintegration
      * Bfunction -- a key created by Dlocalize
      * Boperator -- a key attached by globalB and Dlocalize
      * Boundaries -- a key in the hashtable created by
        Drestriction/Dintegration
      * Bpolynomial -- a key attached by globalB
      * CohomologyGroups -- a key in the hashtable
        created by deRham
      * Cycles -- a key in the hashtable created by
        Drestriction/Dintegration
      * "Oaku" -- see Dlocalize(...,Strategy=>...),
        -- strategy for
        computing a localization of a D-module
      * "OTW" -- see Dlocalize(...,Strategy=>...),
        -- strategy for
        computing a localization of a D-module
      * "OTWcyclic" -- see Dlocalize(...,Strategy=>...),
        -- strategy for
        computing a localization of a D-module
      * dpairInds -- a key attached by createDpairs
      * dpairVars -- a key attached by createDpairs
      * "optGB" -- see Dprune(...,optGB=>...),
        -- indicates whether a
        Grobner basis should be computed
      * Duality -- an option for PolySols=>Alg
      * Explicit -- a key in the hashtable created by
        Drestriction/Dintegration
      * Exponents -- a key in the hashtable created by
        Drestriction/Dintegration
      * GD -- an option for PolySols=>Alg
      * GenCycles -- a key in the hashtable created by
        Drestriction/Dintegration
      * "Exponent" -- see generalB(...,Exponent=>...),
        -- specify exponent m
        for m-generalized Bernstein-Sato polynomial
      * "InitialIdeal" -- see generalB(...,Strategy=>...),
        -- specify strategy for
        computing generalized Bernstein-Sato polynomial
      * "StarIdeal" -- see generalB(...,Strategy=>...),
        -- specify strategy for
        computing generalized Bernstein-Sato polynomial
      * GeneralBernsteinSato -- a strategy option
        for lct, globalBFunction
      * Generator -- a key created by makeCyclic
      * GeneratorPower -- a key created by Dlocalize
      * GroundField
      * HomologyModules -- a key in a hashtable; an
        option of DExt
      * Info
      * IntegrateBfunction -- a key created by
        Dlocalize
      * IntegrateComplex -- a key in the hashtable
        created by Dintegration
      * IntRing -- a strategy option for b-functions
      * "generalizedBFunction" -- see
        isInMultiplierIdeal(RingElement,Ideal,QQ),
        -- multiplier ideal
        membership test
      * "mGeneralizedBFunction" -- see
        isInMultiplierIdeal(RingElement,Ideal,QQ),
        -- multiplier ideal
        membership test
      * LocalizeMap -- a key in the hashtable created by
        deRham
      * LocCohomStrategy (missing documentation)
      * LocMap -- a key created by Dlocalize
      * LocModule -- a key created by Dlocalize
      * LocStrategy
      * None -- an option for DExt=>Special
      * NonGeneric -- a strategy option for b-functions
      * OaTa -- an option for localCohom=>Strategy
      * OaTaWa -- an option for localCohom => LocStrategy
      * OmegaRes -- a key in the hashtable created by deRham
      * Output
      * PolyGens -- a key of the hashtable generated by
        diffOps
      * PreCycles -- a key in the hashtable created by deRham
      * projMap1 -- a key attached by ExternalProduct
      * projMap2 -- a key attached by ExternalProduct
      * ReducedB -- a strategy option for global b-functions
      * Schreyer -- strategy for computing a resolution of a
        D-module
      * SetVariables -- name for an optional argument
      * Special
      * TransferCycles -- a key in the hashtable created
        by deRham
      * TryGeneric -- a strategy option for b-functions
      * twistInvMap -- a key attached by ExternalProduct
      * TwistMap -- indicates whether TwistMap should be
        computed
      * twistMap -- a key attached by ExternalProduct
      * Vars
      * Vhomogenize -- strategy for computing a resolution
        of a D-module
      * ViaAnnFs -- a strategy option for global b-functions
      * ViaBFunction -- a strategy option for lct
      * ViaColonIdeal (missing documentation)
      * ViaElimination (missing documentation)
      * ViaLinearAlgebra -- an option for
        generalB=>Strategy
      * VResolution -- a key in the hashtable created by
        Drestriction/Dintegration
      * Walther -- an option for localCohom=>Strategy

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

The object Dmodules, is a package (Macaulay2Doc).

Alg
***

Functions with optional argument named Alg :
============================================

  * PolySols(...,Alg=>...), --
    algorithm for finding polynomial solutions

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

The object Alg, is a symbol (Macaulay2Doc).

AnnFs -- the annihilating ideal of f^s
**************************************

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

Either a single or a list of polynomials can be supplied for f.

See also
========

  * AnnIFs -- the annihilating ideal of
    f^s for an arbitrary D-module
  * WeylAlgebra (Macaulay2Doc) -- an optional argument

Ways to use AnnFs :
===================

  * AnnFs(List) -- the annihilating ideal of
    f_1^{s_1}...f_r^{s_r}
  * AnnFs(RingElement) -- the annihilating ideal
    of f^s

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

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

annFS -- a key created by Dlocalize
***********************************

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

See Dlocalize.

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

The object annFS, is a symbol (Macaulay2Doc).

AnnFs(List) -- the annihilating ideal of f_1^{s_1}...f_r^{s_r}
**************************************************************

Synopsis
========

  * Function: AnnFs,
  * Usage:
        AnnFs F
  * Inputs:
      * F, a list (Macaulay2Doc), {f_1,...,f_r}, a list of
        polynomials in n variables (f_i has to be an element of A_n, the Weyl
        algebra)
  * Outputs:
      * an ideal (Macaulay2Doc), an ideal in A_n<t_1,...,
        t_r,dt_1,...,dt_r>

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

+-----------------------------------------------------------------------------+
|i1 : W = makeWA ( QQ[x_1..x_3] )                                             |
|                                                                             |
|o1 = W                                                                       |
|                                                                             |
|o1 : PolynomialRing, 3 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : AnnFs {x_2^2-x_1*x_3, x_1^3-x_3^2}                                      |
|                                                                             |
|               2                 3    2         2                            |
|o2 = ideal (- x  + x x  + t , - x  + x  + t , 3x dt  - x dt  + dx , 2x dt  + |
|               2    1 3    0     1    3    1    1  1    3  0     1    2  0   |
|     ------------------------------------------------------------------------|
|     dx , - x dt  - 2x dt  + dx )                                            |
|       2     1  0     3  1     3                                             |
|                                                                             |
|o2 : Ideal of QQ[x ..x , t ..t , dx ..dx , dt ..dt ]                         |
|                  1   3   0   1    1    3    0    1                          |
+-----------------------------------------------------------------------------+

See also
========

  * AnnIFs -- the annihilating ideal of
    f^s for an arbitrary D-module
  * WeylAlgebra (Macaulay2Doc) -- an optional argument

Ways to use this method:
========================

  * AnnFs(List) -- the annihilating ideal of
    f_1^{s_1}...f_r^{s_r}

AnnFs(RingElement) -- the annihilating ideal of f^s
***************************************************

Synopsis
========

  * Function: AnnFs,
  * Usage:
        AnnFs f
  * Inputs:
      * f, a ring element (Macaulay2Doc), a polynomial in a

        Weyl algebra A  (should contain no differential variables)
                      n
  * Outputs:
      * an ideal (Macaulay2Doc), an ideal of A [s]
                                                           n

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

The annihilator ideal is needed to compute a D-module representation of the

localization of k[x ,...,x ] at f.
                   1      n
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1..x_4, z, d_1..d_4, Dz, WeylAlgebra => toList(1..4)/(i -> x_i |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing, 5 differential variables                                |
|-----------------------------------------------------------------------------|
|=> d_i) | {z=>Dz}]                                                           |
+-----------------------------------------------------------------------------+
|i2 : f = x_1 + x_2 * z + x_3 * z^2 + x_4 * z^3                               |
|                                                                             |
|        3      2                                                             |
|o2 = x z  + x z  + x z + x                                                   |
|      4      3      2     1                                                  |
|                                                                             |
|o2 : R                                                                       |
+-----------------------------------------------------------------------------+
|i3 : AnnFs f                                                                 |
|                                                                             |
|             2                                  2                            |
|o3 = ideal (d  - d d , d d  - d d , z*d  - d , d  - d d , z*d  - d , x d  +  |
|             3    2 4   2 3    1 4     3    4   2    1 3     2    3   2 2    |
|     ------------------------------------------------------------------------|
|                                                                             |
|     2x d  + 3x d  - z*Dz, z*d  - d , x d  + 2x d  + 3x d  - Dz, x d  - x d  |
|       3 3     4 4            1    2   2 1     3 2     4 3        1 1    3 3 |
|     ------------------------------------------------------------------------|
|                                    2                                        |
|     - 2x d  + z*Dz - s, 3x z*d  - z Dz + x d  + 2x d )                      |
|         4 4               4   4           2 3     3 4                       |
|                                                                             |
|o3 : Ideal of QQ[x ..x , z, d ..d , Dz, s]                                   |
|                  1   4      1   4                                           |
+-----------------------------------------------------------------------------+

Caveat
======

The ring of f should not have any parameters, i.e., it should be a pure Weyl
algebra. Also this ring should not be a homogeneous Weyl algebra.

See also
========

  * AnnIFs -- the annihilating ideal of
    f^s for an arbitrary D-module
  * WeylAlgebra (Macaulay2Doc) -- an optional argument

Ways to use this method:
========================

  * AnnFs(RingElement) -- the annihilating ideal
    of f^s

AnnG -- a key created by makeCyclic
***********************************

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

See makeCyclic.

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

The object AnnG, is a symbol (Macaulay2Doc).

AnnIFs(Ideal,RingElement) -- the annihilating ideal of f^s for an arbitrary D-module
************************************************************************************

Synopsis
========

  * Function: AnnIFs,
  * Usage:
        AnnIFs(I,f)
  * Inputs:
      * I, an ideal (Macaulay2Doc), that represents a holonomic

        D-moduleA /I
                 n
      * f, a ring element (Macaulay2Doc), a polynomial in a

        Weyl algebra A  (should contain no differential variables)
                      n
  * Outputs:
      * an ideal (Macaulay2Doc), the annihilating ideal of
        A_n[f^{-1},s] f^s tensored with A_n/I over the ring of polynomials

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

+---------------------------------------------+
|i1 : W = QQ[x,dx, WeylAlgebra=>{x=>dx}]      |
|                                             |
|o1 = W                                       |
|                                             |
|o1 : PolynomialRing, 1 differential variables|
+---------------------------------------------+
|i2 : AnnIFs (ideal dx, x^2)                  |
|                                             |
|o2 = ideal(x*dx - 2s)                        |
|                                             |
|o2 : Ideal of QQ[x, dx, s]                   |
+---------------------------------------------+

Caveat
======

Caveats and known problems: The ring of f should not have any parameters: it
should be a pure Weyl algebra. Similarly, this ring should not be a homogeneous
Weyl algebra.

See also
========

  * AnnFs -- the annihilating ideal of f^s
  * WeylAlgebra (Macaulay2Doc) -- an optional argument

Ways to use this method:
========================

  * AnnIFs(Ideal,RingElement) -- the
    annihilating ideal of f^s for an arbitrary D-module

AppellF1 -- Appell F1 system of PDE's
*************************************

Synopsis
========

  * Usage:
        AppellF1 {a0,a1,a2,a3}
  * Inputs:
      * a list (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Vars, => ..., default value Global, null
  * Outputs:
      * an ideal (Macaulay2Doc), which represents Appell F1 (see
        https://en.wikipedia.org/wiki/Appell_series#Derivatives_and_
        differential_equations ) system of PDE's associated to the parameters
        a0, a1, a2, and a3.

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

+-----------------------------------------------------------------------------+
|i1 : w = {1,4/5,-2,3/2}                                                      |
|                                                                             |
|         4      3                                                            |
|o1 = {1, -, -2, -}                                                           |
|         5      2                                                            |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+
|i2 : I = AppellF1 w                                                          |
|                                                                             |
|               3  2    2           2  2               14 2     4             |
|o2 = ideal (- x Dx  - x y*Dx*Dy + x Dx  + x*y*Dx*Dy - --x Dx - -x*y*Dy +     |
|                                                       5       5             |
|     ------------------------------------------------------------------------|
|     3       4        2         3  2                2  2             3       |
|     -x*Dx - -x, - x*y Dx*Dy - y Dy  + x*y*Dx*Dy + y Dy  + 2x*y*Dx + -y*Dy + |
|     2       5                                                       2       |
|     ------------------------------------------------------------------------|
|                                   4                                         |
|     2y, x*Dx*Dy - y*Dx*Dy + 2Dx + -Dy)                                      |
|                                   5                                         |
|                                                                             |
|o2 : Ideal of QQ[x, y, Dx, Dy]                                               |
+-----------------------------------------------------------------------------+

Caveat
======

AppellF1 always returns a different ring and will use variables x and y. Input
should be a List of 4 numbers.

See also
========

  * gkz -- The A-hypergeometric systems of Gelfand, Kapranov and
    Zelevinsky (GKZ)

Ways to use AppellF1 :
======================

  * "AppellF1(List)"

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

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

BasisElts -- a key of the hashtable generated by diffOps
********************************************************

See also
========

  * diffOps -- differential operators of up to the given order
    for a quotient polynomial ring

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

The object BasisElts, is a symbol (Macaulay2Doc).

BFunction -- a key in the hashtable created by Drestriction/Dintegration
************************************************************************

See also
========

  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module

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

The object BFunction, is a symbol (Macaulay2Doc).

Bfunction -- a key created by Dlocalize
***************************************

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

See Dlocalize.

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

The object Bfunction, is a symbol (Macaulay2Doc).

bFunction -- b-function
***********************

Synopsis
========

  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value IntRing, specify strategy for computing b-function

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

  * bFunction(Ideal,List), - for an ideal
  * bFunction(Module,List,List), -
    for a module

Ways to use bFunction :
=======================

  * bFunction(Ideal,List) -- b-function of
    an ideal
  * bFunction(Module,List,List), --
    b-function of a holonomic D-module

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

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

bFunction(...,Strategy=>...) -- specify strategy for computing b-function
*************************************************************************

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

  * IntRing -- the simplest algorithm available. The idea is to compute

    in      (I)  intersect it with k[t ,...,t ](t  = x D )Call the ideal
      (-w,w)                          1      n   i    i i
    obtained J. Finally J + (t  + ... + t - s) \cap k[s] is generated by the
                              1          n
    b-function that we are looking for.
  * TryGeneric -- checks whether the ideal is generic and if that is the case
    uses Alg.5.1.5 in Saito-Sturmfels-Takayama (1999) otherwise is equivalent
    to NonGeneric
  * NonGeneric -- uses 5.1.6 in Saito-Sturmfels-Takayama (1999)
  * Default:IntRing

Further information
===================

  * Default value: IntRing,
  * Function: bFunction, -- b-function
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

bFunction(Ideal,List) -- b-function of an ideal
***********************************************

Synopsis
========

  * Function: bFunction,
  * Usage:
        b = bFunction(I,w)
  * Inputs:
      * I, an ideal (Macaulay2Doc), a holonomic ideal in the Weyl

        algebra A (K).
                 n
      * w, a list (Macaulay2Doc), a list of integer weights
        corresponding to the differential variables in the Weyl algebra.
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value IntRing, specify strategy for computing b-function
  * Outputs:
      * b, a ring element (Macaulay2Doc), a polynomial b(s)
        which is the b-function of I with respect to w

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

Use setHomSwitch,(true) to force all the
subroutines to use homogenized WeylAlgebra (Macaulay2Doc),

Definition. The b-function b(s) is defined as the monic generator of the

intersection of in      (I) and K[s], where s = [w t  + ... + w t ] (here t  =
                  (-w,w)                          1 1          n n         i
x D ).
 i i

+-------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]|
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing, 2 differential variables                |
+-------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                   |
|                                                             |
|o2 = ideal (x , D  - 1)                                      |
|             1   2                                           |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : bFunction(I,{1, 0})                                     |
|                                                             |
|o3 = s + 1                                                   |
|                                                             |
|o3 : QQ[s]                                                   |
+-------------------------------------------------------------+

Caveat
======

The ring of I should not have any parameters: it should be a pure Weyl algebra.
Similarly, this ring should not be a homogeneous WeylAlgebra (Macaulay2Doc),

See also
========

  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * factorBFunction -- factorization
    of a b-function

Ways to use this method:
========================

  * bFunction(Ideal,List) -- b-function of
    an ideal

bFunction(Module,List,List) -- b-function of a holonomic D-module
*****************************************************************

Synopsis
========

  * Function: bFunction,
  * Usage:
        b = bFunction(M,w,m)
  * Inputs:
      * M, a module (Macaulay2Doc), a holonomic module over a

        Weyl algebra A (K)
                      n
      * w, a list (Macaulay2Doc), a list of integer weights
        corresponding to the differential variables in the Weyl algebra
      * m, a list (Macaulay2Doc), a list of integers, each of which
        is the shift for the corresponding component
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value IntRing, specify strategy for computing b-function
  * Outputs:
      * b, a ring element (Macaulay2Doc), a polynomial b(s)
        which is the b-function of M with respect to w and m

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

The algorithm represents M as F/N where F is free and N is a submodule of F.

Then it computes b-functions b (s) for N \cap F  (i-th component of F) and
                              i                i
outputs lcm{ b (s-m ) }
              i    i
+-----------------------------------------------------------------+
|i1 : R = QQ[x, dx, WeylAlgebra => {x=>dx}]                       |
|                                                                 |
|o1 = R                                                           |
|                                                                 |
|o1 : PolynomialRing, 1 differential variables                    |
+-----------------------------------------------------------------+
|i2 : M = cokernel matrix {{x^2, 0, 0}, {0, dx^3, 0}, {0, 0, x^3}}|
|                                                                 |
|o2 = cokernel | x2 0    0  |                                     |
|              | 0  dx^3 0  |                                     |
|              | 0  0    x3 |                                     |
|                                                                 |
|                            3                                    |
|o2 : R-module, quotient of R                                     |
+-----------------------------------------------------------------+
|i3 : factorBFunction bFunction(M, {1}, {0,0,0})                  |
|                                                                 |
|o3 = (s)(s - 2)(s - 1)(s + 1)(s + 2)(s + 3)                      |
|                                                                 |
|o3 : Expression of class Product                                 |
+-----------------------------------------------------------------+
|i4 : factorBFunction bFunction(M, {1}, {1,2,3})                  |
|                                                                 |
|o4 = (s)(s - 4)(s - 3)(s - 2)(s - 1)(s + 1)                      |
|                                                                 |
|o4 : Expression of class Product                                 |
+-----------------------------------------------------------------+

Caveat
======

The Weyl algebra should not have any parameters. Similarly, it should not be a
homogeneous Weyl algebra

See also
========

  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * factorBFunction -- factorization
    of a b-function

Ways to use this method:
========================

  * bFunction(Module,List,List), --
    b-function of a holonomic D-module

bFunctionRoots(RingElement) -- get roots of a b-function
********************************************************

Synopsis
========

  * Function: bFunctionRoots,
  * Usage:
        bFunctionRoots b
  * Inputs:
      * b, a ring element (Macaulay2Doc), the output of one
        of the b-function routines
  * Outputs:
      * a list (Macaulay2Doc), the list of the roots of b

See also
========

  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * bFunction -- b-function
  * generalB -- global generalized
    Bernstein-Sato polynomial

Ways to use this method:
========================

  * bFunctionRoots(RingElement) -- get
    roots of a b-function

BMM -- the characteristic cycle of the localized $D$-module
***********************************************************

Synopsis
========

  * Usage:
        BMM(cc,f), BMM(I,cc)
  * Inputs:
      * cc, a list (Macaulay2Doc), the characteristic cycle of a
        regular holonomic D-module $M$
      * I, an ideal (Macaulay2Doc), representing an `simple' cc
  * Outputs:
      * List, the characteristic cycle of the localized module $M_f =
        M[f^{-1}]$

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

Provided a characteristic cycle in the form {I_1 => m_1, ..., I_k => m_k} with
associated prime ideals I_1,...,I_k and the multiplicities m_1,...,m_k of M
along them, the routine computes the characteristic cycle of M_f.

The method is based on a geometric formula given by V.Ginsburg in
Characteristic varieties and vanishing cycles, Invent. Math. 84 (1986),
327--402. and reinterpreted by J.Briancon, P.Maisonobe and M.Merle in
Localisation de systemes differentiels, stratifications de Whitney et condition
de Thom, Invent. Math. 117 (1994), 531--550.

+------------------------------------------------------------------------+
|i1 : A =  QQ[x_1,x_2,a_1,a_2]                                           |
|                                                                        |
|o1 = A                                                                  |
|                                                                        |
|o1 : PolynomialRing                                                     |
+------------------------------------------------------------------------+
|i2 : cc = {ideal A => 1} -- the characteristic ideal of R = CC[x_1,x_2] |
|                                                                        |
|o2 = {ideal () => 1}                                                    |
|                                                                        |
|o2 : List                                                               |
+------------------------------------------------------------------------+
|i3 : cc1 = BMM(cc,x_1)   -- cc of R_{x_1}                               |
|                                                                        |
|o3 = {ideal () => 1, ideal x  => 1}                                     |
|                            1                                           |
|                                                                        |
|o3 : List                                                               |
+------------------------------------------------------------------------+
|i4 : cc12 = BMM(cc1,x_2) -- cc of R_{x_1x_2}                            |
|                                                                        |
|o4 = {ideal () => 1, ideal x  => 1, ideal x  => 1, ideal (x , x ) => 1} |
|                            2              1               2   1        |
|                                                                        |
|o4 : List                                                               |
+------------------------------------------------------------------------+

Caveat
======

The module has to be a regular holonomic complex-analytic module; while the
holomicity can be checked by isHolonomic, there is no
algorithm to check the regularity.

See also
========

  * pruneCechComplexCC, --
    reduction of the Cech complex that produces characteristic cycles of local
    cohomology modules
  * populateCechComplexCC, --
    Cech complex skeleton for the computation of the characteristic cycles of
    local cohomology modules

Ways to use BMM :
=================

  * "BMM(Ideal,RingElement)"
  * "BMM(List,RingElement)"

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

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

Boperator -- a key attached by globalB and Dlocalize
****************************************************

See also
========

  * globalB -- compute global
    b-function and b-operator for a D-module and a polynomial
  * Dlocalize -- localization of a D-module

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

The object Boperator, is a symbol (Macaulay2Doc).

Boundaries -- a key in the hashtable created by Drestriction/Dintegration
*************************************************************************

See also
========

  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module

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

The object Boundaries, is a symbol (Macaulay2Doc).

Bpolynomial -- a key attached by globalB
****************************************

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

see globalB,

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

The object Bpolynomial, is a symbol (Macaulay2Doc).

Canonical Series Tutorial -- Computing series solutions to regular holonomic systems
************************************************************************************

If D/I is a regular holonomic D-module, the solutions of the system of
differential equations I can be written as Nilsson series (Puiseux series with
logarithms). The constructive version of this result is the canonical series
method [SST, Sections 2.5, 2.6 (see
https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf )]. In this tutorial, we
illustrate an implementation of this method.

If the input ideal I is not regular, this method is not guaranteed to produce
convergent series, or even holonomicRank(I) formal power series solutions of I.
There currently exists no computational method to verify whether D/I is a
regular holonomic D-module. In the case of GKZ systems, regularity has been
characterized in terms of the input matrix.

Contains the following functions:

Currently, this contains the computation of exponents with respect to a weight
vector. Completing the canonical series computation is in the future. To
compute the exponents for a D-ideal I with respect to w, do as follows. Compute
the initial ideal of I with respect to w. Introduce the subring of D consisting
of polynomials in $\theta_1 = x_1 \partial_1, ... , \theta_n= x_n \partial_n$.
This is a commutative polynomial subring of D, referred to here as thetaRing.
The indicial ideal of I with respect to w is produced by extending the initial
ideal to the ring of differential operators with rational function
coefficients, and contract to thetaRing. The exponents of I with respect to w
are the roots of the indicial ideal, counted with multiplicities.

+-----------------------------------------------------------------------------+
|i1 : needsPackage "Dmodules"                                                 |
|                                                                             |
|o1 = Dmodules                                                                |
|                                                                             |
|o1 : Package                                                                 |
+-----------------------------------------------------------------------------+
|i2 : R1 = QQ[z]                                                              |
|                                                                             |
|o2 = R1                                                                      |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : W1 = makeWA R1                                                          |
|                                                                             |
|o3 = W1                                                                      |
|                                                                             |
|o3 : PolynomialRing, 1 differential variables                                |
+-----------------------------------------------------------------------------+
|i4 : a=1/2                                                                   |
|                                                                             |
|     1                                                                       |
|o4 = -                                                                       |
|     2                                                                       |
|                                                                             |
|o4 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i5 : b=3                                                                     |
|                                                                             |
|o5 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i6 : c=5/3                                                                   |
|                                                                             |
|     5                                                                       |
|o6 = -                                                                       |
|     3                                                                       |
|                                                                             |
|o6 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i7 : J = ideal(z*(1-z)*dz^2+(c-(a+b+1)*z)*dz-a*b) -- the Gauss hypergeometric|
|                                                                             |
|              2  2       2   9       5     3                                 |
|o7 = ideal(- z dz  + z*dz  - -z*dz + -dz - -)                                |
|                             2       3     2                                 |
|                                                                             |
|o7 : Ideal of W1                                                             |
|-----------------------------------------------------------------------------|
|equation, exponents 0, 1-c                                                   |
+-----------------------------------------------------------------------------+
|i8 : cssExpts(J,{1})                                                         |
|                                                                             |
|              2                                                              |
|o8 = {{0}, {- -}}                                                            |
|              3                                                              |
|                                                                             |
|o8 : List                                                                    |
+-----------------------------------------------------------------------------+
|i9 : inw(J,{-1,1})                                                           |
|                                                                             |
|                2                                                            |
|o9 = ideal(6z*dz  + 10dz)                                                    |
|                                                                             |
|o9 : Ideal of W1                                                             |
+-----------------------------------------------------------------------------+
|i10 : distraction(oo,QQ[s])                                                  |
|                                                                             |
|              2                                                              |
|o10 = ideal(6s  + 4s)                                                        |
|                                                                             |
|o10 : Ideal of QQ[s]                                                         |
+-----------------------------------------------------------------------------+
|i11 : factor oo_0                                                            |
|                                                                             |
|o11 = (s)(3s + 2)(2)                                                         |
|                                                                             |
|o11 : Expression of class Product                                            |
+-----------------------------------------------------------------------------+
|i12 : c=1  -- Now we have a single exponent of multiplicity 2                |
|                                                                             |
|o12 = 1                                                                      |
+-----------------------------------------------------------------------------+
|i13 : J = ideal(z*(1-z)*dz^2+(c-(a+b+1)*z)*dz-a*b)                           |
|                                                                             |
|               2  2       2   9            3                                 |
|o13 = ideal(- z dz  + z*dz  - -z*dz + dz - -)                                |
|                              2            2                                 |
|                                                                             |
|o13 : Ideal of W1                                                            |
+-----------------------------------------------------------------------------+
|i14 : cssExpts(J,{1})                                                        |
|                                                                             |
|o14 = {{0}}                                                                  |
|                                                                             |
|o14 : List                                                                   |
+-----------------------------------------------------------------------------+
|i15 : cssExptsMult(J,{1})                                                    |
|                                                                             |
|o15 = {{2, {0}}}                                                             |
|                                                                             |
|o15 : List                                                                   |
+-----------------------------------------------------------------------------+

The first step is to rewrite elements of the initial ideal in a terms of the
thetaRing, in a way that will allow us to easily extend and contract see [SST]

+-----------------------------------------------------------------------------+
|i16 : R2 = QQ[x_1..x_3]                                                      |
|                                                                             |
|o16 = R2                                                                     |
|                                                                             |
|o16 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i17 : W2 = makeWA R2                                                         |
|                                                                             |
|o17 = W2                                                                     |
|                                                                             |
|o17 : PolynomialRing, 3 differential variables                               |
+-----------------------------------------------------------------------------+
|i18 : gens W2                                                                |
|                                                                             |
|o18 = {x , x , x , dx , dx , dx }                                            |
|        1   2   3    1    2    3                                             |
|                                                                             |
|o18 : List                                                                   |
+-----------------------------------------------------------------------------+
|i19 : thetaRing = QQ[t_1,t_2,t_3] -- sets variable names t_i = x_i\dx_i      |
|                                                                             |
|o19 = thetaRing                                                              |
|                                                                             |
|o19 : PolynomialRing                                                         |
+-----------------------------------------------------------------------------+
|i20 : f1= x_1*dx_1 -- this element already belongs to thetaRing              |
|                                                                             |
|o20 = x dx                                                                   |
|       1  1                                                                  |
|                                                                             |
|o20 : W2                                                                     |
+-----------------------------------------------------------------------------+
|i21 : genToDistractionGens(f1,thetaRing)  -- checks out                      |
|                                                                             |
|o21 = t                                                                      |
|       1                                                                     |
|                                                                             |
|o21 : thetaRing                                                              |
+-----------------------------------------------------------------------------+
|i22 : f2 = x_1^3*dx_1^3 -- this is a descending factorial in the theta       |
|                                                                             |
|       3  3                                                                  |
|o22 = x dx                                                                   |
|       1  1                                                                  |
|                                                                             |
|o22 : W2                                                                     |
|-----------------------------------------------------------------------------|
|variables                                                                    |
+-----------------------------------------------------------------------------+
|i23 : genToDistractionGens(f2,thetaRing)                                     |
|                                                                             |
|       3     2                                                               |
|o23 = t  - 3t  + 2t                                                          |
|       1     1     1                                                         |
|                                                                             |
|o23 : thetaRing                                                              |
+-----------------------------------------------------------------------------+
|i24 : factor oo   -- now it looks like a descending factorial                |
|                                                                             |
|o24 = (t )(t  - 2)(t  - 1)                                                   |
|        1   1       1                                                        |
|                                                                             |
|o24 : Expression of class Product                                            |
+-----------------------------------------------------------------------------+
|i25 : f = x_1^2*x_2^2*x_3*dx_1*dx_2^2*dx_3^2                                 |
|                                                                             |
|       2 2       2  2                                                        |
|o25 = x x x dx dx dx                                                         |
|       1 2 3  1  2  3                                                        |
|                                                                             |
|o25 : W2                                                                     |
+-----------------------------------------------------------------------------+
|i26 : genToDistractionGens(f,thetaRing)                                      |
|                                                                             |
|         2 2      2          2                                               |
|o26 = t t t  - t t t  - t t t  + t t t                                       |
|       1 2 3    1 2 3    1 2 3    1 2 3                                      |
|                                                                             |
|o26 : thetaRing                                                              |
+-----------------------------------------------------------------------------+

Here is an example that can be continued when more functions are implemented.
This is worked out as [page 138, ex 3.5.3, SST].

+--------------------------------------------------------------------+
|i27 : A = matrix{{1,1,1},{0,1,2}}                                   |
|                                                                    |
|o27 = | 1 1 1 |                                                     |
|      | 0 1 2 |                                                     |
|                                                                    |
|               2        3                                           |
|o27 : Matrix ZZ  <--- ZZ                                            |
+--------------------------------------------------------------------+
|i28 : I = gkz(A,{10,8})                                             |
|                                                                    |
|                                                           2        |
|o28 = ideal (x D  + x D  + x D  - 10, x D  + 2x D  - 8, - D  + D D )|
|              1 1    2 2    3 3        2 2     3 3         2    1 3 |
|                                                                    |
|o28 : Ideal of QQ[x ..x , D ..D ]                                   |
|                   1   3   1   3                                    |
+--------------------------------------------------------------------+
|i29 : holonomicRank(I)                                              |
|                                                                    |
|o29 = 2                                                             |
+--------------------------------------------------------------------+
|i30 : cssExpts(I,{1,0,0})                                           |
|                                                                    |
|o30 = {{2, 8, 0}, {0, 12, -2}}                                      |
|                                                                    |
|o30 : List                                                          |
+--------------------------------------------------------------------+

In this case, the series corresponding to the exponent (2,8,0) is
logarithm-free (actually, this is a hypergeometric polynomial), while the
series corresponding to (0,12,-2) has logarithms. [SST, page 138] has the
polynomial, and four terms of the logarithmic series.

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

Synopsis
========

  * Usage:
        charIdeal M, charIdeal 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 &#x2102; 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 &#x2102;$[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 variables|
+---------------------------------------------+
|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 : charIdeal 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
  * singLocus -- singular locus of a D-module
  * holonomicRank -- rank of a D-module

Ways to use charIdeal :
=======================

  * "charIdeal(Ideal)"
  * "charIdeal(Module)"

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

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

CohomologyGroups -- a key in the hashtable created by deRham
************************************************************

See also
========

  * deRham -- deRham cohomology groups for the complement of a
    hypersurface

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

The object CohomologyGroups, is a symbol (Macaulay2Doc).

createDpairs(PolynomialRing) -- pairs up the variables in Weyl algebra
***********************************************************************

Synopsis
========

  * Function: createDpairs,
  * Usage:
        createDpairs A
  * Inputs:
      * A, a polynomial ring (Macaulay2Doc), 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 variables       |
+----------------------------------------------------+
|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
========

  * WeylAlgebra (Macaulay2Doc) -- an optional argument

Ways to use this method:
========================

  * createDpairs(PolynomialRing), --
    pairs up the variables in Weyl algebra

cssExpts -- the exponents of the canonical series solutions of I in the direction of a weight vector
****************************************************************************************************

Synopsis
========

  * Usage:
        cssExpts(I,w)
  * Inputs:
      * I, holonomic ideal in a Weyl algebra D
      * w, List of (generic) weights for I, of length half the number of
        variables in D
  * Outputs:
      * a list (Macaulay2Doc), of exponents of the exponents of the
        canonical series solutions of I in the direction of (-w,w), as in [SST
        (see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Theorem
        2.3.11].

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

There are examples in the tutorial that can be moved here. Code Pre

+-----------------------------------------------------------------------------+
|i1 : R1 = QQ[z]                                                              |
|                                                                             |
|o1 = R1                                                                      |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : W1 = makeWA R1                                                          |
|                                                                             |
|o2 = W1                                                                      |
|                                                                             |
|o2 : PolynomialRing, 1 differential variables                                |
+-----------------------------------------------------------------------------+
|i3 : a=1/2                                                                   |
|                                                                             |
|     1                                                                       |
|o3 = -                                                                       |
|     2                                                                       |
|                                                                             |
|o3 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i4 : b=3                                                                     |
|                                                                             |
|o4 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i5 : c=5/3                                                                   |
|                                                                             |
|     5                                                                       |
|o5 = -                                                                       |
|     3                                                                       |
|                                                                             |
|o5 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i6 : J = ideal(z*(1-z)*dz^2+(c-(a+b+1)*z)*dz-a*b) -- the Gauss hypergeometric|
|                                                                             |
|              2  2       2   9       5     3                                 |
|o6 = ideal(- z dz  + z*dz  - -z*dz + -dz - -)                                |
|                             2       3     2                                 |
|                                                                             |
|o6 : Ideal of W1                                                             |
|-----------------------------------------------------------------------------|
|equation, exponents 0, 1-c                                                   |
+-----------------------------------------------------------------------------+
|i7 : cssExpts(J,{1})                                                         |
|                                                                             |
|              2                                                              |
|o7 = {{0}, {- -}}                                                            |
|              3                                                              |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use cssExpts :
======================

  * "cssExpts(Ideal,List)"

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

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

cssExptsMult -- the exponents (and multiplicities) of the canonical series solutions of I in the direction of a weight vector
*****************************************************************************************************************************

Synopsis
========

  * Usage:
        cssExptsMult(I,w)
  * Inputs:
      * I, holonomic ideal in a Weyl algebra D
      * w, List of (generic) weights for I, of length half the number of
        variables in D
  * Outputs:
      * a list (Macaulay2Doc), of exponents of the starting
        exponents of the canonical series solutions of I in the direction of
        (-w,w), as in [SST (see
        https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Theorem
        2.3.11], together with their multiplicities.

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

There are examples in the tutorial that can be moved here.

+-----------------------------------------------------------------------------+
|i1 : R1 = QQ[z]                                                              |
|                                                                             |
|o1 = R1                                                                      |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : W1 = makeWA R1                                                          |
|                                                                             |
|o2 = W1                                                                      |
|                                                                             |
|o2 : PolynomialRing, 1 differential variables                                |
+-----------------------------------------------------------------------------+
|i3 : a=1/2                                                                   |
|                                                                             |
|     1                                                                       |
|o3 = -                                                                       |
|     2                                                                       |
|                                                                             |
|o3 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i4 : b=3                                                                     |
|                                                                             |
|o4 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i5 : c=5/3                                                                   |
|                                                                             |
|     5                                                                       |
|o5 = -                                                                       |
|     3                                                                       |
|                                                                             |
|o5 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i6 : J = ideal(z*(1-z)*dz^2+(c-(a+b+1)*z)*dz-a*b) -- the Gauss hypergeometric|
|                                                                             |
|              2  2       2   9       5     3                                 |
|o6 = ideal(- z dz  + z*dz  - -z*dz + -dz - -)                                |
|                             2       3     2                                 |
|                                                                             |
|o6 : Ideal of W1                                                             |
|-----------------------------------------------------------------------------|
|equation, exponents 0, 1-c                                                   |
+-----------------------------------------------------------------------------+
|i7 : cssExpts(J,{1})                                                         |
|                                                                             |
|              2                                                              |
|o7 = {{0}, {- -}}                                                            |
|              3                                                              |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : c=1  -- Now we have a single exponent of multiplicity 2                 |
|                                                                             |
|o8 = 1                                                                       |
+-----------------------------------------------------------------------------+
|i9 : J = ideal(z*(1-z)*dz^2+(c-(a+b+1)*z)*dz-a*b)                            |
|                                                                             |
|              2  2       2   9            3                                  |
|o9 = ideal(- z dz  + z*dz  - -z*dz + dz - -)                                 |
|                             2            2                                  |
|                                                                             |
|o9 : Ideal of W1                                                             |
+-----------------------------------------------------------------------------+
|i10 : cssExpts(J,{1})                                                        |
|                                                                             |
|o10 = {{0}}                                                                  |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
|i11 : cssExptsMult(J,{1})                                                    |
|                                                                             |
|o11 = {{2, {0}}}                                                             |
|                                                                             |
|o11 : List                                                                   |
+-----------------------------------------------------------------------------+

Ways to use cssExptsMult :
==========================

  * "cssExptsMult(Ideal,List)"

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

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

Cycles -- a key in the hashtable created by Drestriction/Dintegration
*********************************************************************

See also
========

  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module

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

The object Cycles, is a symbol (Macaulay2Doc).

D-modules tutorial -- Algebraic computations for linear differential equations
******************************************************************************

D-modules are modules over rings of differential operators over algebraic
varieties. This package is mostly concerned with computations in the Weyl
algebra, the ring of differential operators over affine space (over a field of
characteristic zero). Most algorithms in this package can be found in the book
Gr\"obner deformations of Hypergeometric Differential Equations by Saito,
Sturmfels and Takayama, hereafter referred to as [SST (see
https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf )]. This is also the best
place to learn about computational D-module theory. The book Computational
Algebraic Geometry with Macaulay2 has a chapter on D-modules and local
cohomology. A good introduction to D-module theory is A primer of algebraic
D-modules by Coutinho.

The Weyl algebra $D_n$ is the free associative algebra in $2n$ variables
$x_1,\dots,x_n$, $\partial_1,\dots,\partial_n$, subject to the following
relations: the $x$'s commute with each other; the $\partial$'s commute with
each other; $x_i$ commutes with $\partial_j$ if $i\neq j$; and finally,
$\partial_i x_i = x_i \partial_i +1$ (the Leibniz rule).

+---------------------------------------------+
|i1 : D1 = QQ[z,dz, WeylAlgebra=>{z=>dz}]     |
|                                             |
|o1 = D1                                      |
|                                             |
|o1 : PolynomialRing, 1 differential variables|
+---------------------------------------------+

As a reality check, let us confirm that this is not a commutative ring. Here is
the Leibniz rule.

+-------------+
|i2 : dz*z    |
|             |
|o2 = z*dz + 1|
|             |
|o2 : D1      |
+-------------+

In order to type less, we can use the shortcuts makeWeylAlgebra or makeWA.

+-----------------------------------------------------------------------------+
|i3 : R = QQ[x_1..x_4]                                                        |
|                                                                             |
|o3 = R                                                                       |
|                                                                             |
|o3 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i4 : D4 = makeWA R                                                           |
|                                                                             |
|o4 = D4                                                                      |
|                                                                             |
|o4 : PolynomialRing, 4 differential variables                                |
+-----------------------------------------------------------------------------+
|i5 : describe D4                                                             |
|                                                                             |
|o5 = QQ[x ..x , dx ..dx , Degrees => {8:1}, Heft => {1}, WeylAlgebra => {{x ,|
|         1   4    1    4                                                   1 |
|-----------------------------------------------------------------------------|
|dx }, {x , dx }, {x , dx }, {x , dx }}]                                      |
|  1     2    2     3    3     4    4                                         |
+-----------------------------------------------------------------------------+

Elements and ideals are handled in the usual Macaulay2 way. Let us look at the
Gauss hypergeometric equation (see
https://en.wikipedia.org/wiki/Hypergeometric_function#The_hypergeometric_
differential_equation ) for parameters $a=1, b=2, c=3$.

+---------------------------------------------+
|i6 : use D1                                  |
|                                             |
|o6 = D1                                      |
|                                             |
|o6 : PolynomialRing, 1 differential variables|
+---------------------------------------------+
|i7 : a = 1, b = 2, c = 3                     |
|                                             |
|o7 = (1, 2, 3)                               |
|                                             |
|o7 : Sequence                                |
+---------------------------------------------+
|i8 : g = z*(1-z)*dz^2 + (c-(a+b+1)*z)*dz -a*b|
|                                             |
|        2  2       2                         |
|o8 = - z dz  + z*dz  - 4z*dz + 3dz - 2       |
|                                             |
|o8 : D1                                      |
+---------------------------------------------+
|i9 : I = ideal g                             |
|                                             |
|              2  2       2                   |
|o9 = ideal(- z dz  + z*dz  - 4z*dz + 3dz - 2)|
|                                             |
|o9 : Ideal of D1                             |
+---------------------------------------------+

The holonomicRank function computes the dimension of the solution space of a
linear system of differential equations.

+---------------------+
|i10 : holonomicRank I|
|                     |
|o10 = 2              |
+---------------------+

A-Hypergeometric systems, also known as GKZ systems (see [SST (see
https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Chapters 3 and 4]) are
implemented.

+-----------------------------------------------------------------------------+
|i11 : use D4                                                                 |
|                                                                             |
|o11 = D4                                                                     |
|                                                                             |
|o11 : PolynomialRing, 4 differential variables                               |
+-----------------------------------------------------------------------------+
|i12 : A = matrix{{1,1,1,1},{0,1,3,4}}                                        |
|                                                                             |
|o12 = | 1 1 1 1 |                                                            |
|      | 0 1 3 4 |                                                            |
|                                                                             |
|               2        4                                                    |
|o12 : Matrix ZZ  <--- ZZ                                                     |
+-----------------------------------------------------------------------------+
|i13 : b = {1,2}                                                              |
|                                                                             |
|o13 = {1, 2}                                                                 |
|                                                                             |
|o13 : List                                                                   |
+-----------------------------------------------------------------------------+
|i14 : H = gkz(A,b, D4)                                                       |
|                                                                             |
|                                                                             |
|o14 = ideal (x dx  + x dx  + x dx  + x dx  - 1, x dx  + 3x dx  + 4x dx  - 2, |
|              1  1    2  2    3  3    4  4       2  2     3  3     4  4      |
|      -----------------------------------------------------------------------|
|          3        2       2     2                            3     2        |
|      - dx  + dx dx , dx dx  - dx dx , - dx dx  + dx dx , - dx  + dx dx )    |
|          3     2  4    1  3     2  4      2  3     1  4      2     1  3     |
|                                                                             |
|o14 : Ideal of D4                                                            |
+-----------------------------------------------------------------------------+

Holonomic D-ideals are analogous to zero-dimensional ideals in polynomial rings
(see [SST (see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Section
1.4]). Let us confirm that our GKZ systems are holonomic.

+-------------------+
|i15 : isHolonomic H|
|                   |
|o15 = true         |
+-------------------+

Once we know our ideal is holonomic, we can compute its holonomic rank. The
above is a famous GKZ example because the holonomic rank may change when the
parameter vector $b$ is changed.

+----------------------------------------------+
|i16 : holonomicRank H                         |
|                                              |
|o16 = 5                                       |
+----------------------------------------------+
|i17 : holonomicRank sub(gkz(A,{1,0}), vars D4)|
|                                              |
|o17 = 4                                       |
+----------------------------------------------+

We can compute the characteristic ideal and singular locus of a D-ideal [SST
(see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Section 1.4].
Note that the output of charIdeal belongs to a commutative ring, the associated
graded ring of $D_n$ with respect to the order filtration.

+-----------------------------------------------------------------------------+
|i18 : charIdeal H                                                            |
|                                                                             |
|                                                                             |
|o18 = ideal (dx dx  - dx dx , x dx  + 3x dx  + 4x dx , x dx  - 2x dx  -      |
|               2  3     1  4   2  2     3  3     4  4   1  1     3  3        |
|      -----------------------------------------------------------------------|
|                3        2       2     2       3     2                       |
|      3x dx , dx  - dx dx , dx dx  - dx dx , dx  - dx dx )                   |
|        4  4    3     2  4    1  3     2  4    2     1  3                    |
|                                                                             |
|o18 : Ideal of QQ[x ..x , dx ..dx ]                                          |
|                   1   4    1    4                                           |
+-----------------------------------------------------------------------------+
|i19 : singLocus H                                                            |
|                                                                             |
|                3 3        3 4       2 2 2 2        4 3       3     3        |
|o19 = ideal(4x x x x  + 27x x x  + 6x x x x  + 27x x x  + 192x x x x  -      |
|              1 2 3 4      1 3 4     1 2 3 4      1 2 4       1 2 3 4        |
|      -----------------------------------------------------------------------|
|          4 4                                                                |
|      256x x )                                                               |
|          1 4                                                                |
|                                                                             |
|o19 : Ideal of D4                                                            |
+-----------------------------------------------------------------------------+

The singular locus of a GKZ system is the zero set of a polynomial called the
Principal A-determinant, which is a product of discriminants corresponding to
faces of the matrix A (see Chapters 8 and 9 of the book Discriminants,
Resultants and Multidimensional Determinants by Gelfand, Kapranov and
Zelevinsky). Here is how to find the classic cubic discriminant.

+-----------------------------------------------------------------------------+
|i20 : A1 = matrix{{1,1,1,1},{0,1,2,3}}, b1={0,0}                             |
|                                                                             |
|o20 = (| 1 1 1 1 |, {0, 0})                                                  |
|       | 0 1 2 3 |                                                           |
|                                                                             |
|o20 : Sequence                                                               |
+-----------------------------------------------------------------------------+
|i21 : H1 = sub(gkz(A1,b1),vars D4)                                           |
|                                                                             |
|                                                                         2   |
|o21 = ideal (x dx  + x dx  + x dx  + x dx , x dx  + 2x dx  + 3x dx , - dx  + |
|              1  1    2  2    3  3    4  4   2  2     3  3     4  4      3   |
|      -----------------------------------------------------------------------|
|                  2                                                          |
|      dx dx , - dx  + dx dx , - dx dx  + dx dx )                             |
|        2  4      2     1  3      2  3     1  4                              |
|                                                                             |
|o21 : Ideal of D4                                                            |
+-----------------------------------------------------------------------------+
|i22 : factor (singLocus H1)_0                                                |
|                                                                             |
|                2 2       3     3                     2 2                    |
|o22 = (x )(x )(x x  - 4x x  - 4x x  + 18x x x x  - 27x x )                   |
|        4   1   2 3     1 3     2 4      1 2 3 4      1 4                    |
|                                                                             |
|o22 : Expression of class Product                                            |
+-----------------------------------------------------------------------------+

See also
========

  * Dmodules -- algorithms for D-modules

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

Synopsis
========

  * 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
&#x2102; 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 variables|
+---------------------------------------------+
|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
========

  * charIdeal -- characteristic ideal of a D-module
  * holonomicRank -- rank of a D-module
  * singLocus -- 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).

Ddual -- holonomic dual of a D-module
*************************************

Synopsis
========

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

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

                                           n
If M is a holonomic left D-module, then Ext  (M,D) is a holonomic right
                                            D

D-module.  The holonomic dual is defined to be the left module associated to

   n
Ext  (M,D).  The dual is obtained by computing a free resolution of M,
    D
dualizing, and applying the standard transposition to the n-th homology.
+-----------------------------------------------------------------------------+
|i1 : I = AppellF1({1,0,-3,2})                                                |
|                                                                             |
|               3  2    2           2  2                 2                    |
|o1 = ideal (- x Dx  - x y*Dx*Dy + x Dx  + x*y*Dx*Dy - 2x Dx + 2x*Dx, -       |
|     ------------------------------------------------------------------------|
|        2         3  2                2  2              2                    |
|     x*y Dx*Dy - y Dy  + x*y*Dx*Dy + y Dy  + 3x*y*Dx + y Dy + 2y*Dy + 3y,    |
|     ------------------------------------------------------------------------|
|     x*Dx*Dy - y*Dx*Dy + 3Dx)                                                |
|                                                                             |
|o1 : Ideal of QQ[x, y, Dx, Dy]                                               |
+-----------------------------------------------------------------------------+
|i2 : Ddual I                                                                 |
|                                                                             |
|o2 = cokernel | 0  xDy-yDy-4 x2Dx+y2Dy-xDx-yDy+x+4y                          |
|              | Dx -yDy-1    0                                               |
|                                                                             |
|                                                                             |
|o2 : QQ[x, y, Dx, Dy]-module, quotient of (QQ[x, y,                          |
|-----------------------------------------------------------------------------|
|y2DxDy+y2Dy^2-yDxDy-yDy^2+4xDx+4yDx+5yDy-4Dx+4 0                           | |
|0                                              y3Dy^2-y2Dy^2+7y2Dy-2yDy+5y | |
|                                                                             |
|        2                                                                    |
|Dx, Dy])                                                                     |
+-----------------------------------------------------------------------------+

Caveat
======

The input module M should be holonomic.  The user should check this manually
with the script Ddim.

See also
========

  * Ddim -- dimension of a D-module
  * Dtransposition -- standard transposition for Weyl
    algebra

Ways to use Ddual :
===================

  * "Ddual(Ideal)"
  * "Ddual(Module)"

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

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

deRham -- deRham cohomology groups for the complement of a hypersurface
***********************************************************************

Synopsis
========

  * Usage:
        M = deRham f, Mi = deRham(i,f)
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * f, a ring element (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value Schreyer, null
  * Outputs:
      * Mi, a module (Macaulay2Doc), the i-th deRham cohomology
        group of the complement of the hypersurface {f = 0}
      * M, a hash table (Macaulay2Doc), containing the entries
        of the form i=>Mi

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

The algorithm used appears in the paper 'An algorithm for deRham cohomology
groups of the complement of an affine variety via D-module computation' by
Oaku-Takayama(1999). The method is to compute the localization of the
polynomial ring by f, then compute the derived integration of the localization.
+------------------------+
|i1 : R = QQ[x,y]        |
|                        |
|o1 = R                  |
|                        |
|o1 : PolynomialRing     |
+------------------------+
|i2 : f = x^2-y^3        |
|                        |
|        3    2          |
|o2 = - y  + x           |
|                        |
|o2 : R                  |
+------------------------+
|i3 : deRham f           |
|                        |
|                      1 |
|o3 = HashTable{0 => QQ }|
|                      1 |
|               1 => QQ  |
|               2 => 0   |
|                        |
|o3 : HashTable          |
+------------------------+
|i4 : deRham(1,f)        |
|                        |
|       1                |
|o4 = QQ                 |
|                        |
|o4 : QQ-module, free    |
+------------------------+

See also
========

  * deRhamAll -- deRham complex for the
    complement of a hypersurface
  * Dlocalize -- localization of a D-module
  * Dintegration -- integration modules of a D-module

Ways to use deRham :
====================

  * "deRham(RingElement)"
  * "deRham(ZZ,RingElement)"
  * deRham(Ideal) (missing documentation)
  * deRham(ZZ,Ideal) (missing documentation)

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

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

deRham(...,Strategy=>...)
*************************

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

Option is passed to Dresolution. See Dresolution(...,Strategy=>...),

Further information
===================

  * Default value: Schreyer,
  * Function: deRham, -- deRham cohomology groups for the
    complement of a hypersurface
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

deRhamAll(...,Strategy=>...)
****************************

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

Option is passed to Dresolution. See Dresolution(...,Strategy=>...),

Further information
===================

  * Default value: Schreyer,
  * Function: deRhamAll, -- deRham complex
    for the complement of a hypersurface
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

deRhamAll(RingElement) -- deRham complex for the complement of a hypersurface
*****************************************************************************

Synopsis
========

  * Function: deRhamAll,
  * Usage:
        deRhamAll f
  * Inputs:
      * f, a ring element (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value Schreyer, null
  * Outputs:
      * a hash table (Macaulay2Doc), containing explicit
        cohomology classes in the deRham complex for the complement of the
        hypersurface {f = 0} and supplementary information

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

The routine deRhamAll can be used to compute cup product structures as in the
paper 'The cup product structure for complements of affine varieties' by
Walther(2000).

For a more basic functionality see deRham.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : f = x^2-y^3                                                             |
|                                                                             |
|        3    2                                                               |
|o2 = - y  + x                                                                |
|                                                                             |
|o2 : R                                                                       |
+-----------------------------------------------------------------------------+
|i3 : deRhamAll f                                                             |
|                                                                             |
|                                        2      1                             |
|o3 = HashTable{BFunction => (s - 1)(s - -)(s - -)                            |
|                                        3      3                             |
|                                                    1                        |
|               CohomologyGroups => HashTable{0 => QQ }                       |
|                                                    1                        |
|                                             1 => QQ                         |
|                                             2 => 0                          |
|               LocalizeMap => | -x_2^3+x_1^2 |                               |
|                                               1                         2   |
|               OmegaRes => (QQ[x ..x , D ..D ])  <-- (QQ[x ..x , D ..D ])    |
|                                1   2   1   2             1   2   1   2      |
|                                                                             |
|                           0                         1                       |
|               PreCycles => HashTable{0 => | 0 |}                            |
|                                           | 1 |                             |
|                                      1 => | 0 |                             |
|                                           | 1 |                             |
|                                           | 0 |                             |
|                                      2 => 0                                 |
|               TransferCycles => HashTable{0 => | 3x_2^3-3x_1^2 |}           |
|                                           1 => | 2x_1   |                   |
|                                                | 3x_2^2 |                   |
|                                           2 => 0                            |
|                                                  1                          |
|               VResolution => (QQ[x ..x , D ..D ])  <-- (QQ[x ..x , D ..D    |
|                                   1   2   1   2             1   2   1   2   |
|                                                                             |
|                              0                         1                    |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|                                   }                                         |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                         1                                                   |
| <-- (QQ[x ..x , D ..D ])  <-- 0                                             |
|          1   2   1   2                                                      |
|                               3                                             |
|     2                                                                       |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|  3                         2                                                |
|])  <-- (QQ[x ..x , D ..D ])  <-- 0                                          |
|             1   2   1   2                                                   |
|                                  3                                          |
|        2                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * deRham -- deRham cohomology groups for the complement of a
    hypersurface
  * Dlocalize -- localization of a D-module
  * Dintegration -- integration modules of a D-module

Ways to use this method:
========================

  * deRhamAll(RingElement) -- deRham complex
    for the complement of a hypersurface

DExt -- Ext groups between holonomic modules
********************************************

Synopsis
========

  * Usage:
        DExt(M,N), DExt(M,N,w)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * N, a module (Macaulay2Doc), over the Weyl algebra D
      * w, a list (Macaulay2Doc), a positive weight vector
  * Optional inputs (Macaulay2Doc),:
      * Info, => ..., default
        value 1, null
      * Output, => ..., default
        value HomologyModules, null
      * Special, => ...,
        default value None, null
      * Strategy, => ...,
        default value Schreyer, null
  * Outputs:
      * a hash table (Macaulay2Doc),  the Ext groups between
        holonomic D-modulesM and N

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

The Ext groups between D-modules M and N are the derived functors of Hom, and
are finite-dimensional vector spaces over the ground field when M and N are
holonomic.

The procedure calls Drestriction, which uses w if
specified.

The algorithm used appears in the paper 'Polynomial and rational solutions of
holonomic systems' by Oaku-Takayama-Tsai (2000). The method is to combine
isomorphisms of Bjork and Kashiwara with the restriction algorithm.

+---------------------------------------------+
|i1 : W = QQ[x, D, WeylAlgebra=>{x=>D}]       |
|                                             |
|o1 = W                                       |
|                                             |
|o1 : PolynomialRing, 1 differential variables|
+---------------------------------------------+
|i2 : M = W^1/ideal(x*(D-1))                  |
|                                             |
|o2 = cokernel | xD-x |                       |
|                                             |
|                            1                |
|o2 : W-module, quotient of W                 |
+---------------------------------------------+
|i3 : N = W^1/ideal((D-1)^2)                  |
|                                             |
|o3 = cokernel | D2-2D+1 |                    |
|                                             |
|                            1                |
|o3 : W-module, quotient of W                 |
+---------------------------------------------+
|i4 : DExt(M,N)                               |
|                                             |
|                      2                      |
|o4 = HashTable{0 => QQ }                     |
|                      2                      |
|               1 => QQ                       |
|                                             |
|o4 : HashTable                               |
+---------------------------------------------+

Caveat
======

Input modules M, N should be holonomic.Does not yet compute explicit
representations of Ext groups such as Yoneda representation.

See also
========

  * DHom -- D-homomorphisms between holonomic D-modules
  * Drestriction -- restriction modules of a D-module

Ways to use DExt :
==================

  * "DExt(Module,Module)"
  * "DExt(Module,Module,List)"

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

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

DExt(...,Info=>...)
*******************

Further information
===================

  * Default value: 1
  * Function: DExt, -- Ext groups between holonomic modules
  * Option key: Info,

Functions with optional argument named Info :
=============================================

  * DExt(...,Info=>...)

DExt(...,Output=>...)
*********************

Further information
===================

  * Default value: HomologyModules,
  * Function: DExt, -- Ext groups between holonomic modules
  * Option key: Output,

Functions with optional argument named Output :
===============================================

  * DExt(...,Output=>...)

DExt(...,Special=>...)
**********************

Further information
===================

  * Default value: None,
  * Function: DExt, -- Ext groups between holonomic modules
  * Option key: Special,

Functions with optional argument named Special :
================================================

  * DExt(...,Special=>...)

DExt(...,Strategy=>...)
***********************

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

Option is passed to Dresolution. See Dresolution(...,Strategy=>...),

Further information
===================

  * Default value: Schreyer,
  * Function: DExt, -- Ext groups between holonomic modules
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

DHom -- D-homomorphisms between holonomic D-modules
***************************************************

Synopsis
========

  * Usage:
        DHom(M,N), DHom(M,N,w), DHom(I,J)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * N, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * J, an ideal (Macaulay2Doc), which represents the module N
        = D/J
      * w, a list (Macaulay2Doc), a positive weight vector
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value Schreyer, null
  * Outputs:
      * a hash table (Macaulay2Doc),  a basis of
        D-homomorphisms between holonomic D-modules M and N

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

The set of D-homomorphisms between two holonomic modules M and N is a
finite-dimensional vector space over the ground field. Since a homomorphism is
defined by where it sends a set of generators, the output of this command is a
list of matrices whose columns correspond to the images of the generators of M.
Here the generators of M are determined from its presentation by generators and
relations.

The procedure calls Drestriction, which uses w if
specified.

The algorithm used appears in the paper 'Computing homomorphisms between
holonomic D-modules' by Tsai-Walther(2000). The method is to combine
isomorphisms of Bjork and Kashiwara with the restriction algorithm.

+---------------------------------------------+
|i1 : W = QQ[x, D, WeylAlgebra=>{x=>D}]       |
|                                             |
|o1 = W                                       |
|                                             |
|o1 : PolynomialRing, 1 differential variables|
+---------------------------------------------+
|i2 : M = W^1/ideal(D-1)                      |
|                                             |
|o2 = cokernel | D-1 |                        |
|                                             |
|                            1                |
|o2 : W-module, quotient of W                 |
+---------------------------------------------+
|i3 : N = W^1/ideal((D-1)^2)                  |
|                                             |
|o3 = cokernel | D2-2D+1 |                    |
|                                             |
|                            1                |
|o3 : W-module, quotient of W                 |
+---------------------------------------------+
|i4 : DHom(M,N)                               |
|                                             |
|o4 = {| -xD+x+1 |, | -D+1 |}                 |
|                                             |
|o4 : List                                    |
+---------------------------------------------+

Caveat
======

Input modules M, N, D/I and D/J should be holonomic.

See also
========

  * DExt -- Ext groups between holonomic modules
  * Drestriction -- restriction modules of a D-module

Ways to use DHom :
==================

  * "DHom(Ideal,Ideal)"
  * "DHom(Module,Module)"
  * "DHom(Module,Module,List)"

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

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

DHom(...,Strategy=>...)
***********************

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

Option is passed to Dresolution. See Dresolution(...,Strategy=>...),

Further information
===================

  * Default value: Schreyer,
  * Function: DHom, -- D-homomorphisms between holonomic D-modules
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

diffOps -- differential operators of up to the given order for a quotient polynomial ring
*****************************************************************************************

Synopsis
========

  * Usage:
        diffOps (I, k)
        diffOps (f, k)
  * Inputs:
      * I, an ideal (Macaulay2Doc), contained in a polynomial ring
        R
      * f, a ring element (Macaulay2Doc), an element of a
        polynomial ring R
      * k, an integer (Macaulay2Doc), which is nonnegative
  * Outputs:
      * a hash table (Macaulay2Doc), the differential
        operators of order at most k of the quotient ring R/I (or R/(f))

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

Given an ideal $I$ of a polynomial ring $R$ the set of differential operators
of the quotient ring $R/I$ having order less than or equal to $k$ forms a
finitely generated module over $R/I$. This routine returns its generating set.

The output is in the form of a hash table. The key BasisElts is a row vector of
basic differential operators. The key PolyGens is a matrix over R whose column
vectors represent differential operators of R/I in the following way.  For each
column vector, consider its image in R/I then take its dot product with the
BasisElts. This gives a differential operator, and the set of these operators
generates the differential operators of R/I of order k or less as an
(R/I)-module.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                                           |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x^2-y*z)                                                      |
|                                                                             |
|            2                                                                |
|o2 = ideal(x  - y*z)                                                         |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : diffOps(I, 3)                                                           |
|                                                                             |
|o3 = HashTable{BasisElts => | dx^3 dx^2dy dx^2dz dxdy^2 dxdydz dxdz^2 dy^3   |
|               PolyGens => {-3} | 0  0  0  0  0   -2xz  0    2xy  yz  y2     |
|                           {-3} | 0  0  0  0  0   -6yz  0    0    2xy 0      |
|                           {-3} | 0  0  0  0  0   -6z2  0    12yz 4xz 6xy    |
|                           {-3} | 0  0  0  0  0   0     0    0    0   0      |
|                           {-3} | 0  0  0  0  0   -24xz 0    0    8yz 0      |
|                           {-3} | 0  0  0  0  0   0     0    24xz 4z2 12yz   |
|                           {-3} | 0  0  0  0  0   8y2   0    0    0   0      |
|                           {-3} | 0  0  0  0  0   -24yz 0    0    0   0      |
|                           {-3} | 0  0  0  0  0   0     0    0    8xz 0      |
|                           {-3} | 0  0  0  0  0   0     0    16z2 0   8xz    |
|                           {-2} | 0  z  y  x  0   -3z   0    -3y  x   0      |
|                           {-2} | 0  4x 0  2y 0   0     0    0    -2y 0      |
|                           {-2} | 0  0  4x 2z 0   0     0    0    4z  6y     |
|                           {-2} | 0  4y 0  0  0   24y   y2   0    0   0      |
|                           {-2} | 0  0  0  4x 0   -12z  -2yz 0    0   0      |
|                           {-2} | 0  0  4z 0  0   0     z2   12z  0   12x    |
|                           {-1} | 0  0  0  1  yz  0     0    0    -1  0      |
|                           {-1} | y  2  0  0  0   6     0    0    0   0      |
|                           {-1} | -z 0  2  0  2xz 0     2z   -6   0   0      |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|dy^2dz dydz^2 dz^3 dx^2 dxdy dxdz dy^2 dydz dz^2 dx dy dz |}                 |
|2xz  0    z2   -yz   0   0   2x2z-2yz2   |                                   |
|8yz  y2   6xz  0     0   0   0           |                                   |
|4z2  -yz  0    -6xz  0   0   0           |                                   |
|8xy  0    12yz 4y2   0   0   0           |                                   |
|16xz 4xy  0    -8yz  0   0   24x2z-24yz2 |                                   |
|0    -4xz 0    -8z2  0   0   0           |                                   |
|0    0    8xy  0     0   0   0           |                                   |
|16yz 0    0    8xy   0   0   0           |                                   |
|0    4yz  0    -16xz 0   0   0           |                                   |
|0    -4z2 0    0     0   0   0           |                                   |
|z    y    0    -x    xy  xz  0           |                                   |
|0    0    6z   8y    0   4yz 0           |                                   |
|0    0    0    -10z  4yz 0   0           |                                   |
|-12y 0    12x  0     0   4xy 0           |                                   |
|8z   2y   0    0     0   0   0           |                                   |
|0    -6z  0    0     4xz 0   0           |                                   |
|0    0    0    1     -y  -z  -3z         |                                   |
|-6   0    0    0     0   0   -6x         |                                   |
|0    0    0    0     0   0   0           |                                   |
+-----------------------------------------------------------------------------+

See also
========

  * putWeylAlgebra -- transforms output
    of diffOps into elements of Weyl algebra

Ways to use diffOps :
=====================

  * "diffOps(Ideal,ZZ)"
  * "diffOps(RingElement,ZZ)"

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

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

Dintegrate -- Dintegrate* is an (OBSOLETE) abbreviation for Dintegration*
*************************************************************************

Synopsis
========

  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null

See also
========

  * Dintegration -- integration modules of a D-module
  * DintegrationAll -- integration modules of a
    D-module (extended version)
  * DintegrationClasses -- integration classes of a
    D-module
  * DintegrationComplex -- derived integration
    complex of a D-module
  * DintegrationIdeal -- integration ideal of a
    D-module

Ways to use Dintegrate :
========================

  * "Dintegrate(Ideal,List)"
  * "Dintegrate(Module,List)"
  * "Dintegrate(ZZ,Ideal,List)"
  * "Dintegrate(ZZ,Module,List)"

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

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

Dintegration -- integration modules of a D-module
*************************************************

Synopsis
========

  * Usage:
        N = Dintegration(M,w), NI = Dintegration(I,w), Ni = Dintegration(i,M,w),
        NIi = Dintegration(i,I,w),
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
      * i, an integer (Macaulay2Doc), nonnegative
  * Optional inputs (Macaulay2Doc),:
      * Strategy, =>
        ..., default value Schreyer, null
  * Outputs:
      * Ni, a module (Macaulay2Doc), the i-th derived integration
        module of M with respect to the weight vector w
      * N, a hash table (Macaulay2Doc), contains entries of
        the form i=>Ni
      * NIi, a module (Macaulay2Doc), the i-th derived
        integration module of D/I with respect to the weight vector w
      * NI, a hash table (Macaulay2Doc), contains entries of
        the form i=>NIi

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

The derived integration modules of a D-module M are the derived direct images
in the category of D-modules. This routine computes integration for projection
to coordinate subspaces, where the subspace is determined by the strictly
positive entries of the weight vector w, e.g., {x_i = 0 : w_i > 0} if D =
C<x_1,...,x_n,d_1,...,d_n>. The input weight vector should be a list of n
numbers to induce the weight (-w,w) on D.

The algorithm used appears in the paper 'Algorithms for D-modules' by
Oaku-Takayama(1999).  The method is to take the Fourier transform of M, then
compute the derived restriction, then inverse Fourier transform back.
+-------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]|
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing, 2 differential variables                |
+-------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                   |
|                                                             |
|o2 = ideal (x , D  - 1)                                      |
|             1   2                                           |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : Dintegration(I,{1,0})                                   |
|                                                             |
|o3 = HashTable{0 => cokernel | D_2-1 |}                      |
|               1 => 0                                        |
|                                                             |
|o3 : HashTable                                               |
+-------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * DintegrationAll -- integration modules of a
    D-module (extended version)
  * DintegrationClasses -- integration classes of a
    D-module
  * DintegrationComplex -- derived integration
    complex of a D-module
  * DintegrationIdeal -- integration ideal of a
    D-module
  * Drestriction -- restriction modules of a D-module

Ways to use Dintegration :
==========================

  * "Dintegration(Ideal,List)"
  * "Dintegration(Module,List)"
  * "Dintegration(ZZ,Ideal,List)"
  * "Dintegration(ZZ,Module,List)"

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

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

Dintegration(...,Strategy=>...)
*******************************

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

Option is passed to Dresolution. See Dresolution(...,Strategy=>...),

Further information
===================

  * Default value: Schreyer,
  * Function: Dintegration, -- integration modules of a
    D-module
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

DintegrationAll -- integration modules of a D-module (extended version)
***********************************************************************

Synopsis
========

  * Usage:
        N = DintegrationAll(M,w), NI = DintegrationAll(I,w)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * N, a hash table (Macaulay2Doc),
      * NI, a hash table (Macaulay2Doc),

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

An extension of Dintegration, that computes the integration
complex, integration classes, etc.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]                |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing, 2 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                                   |
|                                                                             |
|o2 = ideal (x , D  - 1)                                                      |
|             1   2                                                           |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : DintegrationAll(I,{1,0})                                                |
|                                                                             |
|o3 = HashTable{BFunction => (s)                                              |
|               Boundaries => HashTable{0 => | D_2-1 |}                       |
|                                       1 => 0                                |
|               Cycles => HashTable{0 => | 1 |}                               |
|                                   1 => 0                                    |
|               HomologyModules => HashTable{0 => cokernel | D_2-1 |}         |
|                                            1 => 0                           |
|                                                      1                 1    |
|               IntegrateComplex => 0  <-- (QQ[x , D ])  <-- (QQ[x , D ])  <--|
|                                               2   2             2   2       |
|                                   -1                                        |
|                                          0                 1                |
|                               1      2      1                               |
|               VResolution => R  <-- R  <-- R                                |
|                                                                             |
|                              0      1      2                                |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
| }                                                                           |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|0                                                                            |
|                                                                             |
|2                                                                            |
+-----------------------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * Dintegration -- integration modules of a D-module
  * DintegrationClasses -- integration classes of a
    D-module
  * DintegrationComplex -- derived integration
    complex of a D-module
  * DintegrationIdeal -- integration ideal of a
    D-module
  * Drestriction -- restriction modules of a D-module

Ways to use DintegrationAll :
=============================

  * "DintegrationAll(Ideal,List)"
  * "DintegrationAll(Module,List)"

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

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

DintegrationClasses -- integration classes of a D-module
********************************************************

Synopsis
========

  * Usage:
        N = DintegrationClasses(M,w), NI = DintegrationClasses(I,w), Ni = DintegrationClasses(i,M,w),
        NIi = DintegrationClasses(i,I,w),
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
      * i, an integer (Macaulay2Doc), nonnegative
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * Ni, a hash table (Macaulay2Doc),
      * N, a hash table (Macaulay2Doc),
      * NIi, a hash table (Macaulay2Doc),
      * NI, a hash table (Macaulay2Doc),

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

An extension of Dintegration, that computes the explicit
cohomology classes of a derived integration complex.
+-------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]|
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing, 2 differential variables                |
+-------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                   |
|                                                             |
|o2 = ideal (x , D  - 1)                                      |
|             1   2                                           |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : DintegrationClasses(I,{1,0})                            |
|                                                             |
|o3 = HashTable{Boundaries => HashTable{0 => | D_2-1 |}}      |
|                                       1 => 0                |
|               Cycles => HashTable{0 => | 1 |}               |
|                                   1 => 0                    |
|                               1      2      1               |
|               VResolution => R  <-- R  <-- R                |
|                                                             |
|                              0      1      2                |
|                                                             |
|o3 : HashTable                                               |
+-------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * Dintegration -- integration modules of a D-module
  * DintegrationAll -- integration modules of a
    D-module (extended version)
  * Drestriction -- restriction modules of a D-module

Ways to use DintegrationClasses :
=================================

  * "DintegrationClasses(Ideal,List)"
  * "DintegrationClasses(Module,List)"
  * "DintegrationClasses(ZZ,Ideal,List)"
  * "DintegrationClasses(ZZ,Module,List)"

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

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

DintegrationComplex -- derived integration complex of a D-module
****************************************************************

Synopsis
========

  * Usage:
        N = DintegrationComplex(M,w), NI = DintegrationComplex(I,w)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * N, a hash table (Macaulay2Doc),
      * NI, a hash table (Macaulay2Doc),

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

An extension of Dintegration, that computes the derived
integration complex.
+-------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]|
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing, 2 differential variables                |
+-------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                   |
|                                                             |
|o2 = ideal (x , D  - 1)                                      |
|             1   2                                           |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : DintegrationComplex(I,{1,0})                            |
|                                                             |
|                        1                 1                  |
|o3 = 0  <-- (QQ[x , D ])  <-- (QQ[x , D ])  <-- 0            |
|                 2   2             2   2                     |
|     -1                                         2            |
|            0                 1                              |
|                                                             |
|o3 : ChainComplex                                            |
+-------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * Dintegration -- integration modules of a D-module
  * DintegrationAll -- integration modules of a
    D-module (extended version)
  * Drestriction -- restriction modules of a D-module

Ways to use DintegrationComplex :
=================================

  * "DintegrationComplex(Ideal,List)"
  * "DintegrationComplex(Module,List)"

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

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

DintegrationIdeal -- integration ideal of a D-module
****************************************************

Synopsis
========

  * Usage:
        DintegrationIdeal(I,w)
  * Inputs:
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * an ideal (Macaulay2Doc), the integration ideal of M w.r.t.
        the weight vector w

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

A supplementary function for Dintegration, that computes
the integration ideal.
+---------------------------------------------------------------------+
|i1 : W = QQ[y,t,Dy,Dt, WeylAlgebra => {y=>Dy, t=>Dt}];               |
+---------------------------------------------------------------------+
|i2 : I = ideal(2*t*Dy+Dt, t*Dt+2*y*Dy+2); -- annihilator of 1/(t^2-y)|
|                                                                     |
|o2 : Ideal of W                                                      |
+---------------------------------------------------------------------+
|i3 : DintegrationIdeal(I, {1,4})                                     |
|                                                                     |
|o3 = ideal 1                                                         |
|                                                                     |
|o3 : Ideal of QQ                                                     |
+---------------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * Dintegration -- integration modules of a D-module
  * DintegrationAll -- integration modules of a
    D-module (extended version)
  * Drestriction -- restriction modules of a D-module

Ways to use DintegrationIdeal :
===============================

  * "DintegrationIdeal(Ideal,List)"

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

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

DintegrationIdeal(...,Strategy=>...)
************************************

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

Option is passed to Dresolution. See Dresolution(...,Strategy=>...),

Further information
===================

  * Default value: Schreyer,
  * Function: DintegrationIdeal, -- integration ideal
    of a D-module
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)"
  * "DintegrationAll(...,Strategy=>...)"
  * "DintegrationClasses(...,Strategy=>...)"
  * "DintegrationComplex(...,Strategy=>...)"
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)"
  * "Drestriction(...,Strategy=>...)"
  * "DrestrictionAll(...,Strategy=>...)"
  * "DrestrictionClasses(...,Strategy=>...)"
  * "DrestrictionComplex(...,Strategy=>...)"
  * "DrestrictionIdeal(...,Strategy=>...)"
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

distraction -- the image in the thetaRing of a torus-fixed ideal in a Weyl algebra
**********************************************************************************

Synopsis
========

  * Usage:
        distraction(I,thetaRing)
  * Inputs:
      * I, Ideal in a WeylAlgebra that is torus-fixed
  * Outputs:
      * an ideal (Macaulay2Doc), that results from intersecting I
        with the thetaRing of D, as in [SST (see
        https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Lemma 2.3.1]
        to I.

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

This computes the distraction of a torus fixed D-ideal [SST, Corollary 2.3.5].
This is necessary to compute indicial ideals [SST, Theorem 2.3.9, Corollary
2.3.5]; the roots of the indicial ideals are the exponents of the starting
terms of canonical series solutions of regular holonomic D-ideals. Code Pre

+-----------------------------------------------------------------------------+
|i1 : R1 = QQ[z]                                                              |
|                                                                             |
|o1 = R1                                                                      |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : W1 = makeWA R1                                                          |
|                                                                             |
|o2 = W1                                                                      |
|                                                                             |
|o2 : PolynomialRing, 1 differential variables                                |
+-----------------------------------------------------------------------------+
|i3 : a=1/2                                                                   |
|                                                                             |
|     1                                                                       |
|o3 = -                                                                       |
|     2                                                                       |
|                                                                             |
|o3 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i4 : b=3                                                                     |
|                                                                             |
|o4 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i5 : c=5/3                                                                   |
|                                                                             |
|     5                                                                       |
|o5 = -                                                                       |
|     3                                                                       |
|                                                                             |
|o5 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i6 : J = ideal(z*(1-z)*dz^2+(c-(a+b+1)*z)*dz-a*b) -- the Gauss hypergeometric|
|                                                                             |
|              2  2       2   9       5     3                                 |
|o6 = ideal(- z dz  + z*dz  - -z*dz + -dz - -)                                |
|                             2       3     2                                 |
|                                                                             |
|o6 : Ideal of W1                                                             |
|-----------------------------------------------------------------------------|
|equation, exponents 0, 1-c                                                   |
+-----------------------------------------------------------------------------+
|i7 : cssExpts(J,{1})                                                         |
|                                                                             |
|              2                                                              |
|o7 = {{0}, {- -}}                                                            |
|              3                                                              |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : K = inw(J,{-1,1})                                                       |
|                                                                             |
|                2                                                            |
|o8 = ideal(6z*dz  + 10dz)                                                    |
|                                                                             |
|o8 : Ideal of W1                                                             |
+-----------------------------------------------------------------------------+
|i9 : distraction(K,QQ[s])                                                    |
|                                                                             |
|             2                                                               |
|o9 = ideal(6s  + 4s)                                                         |
|                                                                             |
|o9 : Ideal of QQ[s]                                                          |
+-----------------------------------------------------------------------------+

Ways to use distraction :
=========================

  * "distraction(Ideal,Ring)"

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

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

Dlocalization -- Dlocalization* is an OBSOLETE name for Dlocalize*
******************************************************************

Synopsis
========

  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value OTW, strategy for computing a localization of a D-module

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

See Dlocalize.

Ways to use Dlocalization :
===========================

  * "Dlocalization(Ideal,RingElement)"
  * "Dlocalization(Module,RingElement)"

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

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

Dlocalize -- localization of a D-module
***************************************

Synopsis
========

  * Usage:
        Dlocalize(M,f), Dlocalize(I,f)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * f, a ring element (Macaulay2Doc), a polynomial
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value OTW, strategy for computing a localization of a D-module
  * Outputs:
      * a module (Macaulay2Doc), the localized module M_f =
        M[f^{-1}] as a D-module

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

One of the nice things about D-modules is that if a finitely generated D-module
is specializable along f, then it's localization with respect to f is also
finitely generated.  For instance, this is true for all holonomic D-modules.

There are two different algorithms for localization implemented. The first
appears in the paper 'A localization algorithm for D-modules' by
Oaku-Takayama-Walther (1999).  The second is due to Oaku and appears in the
paper 'Algorithmic computation of local cohomology modules and the
cohomological dimension of algebraic varieties' by Walther(1999)
+----------------------------------------------------+
|i1 : W = QQ[x,y,Dx,Dy, WeylAlgebra => {x=>Dx,y=>Dy}]|
|                                                    |
|o1 = W                                              |
|                                                    |
|o1 : PolynomialRing, 2 differential variables       |
+----------------------------------------------------+
|i2 : M = W^1/(ideal(x*Dx+1, Dy))                    |
|                                                    |
|o2 = cokernel | xDx+1 Dy |                          |
|                                                    |
|                            1                       |
|o2 : W-module, quotient of W                        |
+----------------------------------------------------+
|i3 : f = x^2-y^3                                    |
|                                                    |
|        3    2                                      |
|o3 = - y  + x                                       |
|                                                    |
|o3 : W                                              |
+----------------------------------------------------+
|i4 : Mf = Dlocalize(M, f)                           |
|                                                    |
|o4 = cokernel | -3xDx-2yDy-15 -y3Dy+x2Dy-6y2 |      |
|                                                    |
|                            1                       |
|o4 : W-module, quotient of W                        |
+----------------------------------------------------+

See also
========

  * DlocalizeAll -- localization of a D-module (extended
    version)
  * DlocalizeMap -- localization map from a D-module to
    its localization
  * AnnFs -- the annihilating ideal of f^s
  * Dintegration -- integration modules of a D-module

Ways to use Dlocalize :
=======================

  * "Dlocalize(Ideal,RingElement)"
  * "Dlocalize(Module,RingElement)"

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

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

Dlocalize(...,Strategy=>...) -- strategy for computing a localization of a D-module
***********************************************************************************

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

  * Oaku -- use Oaku's algorithm
  * OTW -- use Oaku-Takayama-Walther's algorithm
  * OTWcyclic -- use Oaku-Takayama-Walther's algorithm for a cyclic module

Further information
===================

  * Default value: OTW,
  * Function: Dlocalize, -- localization of a D-module
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)"
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)"
  * "DlocalizeMap(...,Strategy=>...)"
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

DlocalizeAll -- localization of a D-module (extended version)
*************************************************************

Synopsis
========

  * Usage:
        DlocalizeAll(M,f), DlocalizeAll(I,f)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * f, a ring element (Macaulay2Doc), a polynomial
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value OTW, strategy for computing a localization of a D-module
  * Outputs:
      * a hash table (Macaulay2Doc), which contains the
        localized moduleM_f = M[f^{-1}] and some additional information

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

An extension of Dlocalize, that in addition computes the
localization map, the b-function, and the power s of the generator f^s.
+----------------------------------------------------------------------------+
|i1 : W = QQ[x,y,Dx,Dy, WeylAlgebra => {x=>Dx,y=>Dy}]                        |
|                                                                            |
|o1 = W                                                                      |
|                                                                            |
|o1 : PolynomialRing, 2 differential variables                               |
+----------------------------------------------------------------------------+
|i2 : M = W^1/(ideal(x*Dx+1, Dy))                                            |
|                                                                            |
|o2 = cokernel | xDx+1 Dy |                                                  |
|                                                                            |
|                            1                                               |
|o2 : W-module, quotient of W                                                |
+----------------------------------------------------------------------------+
|i3 : f = x^2-y^3                                                            |
|                                                                            |
|        3    2                                                              |
|o3 = - y  + x                                                               |
|                                                                            |
|o3 : W                                                                      |
+----------------------------------------------------------------------------+
|i4 : DlocalizeAll(M, f)                                                     |
|                                                                            |
|o4 = HashTable{GeneratorPower => -2                                        }|
|                                                    4      5      5      7  |
|               IntegrateBfunction => (s)(s + 1)(s + -)(s + -)(s + -)(s + -) |
|                                                    3      3      6      6  |
|               LocMap => | y6-2x2y3+x4 |                                    |
|               LocModule => cokernel | -3xDx-2yDy-15 -y3Dy+x2Dy-6y2 |       |
|                                                                            |
|o4 : HashTable                                                              |
+----------------------------------------------------------------------------+

See also
========

  * Dlocalize -- localization of a D-module
  * AnnFs -- the annihilating ideal of f^s
  * Dintegration -- integration modules of a D-module

Ways to use DlocalizeAll :
==========================

  * "DlocalizeAll(Ideal,RingElement)"
  * "DlocalizeAll(Module,RingElement)"

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

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

DlocalizeMap -- localization map from a D-module to its localization
********************************************************************

Synopsis
========

  * Usage:
        DlocalizeMap(M,f), DlocalizeMap(I,f)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * f, a ring element (Macaulay2Doc), a polynomial
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value OTW, strategy for computing a localization of a D-module
  * Outputs:
      * a matrix (Macaulay2Doc), which represents the natural map
        from M to M_f = M[f^{-1}]

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

A supplementary function for Dlocalize, that computes the
localization map.
+----------------------------------------------------+
|i1 : W = QQ[x,y,Dx,Dy, WeylAlgebra => {x=>Dx,y=>Dy}]|
|                                                    |
|o1 = W                                              |
|                                                    |
|o1 : PolynomialRing, 2 differential variables       |
+----------------------------------------------------+
|i2 : M = W^1/(ideal(x*Dx+1, Dy))                    |
|                                                    |
|o2 = cokernel | xDx+1 Dy |                          |
|                                                    |
|                            1                       |
|o2 : W-module, quotient of W                        |
+----------------------------------------------------+
|i3 : f = x^2-y^3                                    |
|                                                    |
|        3    2                                      |
|o3 = - y  + x                                       |
|                                                    |
|o3 : W                                              |
+----------------------------------------------------+
|i4 : DlocalizeMap(M, f)                             |
|                                                    |
|o4 = | y6-2x2y3+x4 |                                |
|                                                    |
|o4 : Matrix                                         |
+----------------------------------------------------+

See also
========

  * Dlocalize -- localization of a D-module
  * AnnFs -- the annihilating ideal of f^s
  * Dintegration -- integration modules of a D-module

Ways to use DlocalizeMap :
==========================

  * "DlocalizeMap(Ideal,RingElement)"
  * "DlocalizeMap(Module,RingElement)"

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

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

dpairInds -- a key attached by createDpairs
*******************************************

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

see createDpairs,

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

The object dpairInds, is a symbol (Macaulay2Doc).

dpairVars -- a key attached by createDpairs
*******************************************

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

see createDpairs,

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

The object dpairVars, is a symbol (Macaulay2Doc).

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

Synopsis
========

  * Usage:
        Dprune M
  * Inputs:
      * M, a matrix (Macaulay2Doc), or a module (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * optGB, => ..., default
        value true, indicates whether a Grobner 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 variables|
+---------------------------------------------+
|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                        |
+---------------------------------------------+

See also
========

  * pruneCechComplexCC, --
    reduction of the Cech complex that produces characteristic cycles of local
    cohomology modules

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

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

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

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

Dprune(...,optGB=>...) -- indicates whether a Grobner basis should be computed
******************************************************************************

Further information
===================

  * Default value: true (Macaulay2Doc),
  * Function: Dprune, -- prunes a D-module
  * Option key: optGB, --
    indicates whether a Grobner basis should be computed

Functions with optional argument named optGB :
==============================================

  * Dprune(...,optGB=>...), --
    indicates whether a Grobner basis should be computed

Dres -- abbreviation for Dresolution
************************************

Synopsis
========

  * Optional inputs (Macaulay2Doc),:
      * LengthLimit, =>
        ..., default value infinity, the limit for the length of a resolution
        of a D-module
      * Strategy, => ...,
        default value Schreyer, strategy for computing a resolution of a
        D-module

See also
========

  * Dresolution -- resolution of a D-module

Ways to use Dres :
==================

  * "Dres(Ideal)"
  * "Dres(Ideal,List)"
  * "Dres(Module)"
  * "Dres(Module,List)"

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

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

Dres(...,LengthLimit=>...) -- the limit for the length of a resolution of a D-module
************************************************************************************

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

In case the actual length of the resolution exceeds the limit, it is truncated.
The default value is infinity.

Further information
===================

  * Default value: infinity (Macaulay2Doc),
  * Function: Dres, -- abbreviation for Dresolution
  * Option key: LengthLimit (Macaulay2Doc), -- stop when the
    resolution reaches this length

Functions with optional argument named LengthLimit :
====================================================

  * Dres(...,LengthLimit=>...)
    -- the limit for the length
    of a resolution of a D-module
  * "Dresolution(...,LengthLimit=>...)"
  * "minimalBetti(...,LengthLimit=>...)" -- see minimalBetti (Macaulay2Doc),
    -- minimal betti numbers of (the minimal free
    resolution of) a homogeneous ideal or module
  * resolution(...,LengthLimit=>...) (Macaulay2Doc)
    -- stop
    when the resolution reaches this length

Dres(...,Strategy=>...) -- strategy for computing a resolution of a D-module
****************************************************************************

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

  * Schreyer -- uses Schreyer method in homogeneous Weyl algebra
  * Vhomogenize -- uses V-homogenization method of Oaku

Further information
===================

  * Default value: Schreyer,
  * Function: Dres, -- abbreviation for Dresolution
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)"
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

Dresolution -- resolution of a D-module
***************************************

Synopsis
========

  * Usage:
        Dresolution M, Dresolution I, Dresolution(M,w), Dresolution(I,w)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
  * Optional inputs (Macaulay2Doc),:
      * LengthLimit, =>
        ..., default value infinity, the limit for the length of a resolution
        of a D-module
      * Strategy, => ...,
        default value Schreyer, strategy for computing a resolution of a
        D-module
  * Outputs:
      * a chain complex (Macaulay2Doc), a Schreyer
        resolution of the D-module M or a resolution adapted to a weight vector
        w of the form (-u,u)

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

This routine computes various resolutions of a D-module. If no weight vector is
specified, then the command produces a resolution by using the Schreyer order
implemented in the engine.  If a weight vector w of the form (-u,u) is
specified, then the command produces a resolution with shifts which is adapted
to the weight vector w. These w-adapted resolutions are compatible with
b-functions and used in the restriction algorithm. For ordinary resolutions,
the user may use the command resolution. Note that the notion of a minimal
resolution is well-defined only in case of homogenized Weyl algebra.

There are two strategies for constructing w-adapted resolutions.   The first
strategy is to construct a Schreyer resolution in the homogenized Weyl algebra
and then dehomogenize.  The second strategy is to homogenize with respect to
the weight vector. These strategies are described in the paper 'Algorithms for
D-modules' by Oaku-Takayama(1999).
+-------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]|
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing, 2 differential variables                |
+-------------------------------------------------------------+
|i2 : I = ideal(x_1*D_1+3*x_2*D_2-1, D_1^3-D_2)               |
|                                                             |
|                               3                             |
|o2 = ideal (x D  + 3x D  - 1, D  - D )                       |
|             1 1     2 2       1    2                        |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : Dresolution(I,{-1,-1,1,1})                              |
|                                                             |
|      1      5      6      2                                 |
|o3 = R  <-- R  <-- R  <-- R  <-- 0                           |
|                                                             |
|     0      1      2      3      4                           |
|                                                             |
|o3 : ChainComplex                                            |
+-------------------------------------------------------------+
Abbreviations :
  * Dres

See also
========

  * gbw -- Groebner bases w.r.t. a weight
  * Drestriction -- restriction modules of a D-module

Ways to use Dresolution :
=========================

  * "Dresolution(Ideal)"
  * "Dresolution(Ideal,List)"
  * "Dresolution(Module)"
  * "Dresolution(Module,List)"

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

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

Drestrict -- an (OBSOLETE) abbreviation for Drestriction
********************************************************

Synopsis
========

  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null

See also
========

  * Drestriction -- restriction modules of a D-module

Ways to use Drestrict :
=======================

  * "Drestrict(Ideal,List)"
  * "Drestrict(Module,List)"
  * "Drestrict(ZZ,Ideal,List)"
  * "Drestrict(ZZ,Module,List)"

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

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

Drestriction -- restriction modules of a D-module
*************************************************

Synopsis
========

  * Usage:
        N = Drestriction(M,w), NI = Drestriction(I,w), Ni = Drestriction(i,M,w),
        NIi = Drestriction(i,I,w)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
      * i, an integer (Macaulay2Doc), nonnegative
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * Ni, a module (Macaulay2Doc), the i-th derived integration
        module of M with respect to the weight vector w
      * N, a hash table (Macaulay2Doc), contains entries of
        the form i=>Ni
      * NIi, a module (Macaulay2Doc), the i-th derived
        integration module of D/I with respect to the weight vector w
      * NI, a hash table (Macaulay2Doc), contains entries of
        the form i=>NIi

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

The derived restriction modules of a D-module M are the derived inverse images
in the sense of algebraic geometry but in the category of D-modules. This
routine computes restrictions to coordinate subspaces, where the subspace is
determined by the strictly positive entries of the weight vectorw, e.g., {x_i =
0 : w_i > 0} if D = C<x_1,...,x_n,d_1,...,d_n>. The input weight vector should
be a list of n numbers to induce the weight (-w,w) on D.

The algorithm used appears in the paper 'Algorithms for D-modules' by
Oaku-Takayama(1999).  The method is to compute an adapted resolution with
respect to the weight vector w and use the b-function with respect to w to
truncate the resolution.

+-------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]|
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing, 2 differential variables                |
+-------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                   |
|                                                             |
|o2 = ideal (x , D  - 1)                                      |
|             1   2                                           |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : Drestriction(I,{1,0})                                   |
|                                                             |
|o3 = HashTable{0 => 0                 }                      |
|               1 => cokernel | D_2-1 |                       |
|                                                             |
|o3 : HashTable                                               |
+-------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the n-th Weyl algebra.

See also
========

  * DrestrictionAll -- restriction modules of a
    D-module (extended version)
  * DrestrictionClasses -- restriction classes of a
    D-module
  * DrestrictionComplex -- derived restriction
    complex of a D-module
  * DrestrictionIdeal -- restriction ideal of a
    D-module
  * Dresolution -- resolution of a D-module
  * Dintegration -- integration modules of a D-module

Ways to use Drestriction :
==========================

  * "Drestriction(Ideal,List)"
  * "Drestriction(Module,List)"
  * "Drestriction(ZZ,Ideal,List)"
  * "Drestriction(ZZ,Module,List)"

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

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

DrestrictionAll -- restriction modules of a D-module (extended version)
***********************************************************************

Synopsis
========

  * Usage:
        N = DrestrictionAll(M,w), NI = DrestrictionAll(I,w)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * N, a hash table (Macaulay2Doc),
      * NI, a hash table (Macaulay2Doc),

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

An extension of Drestriction, that computes the restriction
complex, restriction classes, etc.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]                |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing, 2 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                                   |
|                                                                             |
|o2 = ideal (x , D  - 1)                                                      |
|             1   2                                                           |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : DrestrictionAll(I,{1,0})                                                |
|                                                                             |
|o3 = HashTable{BFunction => (s + 1)                                          |
|               Boundaries => HashTable{0 => 0        }                       |
|                                       1 => | D_2-1 |                        |
|                                            | 0     |                        |
|               Cycles => HashTable{0 => 0    }                               |
|                                   1 => | 1 |                                |
|                                        | 0 |                                |
|               HomologyModules => HashTable{0 => 0                 }         |
|                                            1 => cokernel | D_2-1 |          |
|                                                           1                 |
|               RestrictComplex => 0  <-- 0 <-- (QQ[x , D ])  <-- (QQ[x ,     |
|                                                    2   2             2      |
|                                  -1     0                                   |
|                                               1                 2           |
|                               1      2      1                               |
|               VResolution => R  <-- R  <-- R                                |
|                                                                             |
|                              0      1      2                                |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|     }                                                                       |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|    1                                                                        |
|D ])                                                                         |
| 2                                                                           |
+-----------------------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * Drestriction -- restriction modules of a D-module
  * DrestrictionClasses -- restriction classes of a
    D-module
  * DrestrictionComplex -- derived restriction
    complex of a D-module
  * DrestrictionIdeal -- restriction ideal of a
    D-module
  * Dintegration -- integration modules of a D-module

Ways to use DrestrictionAll :
=============================

  * "DrestrictionAll(Ideal,List)"
  * "DrestrictionAll(Module,List)"

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

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

DrestrictionClasses -- restriction classes of a D-module
********************************************************

Synopsis
========

  * Usage:
        N = DrestrictionClasses(M,w), NI = DrestrictionClasses(I,w), Ni = DrestrictionClasses(i,M,w),
        NIi = DrestrictionClasses(i,I,w),
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
      * i, an integer (Macaulay2Doc), nonnegative
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * Ni, a hash table (Macaulay2Doc),
      * N, a hash table (Macaulay2Doc),
      * NIi, a hash table (Macaulay2Doc),
      * NI, a hash table (Macaulay2Doc),

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

An extension of Drestriction, that computes the explicit
cohomology classes of a derived restriction complex.
+-------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]|
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing, 2 differential variables                |
+-------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                   |
|                                                             |
|o2 = ideal (x , D  - 1)                                      |
|             1   2                                           |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : DrestrictionClasses(I,{1,0})                            |
|                                                             |
|o3 = HashTable{Boundaries => HashTable{0 => 0        }}      |
|                                       1 => | D_2-1 |        |
|                                            | 0     |        |
|               Cycles => HashTable{0 => 0    }               |
|                                   1 => | 1 |                |
|                                        | 0 |                |
|                               1      2      1               |
|               VResolution => R  <-- R  <-- R                |
|                                                             |
|                              0      1      2                |
|                                                             |
|o3 : HashTable                                               |
+-------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * Drestriction -- restriction modules of a D-module
  * DrestrictionAll -- restriction modules of a
    D-module (extended version)
  * Dintegration -- integration modules of a D-module

Ways to use DrestrictionClasses :
=================================

  * "DrestrictionClasses(Ideal,List)"
  * "DrestrictionClasses(Module,List)"
  * "DrestrictionClasses(ZZ,Ideal,List)"
  * "DrestrictionClasses(ZZ,Module,List)"

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

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

DrestrictionComplex -- derived restriction complex of a D-module
****************************************************************

Synopsis
========

  * Usage:
        N = DrestrictionComplex(M,w), NI = DrestrictionComplex(I,w)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * N, a hash table (Macaulay2Doc),
      * NI, a hash table (Macaulay2Doc),

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

An extension of Drestriction, that computes the derived
restriction complex.
+-------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2,D_1,D_2,WeylAlgebra=>{x_1=>D_1,x_2=>D_2}]|
|                                                             |
|o1 = R                                                       |
|                                                             |
|o1 : PolynomialRing, 2 differential variables                |
+-------------------------------------------------------------+
|i2 : I = ideal(x_1, D_2-1)                                   |
|                                                             |
|o2 = ideal (x , D  - 1)                                      |
|             1   2                                           |
|                                                             |
|o2 : Ideal of R                                              |
+-------------------------------------------------------------+
|i3 : DrestrictionComplex(I,{1,0})                            |
|                                                             |
|                              1                 1            |
|o3 = 0  <-- 0 <-- (QQ[x , D ])  <-- (QQ[x , D ])             |
|                       2   2             2   2               |
|     -1     0                                                |
|                  1                 2                        |
|                                                             |
|o3 : ChainComplex                                            |
+-------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * Drestriction -- restriction modules of a D-module
  * DrestrictionAll -- restriction modules of a
    D-module (extended version)
  * Dintegration -- integration modules of a D-module

Ways to use DrestrictionComplex :
=================================

  * "DrestrictionComplex(Ideal,List)"
  * "DrestrictionComplex(Module,List)"

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

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

DrestrictionIdeal -- restriction ideal of a D-module
****************************************************

Synopsis
========

  * Usage:
        DrestrictionIdeal(I,w)
  * Inputs:
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * w, a list (Macaulay2Doc), a weight vector
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value Schreyer, null
  * Outputs:
      * an ideal (Macaulay2Doc), the restriction ideal of M w.r.t.
        the weight vector w

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

A supplementary function for Drestriction, that computes
the restriction ideal.
+---------------------------------------------------------------------+
|i1 : W = QQ[y,t,Dy,Dt, WeylAlgebra => {y=>Dy, t=>Dt}];               |
+---------------------------------------------------------------------+
|i2 : I = ideal(2*t*Dy+Dt, t*Dt+2*y*Dy+2); -- annihilator of 1/(t^2-y)|
|                                                                     |
|o2 : Ideal of W                                                      |
+---------------------------------------------------------------------+
|i3 : DrestrictionIdeal(I, {1,4})                                     |
|                                                                     |
|o3 = ideal 1                                                         |
|                                                                     |
|o3 : Ideal of QQ                                                     |
+---------------------------------------------------------------------+

Caveat
======

The module M should be specializable to the subspace. This is true for
holonomic modules.The weight vector w should be a list of n numbers if M is a
module over the nth Weyl algebra.

See also
========

  * Drestriction -- restriction modules of a D-module
  * DrestrictionAll -- restriction modules of a
    D-module (extended version)
  * Dintegration -- integration modules of a D-module

Ways to use DrestrictionIdeal :
===============================

  * "DrestrictionIdeal(Ideal,List)"

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

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

Dtrace(ZZ) -- set the depth of comments made by D-module routines
*****************************************************************

Synopsis
========

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

See also
========

  * getDtrace -- (internal) -- get the INFOLEVEL switch

Ways to use this method:
========================

  * Dtrace(ZZ) -- set the depth of comments made by
    D-module routines

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

Synopsis
========

  * Usage:
        Dtransposition A
  * Inputs:
      * A, a matrix (Macaulay2Doc), a matrix, function, ideal, or
        chain complex 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 : makeWA(QQ[x,y])                         |
|                                             |
|o1 = QQ[x..y, dx, dy]                        |
|                                             |
|o1 : PolynomialRing, 2 differential variables|
+---------------------------------------------+
|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) -- an optional argument

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

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

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

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

Duality -- an option for PolySols=>Alg
**************************************

See also
========

  * PolySols -- polynomial solutions of a holonomic system

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

The object Duality, is a symbol (Macaulay2Doc).

eulerOperators
**************

Ways to use eulerOperators :
============================

  * eulerOperators(Matrix,List,PolynomialRing) (missing documentation)
  * eulerOperators(Matrix,PolynomialRing) (missing documentation)

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

The object eulerOperators (missing documentation) is a method function (Macaulay2Doc).

Explicit -- a key in the hashtable created by Drestriction/Dintegration
***********************************************************************

See also
========

  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module

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

The object Explicit, is a symbol (Macaulay2Doc).

Exponents -- a key in the hashtable created by Drestriction/Dintegration
************************************************************************

See also
========

  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module

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

The object Exponents, is a symbol (Macaulay2Doc).

ExternalProduct -- external product of modules or complexes
***********************************************************

Synopsis
========

  * Optional inputs (Macaulay2Doc),:
      * TwistMap,
        => ..., default value false, indicates whether TwistMap should be
        computed

Ways to use ExternalProduct :
=============================

  * "ExternalProduct(ChainComplex,ChainComplex)"
  * "ExternalProduct(Module,Module)"

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

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

ExternalProduct(...,TwistMap=>...) -- indicates whether TwistMap should be computed
***********************************************************************************

Further information
===================

  * Default value: false (Macaulay2Doc),
  * Function: ExternalProduct, -- external product of
    modules or complexes
  * Option key: TwistMap, -- indicates whether TwistMap should
    be computed

Functions with optional argument named TwistMap :
=================================================

  * ExternalProduct(...,TwistMap=>...)
    -- indicates whether
    TwistMap should be computed

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

Synopsis
========

  * 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 variables |
+----------------------------------------------+
|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).

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

Synopsis
========

  * 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 variables|
+---------------------------------------------+
|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).

factorBFunction(RingElement) -- factorization of a b-function
*************************************************************

Synopsis
========

  * Function: factorBFunction,
  * Usage:
        bFunction b
  * Inputs:
      * b, a ring element (Macaulay2Doc), a polynomial
        obtained via one of the b-function routines
  * Outputs:
      * a product expression (Macaulay2Doc), the factorization
        of b

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

Fact. The roots of any b-function are rational.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x, dx, WeylAlgebra => {x=>dx}]                                   |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing, 1 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : f = x^10                                                                |
|                                                                             |
|      10                                                                     |
|o2 = x                                                                       |
|                                                                             |
|o2 : R                                                                       |
+-----------------------------------------------------------------------------+
|i3 : b = globalBFunction f                                                   |
|                                                                             |
|      10   11 9   66 8   363 7   157773 6   180411 5   341693 4   16819 3    |
|o3 = s   + --s  + --s  + ---s  + ------s  + ------s  + ------s  + -----s  +  |
|            2      5      20      10000      20000     100000     20000      |
|     ------------------------------------------------------------------------|
|      1594197 2    66429       567                                           |
|     --------s  + -------s + -------                                         |
|     12500000     6250000    1562500                                         |
|                                                                             |
|o3 : QQ[s]                                                                   |
+-----------------------------------------------------------------------------+
|i4 : factorBFunction b                                                       |
|                                                                             |
|                 1      1      2      3      4       1       3       7       |
|o4 = (s + 1)(s + -)(s + -)(s + -)(s + -)(s + -)(s + --)(s + --)(s + --)(s +  |
|                 2      5      5      5      5      10      10      10       |
|                                                                             |
|o4 : Expression of class Product                                             |
|-----------------------------------------------------------------------------|
| 9                                                                           |
|--)                                                                          |
|10                                                                           |
+-----------------------------------------------------------------------------+

Caveat
======

f should be an output of one of the b-function routines

See also
========

  * bFunction -- b-function
  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)

Ways to use this method:
========================

  * factorBFunction(RingElement), --
    factorization of a b-function

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

Synopsis
========

  * Usage:
        Fourier A
  * Inputs:
      * A, a matrix (Macaulay2Doc), a matrix, function, or ideal
        over the Weyl algebra
  * Outputs:
      * a matrix (Macaulay2Doc), the Fourier transform of A as a
        matrix, function, or ideal over the Weyl algebra

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

The Fourier transform is the automorphism of the Weyl algebra which sends x  to
                                                                           i
-D  and D  to x .
  i      i     i

+---------------------------------------------+
|i1 : makeWA(QQ[x,y])                         |
|                                             |
|o1 = QQ[x..y, dx, dy]                        |
|                                             |
|o1 : PolynomialRing, 2 differential variables|
+---------------------------------------------+
|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 : Fourier L                               |
|                                             |
|       5        2    2                       |
|o3 = 3x y + y*dx  - y dy - 2y                |
|                                             |
|o3 : QQ[x..y, dx, dy]                        |
+---------------------------------------------+

See also
========

  * WeylAlgebra (Macaulay2Doc) -- an optional argument

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

  * "Fourier(Ideal)"
  * "Fourier(Matrix)"
  * "Fourier(RingElement)"
  * Fourier(ChainComplex) (missing documentation)
  * Fourier(Module) (missing documentation)

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

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

FourierInverse -- Inverse Fourier map (D-modules)
*************************************************

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

 see Fourier,

Ways to use FourierInverse :
============================

  * "FourierInverse(ChainComplex)"
  * "FourierInverse(Ideal)"
  * "FourierInverse(Matrix)"
  * "FourierInverse(Module)"
  * "FourierInverse(RingElement)"

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

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

gbw -- Groebner bases w.r.t. a weight
*************************************

Synopsis
========

  * Usage:
        gbw(I,w)
        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
  * Outputs:
      * gbI, an ideal (Macaulay2Doc), with the generators forming
        a Gr\"obner basis of the ideal with respect to the weight vector
      * gbM, a matrix (Macaulay2Doc), with the columns forming a
        Gr\"obner basis of the submodule generated by the columns of the matrix
        with respect to the weight vector

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

This routine computes a Gr\"obner basis of a left ideal I of the Weyl algebra
with respect to a weight vector w = (u,v) where either u+v > 0 or u+v = 0. In
the case where u+v > 0 the ordinary Buchberger algorithm works for any term
order refining the weight order. In the case where u+v = 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. 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].

+-----------------------------------------------------------------------------+
|i1 : makeWA(QQ[x,y])                                                         |
|                                                                             |
|o1 = QQ[x..y, dx, dy]                                                        |
|                                                                             |
|o1 : PolynomialRing, 2 differential variables                                |
+-----------------------------------------------------------------------------+
|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,3,-1})                                                      |
|                                                                             |
|                                2                                2  2    2   |
|o3 = ideal (x*dx + 2y*dy - 3, dx  - dy, 2y*dx*dy + x*dy - 2dx, 4y dy  - x dy |
|     ------------------------------------------------------------------------|
|     + 2x*dx - 2y*dy)                                                        |
|                                                                             |
|o3 : Ideal of QQ[x..y, dx, dy]                                               |
+-----------------------------------------------------------------------------+
|i4 : gbw(I, {-1,-3,1,3})                                                     |
|                                                                             |
|                                  2                                          |
|o4 = ideal (x*dx + 2y*dy - 3, - dx  + dy)                                    |
|                                                                             |
|o4 : Ideal of QQ[x..y, dx, dy]                                               |
+-----------------------------------------------------------------------------+

Caveat
======

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

See also
========

  * inw -- initial form/ideal w.r.t. a weight
  * setHomSwitch -- toggles the use of
    homogeneous Weyl algebra

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

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

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

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

GD -- an option for PolySols=>Alg
*********************************

See also
========

  * PolySols -- polynomial solutions of a holonomic system

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

The object GD, is a symbol (Macaulay2Doc).

GenCycles -- a key in the hashtable created by Drestriction/Dintegration
************************************************************************

See also
========

  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module

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

The object GenCycles, is a symbol (Macaulay2Doc).

generalB(...,Exponent=>...) -- specify exponent m for m-generalized Bernstein-Sato polynomial
*********************************************************************************************

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

See Berkesch and Leykin ``Algorithms for Bernstein-Sato polynomials and
multiplier ideals''.

Further information
===================

  * Default value: null
  * Function: generalB, -- global
    generalized Bernstein-Sato polynomial
  * Option key: Exponent,
    -- specify exponent m for m-generalized Bernstein-Sato polynomial

Functions with optional argument named Exponent :
=================================================

  * generalB(...,Exponent=>...)
    -- specify exponent m for
    m-generalized Bernstein-Sato polynomial

generalB(...,Strategy=>...) -- specify strategy for computing generalized Bernstein-Sato polynomial
***************************************************************************************************

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

  * InitialIdeal -- use the initial ideal in_{(-w,w)} Ann f^s; this Strategy is
    the fastest on many examples, but can not be used with the Exponent,
    option.
  * StarIdeal -- use ``star ideal'', the (-w,w) homogeneous elements of the Ann
    f^s
See Berkesch and Leykin ``Algorithms for Bernstein-Sato polynomials and
multiplier ideals''.

Further information
===================

  * Default value: InitialIdeal,
  * Function: generalB, -- global
    generalized Bernstein-Sato polynomial
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

generalB(List,RingElement) -- global generalized Bernstein-Sato polynomial
**************************************************************************

Synopsis
========

  * Function: generalB,
  * Usage:
        b = generalB(F,g), b = generalB F
  * Inputs:
      * F, a list (Macaulay2Doc), a list of polynomials
      * g, a ring element (Macaulay2Doc), a polynomial
  * Optional inputs (Macaulay2Doc),:
      * Exponent, => ...,
        default value null, specify exponent m for m-generalized Bernstein-Sato
        polynomial
      * Strategy, => ...,
        default value InitialIdeal, specify strategy for computing generalized
        Bernstein-Sato polynomial
  * Outputs:
      * b, a ring element (Macaulay2Doc), the general
        Bernstein-Sato polynomial b(s) in Q[s]

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

Bernstein-Sato polynomial for an arbitrary affine variety was introduced in
Budur, Mustata, and Saito ``Bernstein--Sato polynomials of arbitrary
varieties''. If the option Exponent,
is specified, then the
m-generalized Bernstein-Sato polynomial is computed. See Berkesch and Leykin
``Algorithms for Bernstein-Sato polynomials and multiplier ideals'' for
definitions.
+-----------------------------------------------------------------------------+
|i1 : W = makeWA(QQ[x_1..x_3]);                                               |
+-----------------------------------------------------------------------------+
|i2 : factorBFunction generalB ({x_2^2-x_1*x_3, x_1^3-x_3^2}, x_2)            |
|                                                                             |
|                 5      9      11      11      13      29      31      35    |
|o2 = (s + 2)(s + -)(s + -)(s + --)(s + --)(s + --)(s + --)(s + --)(s + --)(s |
|                 2      4       4       6       6      12      12      12    |
|                                                                             |
|o2 : Expression of class Product                                             |
|-----------------------------------------------------------------------------|
|  37                                                                         |
|+ --)                                                                        |
|  12                                                                         |
+-----------------------------------------------------------------------------+

Caveat
======

The input could be either in a polynomial ring or the Weyl algebra. In the
latter case the algebra should not have any central variables and should not be
a homogeneous Weyl algebra.

See also
========

  * bFunction -- b-function
  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * lct -- compute the log canonical threshold for an
    ideal
  * multiplierIdeal -- multiplier ideal

Ways to use this method:
========================

  * "generalB(List)"
  * generalB(List,RingElement), --
    global generalized Bernstein-Sato polynomial

GeneralBernsteinSato -- a strategy option for lct, globalBFunction
******************************************************************

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

see lct,globalBFunction.

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

The object GeneralBernsteinSato, is a symbol (Macaulay2Doc).

Generator -- a key created by makeCyclic
****************************************

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

See makeCyclic.

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

The object Generator, is a symbol (Macaulay2Doc).

GeneratorPower -- a key created by Dlocalize
********************************************

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

See Dlocalize.

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

The object GeneratorPower, is a symbol (Macaulay2Doc).

genToDistractionGens -- the image in the thetaRing of a torus-fixed element in a Weyl algebra
*********************************************************************************************

Synopsis
========

  * Usage:
        genToDistractionGen(f,thetaRing)
  * Inputs:
      * f, a ring element (Macaulay2Doc), in a Weyl algebra
        D of the form x^u Dx^v
      * thetaRing, a ring (Macaulay2Doc), that is a stand in for
        the theta ring inside D
  * Outputs:
      * a list (Macaulay2Doc), in thetaRing that is the result of
        applying [SST (see https://mathscinet.ams.org/mathscinet/pdf/1734566.
        pdf ), Lemma 2.3.1] to f.

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

This function rewrites a monomial $x^u \partial^v$ as a product $x^a p(\theta)
\partial^b$, where $\theta_i = x_i \partial_i$ for $i = 1,\dots, n$. This is a
step in a procedure for checking that D-ideal is torus-fixed, and is used in
the isTorusFixed routine. Code Pre

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1..x_4]                                                        |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : W = makeWA R                                                            |
|                                                                             |
|o2 = W                                                                       |
|                                                                             |
|o2 : PolynomialRing, 4 differential variables                                |
+-----------------------------------------------------------------------------+
|i3 : describe W                                                              |
|                                                                             |
|o3 = QQ[x ..x , dx ..dx , Degrees => {8:1}, Heft => {1}, WeylAlgebra => {{x ,|
|         1   4    1    4                                                   1 |
|-----------------------------------------------------------------------------|
|dx }, {x , dx }, {x , dx }, {x , dx }}]                                      |
|  1     2    2     3    3     4    4                                         |
+-----------------------------------------------------------------------------+

Ways to use genToDistractionGens :
==================================

  * "genToDistractionGens(RingElement,Ring)"

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

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

getDtrace -- (internal) -- get the INFOLEVEL switch
***************************************************

See also
========

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

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

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

getHomSwitch -- (internal) -- get the HOMOGENIZATION switch
***********************************************************

See also
========

  * setHomSwitch -- toggles the use of
    homogeneous Weyl algebra

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

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

getIntRoots(RingElement) -- get integer roots of a b-function
*************************************************************

Synopsis
========

  * Function: getIntRoots,
  * Usage:
        getIntRoots b
  * Inputs:
      * b, a ring element (Macaulay2Doc), the output of one
        of the b-function routines
  * Outputs:
      * a list (Macaulay2Doc), the list of the integer roots of b

See also
========

  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * bFunction -- b-function

Ways to use this method:
========================

  * getIntRoots(RingElement) -- get
    integer roots of a b-function

gkz -- The A-hypergeometric systems of Gelfand, Kapranov and Zelevinsky (GKZ)
*****************************************************************************

Synopsis
========

  * Usage:
        gkz(A,b)
        gkz(A,b,D)
  * Inputs:
      * A, a matrix (Macaulay2Doc),
      * b, a list (Macaulay2Doc),
      * D, a polynomial ring (Macaulay2Doc),
  * Outputs:
      * an ideal (Macaulay2Doc), the GKZ hypergeometric system
        associated to the matrix A and the parameter vector b in the Weyl
        algebra D.

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

The GKZ hypergeometric system of PDE's associated to a $d$ $\times$ $n$ integer
matrix A is an ideal in the Weyl algebra $D_n$ over &#x2102; with generators
$x_1,\dots,x_n$ and $\partial_1,\dots,\partial_n$. It consists of the toric
ideal $I_A$ in the polynomial subring &#x2102;$[\partial_1,...,\partial_n]$ and
Euler relations given by the entries of the vector (A $\theta$ - b), where
$\theta$ is the vector $(\theta_1,...,\theta_n)^t$, and $\theta_i = x_i
\partial_i$. A field of characteristic zero may be used instead of &#x2102;.
For more details, see [SST (see
https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Chapters 3 and 4].

+-----------------------------------------------------------------------------+
|i1 : A = matrix{{1,1,1},{0,1,2}}                                             |
|                                                                             |
|o1 = | 1 1 1 |                                                               |
|     | 0 1 2 |                                                               |
|                                                                             |
|              2        3                                                     |
|o1 : Matrix ZZ  <--- ZZ                                                      |
+-----------------------------------------------------------------------------+
|i2 : b = {3,4}                                                               |
|                                                                             |
|o2 = {3, 4}                                                                  |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : I = gkz (A,b)                                                           |
|                                                                             |
|                                                         2                   |
|o3 = ideal (x D  + x D  + x D  - 3, x D  + 2x D  - 4, - D  + D D )           |
|             1 1    2 2    3 3       2 2     3 3         2    1 3            |
|                                                                             |
|o3 : Ideal of QQ[x ..x , D ..D ]                                             |
|                  1   3   1   3                                              |
+-----------------------------------------------------------------------------+
|i4 : describe ring I                                                         |
|                                                                             |
|o4 = QQ[x ..x , D ..D , Degrees => {6:1}, Heft => {1}, WeylAlgebra => {{x ,  |
|         1   3   1   3                                                   1   |
|-----------------------------------------------------------------------------|
|D }, {x , D }, {x , D }}]                                                    |
| 1     2   2     3   3                                                       |
+-----------------------------------------------------------------------------+

The ambient Weyl algebra can be determined as an input.

+--------------------------------------------------------------------------+
|i5 : D = makeWA(QQ[x_1..x_3])                                             |
|                                                                          |
|o5 = D                                                                    |
|                                                                          |
|o5 : PolynomialRing, 3 differential variables                             |
+--------------------------------------------------------------------------+
|i6 : gkz(A,b,D)                                                           |
|                                                                          |
|                                                               2          |
|o6 = ideal (x dx  + x dx  + x dx  - 3, x dx  + 2x dx  - 4, - dx  + dx dx )|
|             1  1    2  2    3  3       2  2     3  3          2     1  3 |
|                                                                          |
|o6 : Ideal of D                                                           |
+--------------------------------------------------------------------------+

One may separately produce the toric ideal and the Euler operators.

+----------------------------------------------------+
|i7 : toricIdealPartials(A,D)                        |
|                                                    |
|               2                                    |
|o7 = ideal(- dx  + dx dx )                          |
|               2     1  3                           |
|                                                    |
|o7 : Ideal of QQ[dx ..dx ]                          |
|                   1    3                           |
+----------------------------------------------------+
|i8 : eulerOperators(A,b,D)                          |
|                                                    |
|o8 = {x dx  + x dx  + x dx  - 3, x dx  + 2x dx  - 4}|
|       1  1    2  2    3  3       2  2     3  3     |
|                                                    |
|o8 : List                                           |
+----------------------------------------------------+

Caveat
======

gkz(A,b) always returns a different ring and will use variables x_1,...,x_n,
D_1,...D_n.

See also
========

  * AppellF1 -- Appell F1 system of PDE's

Ways to use gkz :
=================

  * "gkz(Matrix,List)"
  * "gkz(Matrix,List,PolynomialRing)"

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

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

globalB(Ideal,RingElement) -- compute global b-function and b-operator for a D-module and a polynomial
******************************************************************************************************

Synopsis
========

  * Function: globalB,
  * Usage:
        H = globalB(I,f)
  * Inputs:
      * I, an ideal (Macaulay2Doc), a holonomic ideal
      * f, a ring element (Macaulay2Doc), a polynomial in a
        Weyl algebra (should not contain differential variables)
  * Outputs:
      * H, a hash table (Macaulay2Doc), containing the keys
        Bpolynomial and Boperator

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

The algorithm used here is a modification of the original algorithm of Oaku for
computing Bernstein-Sato polynomials
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x, dx, WeylAlgebra => {x=>dx}]                                   |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing, 1 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : f = x^7                                                                 |
|                                                                             |
|      7                                                                      |
|o2 = x                                                                       |
|                                                                             |
|o2 : R                                                                       |
+-----------------------------------------------------------------------------+
|i3 : b = globalB(ideal dx, f)                                                |
|                                                                             |
|                              7                                              |
|o3 = HashTable{Boperator => dx                                               |
|                                     7           6           5           4   |
|               Bpolynomial => 823543s  + 3294172s  + 5411854s  + 4705960s  + |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|                                    }                                        |
|        3          2                                                         |
|2321767s  + 643468s  + 91476s + 5040                                         |
+-----------------------------------------------------------------------------+
|i4 : factorBFunction b.Bpolynomial                                           |
|                                                                             |
|                 1      2      3      4      5      6                        |
|o4 = (s + 1)(s + -)(s + -)(s + -)(s + -)(s + -)(s + -)                       |
|                 7      7      7      7      7      7                        |
|                                                                             |
|o4 : Expression of class Product                                             |
+-----------------------------------------------------------------------------+

See also
========

  * bFunction -- b-function
  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * factorBFunction -- factorization
    of a b-function

Ways to use this method:
========================

  * globalB(Ideal,RingElement), --
    compute global b-function and b-operator for a D-module and a polynomial

globalBFunction(...,Strategy=>...) -- specify strategy for computing global b-function
**************************************************************************************

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

  * IntRing, TryGeneric, NonGeneric -- passed to bFunction,
    see bFunction(...,Strategy=>...),
                                   s
  * ViaAnnFs -- computes J(s)=Ann(f ) and then intersects J(s)+D[s]f} with K[s]
  * ReducedB -- computes b(s)/(s+1) by taking the intersection of
    J(s)+D[s](f,df/dx1,...,df/dxn) with K[s], then multiplies by s+1.
  * GeneralBernsteinSato -- calls generalB,
    {f}.
  * Default: GeneralBernsteinSato

Further information
===================

  * Default value: GeneralBernsteinSato,
  * Function: globalBFunction, --
    global b-function (else known as the Bernstein-Sato polynomial)
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

globalBFunction(RingElement) -- global b-function (else known as the Bernstein-Sato polynomial)
***********************************************************************************************

Synopsis
========

  * Function: globalBFunction,
  * Usage:
        b = globalBFunction f
  * Inputs:
      * f, a ring element (Macaulay2Doc), a polynomial
  * Optional inputs (Macaulay2Doc),:
      * Strategy,
        => ..., default value GeneralBernsteinSato, specify strategy for
        computing global b-function
  * Outputs:
      * b, a ring element (Macaulay2Doc), the b-function
        b(s) in Q[s]

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

Definition. Let D = A_{2n}(K) = K<x_1,...,x_n,d_1,...,d_n> be a Weyl algebra.
The Bernstein-Sato polynomial of a polynomial f is defined to be the monic
generator of the ideal of all polynomials b(s) in K[s] such that  b(s) f^s =
Q(s,x,d) f^{s+1} where Q lives in D[s].

Algorithm. Let I_f = D<t,dt>*<t-f, d_1+df/dx_1*dt, ..., d_n+df/dx_n*dt> Let
B(s) = bFunction(I, {1, 0, ..., 0}) where 1 in the weight that corresponds to
dt. Then the global b-function is b_f = B(-s-1)

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x]                                                               |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : f = x^10                                                                |
|                                                                             |
|      10                                                                     |
|o2 = x                                                                       |
|                                                                             |
|o2 : R                                                                       |
+-----------------------------------------------------------------------------+
|i3 : b = globalBFunction f                                                   |
|                                                                             |
|      10   11 9   66 8   363 7   157773 6   180411 5   341693 4   16819 3    |
|o3 = s   + --s  + --s  + ---s  + ------s  + ------s  + ------s  + -----s  +  |
|            2      5      20      10000      20000     100000     20000      |
|     ------------------------------------------------------------------------|
|      1594197 2    66429       567                                           |
|     --------s  + -------s + -------                                         |
|     12500000     6250000    1562500                                         |
|                                                                             |
|o3 : QQ[s]                                                                   |
+-----------------------------------------------------------------------------+
|i4 : factorBFunction b                                                       |
|                                                                             |
|                 1      1      2      3      4       1       3       7       |
|o4 = (s + 1)(s + -)(s + -)(s + -)(s + -)(s + -)(s + --)(s + --)(s + --)(s +  |
|                 2      5      5      5      5      10      10      10       |
|                                                                             |
|o4 : Expression of class Product                                             |
|-----------------------------------------------------------------------------|
| 9                                                                           |
|--)                                                                          |
|10                                                                           |
+-----------------------------------------------------------------------------+

See also
========

  * bFunction -- b-function
  * factorBFunction -- factorization
    of a b-function
  * generalB -- global generalized
    Bernstein-Sato polynomial
  * globalB -- compute global
    b-function and b-operator for a D-module and a polynomial

Ways to use this method:
========================

  * globalBFunction(RingElement), --
    global b-function (else known as the Bernstein-Sato polynomial)

globalBoperator(RingElement) -- compute a b-operator of a polynomial
********************************************************************

Synopsis
========

  * Function: globalBoperator,

See also
========

  * globalB -- compute global
    b-function and b-operator for a D-module and a polynomial

Ways to use this method:
========================

  * globalBoperator(RingElement), --
    compute a b-operator of a polynomial

GroundField
***********

Functions with optional argument named GroundField :
====================================================

  * paramBpoly(...,GroundField=>...)
    -- characteristic for
    modular computation

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

The object GroundField, is a symbol (Macaulay2Doc).

hasRationalSing(List) -- check if a complete intersection has at most rational singularities
********************************************************************************************

Synopsis
========

  * Function: hasRationalSing,
  * Usage:
        b = hasRationalSing F
  * Inputs:
      * F, a list (Macaulay2Doc), a regular sequence (of
        polynomials)
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), answers: are the
        singularities of the given variety at most rational?

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

+-----------------------------------------------------------------+
|i1 : R = QQ[x_1..x_4];                                           |
+-----------------------------------------------------------------+
|i2 : multiplierIdeal(ideal {x_1^3 - x_2^2, x_2^3 - x_3^2}, 31/18)|
|                                                                 |
|                 2         2                                     |
|o2 = ideal (x , x , x x , x )                                    |
|             3   2   1 2   1                                     |
|                                                                 |
|o2 : Ideal of R                                                  |
+-----------------------------------------------------------------+

See also
========

  * jumpingCoefficients -- jumping
    coefficients and corresponding multiplier ideals

Ways to use this method:
========================

  * hasRationalSing(List) -- check if a
    complete intersection has at most rational singularities

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

Synopsis
========

  * 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

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 &#x2102;. and let $R$ denote the ring of
differential operators &#x2102;$(x_1,\dots,x_n)<\partial_1,\dots,\partial_n>$
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
&#x2102;$[x_1,\dots,x_n]$. 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 variables|
+---------------------------------------------+
|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                                       |
+---------------------------------------------+

See also
========

  * charIdeal -- characteristic ideal of a D-module
  * singLocus -- 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).

HomologyModules -- a key in a hashtable; an option of DExt
**********************************************************

See also
========

  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module
  * DExt -- Ext groups between holonomic modules

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

The object HomologyModules, is a symbol (Macaulay2Doc).

ICcohom
*******

Ways to use ICcohom :
=====================

  * ICcohom(Ideal) (missing documentation)
  * ICcohom(ZZ,Ideal) (missing documentation)

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

The object ICcohom (missing documentation) is a method function with options (Macaulay2Doc).

ICmodule
********

Ways to use ICmodule :
======================

  * ICmodule(Ideal) (missing documentation)

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

The object ICmodule (missing documentation) is a method function with options (Macaulay2Doc).

indicialIdeal -- the image in the thetaRing of an indicial ideal in a Weyl algebra
**********************************************************************************

Synopsis
========

  * Usage:
        indicialIdeal(I,w)
  * Inputs:
      * I, Ideal in a WeylAlgebra that is torus-fixed
      * w, List in the numbers of variables, to yield a weight vector (-w,w) in
        the Weyl algebra
  * Outputs:
      * an ideal (Macaulay2Doc), that results from intersecting
        with the thetaRing of D with the result of extending the ideal
        in_(-w,w)(I) with the rational function field in the Weyl algebra
        variables, as in [SST (see
        https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ), Theorem 2.3.9]
        to I.

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

This computes the distraction of a torus fixed D-ideal [SST, Corollary 2.3.5].
This is necessary to compute indicial ideals [SST, Theorem 2.3.9, Corollary
2.3.5]; the roots of the indicial ideals are the exponents of the starting
terms of canonical series solutions of regular holonomic D-ideals.

+-----------------------------------------------------------------------------+
|i1 : R1 = QQ[z]                                                              |
|                                                                             |
|o1 = R1                                                                      |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : W1 = makeWA R1                                                          |
|                                                                             |
|o2 = W1                                                                      |
|                                                                             |
|o2 : PolynomialRing, 1 differential variables                                |
+-----------------------------------------------------------------------------+
|i3 : a=1/2                                                                   |
|                                                                             |
|     1                                                                       |
|o3 = -                                                                       |
|     2                                                                       |
|                                                                             |
|o3 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i4 : b=3                                                                     |
|                                                                             |
|o4 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i5 : c=5/3                                                                   |
|                                                                             |
|     5                                                                       |
|o5 = -                                                                       |
|     3                                                                       |
|                                                                             |
|o5 : QQ                                                                      |
+-----------------------------------------------------------------------------+
|i6 : J = ideal(z*(1-z)*dz^2+(c-(a+b+1)*z)*dz-a*b) -- the Gauss hypergeometric|
|                                                                             |
|              2  2       2   9       5     3                                 |
|o6 = ideal(- z dz  + z*dz  - -z*dz + -dz - -)                                |
|                             2       3     2                                 |
|                                                                             |
|o6 : Ideal of W1                                                             |
|-----------------------------------------------------------------------------|
|equation, exponents 0, 1-c                                                   |
+-----------------------------------------------------------------------------+
|i7 : cssExpts(J,{1})                                                         |
|                                                                             |
|              2                                                              |
|o7 = {{0}, {- -}}                                                            |
|              3                                                              |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+
|i8 : K = inw(J,{-1,1})                                                       |
|                                                                             |
|                2                                                            |
|o8 = ideal(6z*dz  + 10dz)                                                    |
|                                                                             |
|o8 : Ideal of W1                                                             |
+-----------------------------------------------------------------------------+
|i9 : distraction(K,QQ[s])                                                    |
|                                                                             |
|             2                                                               |
|o9 = ideal(6s  + 4s)                                                         |
|                                                                             |
|o9 : Ideal of QQ[s]                                                          |
+-----------------------------------------------------------------------------+

Ways to use indicialIdeal :
===========================

  * "indicialIdeal(Ideal,List)"

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

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

Info
****

Functions with optional argument named Info :
=============================================

  * DExt(...,Info=>...)

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

The object Info, is a symbol (Macaulay2Doc).

IntegrateBfunction -- a key created by Dlocalize
************************************************

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

See Dlocalize.

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

The object IntegrateBfunction, is a symbol (Macaulay2Doc).

IntegrateComplex -- a key in the hashtable created by Dintegration
******************************************************************

See also
========

  * Dintegration -- integration modules of a D-module

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

The object IntegrateComplex, is a symbol (Macaulay2Doc).

IntRing -- a strategy option for b-functions
********************************************

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

see bFunction,

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

The object IntRing, is a symbol (Macaulay2Doc).

inw -- initial form/ideal w.r.t. a weight
*****************************************

Synopsis
========

  * Usage:
        inw(F,w)
        inw(I,w)
        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 variables   |
+------------------------------------------------+
|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 -- Groebner bases w.r.t. a weight
  * setHomSwitch -- toggles 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).

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

Synopsis
========

  * 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 variables                             |
+--------------------------------------------------------------------------+
|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                                                                 |
+--------------------------------------------------------------------------+
|i4 : I = gkz(A,b,D)                                                       |
|                                                                          |
|                                                               2          |
|o4 = ideal (x dx  + x dx  + x dx  - 3, x dx  + 2x dx  - 4, - dx  + dx dx )|
|             1  1    2  2    3  3       2  2     3  3          2     1  3 |
|                                                                          |
|o4 : Ideal of D                                                           |
+--------------------------------------------------------------------------+
|i5 : isHolonomic I                                                        |
|                                                                          |
|o5 = true                                                                 |
+--------------------------------------------------------------------------+

See also
========

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

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

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

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

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

isInMultiplierIdeal(RingElement,Ideal,QQ) -- multiplier ideal membership test
*****************************************************************************

Synopsis
========

  * Function: isInMultiplierIdeal,
  * Usage:
        b = isInMultiplierIdeal(g,I,c)
  * Inputs:
      * g, a ring element (Macaulay2Doc), a polynomial
      * I, an ideal (Macaulay2Doc), an ideal in a polynomial ring
      * c, a rational number (Macaulay2Doc), coefficient (or a list
        of coefficients)
  * Optional inputs (Macaulay2Doc),:
      * Strategy => ..., default value generalizedBFunction
  * Outputs:
      * b, a Boolean value (Macaulay2Doc), answers: is in the
        multiplier ideal J_I(c)?

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

Test if the given polynomial is in the multiplier ideal for given ideal and
coefficient. In general, the test is cheaper than computing the whole
multiplier ideal.

There are two options for strategy:
  * generalizedBFunction -- via computation of the generalized Bernstein-Sato
    polynomial
  * mGeneralizedBFunction -- via computation of the m-generalized
    Bernstein-Sato polynomial
See Berkesch and Leykin ``Algorithms for Bernstein-Sato polynomials and
multiplier ideals'' for details.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1..x_4];                                                       |
+-----------------------------------------------------------------------------+
|i2 : isInMultiplierIdeal(x_1, ideal {x_1^3 - x_2^2, x_2^3 - x_3^2}, 31/18)   |
|                                                                             |
|o2 = false                                                                   |
+-----------------------------------------------------------------------------+
|i3 : isInMultiplierIdeal(x_1*x_2, ideal {x_1^3 - x_2^2, x_2^3 - x_3^2},      |
|                                                                             |
|o3 = true                                                                    |
|-----------------------------------------------------------------------------|
|31/18)                                                                       |
+-----------------------------------------------------------------------------+

See also
========

  * multiplierIdeal -- multiplier ideal
  * jumpingCoefficients -- jumping
    coefficients and corresponding multiplier ideals
  * generalB -- global generalized
    Bernstein-Sato polynomial

Ways to use this method:
========================

  * isInMultiplierIdeal(RingElement,Ideal,QQ)
    -- multiplier ideal
    membership test

isTorusFixed -- checks if an ideal in a Weyl algebra is torus-fixed
*******************************************************************

Synopsis
========

  * Usage:
        isTorusFixed I
  * Inputs:
      * I, an ideal (Macaulay2Doc), in a WeylAlgebra
  * Outputs:
      * a Boolean value (Macaulay2Doc), true if I is
        torus-fixed, false if not

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

There is a natural action of the n-dimensional algebraic torus on $D$ where $t
\in (\mathbb{C}^*)^n$ acts on $\partial_i$ as $t_i\partial_i$ and on $x_i$ as
$t_i^{-1}x_i$. The function isTorusFixed verifies whether a D-ideal is
invariant under this action.

See [SST (see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf )], just
before Lemma 2.3.1.

+-----------------------------------------------------------------------------+
|i1 : W = makeWA(QQ[x_1,x_2])                                                 |
|                                                                             |
|o1 = W                                                                       |
|                                                                             |
|o1 : PolynomialRing, 2 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : b = 2                                                                   |
|                                                                             |
|o2 = 2                                                                       |
+-----------------------------------------------------------------------------+
|i3 : I = ideal(x_1*dx_1*(x_1*dx_1+b), x_1*dx_1*(x_2*dx_2+b),                 |
|         x_2*dx_2*(x_1*dx_1+b), x_2*dx_2*(x_2*dx_2+b))                       |
|                                                                             |
|             2  2                                                      2  2  |
|o3 = ideal (x dx  + 3x dx , x x dx dx  + 2x dx , x x dx dx  + 2x dx , x dx  +|
|             1  1     1  1   1 2  1  2     1  1   1 2  1  2     2  2   2  2  |
|     ------------------------------------------------------------------------|
|     3x dx )                                                                 |
|       2  2                                                                  |
|                                                                             |
|o3 : Ideal of W                                                              |
+-----------------------------------------------------------------------------+
|i4 : isTorusFixed I                                                          |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use isTorusFixed :
==========================

  * "isTorusFixed(Ideal)"

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

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

jumpingCoefficients(Ideal) -- jumping coefficients and corresponding multiplier ideals
**************************************************************************************

Synopsis
========

  * Function: jumpingCoefficients,
  * Usage:
        (cs, mI) = jumpingCoefficients I, (cs, mI) = jumpingCoefficients(I,a,b)
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal in a polynomial ring
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit, => ..., default
        value null, multiplier ideal
      * Strategy, => ..., default value
        ViaElimination, multiplier ideal
  * Outputs:
      * cs, a list (Macaulay2Doc), the list of jumping coefficients
      * mI, a list (Macaulay2Doc), the list of corresponding
        multiplier ideals

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

Computes the jumping coefficients and their multiplier ideals in an open
interval (a,b). By default a = 0, b = See analyticSpread (ReesAlgebra),
I. The options are passed to
multiplierIdeal.

See Berkesch and Leykin ``Algorithms for Bernstein-Sato polynomials and
multiplier ideals'' for details.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_1..x_4];                                                       |
+-----------------------------------------------------------------------------+
|i2 : jumpingCoefficients ideal {x_1^3 - x_2^2, x_2^3 - x_3^2}                |
|                                                                             |
|       4  29  31  11  35                                        2            |
|o2 = ({-, --, --, --, --}, {ideal (x , x , x ), ideal (x , x , x ), ideal    |
|       3  18  18   6  18            3   2   1           3   2   1            |
|     ------------------------------------------------------------------------|
|           2         2           2               2         3           2     |
|     (x , x , x x , x ), ideal (x , x x , x x , x , x x , x ), ideal (x ,    |
|       3   2   1 2   1           3   2 3   1 3   2   1 2   1           3     |
|     ------------------------------------------------------------------------|
|                  2   2     3                                                |
|     x x , x x , x , x x , x )})                                             |
|      2 3   1 3   2   1 2   1                                                |
|                                                                             |
|o2 : Sequence                                                                |
+-----------------------------------------------------------------------------+

See also
========

  * multiplierIdeal -- multiplier ideal

Ways to use this method:
========================

  * jumpingCoefficients(Ideal), --
    jumping coefficients and corresponding multiplier ideals
  * "jumpingCoefficients(Ideal,QQ,QQ)"
  * "jumpingCoefficients(Ideal,QQ,ZZ)"
  * "jumpingCoefficients(Ideal,ZZ,QQ)"
  * "jumpingCoefficients(Ideal,ZZ,ZZ)"

kappaAnnF1PlanarCurve -- D-annihilator of 1/f for a planar curve
****************************************************************

Synopsis
========

  * Usage:
        kappaAnnF1PlanarCurve f
  * Inputs:
      * k, an integer (Macaulay2Doc), positive
      * f, a ring element (Macaulay2Doc), a polynomial in $R
        = K[x_1,x_2]$
  * Outputs:
      * I, an ideal (Macaulay2Doc), an ideal in the Weyl algebra
        $D = K<x_1,x_2,\partial_1,\partial_2>$

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

The method uses kOrderAnnFs, to efficiently compute the
annihilator of $f^{-1}$, which equals the output of AnnFs, after
substitution $s=-1$, for a planar curve. This annihilator defines the
localization: $D/I \cong R_f$. See [Castro-Jimenez, Leykin "Computing
localizations iteratively" (2012) (see https://arxiv.org/abs/1110.0182 )] for
details.

+-----------------------------------------------------------------------------+
|i1 : f = reiffen(4,5)                                                        |
|                                                                             |
|        4    5    4                                                          |
|o1 = x x  + x  + x                                                           |
|      1 2    2    1                                                          |
|                                                                             |
|o1 : QQ[x ..x ]                                                              |
|         1   2                                                               |
+-----------------------------------------------------------------------------+
|i2 : As = AnnFs f                                                            |
|                                                                             |
|              2                              2                          2    |
|o2 = ideal (4x dx  + 5x x dx  + 3x x dx  + 4x dx  - 16x s - 20x s, 16x x dx  |
|              1  1     1 2  1     1 2  2     2  2      1       2      1 2  1 |
|     ------------------------------------------------------------------------|
|         3         3                     2                     2         2   |
|     + 4x dx  + 12x dx  - 125x x dx  - 4x dx  + 5x x dx  - 100x dx  - 64x s +|
|         2  1      2  2       1 2  1     1  2     1 2  2       2  2      2   |
|     ------------------------------------------------------------------------|
|                 3        4       4        3          2    2      3  2       |
|     500x s, 4x x dx  + 5x dx  - x dx  - 4x dx , - 64x x dx  + 36x dx  -     |
|         2     1 2  1     2  1    2  2     1  2       1 2  1      2  1       |
|     ------------------------------------------------------------------------|
|          2            3            3  2       2  2            2      2      |
|     96x x dx dx  - 32x dx dx  - 36x dx  + 500x dx  + 125x x dx  - 36x dx dx |
|        1 2  1  2      2  1  2      2  2       1  1       1 2  1      1  1  2|
|     ------------------------------------------------------------------------|
|                           2            2  2           2       2  2          |
|     + 720x x dx dx  + 100x dx dx  + 24x dx  - 29x x dx  + 260x dx  -        |
|           1 2  1  2       2  1  2      1  2      1 2  2       2  2          |
|     ------------------------------------------------------------------------|
|                     2          2                                     2      |
|     368x x dx  - 72x dx  - 264x dx  - 500x dx s + 300x dx s + 1024x s  +    |
|         1 2  1      2  1       2  2       2  1        2  2         2        |
|     ------------------------------------------------------------------------|
|                                                                  2          |
|     2425x dx  + 125x dx  - 105x dx  + 1795x dx  + 1216x s - 8000s  - 7700s) |
|          1  1       2  1       1  2        2  2        2                    |
|                                                                             |
|o2 : Ideal of QQ[x ..x , dx ..dx , s]                                        |
|                  1   2    1    2                                            |
+-----------------------------------------------------------------------------+
|i3 : A = sub(As, {last gens ring As => -1});                                 |
|                                                                             |
|o3 : Ideal of QQ[x ..x , dx ..dx , s]                                        |
|                  1   2    1    2                                            |
+-----------------------------------------------------------------------------+
|i4 : (kappa,A') = kappaAnnF1PlanarCurve f                                    |
|                                                                             |
|                  2                              2                           |
|o4 = (2, ideal (4x dx  + 5x x dx  + 3x x dx  + 4x dx  + 16x  + 20x ,         |
|                  1  1     1 2  1     1 2  2     2  2      1      2          |
|     ------------------------------------------------------------------------|
|          2        3         3                     2                     2   |
|     16x x dx  + 4x dx  + 12x dx  - 125x x dx  - 4x dx  + 5x x dx  - 100x dx |
|        1 2  1     2  1      2  2       1 2  1     1  2     1 2  2       2  2|
|     ------------------------------------------------------------------------|
|          2             3  2      3                  2                       |
|     + 64x  - 500x , 16x dx  - 16x dx dx  + 125x x dx  - 35x x dx dx  +      |
|          2       2     2  1      2  1  2       1 2  1      1 2  1  2        |
|     ------------------------------------------------------------------------|
|         2            2  2          2      2  2                   2          |
|     100x dx dx  + 12x dx  - 2x x dx  - 24x dx  + 112x x dx  - 36x dx  +     |
|         2  1  2      1  2     1 2  2      2  2       1 2  1      2  1       |
|     ------------------------------------------------------------------------|
|        2                                                                    |
|     84x dx  - 930x dx  + 625x dx  + 26x dx  - 893x dx  + 448x  - 3720,      |
|        2  2       1  1       2  1      1  2       2  2       2              |
|     ------------------------------------------------------------------------|
|         4          4          3          3         2             2          |
|     256x dx  - 256x dx  - 500x dx  - 256x dx  + 64x x dx  - 80x x dx  +     |
|         2  1       2  2       2  1       1  2      1 2  2      1 2  2       |
|     ------------------------------------------------------------------------|
|         3           3                      2                         2      |
|     100x dx  - 1024x  + 15625x x dx  + 500x dx  - 625x x dx  + 12500x dx  + |
|         2  2        2         1 2  1       1  2       1 2  2         2  2   |
|     ------------------------------------------------------------------------|
|                 4       5       4          3     4                          |
|     62500x , x x dx  + x dx  + x dx  + 4x x  + 5x ))                        |
|           2   1 2  2    2  2    1  2     1 2     2                          |
|                                                                             |
|o4 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i5 : A == sub(A', ring A)                                                    |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * kOrderAnnFa -- k-th order D-annihilator of a power of a
    polynomial
  * kOrderAnnFs -- k-th order D-annihilator of a power of a
    polynomial
  * AnnFs -- the annihilating ideal of f^s

Ways to use kappaAnnF1PlanarCurve :
===================================

  * "kappaAnnF1PlanarCurve(RingElement)"

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

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

kOrderAnnFa -- k-th order D-annihilator of a power of a polynomial
******************************************************************

Synopsis
========

  * Usage:
        kOrderAnnFa(k,f,a)
        kOrderAnnFs(k,f)
  * Inputs:
      * k, an integer (Macaulay2Doc), positive
      * f, a ring element (Macaulay2Doc), a polynomial in
        $K[x_1,...,x_n]$
      * a, an integer (Macaulay2Doc), (usually negative) exponent
  * Outputs:
      * I, an ideal (Macaulay2Doc), an ideal in the Weyl algebra
        $K<x_1,...,x_n,\partial_1,...,\partial_n>$ (or
        $K[s]<x_1,...,x_n,\partial_1,...,\partial_n>$)

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

See kOrderAnnFa, (see kOrderAnnFs) return an
ideal generated by elements of order at most $k$ of the annihilator of $f^a$
($f^s$). See [Castro-Jimenez, Leykin "Computing localizations iteratively"
(2012) (see https://arxiv.org/abs/1110.0182 )] for details.

+----------------------------------------------------------------------+
|i1 : R = QQ[x_1,x_2]; f = x_1^2-x_2^3;                                |
+----------------------------------------------------------------------+
|i3 : A1 = kOrderAnnFa(1,f,-1)                                         |
|                                                                      |
|                                   2               3       2        2 |
|o3 = ideal (3x dx  + 2x dx  + 6, 3x dx  + 2x dx , x dx  - x dx  + 3x )|
|              1  1     2  2        2  1     1  2   2  2    1  2     2 |
|                                                                      |
|o3 : Ideal of QQ[x ..x , dx ..dx ]                                    |
|                  1   2    1    2                                     |
+----------------------------------------------------------------------+
|i4 : As = kOrderAnnFs(1,f)                                            |
|                                                                      |
|              2                                                       |
|o4 = ideal (3x dx  + 2x dx , 6s - 3x dx  - 2x dx )                    |
|              2  1     1  2         1  1     2  2                     |
|                                                                      |
|o4 : Ideal of QQ[x ..x , dx ..dx , s]                                 |
|                  1   2    1    2                                     |
+----------------------------------------------------------------------+

See also
========

  * kappaAnnF1PlanarCurve -- D-annihilator of 1/f
    for a planar curve
  * AnnFs -- the annihilating ideal of f^s

Ways to use kOrderAnnFa :
=========================

  * "kOrderAnnFa(ZZ,RingElement,ZZ)"

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

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

lct(...,Strategy=>...) -- specify strategy for computing lct
************************************************************

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

  * ViaBFunction -- use bFunction,
  * GeneralBernsteinSato -- use globalB,

Further information
===================

  * Default value: GeneralBernsteinSato,
  * Function: lct, -- compute the log canonical threshold
    for an ideal
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

lct(Ideal) -- compute the log canonical threshold for an ideal
**************************************************************

Synopsis
========

  * Function: lct,
  * Usage:
        l = lct I
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal in a polynomial ring
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value GeneralBernsteinSato, specify strategy for computing lct
  * Outputs:
      * l, a ring element (Macaulay2Doc), a rational number,
        the log canonical threshold of I

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

+--------------------------------------------+
|i1 : QQ[x_1..x_3];                          |
+--------------------------------------------+
|i2 : I = ideal (x_2^2-x_1*x_3, x_1^3-x_3^2);|
|                                            |
|o2 : Ideal of QQ[x ..x ]                    |
|                  1   3                     |
+--------------------------------------------+
|i3 : lct I                                  |
|                                            |
|     17                                     |
|o3 = --                                     |
|     12                                     |
|                                            |
|o3 : QQ                                     |
+--------------------------------------------+

See also
========

  * bFunction -- b-function
  * generalB -- global generalized
    Bernstein-Sato polynomial

Ways to use this method:
========================

  * lct(Ideal) -- compute the log canonical threshold
    for an ideal

localBFunction(RingElement,Ideal) -- local b-function (a.k.a. the local Bernstein-Sato polynomial)
**************************************************************************************************

Synopsis
========

  * Function: localBFunction,
  * Usage:
        b = localBFunction(f,P)
  * Inputs:
      * f, a ring element (Macaulay2Doc), a polynomial
      * P, an ideal (Macaulay2Doc), a (prime) ideal
  * Outputs:
      * b, a ring element (Macaulay2Doc), the local
        b-function b_P(s) in Q[s]

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

Computes the local b-function of f at P, if P is a prime ideal.

+--------------------------------------------------+
|i1 : R = QQ[x,y]; f = x^2*(x+y+1); P = ideal(x,y);|
|                                                  |
|o3 : Ideal of R                                   |
+--------------------------------------------------+
|i4 : b = localBFunction(f,P)                      |
|                                                  |
|      2   3    1                                  |
|o4 = s  + -s + -                                  |
|          2    2                                  |
|                                                  |
|o4 : QQ[s]                                        |
+--------------------------------------------------+
|i5 : factorBFunction b                            |
|                                                  |
|                 1                                |
|o5 = (s + 1)(s + -)                               |
|                 2                                |
|                                                  |
|o5 : Expression of class Product                  |
+--------------------------------------------------+

Caveat
======

(feature) If P is not prime, computes the lcm of local b-functions over all
primes containing P

See also
========

  * bFunction -- b-function
  * factorBFunction -- factorization
    of a b-function
  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * generalB -- global generalized
    Bernstein-Sato polynomial
  * globalB -- compute global
    b-function and b-operator for a D-module and a polynomial

Ways to use this method:
========================

  * localBFunction(RingElement,Ideal)
    -- local b-function (a.k.a. the
    local Bernstein-Sato polynomial)

localCohom -- local cohomology
******************************

Synopsis
========

  * Optional inputs (Macaulay2Doc),:
      * LocStrategy,
        => ..., default value null, specify localization strategy for local
        cohomology
      * Strategy, =>
        ..., default value Walther, specify strategy for local cohomology

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

Local cohomology of a polynomial ring:
  * localCohom(Ideal)
  * localCohom(List,Ideal)
  * localCohom(ZZ,Ideal)
Local cohomology of a holonomic module:
  * localCohom(Ideal,Module)
  * localCohom(ZZ,Ideal,Module)
  * localCohom(List,Ideal,Module)

See also
========

  * pruneLocalCohom -- prunes local
    cohomology modules

Ways to use localCohom :
========================

  * localCohom(Ideal) -- local cohomology of a
    polynomial ring
  * localCohom(Ideal,Module) -- local
    cohomology of a D-module
  * localCohom(List,Ideal) -- local
    cohomology of a polynomial ring
  * localCohom(List,Ideal,Module),
    -- local cohomology of a D-module
  * localCohom(ZZ,Ideal) -- local cohomology
    of a polynomial ring
  * localCohom(ZZ,Ideal,Module), --
    local cohomology of a D-module

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

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

localCohom(...,LocStrategy=>...) -- specify localization strategy for local cohomology
**************************************************************************************

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

See localCohom(...,Strategy=>...),

Further information
===================

  * Default value: null
  * Function: localCohom, -- local cohomology
  * Option key: LocStrategy,

Functions with optional argument named LocStrategy :
====================================================

  * ICcohom(...,LocStrategy=>...) (missing documentation)
  * ICmodule(...,LocStrategy=>...) (missing documentation)
  * localCohom(...,LocStrategy=>...)
    -- specify localization
    strategy for local cohomology

localCohom(...,Strategy=>...) -- specify strategy for local cohomology
**********************************************************************

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

This option together with LocStrategy, determines a strategy
for localCohom(...Ideal...) and localCohom(...Ideal, Module...).
  * Walther -- the algorithm of U. Walther that uses Cech complex.
  * LocStrategy => null -- used only for localCohom(...Ideal...), localizations
    are done by straitforward computation of annihilators and b-polynomials as
    described in [1].
  * LocStrategy => OaTaWa -- localizations are done following
    Oaku-Takayama-Walther method.
  * LocStrategy => Oaku -- localizations are done following Oaku's algorithm.
  * OaTa -- restriction algorithm is used, which is due to T. Oaku and N.
    Takayama [2]
For detailed description of the algorithms see
  * [1]U. Walther, Algorithmic computation of local cohomology modules and the
    local cohomological dimension of algebraic varieties (JPAA (139), 1999.)
  * [2]Oaku, TakayamaAlgorithms for D-modules...

Further information
===================

  * Default value: Walther,
  * Function: localCohom, -- local cohomology
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

localCohom(Ideal) -- local cohomology of a polynomial ring
**********************************************************

Synopsis
========

  * Function: localCohom,
  * Usage:
        H = localCohom I
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal of R = k[x ,...,x ]
                                                                    1      n
  * Optional inputs (Macaulay2Doc),:
      * LocStrategy,
        => ..., default value null, specify localization strategy for local
        cohomology
      * Strategy, =>
        ..., default value Walther, specify strategy for local cohomology
  * Outputs:
      * H, a hash table (Macaulay2Doc), each entry of H has an
        integer key and contains the cohomology module in the corresponding
        degree.

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

+-----------------------------------------------------------------------------+
|i1 : W = QQ[X, dX, Y, dY, Z, dZ, WeylAlgebra=>{X=>dX, Y=>dY, Z=>dZ}]         |
|                                                                             |
|o1 = W                                                                       |
|                                                                             |
|o1 : PolynomialRing, 3 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : I = ideal (X*(Y-Z), X*Y*Z)                                              |
|                                                                             |
|o2 = ideal (X*Y - X*Z, X*Y*Z)                                                |
|                                                                             |
|o2 : Ideal of W                                                              |
+-----------------------------------------------------------------------------+
|i3 : h = localCohom I                                                        |
|                                                                             |
|o3 = HashTable{0 => subquotient (| dZ dY dX |, | dX dY dZ |)                 |
|               1 => subquotient (| 0          0      0           -dXdY-      |
|                                 | -YdY-ZdZ-2 -XdX-1 -3dXZdZ-3dX -dXZdZ      |
|               2 => cokernel | -XYZ XY-XZ 3XdX-2YdY-2ZdZ YdY+ZdZ+3 Y2dY      |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
|dXdZ dXY-dXZ XdX+1  0               0        XdXdZ-dY   -XdXZ-Y      |, |    |
|-dX  dXYZ    XdXZ+Z dXYdY+dXZdZ+2dX XdXdY+dY XdXZdZ+XdX -XdXZ2-YZ-Z2 |  |    |
|-2YdYZ-2YZdZ+Z2dZ |                                                          |
|-----------------------------------------------------------------------------|
|                                                           }                 |
|XY-XZ dY+dZ XdX+YdZ-ZdZ -YdZ+ZdZ+1 0       0       0     |)                  |
|XYZ   0     0           0          YdY-ZdZ XdX-ZdZ ZdZ+1 |                   |
+-----------------------------------------------------------------------------+
|i4 : pruneLocalCohom h                                                       |
|                                                                             |
|o4 = HashTable{0 => 0                         }                              |
|               1 => | dZ dY X |                                              |
|               2 => | Y-Z Z2 dYZ+ZdZ+2 XdX+2 |                               |
|                                                                             |
|o4 : HashTable                                                               |
+-----------------------------------------------------------------------------+

Caveat
======

The modules returned are not simplified, use pruneLocalCohom.

See also
========

  * pruneLocalCohom -- prunes local
    cohomology modules

Ways to use this method:
========================

  * localCohom(Ideal) -- local cohomology of a
    polynomial ring

localCohom(Ideal,Module) -- local cohomology of a D-module
**********************************************************

Synopsis
========

  * Function: localCohom,
  * Usage:
        H = localCohom(I,M)
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal of R = k[x ,...,x ]
                                                                    1      n
      * M, a module (Macaulay2Doc), a holonomic module over Weyl

        algebra A (k)
                 n
  * Optional inputs (Macaulay2Doc),:
      * LocStrategy,
        => ..., default value null, specify localization strategy for local
        cohomology
      * Strategy, =>
        ..., default value Walther, specify strategy for local cohomology
  * Outputs:
      * H, a hash table (Macaulay2Doc), each entry of H has an
        integer key and contains the cohomology module in the corresponding
        degree.

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

+-----------------------------------------------------------------------------+
|i1 : W = QQ[X, dX, Y, dY, Z, dZ, WeylAlgebra=>{X=>dX, Y=>dY, Z=>dZ}]         |
|                                                                             |
|o1 = W                                                                       |
|                                                                             |
|o1 : PolynomialRing, 3 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : I = ideal (X*(Y-Z), X*Y*Z)                                              |
|                                                                             |
|o2 = ideal (X*Y - X*Z, X*Y*Z)                                                |
|                                                                             |
|o2 : Ideal of W                                                              |
+-----------------------------------------------------------------------------+
|i3 : h = localCohom(I, W^1 / ideal{dX,dY,dZ})                                |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|                                                                             |
|o3 = HashTable{0 => subquotient (| dZ dY dX |, | dX dY dZ |)                 |
|               1 => subquotient (| 0      0        -dY-dZ   0          0     |
|                                 | -XdX-2 -XdX+YdY -Z2dZ-2Z -dYZdZ-2dY XdXdZ-|
|               2 => cokernel | -X2Y2Z2 X2Y2-2X2YZ+X2Z2 -YdY-ZdZ-6 -XdX-4 YZdZ|
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
|      0          0         0             dXdY+dXdZ   0                       |
|YdYdZ -XdXdY-2dY XdX^2+3dX 2XdX^2-3dXYdY dXZ2dZ+2dXZ dXdYZdZ+2dXdY           |
|-Z2dZ+2Y-4Z |                                                                |
|-----------------------------------------------------------------------------|
|                                                                             |
|0             -dYdZ-dZ^2                               0                     |
|dX^2ZdZ+2dX^2 -XdXZdZ+YdYZdZ-dYZ2dZ-Z2dZ^2-2dYZ-4ZdZ-2 XdXdYdZ+2dYdZ         |
|-----------------------------------------------------------------------------|
|                                                                             |
|0                  XdX+2     XdX+4YdZ-4ZdZ-6             0                   |
|-2XdX^2dZ+3dXYdYdZ XdXZ2+2Z2 XdXZ2+4YZ2dZ+4Z3dZ+8YZ+10Z2 dX^2YdY+2dX^2       |
|-----------------------------------------------------------------------------|
|                                                                             |
|0             -dX^2dY-dX^2dZ   XdXdZ+2dZ              0                      |
|XdX^2dY+3dXdY -dX^2Z2dZ-2dX^2Z XdXZ2dZ+2XdXZ+2Z2dZ+4Z -dX^2dYZdZ-2dX^2dY     |
|-----------------------------------------------------------------------------|
|                                                                             |
|3dXdYdZ+3dXdZ^2                                            0                 |
|2XdX^2ZdZ-3dXYdYZdZ+3dXdYZ2dZ+3dXZ2dZ^2+6dXdYZ+12dXZdZ+6dX -dX^2YdYdZ-2dX^2dZ|
|-----------------------------------------------------------------------------|
|                                                                             |
|0                  -2XdXY+3XdXZ-4Y+6Z      -XdX^2-3dX                        |
|-XdX^2dYdZ-3dXdYdZ -2XdXYZ2-XdXZ3-4YZ2-2Z3 -XdX^2Z2-3dXZ2                    |
|-----------------------------------------------------------------------------|
|                                                                             |
|-XdX^2-6dXYdZ+6dXZdZ+9dX                -3dX^2YdZ+3dX^2ZdZ+6dX^2             |
|-XdX^2Z2-6dXYZ2dZ-6dXZ3dZ-12dXYZ-15dXZ2 -3dX^2YZ2dZ-dX^2Z3dZ-6dX^2YZ-2dX^2Z2 |
|-----------------------------------------------------------------------------|
|                                                                             |
|2dX^2YdZ-2dX^2ZdZ-4dX^2                                                      |
|2dX^2YZ2dZ+2dX^2Z3dZ+4dX^2YZ+4dX^2Z2                                         |
|-----------------------------------------------------------------------------|
|                                                                             |
|-2XdXYdZ+3XdXZdZ+2XdX+4YdY-6dYZ+4                                            |
|-2XdXYZ2dZ-XdXZ3dZ-4XdXYZ-4XdXZ2+4YdYZ2+4Z2                                  |
|-----------------------------------------------------------------------------|
|                                                                             |
|2XdXYdZ-3XdXZdZ-6XdX-2YdZ                  -XdX^2dZ-3dXdZ                    |
|2XdXYZ2dZ+XdXZ3dZ+4XdXYZ+2XdXZ2-2YZ2dZ-4YZ -XdX^2Z2dZ-2XdX^2Z-3dXZ2dZ-6dXZ   |
|-----------------------------------------------------------------------------|
|                                                                             |
|-dX^2dYdZ-dX^2dZ^2                                                           |
|dX^2YdYZdZ-dX^2dYZ2dZ-dX^2Z2dZ^2-2dX^2dYZ-2dX^2ZdZ-2dX^2                     |
|-----------------------------------------------------------------------------|
|                                                                             |
|2XdXYZ-3XdXZ2+8Y2-12YZ+2Z2   2dX^2YdY-3dX^2dYZ+2dX^2YdZ-3dX^2ZdZ             |
|2XdXYZ3+XdXZ4+8Y2Z2+4YZ3+2Z4 2dX^2YdYZ2+2dX^2YZ2dZ+dX^2Z3dZ+4dX^2YZ+6dX^2Z2  |
|-----------------------------------------------------------------------------|
|                                                                             |
|4dX^2Y2-8dX^2YZ+4dX^2Z2 2XdX^2Y-3XdX^2Z+6dXY-9dXZ                            |
|4dX^2Y2Z2               2XdX^2YZ2+XdX^2Z3+6dXYZ2+3dXZ3                       |
|-----------------------------------------------------------------------------|
|                                                                             |
|4dX^2YdYdZ-6dX^2dYZdZ+4dX^2YdZ^2-6dX^2ZdZ^2-6dX^2dY-6dX^2dZ                  |
|4dX^2YdYZ2dZ+3dX^2dYZ3dZ+4dX^2YZ2dZ^2+2dX^2Z3dZ^2+8dX^2YdYZ+6dX^2dYZ2+16dX^  |
|-----------------------------------------------------------------------------|
|                                                                             |
|                                                                             |
|2YZdZ+18dX^2Z2dZ+8dX^2Y+24dX^2Z                                              |
|-----------------------------------------------------------------------------|
|                                                                             |
|4dX^2Y2dZ-6dX^2YZdZ+2dX^2Z2dZ-8dX^2Y+4dX^2Z                                  |
|4dX^2Y2Z2dZ+2dX^2YZ3dZ+2dX^2Z4dZ+8dX^2Y2Z+4dX^2YZ2+4dX^2Z3                   |
|-----------------------------------------------------------------------------|
|                                                                             |
|-2XdX^2YdZ+3XdX^2ZdZ+6XdX^2+3dXYdZ                                           |
|-2XdX^2YZ2dZ-XdX^2Z3dZ-4XdX^2YZ-2XdX^2Z2+3dXYZ2dZ+6dXYZ                      |
|-----------------------------------------------------------------------------|
|                                                                             |
|2XdX^2YdZ-3XdX^2ZdZ-2XdX^2-6dXYdY+9dXdYZ-6dX                                 |
|2XdX^2YZ2dZ+XdX^2Z3dZ+4XdX^2YZ+4XdX^2Z2-6dXYdYZ2-6dXZ2                       |
|-----------------------------------------------------------------------------|
|                                                                             |
|-2XdX^2YZ+3XdX^2Z2-12dXY2+18dXYZ-3dXZ2                                       |
|-2XdX^2YZ3-XdX^2Z4-12dXY2Z2-6dXYZ3-3dXZ4                                     |
|-----------------------------------------------------------------------------|
|                                                                             |
|2dX^2Y2dY-3dX^2YdYZ+2dX^2YZdZ-3dX^2Z2dZ+4dX^2Y-6dX^2Z      |, |              |
|2dX^2Y2dYZ2+dX^2YdYZ3+2dX^2YZ3dZ+dX^2Z4dZ+8dX^2YZ2+4dX^2Z3 |  |              |
|-----------------------------------------------------------------------------|
|                                                               }             |
|X2Y2-2X2YZ+X2Z2 dY+dZ -YdZ+ZdZ+2 -XdX-2 0      0      0      |)              |
|X2Y2Z2          0     0          0      -ZdZ-2 -YdY-2 -XdX-2 |               |
+-----------------------------------------------------------------------------+
|i4 : pruneLocalCohom h                                                       |
|                                                                             |
|o4 = HashTable{0 => 0                                                        |
|               1 => | dZ dY XdX+3 X3 |                                       |
|               2 => | dYZ+YdZ+2 YdY+ZdZ+6 Y2-2YZ+Z2 XdX+4 YZdZ-Z2dZ+2Y-4Z    |
|                                                                             |
|o4 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|                          }                                                  |
|                                                                             |
|2YZ3-Z4 Z4dZ+2YZ2+4Z3 Z5 |                                                   |
+-----------------------------------------------------------------------------+

Caveat
======

The modules returned are not simplified, use pruneLocalCohom.

See also
========

  * pruneLocalCohom -- prunes local
    cohomology modules

Ways to use this method:
========================

  * localCohom(Ideal,Module) -- local
    cohomology of a D-module

localCohom(List,Ideal) -- local cohomology of a polynomial ring
***************************************************************

Synopsis
========

  * Function: localCohom,
  * Usage:
        localCohom(l,I)
  * Inputs:
      * l, a list (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * LocStrategy,
        => ..., default value null, specify localization strategy for local
        cohomology
      * Strategy, =>
        ..., default value Walther, specify strategy for local cohomology
  * Outputs:
      * a hash table (Macaulay2Doc), the local cohomology of I
        in the degrees specified by l

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

See localCohom(Ideal), for the full description.
+-----------------------------------------------------------------------------+
|i1 : W = QQ[X, dX, Y, dY, Z, dZ, WeylAlgebra=>{X=>dX, Y=>dY, Z=>dZ}]         |
|                                                                             |
|o1 = W                                                                       |
|                                                                             |
|o1 : PolynomialRing, 3 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : I = ideal (X*(Y-Z), X*Y*Z)                                              |
|                                                                             |
|o2 = ideal (X*Y - X*Z, X*Y*Z)                                                |
|                                                                             |
|o2 : Ideal of W                                                              |
+-----------------------------------------------------------------------------+
|i3 : h = localCohom({1,2}, I)                                                |
|                                                                             |
|o3 = HashTable{1 => subquotient (| 0          0      0           -dXdY-      |
|                                 | -YdY-ZdZ-2 -XdX-1 -3dXZdZ-3dX -dXZdZ      |
|               2 => cokernel | -XYZ XY-XZ 3XdX-2YdY-2ZdZ YdY+ZdZ+3 Y2dY      |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|dXdZ dXY-dXZ XdX+1  0               0        XdXdZ-dY   -XdXZ-Y      |, |    |
|-dX  dXYZ    XdXZ+Z dXYdY+dXZdZ+2dX XdXdY+dY XdXZdZ+XdX -XdXZ2-YZ-Z2 |  |    |
|-2YdYZ-2YZdZ+Z2dZ |                                                          |
|-----------------------------------------------------------------------------|
|XY-XZ dY+dZ XdX+YdZ-ZdZ -YdZ+ZdZ+1 0       0       0     |)}                 |
|XYZ   0     0           0          YdY-ZdZ XdX-ZdZ ZdZ+1 |                   |
+-----------------------------------------------------------------------------+
|i4 : pruneLocalCohom h                                                       |
|                                                                             |
|o4 = HashTable{1 => | dZ dY X |               }                              |
|               2 => | Y-Z Z2 dYZ+ZdZ+2 XdX+2 |                               |
|                                                                             |
|o4 : HashTable                                                               |
+-----------------------------------------------------------------------------+

See also
========

  * pruneLocalCohom -- prunes local
    cohomology modules

Ways to use this method:
========================

  * localCohom(List,Ideal) -- local
    cohomology of a polynomial ring

localCohom(List,Ideal,Module) -- local cohomology of a D-module
***************************************************************

Synopsis
========

  * Function: localCohom,
  * Usage:
        localCohom(l,I,M)
  * Inputs:
      * l, a list (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
      * M, a module (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * LocStrategy,
        => ..., default value null, specify localization strategy for local
        cohomology
      * Strategy, =>
        ..., default value Walther, specify strategy for local cohomology
  * Outputs:
      * a hash table (Macaulay2Doc), the local cohomology

        H (M) in degrees listed in l, where I is an ideal in a polynomial ring
         I
        and M is a D-module

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

See localCohom(Ideal,Module), for the
full description.
+-----------------------------------------------------------------------------+
|i1 : W = QQ[X, dX, Y, dY, Z, dZ, WeylAlgebra=>{X=>dX, Y=>dY, Z=>dZ}]         |
|                                                                             |
|o1 = W                                                                       |
|                                                                             |
|o1 : PolynomialRing, 3 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : I = ideal (X*(Y-Z), X*Y*Z)                                              |
|                                                                             |
|o2 = ideal (X*Y - X*Z, X*Y*Z)                                                |
|                                                                             |
|o2 : Ideal of W                                                              |
+-----------------------------------------------------------------------------+
|i3 : h = localCohom({1,2}, I, W^1 / ideal{dX,dY,dZ})                         |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|                                                                             |
|o3 = HashTable{1 => subquotient (| 0      0        -dY-dZ   0          0     |
|                                 | -XdX-2 -XdX+YdY -Z2dZ-2Z -dYZdZ-2dY XdXdZ-|
|               2 => cokernel | -X2Y2Z2 X2Y2-2X2YZ+X2Z2 -YdY-ZdZ-6 -XdX-4 YZdZ|
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|      0          0         0             dXdY+dXdZ   0                       |
|YdYdZ -XdXdY-2dY XdX^2+3dX 2XdX^2-3dXYdY dXZ2dZ+2dXZ dXdYZdZ+2dXdY           |
|-Z2dZ+2Y-4Z |                                                                |
|-----------------------------------------------------------------------------|
|0             -dYdZ-dZ^2                               0                     |
|dX^2ZdZ+2dX^2 -XdXZdZ+YdYZdZ-dYZ2dZ-Z2dZ^2-2dYZ-4ZdZ-2 XdXdYdZ+2dYdZ         |
|-----------------------------------------------------------------------------|
|0                  XdX+2     XdX+4YdZ-4ZdZ-6             0                   |
|-2XdX^2dZ+3dXYdYdZ XdXZ2+2Z2 XdXZ2+4YZ2dZ+4Z3dZ+8YZ+10Z2 dX^2YdY+2dX^2       |
|-----------------------------------------------------------------------------|
|0             -dX^2dY-dX^2dZ   XdXdZ+2dZ              0                      |
|XdX^2dY+3dXdY -dX^2Z2dZ-2dX^2Z XdXZ2dZ+2XdXZ+2Z2dZ+4Z -dX^2dYZdZ-2dX^2dY     |
|-----------------------------------------------------------------------------|
|3dXdYdZ+3dXdZ^2                                            0                 |
|2XdX^2ZdZ-3dXYdYZdZ+3dXdYZ2dZ+3dXZ2dZ^2+6dXdYZ+12dXZdZ+6dX -dX^2YdYdZ-2dX^2dZ|
|-----------------------------------------------------------------------------|
|0                  -2XdXY+3XdXZ-4Y+6Z      -XdX^2-3dX                        |
|-XdX^2dYdZ-3dXdYdZ -2XdXYZ2-XdXZ3-4YZ2-2Z3 -XdX^2Z2-3dXZ2                    |
|-----------------------------------------------------------------------------|
|-XdX^2-6dXYdZ+6dXZdZ+9dX                -3dX^2YdZ+3dX^2ZdZ+6dX^2             |
|-XdX^2Z2-6dXYZ2dZ-6dXZ3dZ-12dXYZ-15dXZ2 -3dX^2YZ2dZ-dX^2Z3dZ-6dX^2YZ-2dX^2Z2 |
|-----------------------------------------------------------------------------|
|2dX^2YdZ-2dX^2ZdZ-4dX^2                                                      |
|2dX^2YZ2dZ+2dX^2Z3dZ+4dX^2YZ+4dX^2Z2                                         |
|-----------------------------------------------------------------------------|
|-2XdXYdZ+3XdXZdZ+2XdX+4YdY-6dYZ+4                                            |
|-2XdXYZ2dZ-XdXZ3dZ-4XdXYZ-4XdXZ2+4YdYZ2+4Z2                                  |
|-----------------------------------------------------------------------------|
|2XdXYdZ-3XdXZdZ-6XdX-2YdZ                  -XdX^2dZ-3dXdZ                    |
|2XdXYZ2dZ+XdXZ3dZ+4XdXYZ+2XdXZ2-2YZ2dZ-4YZ -XdX^2Z2dZ-2XdX^2Z-3dXZ2dZ-6dXZ   |
|-----------------------------------------------------------------------------|
|-dX^2dYdZ-dX^2dZ^2                                                           |
|dX^2YdYZdZ-dX^2dYZ2dZ-dX^2Z2dZ^2-2dX^2dYZ-2dX^2ZdZ-2dX^2                     |
|-----------------------------------------------------------------------------|
|2XdXYZ-3XdXZ2+8Y2-12YZ+2Z2   2dX^2YdY-3dX^2dYZ+2dX^2YdZ-3dX^2ZdZ             |
|2XdXYZ3+XdXZ4+8Y2Z2+4YZ3+2Z4 2dX^2YdYZ2+2dX^2YZ2dZ+dX^2Z3dZ+4dX^2YZ+6dX^2Z2  |
|-----------------------------------------------------------------------------|
|4dX^2Y2-8dX^2YZ+4dX^2Z2 2XdX^2Y-3XdX^2Z+6dXY-9dXZ                            |
|4dX^2Y2Z2               2XdX^2YZ2+XdX^2Z3+6dXYZ2+3dXZ3                       |
|-----------------------------------------------------------------------------|
|4dX^2YdYdZ-6dX^2dYZdZ+4dX^2YdZ^2-6dX^2ZdZ^2-6dX^2dY-6dX^2dZ                  |
|4dX^2YdYZ2dZ+3dX^2dYZ3dZ+4dX^2YZ2dZ^2+2dX^2Z3dZ^2+8dX^2YdYZ+6dX^2dYZ2+16dX^  |
|-----------------------------------------------------------------------------|
|                                                                             |
|2YZdZ+18dX^2Z2dZ+8dX^2Y+24dX^2Z                                              |
|-----------------------------------------------------------------------------|
|4dX^2Y2dZ-6dX^2YZdZ+2dX^2Z2dZ-8dX^2Y+4dX^2Z                                  |
|4dX^2Y2Z2dZ+2dX^2YZ3dZ+2dX^2Z4dZ+8dX^2Y2Z+4dX^2YZ2+4dX^2Z3                   |
|-----------------------------------------------------------------------------|
|-2XdX^2YdZ+3XdX^2ZdZ+6XdX^2+3dXYdZ                                           |
|-2XdX^2YZ2dZ-XdX^2Z3dZ-4XdX^2YZ-2XdX^2Z2+3dXYZ2dZ+6dXYZ                      |
|-----------------------------------------------------------------------------|
|2XdX^2YdZ-3XdX^2ZdZ-2XdX^2-6dXYdY+9dXdYZ-6dX                                 |
|2XdX^2YZ2dZ+XdX^2Z3dZ+4XdX^2YZ+4XdX^2Z2-6dXYdYZ2-6dXZ2                       |
|-----------------------------------------------------------------------------|
|-2XdX^2YZ+3XdX^2Z2-12dXY2+18dXYZ-3dXZ2                                       |
|-2XdX^2YZ3-XdX^2Z4-12dXY2Z2-6dXYZ3-3dXZ4                                     |
|-----------------------------------------------------------------------------|
|2dX^2Y2dY-3dX^2YdYZ+2dX^2YZdZ-3dX^2Z2dZ+4dX^2Y-6dX^2Z      |, |              |
|2dX^2Y2dYZ2+dX^2YdYZ3+2dX^2YZ3dZ+dX^2Z4dZ+8dX^2YZ2+4dX^2Z3 |  |              |
|-----------------------------------------------------------------------------|
|X2Y2-2X2YZ+X2Z2 dY+dZ -YdZ+ZdZ+2 -XdX-2 0      0      0      |)}             |
|X2Y2Z2          0     0          0      -ZdZ-2 -YdY-2 -XdX-2 |               |
+-----------------------------------------------------------------------------+
|i4 : pruneLocalCohom h                                                       |
|                                                                             |
|o4 = HashTable{1 => | dZ dY XdX+3 X3 |                                       |
|               2 => | dYZ+YdZ+2 YdY+ZdZ+6 Y2-2YZ+Z2 XdX+4 YZdZ-Z2dZ+2Y-4Z    |
|                                                                             |
|o4 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|                          }                                                  |
|2YZ3-Z4 Z4dZ+2YZ2+4Z3 Z5 |                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * pruneLocalCohom -- prunes local
    cohomology modules

Ways to use this method:
========================

  * localCohom(List,Ideal,Module),
    -- local cohomology of a D-module

localCohom(ZZ,Ideal) -- local cohomology of a polynomial ring
*************************************************************

Synopsis
========

  * Function: localCohom,
  * Usage:
        localCohom(d,I)
  * Inputs:
      * d, an integer (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * LocStrategy,
        => ..., default value null, specify localization strategy for local
        cohomology
      * Strategy, =>
        ..., default value Walther, specify strategy for local cohomology
  * Outputs:
      * a hash table (Macaulay2Doc), the local cohomology of I
        in degree d

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

See localCohom(Ideal), for the full description.
+---------------------------------------------------------------------------+
|i1 : W = QQ[X, dX, Y, dY, Z, dZ, WeylAlgebra=>{X=>dX, Y=>dY, Z=>dZ}]       |
|                                                                           |
|o1 = W                                                                     |
|                                                                           |
|o1 : PolynomialRing, 3 differential variables                              |
+---------------------------------------------------------------------------+
|i2 : I = ideal (X*(Y-Z), X*Y*Z)                                            |
|                                                                           |
|o2 = ideal (X*Y - X*Z, X*Y*Z)                                              |
|                                                                           |
|o2 : Ideal of W                                                            |
+---------------------------------------------------------------------------+
|i3 : h = localCohom (2,I)                                                  |
|                                                                           |
|o3 = cokernel | -XYZ XY-XZ 3XdX-2YdY-2ZdZ YdY+ZdZ+3 Y2dY-2YdYZ-2YZdZ+Z2dZ ||
|                                                                           |
|                            1                                              |
|o3 : W-module, quotient of W                                               |
+---------------------------------------------------------------------------+
|i4 : Dprune h                                                              |
|                                                                           |
|o4 = cokernel | Y-Z Z2 dYZ+ZdZ+2 XdX+2 |                                   |
|                                                                           |
|                            1                                              |
|o4 : W-module, quotient of W                                               |
+---------------------------------------------------------------------------+

See also
========

  * pruneLocalCohom -- prunes local
    cohomology modules

Ways to use this method:
========================

  * localCohom(ZZ,Ideal) -- local cohomology
    of a polynomial ring

localCohom(ZZ,Ideal,Module) -- local cohomology of a D-module
*************************************************************

Synopsis
========

  * Function: localCohom,
  * Usage:
        localCohom(d,I,M)
  * Inputs:
      * d, an integer (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
      * M, a module (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * LocStrategy,
        => ..., default value null, specify localization strategy for local
        cohomology
      * Strategy, =>
        ..., default value Walther, specify strategy for local cohomology
  * Outputs:
      * a hash table (Macaulay2Doc), the local cohomology

        H (M) in degree d, where I is an ideal in a polynomial ring and M is a
         I
        D-module

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

See localCohom(Ideal,Module), for the
full description.
+-----------------------------------------------------------------------------+
|i1 : W = QQ[X, dX, Y, dY, Z, dZ, WeylAlgebra=>{X=>dX, Y=>dY, Z=>dZ}]         |
|                                                                             |
|o1 = W                                                                       |
|                                                                             |
|o1 : PolynomialRing, 3 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : I = ideal (X*(Y-Z), X*Y*Z)                                              |
|                                                                             |
|o2 = ideal (X*Y - X*Z, X*Y*Z)                                                |
|                                                                             |
|o2 : Ideal of W                                                              |
+-----------------------------------------------------------------------------+
|i3 : h = localCohom(2, I, W^1 / ideal{dX,dY,dZ})                             |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|WARNING! Dlocalization is an obsolete name for Dlocalize                     |
|                                                                             |
|o3 = HashTable{2 => cokernel | -X2Y2Z2 X2Y2-2X2YZ+X2Z2 -YdY-ZdZ-6 -XdX-4     |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|YZdZ-Z2dZ+2Y-4Z |}                                                           |
+-----------------------------------------------------------------------------+
|i4 : pruneLocalCohom h                                                       |
|                                                                             |
|o4 = HashTable{2 => | dYZ+YdZ+2 YdY+ZdZ+6 Y2-2YZ+Z2 XdX+4 YZdZ-Z2dZ+2Y-4Z    |
|                                                                             |
|o4 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|2YZ3-Z4 Z4dZ+2YZ2+4Z3 Z5 |}                                                  |
+-----------------------------------------------------------------------------+

See also
========

  * pruneLocalCohom -- prunes local
    cohomology modules

Ways to use this method:
========================

  * localCohom(ZZ,Ideal,Module), --
    local cohomology of a D-module

LocalizeMap -- a key in the hashtable created by deRham
*******************************************************

See also
========

  * deRham -- deRham cohomology groups for the complement of a
    hypersurface

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

The object LocalizeMap, is a symbol (Macaulay2Doc).

LocCohomStrategy
****************

Functions with optional argument named LocCohomStrategy :
=========================================================

  * ICcohom(...,LocCohomStrategy=>...) (missing documentation)
  * ICmodule(...,LocCohomStrategy=>...) (missing documentation)

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

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

LocMap -- a key created by Dlocalize
************************************

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

See Dlocalize.

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

The object LocMap, is a symbol (Macaulay2Doc).

LocModule -- a key created by Dlocalize
***************************************

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

See Dlocalize.

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

The object LocModule, is a symbol (Macaulay2Doc).

LocStrategy
***********

Functions with optional argument named LocStrategy :
====================================================

  * ICcohom(...,LocStrategy=>...) (missing documentation)
  * ICmodule(...,LocStrategy=>...) (missing documentation)
  * localCohom(...,LocStrategy=>...)
    -- specify localization
    strategy for local cohomology

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

The object LocStrategy, is a symbol (Macaulay2Doc).

logCohomology(RingElement) -- logarithmic cohomology groups in two variables
****************************************************************************

Synopsis
========

  * Function: logCohomology,
  * Usage:
        logCohomology f
  * Inputs:
      * f, a ring element (Macaulay2Doc), polynomial in two
        variables
  * Outputs:
      * a hash table (Macaulay2Doc), with entries
        {VResolution, Input, TransferCycles, CohomologyGroups, PreCycles,
        OmegaRes, LocalizeMap, BFunction}

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

For a polynomial f in two variables executes the algorithm described in
Castro-Jimenez and Takayama "The Computation of the Logarithmic Cohomology for
Plane Curves" (arXiv:0712.0001).
+-----------------------------------------------------------------------------+
|i1 : S=QQ[x,y];                                                              |
+-----------------------------------------------------------------------------+
|i2 : f=x*y*(x-y);                                                            |
+-----------------------------------------------------------------------------+
|i3 : logCohomology(f)                                                        |
|                                                                             |
|o3 = HashTable{BFunction => (s - 1)                                          |
|                                                    1                        |
|               CohomologyGroups => HashTable{0 => QQ }                       |
|                                                    3                        |
|                                             1 => QQ                         |
|                                                    2                        |
|                                             2 => QQ                         |
|               Input => cokernel | xdx+ydy+3 xydy-y2dy+x-2y |                |
|               LocalizeMap => LocMap                                         |
|                                             1                       2       |
|               OmegaRes => (QQ[x..y, dx, dy])  <-- (QQ[x..y, dx, dy])  <--   |
|                                                                             |
|                           0                       1                         |
|               PreCycles => HashTable{0 => | x |       }                     |
|                                           | 1 |                             |
|                                      1 => | -x -y 0  |                      |
|                                           | 0  0  -1 |                      |
|                                           | 0  0  0  |                      |
|                                      2 => | -y -x |                         |
|               TransferCycles => HashTable{0 => | -x2y+xy2 |    }            |
|                                           1 => | xy y2 -xy+y2 |             |
|                                                | x2 xy 0      |             |
|                                           2 => | -y -x |                    |
|                                                1                       3    |
|               VResolution => (QQ[x..y, dx, dy])  <-- (QQ[x..y, dx, dy])     |
|                                                                             |
|                              0                       1                      |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|                             }                                               |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                   1                                                         |
| (QQ[x..y, dx, dy])  <-- 0                                                   |
|                                                                             |
| 2                       3                                                   |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                      2                                                      |
|<-- (QQ[x..y, dx, dy])  <-- 0                                                |
|                                                                             |
|    2                       3                                                |
+-----------------------------------------------------------------------------+

See also
========

  * deRham -- deRham cohomology groups for the complement of a
    hypersurface

Ways to use this method:
========================

  * logCohomology(RingElement), --
    logarithmic cohomology groups in two variables

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

Synopsis
========

  * 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 variables                    |
+-----------------------------------------------------------------+
|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).

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

Synopsis
========

  * Usage:
        makeWeylAlgebra R
        makeWA R
  * Inputs:
      * R, a polynomial ring (Macaulay2Doc), the
        (commutative) polynomial ring
      * SetVariables, a Boolean value (Macaulay2Doc), whether to
        set variables of the created algebra to be global
  * Optional inputs (Macaulay2Doc),:
      * SetVariables => ..., default value true
  * 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 variables|
+---------------------------------------------+

To skip naming the ring, use parentheses.

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

Caveat
======

The polynomial ring R must be commutative.

See also
========

  * WeylAlgebra (Macaulay2Doc) -- an optional argument

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

  * "makeWeylAlgebra(PolynomialRing)"

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

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

multiplierIdeal(Ideal,QQ) -- multiplier ideal
*********************************************

Synopsis
========

  * Function: multiplierIdeal,
  * Usage:
        mI = multiplierIdeal(I,c)
  * Inputs:
      * I, an ideal (Macaulay2Doc), an ideal in a polynomial ring
      * c, a rational number (Macaulay2Doc), coefficient (or a list
        of coefficients)
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit => ..., default value null
      * Strategy => ..., default value ViaElimination
  * Outputs:
      * mI, an ideal (Macaulay2Doc), multiplier ideal J_I(c) (or a
        list of)

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

Computes the multiplier ideal for given ideal and coefficient.

There are three options for Strategy:
  * ViaElimination -- the default;
  * ViaLinearAlgebra -- skips one expensive elimination step by using linear
    algebra;
  * ViaColonIdeal -- same as elimination, but may be slightly faster.
The option DegreeLimit specifies the maximal degree of polynomials to consider
for membership in the multiplier ideal.See Berkesch and Leykin ``Algorithms for
Bernstein-Sato polynomials and multiplier ideals'' for details.
+-----------------------------------------------------------------+
|i1 : R = QQ[x_1..x_4];                                           |
+-----------------------------------------------------------------+
|i2 : multiplierIdeal(ideal {x_1^3 - x_2^2, x_2^3 - x_3^2}, 31/18)|
|                                                                 |
|                 2         2                                     |
|o2 = ideal (x , x , x x , x )                                    |
|             3   2   1 2   1                                     |
|                                                                 |
|o2 : Ideal of R                                                  |
+-----------------------------------------------------------------+

Caveat
======

When Strategy=>ViaLinearAlgebra the option DegreeLimit must be specified. The
output it guaranteed to be the whole multiplier ideal only when dim(I)=0. For
positive-dimensional input the up-to-specified-degree part of the multiplier
ideal is returned.

See also
========

  * jumpingCoefficients -- jumping
    coefficients and corresponding multiplier ideals

Ways to use this method:
========================

  * "multiplierIdeal(Ideal,List)"
  * multiplierIdeal(Ideal,QQ), --
    multiplier ideal
  * "multiplierIdeal(Ideal,ZZ)"

None -- an option for DExt=>Special
***********************************

See also
========

  * DExt -- Ext groups between holonomic modules

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

The object None, is a symbol (Macaulay2Doc).

NonGeneric -- a strategy option for b-functions
***********************************************

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

see bFunction,

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

The object NonGeneric, is a symbol (Macaulay2Doc).

OaTa -- an option for localCohom=>Strategy
******************************************

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

see localCohom,

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

The object OaTa, is a symbol (Macaulay2Doc).

OaTaWa -- an option for localCohom => LocStrategy
*************************************************

See also
========

  * localCohom -- local cohomology

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

The object OaTaWa, is a symbol (Macaulay2Doc).

OmegaRes -- a key in the hashtable created by deRham
****************************************************

See also
========

  * deRham -- deRham cohomology groups for the complement of a
    hypersurface

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

The object OmegaRes, is a symbol (Macaulay2Doc).

Output
******

Functions with optional argument named Output :
===============================================

  * DExt(...,Output=>...)

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

The object Output, is a symbol (Macaulay2Doc).

paramBpoly(...,GroundField=>...) -- characteristic for modular computation
**************************************************************************

Further information
===================

  * Default value: 32749
  * Function: paramBpoly, --
    compute the list of all possible Bernstein-Sato polynomials for a
    polynomial with parametric coefficients
  * Option key: GroundField,

Functions with optional argument named GroundField :
====================================================

  * paramBpoly(...,GroundField=>...)
    -- characteristic for
    modular computation

paramBpoly(RingElement,String) -- compute the list of all possible Bernstein-Sato polynomials for a polynomial with parametric coefficients
*******************************************************************************************************************************************

Synopsis
========

  * Function: paramBpoly,
  * Usage:
        paramBpoly(f,filename)
  * Inputs:
      * f, a ring element (Macaulay2Doc), a polynomial in
        Weyl algebra A_n(Q)
      * filename, a string (Macaulay2Doc), the base name for the
        output files
  * Optional inputs (Macaulay2Doc),:
      * GroundField,
        => ..., default value 32749, characteristic for modular computation
  * Outputs:
      * a list (Macaulay2Doc), all possible Bernstein-Sato
        polynomials

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

+--------------------------------------------------------------------+
|i1 : A =  (QQ [a,b,c]) [x, y, Dx, Dy, WeylAlgebra => {x=>Dx, y=>Dy}]|
|                                                                    |
|o1 = A                                                              |
|                                                                    |
|o1 : PolynomialRing, 2 differential variables                       |
+--------------------------------------------------------------------+
|i2 : paramBpoly(a*x^2 + b*x*y + c*y^2, "quadratic")                 |
|                                                                    |
|             2       1                                              |
|o2 = {(S + 1) , (S + -)(S + 1)}                                     |
|                     2                                              |
|                                                                    |
|o2 : List                                                           |
+--------------------------------------------------------------------+

Caveat
======

A finite field should be used in place of Q in order to speed up computations.
This routine works only on relatively small examples.

See also
========

  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)

Ways to use this method:
========================

  * paramBpoly(RingElement,String),
    -- compute the list of all possible Bernstein-Sato polynomials for a
    polynomial with parametric coefficients

pInfo -- prints tracing info
****************************

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

Prints tracing information according to the print level set by Dtrace.

See also
========

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

Ways to use pInfo :
===================

  * "pInfo(ZZ,List)"
  * "pInfo(ZZ,Thing)"

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

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

PolyAnn -- annihilator of a polynomial in the Weyl algebra
**********************************************************

Synopsis
========

  * Usage:
        PolyAnn f
  * Inputs:
      * f, a ring element (Macaulay2Doc), polynomial
  * Outputs:
      * an ideal (Macaulay2Doc), the annihilating (left) ideal of
        f in the Weyl algebra

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

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

Caveat
======

The input f should be an element of a Weyl algebra, and not an element of a
commutative polynomial ring. However, f should only involve commutative
variables.

See also
========

  * RatAnn -- annihilator of a rational function in Weyl algebra

Ways to use PolyAnn :
=====================

  * "PolyAnn(RingElement)"

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

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

PolyExt -- Ext groups between a holonomic module and a polynomial ring
**********************************************************************

Synopsis
========

  * Usage:
        PolyExt M, PolyExt I; RatExt(i,M), RatExt(i,I)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * i, an integer (Macaulay2Doc), nonnegative
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value Schreyer, null
  * Outputs:
      * a hash table (Macaulay2Doc), or a module (Macaulay2Doc),
        the Ext^i group(s) between holonomic M and the
        polynomial ring

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

The Ext groups between a D-module M and the polynomial ring are the derived
functors of Hom, and are finite-dimensional vector spaces over the ground field
when M is holonomic.

The algorithm used appears in the paper 'Polynomial and rational solutions of
holonomic systems' by Oaku-Takayama-Tsai (2000). The method is to combine
isomorphisms of Bjork and Kashiwara with the restriction algorithm.

+---------------------------------------------+
|i1 : W = QQ[x, D, WeylAlgebra=>{x=>D}]       |
|                                             |
|o1 = W                                       |
|                                             |
|o1 : PolynomialRing, 1 differential variables|
+---------------------------------------------+
|i2 : M = W^1/ideal(x^2*D^2)                  |
|                                             |
|o2 = cokernel | x2D2 |                       |
|                                             |
|                            1                |
|o2 : W-module, quotient of W                 |
+---------------------------------------------+
|i3 : PolyExt(M)                              |
|                                             |
|                      2                      |
|o3 = HashTable{0 => QQ }                     |
|                      2                      |
|               1 => QQ                       |
|                                             |
|o3 : HashTable                               |
+---------------------------------------------+

Caveat
======

Does not yet compute explicit representations of Ext groups such as Yoneda
representation.

See also
========

  * PolySols -- polynomial solutions of a holonomic system
  * RatExt -- Ext(holonomic D-module, polynomial ring localized
    at the singular locus)
  * DExt -- Ext groups between holonomic modules
  * Dintegration -- integration modules of a D-module

Ways to use PolyExt :
=====================

  * "PolyExt(Ideal)"
  * "PolyExt(Module)"
  * "PolyExt(ZZ,Ideal)"
  * "PolyExt(ZZ,Module)"

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

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

PolyExt(...,Strategy=>...)
**************************

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

Option is passed to Dresolution. See Dresolution(...,Strategy=>...),

Further information
===================

  * Default value: Schreyer,
  * Function: PolyExt, -- Ext groups between a holonomic module
    and a polynomial ring
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

PolyGens -- a key of the hashtable generated by diffOps
*******************************************************

See also
========

  * diffOps -- differential operators of up to the given order
    for a quotient polynomial ring

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

The object PolyGens, is a symbol (Macaulay2Doc).

PolySols -- polynomial solutions of a holonomic system
******************************************************

Synopsis
========

  * Usage:
        PolySols I
        PolySols M
        PolySols(I,w)
        PolySols(M,w)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra $D$
      * I, an ideal (Macaulay2Doc), holonomic ideal in the Weyl
        algebra $D$
      * w, a list (Macaulay2Doc), a weight vector
  * Optional inputs (Macaulay2Doc),:
      * Alg, => ..., default
        value GD, algorithm for finding polynomial solutions
  * Outputs:
      * a list (Macaulay2Doc), a basis of the polynomial solutions
        of $I$ (or of $D$-homomorphisms between $M$ and the polynomial ring)
        using $w$ for Groebner deformations

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

The polynomial solutions of a holonomic system form a finite-dimensional vector
space. There are two algorithms implemented to get these solutions. The first
algorithm is based on Gr\"obner deformations and works for ideals $I$ of PDE's
- see the paper Polynomial and rational solutions of a holonomic system by
Oaku, Takayama and Tsai (2000).  The second algorithm is based on homological
algebra - see the paper Computing homomorphisms between holonomic D-modules by
Tsai and Walther (2000).

+---------------------------------------------+
|i1 : makeWA(QQ[x])                           |
|                                             |
|o1 = QQ[x, dx]                               |
|                                             |
|o1 : PolynomialRing, 1 differential variables|
+---------------------------------------------+
|i2 : I = ideal(dx^2, (x-1)*dx-1)             |
|                                             |
|              2                              |
|o2 = ideal (dx , x*dx - dx - 1)              |
|                                             |
|o2 : Ideal of QQ[x, dx]                      |
+---------------------------------------------+
|i3 : PolySols I                              |
|                                             |
|o3 = {x - 1}                                 |
|                                             |
|o3 : List                                    |
+---------------------------------------------+

See also
========

  * RatSols -- rational solutions of a holonomic system
  * Dintegration -- integration modules of a D-module

Ways to use PolySols :
======================

  * "PolySols(Ideal)"
  * "PolySols(Ideal,List)"
  * "PolySols(Module)"
  * "PolySols(Module,List)"

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

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

PolySols(...,Alg=>...) -- algorithm for finding polynomial solutions
********************************************************************

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

  * GD -- uses Groebner deformations
  * Duality -- uses homological duality

Further information
===================

  * Default value: GD,
  * Function: PolySols, -- polynomial solutions of a holonomic
    system
  * Option key: Alg,

Functions with optional argument named Alg :
============================================

  * PolySols(...,Alg=>...), --
    algorithm for finding polynomial solutions

populateCechComplexCC(Ideal,List) -- Cech complex skeleton for the computation of the characteristic cycles of local cohomology modules
***************************************************************************************************************************************

Synopsis
========

  * Function: populateCechComplexCC,
  * Usage:
        populateCechComplexCC(I,cc)
  * Inputs:
      * I, an ideal (Macaulay2Doc), at which the local cohomology
        modules H^i_I(M) are computed.
      * cc, a list (Macaulay2Doc), the characteristic cycle of a
        regular holonomic module M
  * Outputs:
      * a mutable hash table (Macaulay2Doc), with
        entries corresponding to the direct summands of the chains in the Cech
        complex

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

For the ideal I=(f_1,...,f_k) the routine computes the characteristic cycles of
the localized modules M_{f_{i_1},...,f_{i_k}} and places them in the
corresponding places in the Cech complex.
+---------------------------------------------------------+
|i1 : W =  QQ[x_1..x_6, a_1..a_6];                        |
+---------------------------------------------------------+
|i2 : I = minors(2, matrix{{x_1, x_2, x_3}, {x_4, 0, 0}});|
|                                                         |
|o2 : Ideal of W                                          |
+---------------------------------------------------------+
|i3 : cc = {ideal W => 1};                                |
+---------------------------------------------------------+

Caveat
======

The module has to be a regular holonomic complex-analytic module; while the
holomicity can be checked by isHolonomic, there is no
algorithm to check the regularity.

See also
========

  * BMM -- the characteristic cycle of the localized $D$-module
  * pruneCechComplexCC, --
    reduction of the Cech complex that produces characteristic cycles of local
    cohomology modules

Ways to use this method:
========================

  * populateCechComplexCC(Ideal,List)
    -- Cech complex skeleton for the
    computation of the characteristic cycles of local cohomology modules

PreCycles -- a key in the hashtable created by deRham
*****************************************************

See also
========

  * deRham -- deRham cohomology groups for the complement of a
    hypersurface

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

The object PreCycles, is a symbol (Macaulay2Doc).

projMap1 -- a key attached by ExternalProduct
*********************************************

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

see ExternalProduct,

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

The object projMap1, is a symbol (Macaulay2Doc).

projMap2 -- a key attached by ExternalProduct
*********************************************

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

see ExternalProduct,

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

The object projMap2, is a symbol (Macaulay2Doc).

pruneCechComplexCC(MutableHashTable) -- reduction of the Cech complex that produces characteristic cycles of local cohomology modules
*************************************************************************************************************************************

Synopsis
========

  * Function: pruneCechComplexCC,
  * Usage:
        pruneCechComplexCC M
  * Inputs:
      * M, a mutable hash table (Macaulay2Doc), the
        output of populateCechComplexCC,
  * Outputs:
      * a mutable hash table (Macaulay2Doc),

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

The function reduces the Cech complex skeleton produced by
populateCechComplexCC, leaving the
pieces of the characteristic cycles of the chains that together constitute the
characteristic cycles of the local cohomology modules.
+---------------------------------------------------------+
|i1 : W =  QQ[x_1..x_6, a_1..a_6];                        |
+---------------------------------------------------------+
|i2 : I = minors(2, matrix{{x_1, x_2, x_3}, {x_4, 0, 0}});|
|                                                         |
|o2 : Ideal of W                                          |
+---------------------------------------------------------+
|i3 : cc = {ideal W => 1};                                |
+---------------------------------------------------------+

Caveat
======

The module has to be a regular holonomic complex-analytic module; while the
holomicity can be checked by isHolonomic, there is no
algorithm to check the regularity.

See also
========

  * BMM -- the characteristic cycle of the localized $D$-module
  * populateCechComplexCC, --
    Cech complex skeleton for the computation of the characteristic cycles of
    local cohomology modules

Ways to use this method:
========================

  * pruneCechComplexCC(MutableHashTable)
    -- reduction of the Cech complex
    that produces characteristic cycles of local cohomology modules

pruneLocalCohom(HashTable) -- prunes local cohomology modules
*************************************************************

Synopsis
========

  * Function: pruneLocalCohom,
  * Usage:
        pruneLocalCohom H
  * Inputs:
      * a hash table (Macaulay2Doc), the output of
        localCohom,
  * Outputs:
      * a hash table (Macaulay2Doc),

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

This function applies Dprune, to all the keys of H.

See also
========

  * localCohom -- local cohomology
  * Dprune -- prunes a D-module

Ways to use this method:
========================

  * pruneLocalCohom(HashTable) -- prunes
    local cohomology modules

putWeylAlgebra(HashTable) -- transforms output of diffOps into elements of Weyl algebra
***************************************************************************************

Synopsis
========

  * Function: putWeylAlgebra,
  * Usage:
        putWeylAlgebra m
  * Inputs:
      * a hash table (Macaulay2Doc), the output of diffOps
  * Outputs:
      * the differential operators as elements of the Weyl algebra

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

If I is an ideal of the polynomial ring R and m is the output of diffOps(I, k)
then this routine returns elements of the Weyl algebra W corresponding to R
whose images in W/IW are an R/I-generating set for the differential operators
of order at most k.
+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                                           |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(x^2-y*z)                                                      |
|                                                                             |
|            2                                                                |
|o2 = ideal(x  - y*z)                                                         |
|                                                                             |
|o2 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i3 : m = diffOps(I, 3)                                                       |
|                                                                             |
|o3 = HashTable{BasisElts => | dx^3 dx^2dy dx^2dz dxdy^2 dxdydz dxdz^2 dy^3   |
|               PolyGens => {-3} | 0  0  0  0  0   -2xz  0    2xy  yz  y2     |
|                           {-3} | 0  0  0  0  0   -6yz  0    0    2xy 0      |
|                           {-3} | 0  0  0  0  0   -6z2  0    12yz 4xz 6xy    |
|                           {-3} | 0  0  0  0  0   0     0    0    0   0      |
|                           {-3} | 0  0  0  0  0   -24xz 0    0    8yz 0      |
|                           {-3} | 0  0  0  0  0   0     0    24xz 4z2 12yz   |
|                           {-3} | 0  0  0  0  0   8y2   0    0    0   0      |
|                           {-3} | 0  0  0  0  0   -24yz 0    0    0   0      |
|                           {-3} | 0  0  0  0  0   0     0    0    8xz 0      |
|                           {-3} | 0  0  0  0  0   0     0    16z2 0   8xz    |
|                           {-2} | 0  z  y  x  0   -3z   0    -3y  x   0      |
|                           {-2} | 0  4x 0  2y 0   0     0    0    -2y 0      |
|                           {-2} | 0  0  4x 2z 0   0     0    0    4z  6y     |
|                           {-2} | 0  4y 0  0  0   24y   y2   0    0   0      |
|                           {-2} | 0  0  0  4x 0   -12z  -2yz 0    0   0      |
|                           {-2} | 0  0  4z 0  0   0     z2   12z  0   12x    |
|                           {-1} | 0  0  0  1  yz  0     0    0    -1  0      |
|                           {-1} | y  2  0  0  0   6     0    0    0   0      |
|                           {-1} | -z 0  2  0  2xz 0     2z   -6   0   0      |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|dy^2dz dydz^2 dz^3 dx^2 dxdy dxdz dy^2 dydz dz^2 dx dy dz |}                 |
|2xz  0    z2   -yz   0   0   2x2z-2yz2   |                                   |
|8yz  y2   6xz  0     0   0   0           |                                   |
|4z2  -yz  0    -6xz  0   0   0           |                                   |
|8xy  0    12yz 4y2   0   0   0           |                                   |
|16xz 4xy  0    -8yz  0   0   24x2z-24yz2 |                                   |
|0    -4xz 0    -8z2  0   0   0           |                                   |
|0    0    8xy  0     0   0   0           |                                   |
|16yz 0    0    8xy   0   0   0           |                                   |
|0    4yz  0    -16xz 0   0   0           |                                   |
|0    -4z2 0    0     0   0   0           |                                   |
|z    y    0    -x    xy  xz  0           |                                   |
|0    0    6z   8y    0   4yz 0           |                                   |
|0    0    0    -10z  4yz 0   0           |                                   |
|-12y 0    12x  0     0   4xy 0           |                                   |
|8z   2y   0    0     0   0   0           |                                   |
|0    -6z  0    0     4xz 0   0           |                                   |
|0    0    0    1     -y  -z  -3z         |                                   |
|-6   0    0    0     0   0   -6x         |                                   |
|0    0    0    0     0   0   0           |                                   |
+-----------------------------------------------------------------------------+
|i4 : putWeylAlgebra m                                                        |
|                                                                             |
|o4 = | ydy-zdz zdx^2+4xdxdy+4ydy^2+2dy ydx^2+4xdxdz+4zdz^2+2dz               |
|     ------------------------------------------------------------------------|
|     xdx^2+2ydxdy+2zdxdz+4xdydz+dx yzdx+2xzdz                                |
|     ------------------------------------------------------------------------|
|     -2xzdx^3-6yzdx^2dy+8y2dy^3-6z2dx^2dz-24xzdxdydz-24yzdy^2dz-3zdx^2+24ydy^|
|     ------------------------------------------------------------------------|
|     2-12zdydz+6dy y2dy^2-2yzdydz+z2dz^2+2zdz                                |
|     ------------------------------------------------------------------------|
|     2xydx^3+12yzdx^2dz+24xzdxdz^2+16z2dz^3-3ydx^2+12zdz^2-6dz               |
|     ------------------------------------------------------------------------|
|     yzdx^3+2xydx^2dy+4xzdx^2dz+8yzdxdydz+4z2dxdz^2+8xzdydz^2+xdx^2-2ydxdy+  |
|     ------------------------------------------------------------------------|
|     4zdxdz-dx y2dx^3+6xydx^2dz+12yzdxdz^2+8xzdz^3+6ydxdz+12xdz^2            |
|     ------------------------------------------------------------------------|
|     2xzdx^3+8yzdx^2dy+8xydxdy^2+4z2dx^2dz+16xzdxdydz+16yzdy^2dz+zdx^2-12ydy^|
|     ------------------------------------------------------------------------|
|     2+8zdydz-6dy y2dx^2dy-yzdx^2dz+4xydxdydz-4xzdxdz^2+4yzdydz^2-4z2dz^3+ydx|
|     ------------------------------------------------------------------------|
|     ^2+2ydydz-6zdz^2 z2dx^3+6xzdx^2dy+12yzdxdy^2+8xydy^3+6zdxdy+12xdy^2     |
|     ------------------------------------------------------------------------|
|     -yzdx^3+4y2dxdy^2-6xzdx^2dz-8yzdxdydz+8xydy^2dz-8z2dxdz^2-16xzdydz^2-xdx|
|     ------------------------------------------------------------------------|
|     ^2+8ydxdy-10zdxdz+dx xydx^2+4yzdxdz+4xzdz^2-ydx                         |
|     ------------------------------------------------------------------------|
|     xzdx^2+4yzdxdy+4xydy^2-zdx                                              |
|     ------------------------------------------------------------------------|
|     2x2zdx^3-2yz2dx^3+24x2zdxdydz-24yz2dxdydz-3zdx-6xdy |                   |
|                                                                             |
|                                  1                            17            |
|o4 : Matrix (QQ[x..z, dx, dy, dz])  <--- (QQ[x..z, dx, dy, dz])              |
+-----------------------------------------------------------------------------+

See also
========

  * diffOps -- differential operators of up to the given order
    for a quotient polynomial ring

Ways to use this method:
========================

  * putWeylAlgebra(HashTable), --
    transforms output of diffOps into elements of Weyl algebra

RatAnn -- annihilator of a rational function in Weyl algebra
************************************************************

Synopsis
========

  * Usage:
        RatAnn f
        RatAnn(g,f)
  * Inputs:
      * f, a ring element (Macaulay2Doc), polynomial
      * g, a ring element (Macaulay2Doc), polynomial
  * Outputs:
      * an ideal (Macaulay2Doc), left ideal of the Weyl algebra

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

RatAnn f computes the annihilator ideal in the Weyl algebra of the rational
function $1/f$.  RatAnn(g,f) computes the annihilator ideal in the Weyl algebra
of the rational function $g/f$.

+-----------------------------------------------------------------------------+
|i1 : makeWA(QQ[x,y])                                                         |
|                                                                             |
|o1 = QQ[x..y, dx, dy]                                                        |
|                                                                             |
|o1 : PolynomialRing, 2 differential variables                                |
+-----------------------------------------------------------------------------+
|i2 : f = x^2-y^3                                                             |
|                                                                             |
|        3    2                                                               |
|o2 = - y  + x                                                                |
|                                                                             |
|o2 : QQ[x..y, dx, dy]                                                        |
+-----------------------------------------------------------------------------+
|i3 : g = 2*x*y                                                               |
|                                                                             |
|o3 = 2x*y                                                                    |
|                                                                             |
|o3 : QQ[x..y, dx, dy]                                                        |
+-----------------------------------------------------------------------------+
|i4 : I = RatAnn (g,f)                                                        |
|                                                                             |
|                                3  2    2  2     2           2  2          3 |
|o4 = ideal (3x*dx + 2y*dy + 1, y dy  - x dy  + 6y dy + 6y, 9y dx dy - 4y*dy  |
|     ------------------------------------------------------------------------|
|             2      2    3  2     2  2                                       |
|     + 27y*dx  + 2dy , 9y dx  - 4y dy  + 10y*dy - 10)                        |
|                                                                             |
|o4 : Ideal of QQ[x..y, dx, dy]                                               |
+-----------------------------------------------------------------------------+

Caveat
======

The inputs f and g should be elements of a Weyl algebra, and not elements of a
commutative polynomial ring. However, f and g should only use the commutative
variables.

See also
========

  * PolyAnn -- annihilator of a polynomial in the Weyl algebra

Ways to use RatAnn :
====================

  * "RatAnn(RingElement)"
  * "RatAnn(RingElement,RingElement)"

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

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

RatExt -- Ext(holonomic D-module, polynomial ring localized at the singular locus)
**********************************************************************************

Synopsis
========

  * Usage:
        RatExt M, RatExt I; RatExt(M,f), RatExt(I,f);
        RatExt(i,M), RatExt(i,I); RatExt(i,M,f), RatExt(i,I,f)
  * Inputs:
      * M, a module (Macaulay2Doc), over the Weyl algebra D
      * I, an ideal (Macaulay2Doc), which represents the module M
        = D/I
      * f, a ring element (Macaulay2Doc), a polynomial
      * i, an integer (Macaulay2Doc), nonnegative
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value Schreyer, null
  * Outputs:
      * a hash table (Macaulay2Doc), or a module (Macaulay2Doc),
        the Ext^i group(s) between holonomic M and the
        polynomial ring localized at the singular locus of M (or at f if
        specified)

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

The Ext groups between M and N are the derived functors of Hom, and are
finite-dimensional vector spaces over the ground field when M and N are
holonomic.

The algorithm used appears in the paper 'Polynomial and rational solutions of
holonomic systems' by Oaku-Takayama-Tsai (2000). The method is to combine
isomorphisms of Bjork and Kashiwara with the restriction algorithm.

+---------------------------------------------+
|i1 : W = QQ[x, D, WeylAlgebra=>{x=>D}]       |
|                                             |
|o1 = W                                       |
|                                             |
|o1 : PolynomialRing, 1 differential variables|
+---------------------------------------------+
|i2 : M = W^1/ideal(x*D+5)                    |
|                                             |
|o2 = cokernel | xD+5 |                       |
|                                             |
|                            1                |
|o2 : W-module, quotient of W                 |
+---------------------------------------------+
|i3 : RatExt M                                |
|                                             |
|                      1                      |
|o3 = HashTable{0 => QQ }                     |
|                      1                      |
|               1 => QQ                       |
|                                             |
|o3 : HashTable                               |
+---------------------------------------------+

Caveat
======

Input modules M or D/I should be holonomic.

See also
========

  * Dresolution -- resolution of a D-module
  * Dintegration -- integration modules of a D-module

Ways to use RatExt :
====================

  * "RatExt(Ideal)"
  * "RatExt(Ideal,RingElement)"
  * "RatExt(Module)"
  * "RatExt(Module,RingElement)"
  * "RatExt(ZZ,Ideal)"
  * "RatExt(ZZ,Ideal,RingElement)"
  * "RatExt(ZZ,Module)"
  * "RatExt(ZZ,Module,RingElement)"

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

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

RatExt(...,Strategy=>...)
*************************

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

Option is passed to Dresolution. See Dresolution(...,Strategy=>...),

Further information
===================

  * Default value: Schreyer,
  * Function: RatExt, -- Ext(holonomic D-module, polynomial ring
    localized at the singular locus)
  * Option key: Strategy (Macaulay2Doc), -- an optional argument

Functions with optional argument named Strategy :
=================================================

  * "addHook(...,Strategy=>...)" -- see addHook (Macaulay2Doc),
    -- add a hook function to an object for later processing
  * "annihilator(...,Strategy=>...)" -- see annihilator (Saturation),
    -- the annihilator ideal
  * "associatedPrimes(...,Strategy=>...)" -- see associatedPrimes (PrimaryDecomposition),
    -- find associated primes
  * "basis(...,Strategy=>...)" -- see basis (Macaulay2Doc), --
    basis or generating set of all or part of a ring, ideal or module
  * bFunction(...,Strategy=>...)
    -- specify strategy for
    computing b-function
  * "mingens(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * "trim(...,Strategy=>...)" -- see Complement (Macaulay2Doc),
    -- a Strategy option value
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * DintegrateAll(...,Strategy=>...) (missing documentation)
  * DintegrateClasses(...,Strategy=>...) (missing documentation)
  * DintegrateComplex(...,Strategy=>...) (missing documentation)
  * DintegrateIdeal(...,Strategy=>...) (missing documentation)
  * Dintegration(...,Strategy=>...)
  * "Dintegrate(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestrict(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "Drestriction(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DrestrictionIdeal(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * DlocalizationAll(...,Strategy=>...) (missing documentation)
  * DlocalizationMap(...,Strategy=>...) (missing documentation)
  * "Dlocalization(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeMap(...,Strategy=>...)" -- see
    Dlocalize(...,Strategy=>...),
    -- strategy for computing a
    localization of a D-module
  * Dres(...,Strategy=>...),
    -- strategy for computing a resolution of a D-module
  * "Dresolution(...,Strategy=>...)" -- see Dres(...,Strategy=>...),
    -- strategy for computing a
    resolution of a D-module
  * DrestrictAll(...,Strategy=>...) (missing documentation)
  * DrestrictClasses(...,Strategy=>...) (missing documentation)
  * DrestrictComplex(...,Strategy=>...) (missing documentation)
  * DrestrictIdeal(...,Strategy=>...) (missing documentation)
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * gcdLLL(...,Strategy=>...) (missing documentation)
  * generalB(...,Strategy=>...)
    -- specify strategy for
    computing generalized Bernstein-Sato polynomial
  * "GF(...,Strategy=>...)" -- see GF (Macaulay2Doc), -- make a finite
    field
  * globalBFunction(...,Strategy=>...)
    -- specify strategy
    for computing global b-function
  * "groebnerBasis(...,Strategy=>...)" -- see groebnerBasis (Macaulay2Doc),
    -- Gröbner basis, as a matrix
  * hermite(...,Strategy=>...) (missing documentation)
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * ICcohom(...,Strategy=>...) (missing documentation)
  * "idealizer(...,Strategy=>...)" -- see idealizer (IntegralClosure),
    -- compute Hom(I,I) as a quotient ring
  * integralClosure(...,Strategy=>...) (IntegralClosure),
    --
    control the algorithm used
  * "intersect(Ideal,Ideal,Strategy=>...)" -- see intersect(Ideal,Ideal) (Macaulay2Doc),
    -- compute an intersection of a
    sequence of ideals or modules
  * "intersect(Module,Module,Strategy=>...)" -- see
    intersect(Ideal,Ideal) (Macaulay2Doc), --
    compute an intersection of a sequence of ideals or modules
  * "intersectInP(...,Strategy=>...)" -- see
    intersectInP(...,BasisElementLimit=>...) (ReesAlgebra),
    --
    Option for intersectInP
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * "isPrimary(...,Strategy=>...)" -- see isPrimary (PrimaryDecomposition),
    -- determine whether a submodule is
    primary
  * "isPrime(Ideal,Strategy=>...)" -- see isPrime(Ideal) (MinimalPrimes),
    -- whether an ideal is prime
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * LLL(...,Strategy=>...) (LLLBases)
    -- choose among
    different algorithms
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "localize(...,Strategy=>...)" -- see localize (PrimaryDecomposition),
    -- localize an ideal at a prime ideal
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * "decompose(Ideal,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * "minimalPrimes(...,Strategy=>...)" -- see minimalPrimes (MinimalPrimes),
    -- minimal primes of an ideal
  * minors(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "jumpingCoefficients(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * "multiplierIdeal(...,Strategy=>...)" -- see
    multiplierIdeal(Ideal,QQ), -- multiplier
    ideal
  * PolyExt(...,Strategy=>...)
  * "primaryComponent(...,Strategy=>...)" -- see primaryComponent (PrimaryDecomposition),
    -- find a primary component
    corresponding to an associated prime
  * pushForward(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (Saturation)
  * "radical(...,Strategy=>...)" -- see radical (MinimalPrimes),
    -- the radical of an ideal
  * "radicalContainment(...,Strategy=>...)" -- see radicalContainment (MinimalPrimes),
    -- whether an element is contained in
    the radical of an ideal
  * RatExt(...,Strategy=>...)
  * "analyticSpread(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "distinguished(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isLinearType(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "isReduction(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "minimalReduction(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "multiplicity(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "normalCone(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "reesAlgebra(...,Strategy=>...)" -- see reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * reesIdeal(...,Strategy=>...) (ReesAlgebra)
    -- Choose a
    strategy for the saturation step
  * "specialFiber(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "specialFiberIdeal(...,Strategy=>...)" -- see
    reesIdeal(...,Strategy=>...) (ReesAlgebra),
    -- Choose a
    strategy for the saturation step
  * "regSeqInIdeal(...,Strategy=>...)" -- see regSeqInIdeal (PrimaryDecomposition),
    -- a regular sequence contained in an
    ideal
  * resolution(...,Strategy=>...) (Macaulay2Doc)
  * saturate(...,Strategy=>...) (Saturation)
  * "primaryDecomposition(...,Strategy=>...)" -- see strategies for computing primary decomposition (PrimaryDecomposition),
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix
  * "tangentCone(...,Strategy=>...)" -- see tangentCone(Ideal) (TangentCone),

RatSols -- rational solutions of a holonomic system
***************************************************

Synopsis
========

  * Usage:
        RatSols I
        RatSols(I,f)
        RatSols(I,f,w)
        RatSols(I,ff)
        RatSols(I,ff,w)
  * Inputs:
      * I, an ideal (Macaulay2Doc), holonomic ideal in the Weyl
        algebra D
      * f, a ring element (Macaulay2Doc), a polynomial
      * ff, a list (Macaulay2Doc), a list of polynomials
      * w, a list (Macaulay2Doc), a weight vector
  * Outputs:
      * a list (Macaulay2Doc), a basis of the rational solutions of
        I with poles along f or along the polynomials in ff using w for
        Groebner deformations

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

The rational solutions of a holonomic system form a finite-dimensional vector
space. The only possibilities for the poles of a rational solution are the
codimension one components of the singular locus. An algorithm to compute
rational solutions is based on Gr\"obner deformations and works for ideals $I$
of PDE's - see the paper Polynomial and rational solutions of a holonomic
system by Oaku, Takayama and Tsai (2000).

+---------------------------------------------+
|i1 : makeWA(QQ[x])                           |
|                                             |
|o1 = QQ[x, dx]                               |
|                                             |
|o1 : PolynomialRing, 1 differential variables|
+---------------------------------------------+
|i2 : I = ideal((x+1)*dx+5)                   |
|                                             |
|o2 = ideal(x*dx + dx + 5)                    |
|                                             |
|o2 : Ideal of QQ[x, dx]                      |
+---------------------------------------------+
|i3 : RatSols I                               |
|                                             |
|                     1                       |
|o3 = {-------------------------------}       |
|       5     4      3      2                 |
|      x  + 5x  + 10x  + 10x  + 5x + 1        |
|                                             |
|o3 : List                                    |
+---------------------------------------------+

Caveat
======

The most efficient method to find rational solutions of a system of
differential equations is to find the singular locus, then try to find its
irreducible factors.  With these, call RatSols(I, ff, w), where w should be
generic enough so that the PolySols routine will not complain of a non-generic
weight vector.

See also
========

  * PolySols -- polynomial solutions of a holonomic system
  * RatExt -- Ext(holonomic D-module, polynomial ring localized
    at the singular locus)
  * DHom -- D-homomorphisms between holonomic D-modules

Ways to use RatSols :
=====================

  * "RatSols(Ideal)"
  * "RatSols(Ideal,List)"
  * "RatSols(Ideal,List,List)"
  * "RatSols(Ideal,RingElement)"
  * "RatSols(Ideal,RingElement,List)"

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

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

ReducedB -- a strategy option for global b-functions
****************************************************

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

see globalBFunction,

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

The object ReducedB, is a symbol (Macaulay2Doc).

reiffen -- Reiffen's curve
**************************

Synopsis
========

  * Usage:
        reiffen(p,q)
  * Inputs:
      * p, an integer (Macaulay2Doc),
      * q, an integer (Macaulay2Doc),
  * Outputs:
      * a ring element (Macaulay2Doc), the defining
        polynomial of Reiffen's (p,q)-curve

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

Reiffen's (p,q)-curve is a singular curve defined by $f_{p,q} =
x_1^p+x_2^q+x_1x_2^{q-1} = 0$ for $p>=4$ and $q>=p+1$.

+-------------------+
|i1 : reiffen(4,5)  |
|                   |
|        4    5    4|
|o1 = x x  + x  + x |
|      1 2    2    1|
|                   |
|o1 : QQ[x ..x ]    |
|         1   2     |
+-------------------+

Ways to use reiffen :
=====================

  * "reiffen(ZZ,ZZ)"

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

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

Schreyer -- strategy for computing a resolution of a D-module
*************************************************************

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

The object Schreyer, is a symbol (Macaulay2Doc).

setHomSwitch(Boolean) -- toggles the use of homogeneous Weyl algebra
********************************************************************

Synopsis
========

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

See also
========

  * getHomSwitch -- (internal) -- get the HOMOGENIZATION
    switch

Ways to use this method:
========================

  * setHomSwitch(Boolean) -- toggles the use
    of homogeneous Weyl algebra

SetVariables -- name for an optional argument
*********************************************

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

A symbol used as the name of an optional argument, for some function(s).

Functions with optional argument named SetVariables :
=====================================================

  * "makeWeylAlgebra(...,SetVariables=>...)" -- see makeWeylAlgebra,
    -- Weyl algebra corresponding to a polynomial ring

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

The object SetVariables, is a symbol (Macaulay2Doc).

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

Synopsis
========

  * Usage:
        singLocus M
        singLocus 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
singular point of an ODE. Geometrically, the singular locus of a D-module M
equals the projection of the characteristic variety of M minus the zero section
of the cotangent bundle to the base affine space C ^n.  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 variables|
+---------------------------------------------+
|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 : singLocus I                             |
|                                             |
|o3 = ideal y                                 |
|                                             |
|o3 : Ideal of QQ[x..y, dx, dy]               |
+---------------------------------------------+

See also
========

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

Ways to use singLocus :
=======================

  * "singLocus(Ideal)"
  * "singLocus(Module)"

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

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

solveFrobeniusIdeal -- solving Frobenius ideals
***********************************************

Synopsis
========

  * Usage:
        solveFrobeniusIdeal I
  * Inputs:
      * I, a Frobenius ideal which is m-primary
  * Outputs:
      * a list (Macaulay2Doc), a list of polynomials in logarithms
        of the variable

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

See [SST (see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ),
Algorithm 2.3.14].

Here is [SST (see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ),
Example 2.3.16]:

+-----------------------------------------------------------------------------+
|i1 : R = QQ[t_1..t_5];                                                       |
+-----------------------------------------------------------------------------+
|i2 : I = ideal(R_0+R_1+R_2+R_3+R_4, R_0+R_1-R_3, R_1+R_2-R_3, R_0*R_2,       |
|                                                                             |
|o2 : Ideal of R                                                              |
|-----------------------------------------------------------------------------|
|R_1*R_3);                                                                    |
+-----------------------------------------------------------------------------+
|i3 : netList solveFrobeniusIdeal I                                           |
|                                                                             |
|     +-----------------------------------------------------------------------|
|o3 = |1                                                                      |
|     +-----------------------------------------------------------------------|
|     |- 2t  + 3t  - 2t  + t                                                  |
|     |    1     2     3    4                                                 |
|     +-----------------------------------------------------------------------|
|     |- t  + t  - t  + t                                                     |
|     |   1    2    3    5                                                    |
|     +-----------------------------------------------------------------------|
|     |1       1 2   1       1       1       1 2   1       1       1       3  |
|     |-t t  - -t  + -t t  + -t t  + -t t  + -t  - -t t  - -t t  - -t t  - -t |
|     |4 1 2   8 2   4 2 3   4 1 4   4 3 4   8 4   2 1 5   4 2 5   2 3 5   4 4|
|     +-----------------------------------------------------------------------|
|-----------------------------------------------------------------------------|
|-------+                                                                     |
|       |                                                                     |
|-------+                                                                     |
|       |                                                                     |
|       |                                                                     |
|-------+                                                                     |
|       |                                                                     |
|       |                                                                     |
|-------+                                                                     |
|      2|                                                                     |
|t  + t |                                                                     |
| 5    5|                                                                     |
|-------+                                                                     |
+-----------------------------------------------------------------------------+

Ways to use solveFrobeniusIdeal :
=================================

  * "solveFrobeniusIdeal(Ideal)"

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

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

Special
*******

See also
========

  * DExt -- Ext groups between holonomic modules

Functions with optional argument named Special :
================================================

  * DExt(...,Special=>...)

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

The object Special, is a symbol (Macaulay2Doc).

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

Synopsis
========

  * 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)<dx>)

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

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

+---------------------------------------------------------+
|i1 : makeWA(QQ[x_1..x_4])                                |
|                                                         |
|o1 = QQ[x ..x , dx ..dx ]                                |
|         1   4    1    4                                 |
|                                                         |
|o1 : PolynomialRing, 4 differential variables            |
+---------------------------------------------------------+
|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).

toricIdealPartials -- image of a monomial map
*********************************************

Synopsis
========

  * Usage:
        toricIdealPartials(A,D)
  * Inputs:
      * A, a matrix (Macaulay2Doc), a matrix over ZZ whose
        columns give the coefficients of a monomial map
      * D, a polynomial ring (Macaulay2Doc), the
        corresponding Weyl algebra
  * Outputs:
      * an ideal (Macaulay2Doc), the toric ideal of the image the
        monomial map described by A formed in the polynomial ring generated by
        the differential variables of D.

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

+---------------------------------------------+
|i1 : A = matrix{{1,1,1},{0,1,2}}             |
|                                             |
|o1 = | 1 1 1 |                               |
|     | 0 1 2 |                               |
|                                             |
|              2        3                     |
|o1 : Matrix ZZ  <--- ZZ                      |
+---------------------------------------------+
|i2 : D = makeWA(QQ[x_1..x_3])                |
|                                             |
|o2 = D                                       |
|                                             |
|o2 : PolynomialRing, 3 differential variables|
+---------------------------------------------+
|i3 : toricIdealPartials(A,D)                 |
|                                             |
|               2                             |
|o3 = ideal(- dx  + dx dx )                   |
|               2     1  3                    |
|                                             |
|o3 : Ideal of QQ[dx ..dx ]                   |
|                   1    3                    |
+---------------------------------------------+

Ways to use toricIdealPartials :
================================

  * "toricIdealPartials(Matrix,PolynomialRing)"

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

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

TransferCycles -- a key in the hashtable created by deRham
**********************************************************

See also
========

  * deRham -- deRham cohomology groups for the complement of a
    hypersurface

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

The object TransferCycles, is a symbol (Macaulay2Doc).

TryGeneric -- a strategy option for b-functions
***********************************************

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

see bFunction,

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

The object TryGeneric, is a symbol (Macaulay2Doc).

twistInvMap -- a key attached by ExternalProduct
************************************************

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

see ExternalProduct,

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

The object twistInvMap, is a symbol (Macaulay2Doc).

TwistMap -- indicates whether TwistMap should be computed
*********************************************************

Functions with optional argument named TwistMap :
=================================================

  * ExternalProduct(...,TwistMap=>...)
    -- indicates whether
    TwistMap should be computed

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

The object TwistMap, is a symbol (Macaulay2Doc).

twistMap -- a key attached by ExternalProduct
*********************************************

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

see ExternalProduct,

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

The object twistMap, is a symbol (Macaulay2Doc).

Vars
****

Functions with optional argument named Vars :
=============================================

  * "AppellF1(...,Vars=>...)"

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

The object Vars, is a symbol (Macaulay2Doc).

Vhomogenize -- strategy for computing a resolution of a D-module
****************************************************************

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

The object Vhomogenize, is a symbol (Macaulay2Doc).

ViaAnnFs -- a strategy option for global b-functions
****************************************************

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

see globalBFunction,

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

The object ViaAnnFs, is a symbol (Macaulay2Doc).

ViaBFunction -- a strategy option for lct
*****************************************

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

see lct,

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

The object ViaBFunction, is a symbol (Macaulay2Doc).

ViaColonIdeal
*************

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

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

ViaElimination
**************

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

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

ViaLinearAlgebra -- an option for generalB=>Strategy
****************************************************

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

see generalB,

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

The object ViaLinearAlgebra, is a symbol (Macaulay2Doc).

VResolution -- a key in the hashtable created by Drestriction/Dintegration
**************************************************************************

See also
========

  * Drestriction -- restriction modules of a D-module
  * Dintegration -- integration modules of a D-module

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

The object VResolution, is a symbol (Macaulay2Doc).

Walther -- an option for localCohom=>Strategy
*********************************************

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

see localCohom,

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

The object Walther, is a symbol (Macaulay2Doc).

WeylClosure -- Weyl closure of an ideal
***************************************

Synopsis
========

  * Usage:
        WeylClosure I
        WeylClosure(I,f)
  * Inputs:
      * I, an ideal (Macaulay2Doc), a left ideal of the Weyl
        Algebra
      * f, a ring element (Macaulay2Doc), a polynomial
  * Outputs:
      * an ideal (Macaulay2Doc), the Weyl closure (w.r.t. $f$) of
        $I$

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

Let $D$ be the Weyl algebra with generators $x_1,\dots,x_n$ and
$\partial_1,\dots,\partial_n$ over a field $K$ of characteristic zero, and
denote $R = K(x_1..x_n)<\partial_1..\partial_n>$, the ring of differential
operators with rational function coefficients. The Weyl closure of an ideal $I$
in $D$ is the intersection of the extended ideal $R I$ with $D$.  It consists
of all operators which vanish on the common holomorphic solutions of $D$ and is
thus analogous to the radical operation on a commutative ideal.

The partial Weyl closure of $I$ with respect to a polynomial $f$ is the
intersection of the extended ideal $D[f^{-1}] I$ with $D$.

The Weyl closure is computed by localizing $D/I$ with respect to a polynomial
$f$ vanishing on the singular locus, and computing the kernel of the map $D \to
D/I \to (D/I)[f^{-1}]$.

+------------------------------------------------+
|i1 : makeWA(QQ[x])                              |
|                                                |
|o1 = QQ[x, dx]                                  |
|                                                |
|o1 : PolynomialRing, 1 differential variables   |
+------------------------------------------------+
|i2 : I = ideal(x*dx-2)                          |
|                                                |
|o2 = ideal(x*dx - 2)                            |
|                                                |
|o2 : Ideal of QQ[x, dx]                         |
+------------------------------------------------+
|i3 : holonomicRank I                            |
|                                                |
|o3 = 1                                          |
+------------------------------------------------+
|i4 : WeylClosure I                              |
|                                                |
|                                  3      2      |
|o4 = ideal (x*dx - 2, x*dx - 2, dx , x*dx  - dx)|
|                                                |
|o4 : Ideal of QQ[x, dx]                         |
+------------------------------------------------+

Caveat
======

The ideal I should be of finite holonomic rank, which can be tested manually by
using the function holonomicRank. The Weyl closure of non-finite rank ideals or
arbitrary submodules has not been implemented.

See also
========

  * Dlocalize -- localization of a D-module
  * singLocus -- singular locus of a D-module
  * holonomicRank -- rank of a D-module

Ways to use WeylClosure :
=========================

  * "WeylClosure(Ideal)"
  * "WeylClosure(Ideal,RingElement)"

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

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