This is BernsteinSato.info, produced by Macaulay2, version 1.25.11

BernsteinSato -- algorithms for b-functions, local cohomology, and intersection cohomology
******************************************************************************************

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

B-functions

  * bFunction -- b-function
  * generalB -- global generalized
    Bernstein-Sato polynomial
  * globalB -- compute global
    b-function and b-operator for a D-module and a polynomial
  * globalBFunction -- global
    b-function (else known as the Bernstein-Sato polynomial)
  * globalBoperator -- compute a
    b-operator of a polynomial
  * localBFunction -- local
    b-function (a.k.a. the local Bernstein-Sato polynomial)
  * factorBFunction -- factorization
    of a b-function
  * bFunctionRoots -- get roots of a
    b-function
  * getIntRoots -- get integer roots of a
    b-function
  * paramBpoly -- compute the list
    of all possible Bernstein-Sato polynomials for a parametric polynomial
  * AnnFs -- differential annihilator of a polynomial in a Weyl
    algebra
  * AnnIFs -- the annihilating ideal of
    f^s 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
  * polynomialExt -- Ext groups between a holonomic
    module and a polynomial ring
  * rationalFunctionExt -- 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
  * polynomialSolutions -- polynomial solutions of
    a holonomic system
  * rationalFunctionSolutions -- rational
    solutions of a holonomic system
  * populateCechComplexCC, --
    Cech complex skeleton for the computation of the characteristic cycles of
    local cohomology modules
  * pruneCechComplexCC, --
    reduction of the Cech complex that produces characteristic cycles of local
    cohomology modules
  * logCohomology -- logarithmic
    cohomology groups in two variables
  * Multiplier Ideals
      * lct -- compute the log canonical threshold for
        an ideal
      * multiplierIdeal -- multiplier
        ideal
      * isInMultiplierIdeal
        -- multiplier ideal
        membership test
      * jumpingCoefficients -- jumping
        coefficients and corresponding multiplier ideals
      * hasRationalSing -- check if a
        complete intersection has at most rational singularities

Authors
=======

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

Version
=======

This documentation describes version 1.0 of BernsteinSato, released February
2023.

Citation
========

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

+----------------------------------------------------------------------------+
|@misc{BernsteinSatoSource,                                                  |
|  title = {{BernsteinSato: Bernstein-Sato. Version~1.0}},                   |
|  author = {Anton Leykin and Harrison Tsai},                                |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * AnnFs -- differential annihilator of a polynomial in a
        Weyl algebra
      * "AnnIFs" -- see AnnIFs(Ideal,RingElement),
        -- the annihilating ideal of f^s for
        an arbitrary D-module
      * bFunction -- b-function
      * "bFunctionRoots" -- see bFunctionRoots(RingElement),
        -- get roots of a b-function
      * 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
      * diffRatFun -- derivative of a rational function in a
        Weyl algebra
      * 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
      * Dlocalize -- localization of a D-module
      * DlocalizeAll -- localization of a D-module
        (extended version)
      * DlocalizeMap -- localization map from a D-module
        to its localization
      * Dresolution -- resolution of a D-module
      * 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
      * ExternalProduct -- external product of modules
        or complexes
      * "factorBFunction" -- see factorBFunction(RingElement),
        -- factorization of a b-function
      * "generalB" -- see generalB(List,RingElement),
        -- global generalized Bernstein-Sato
        polynomial
      * "getIntRoots" -- see getIntRoots(RingElement),
        -- get integer roots of a b-function
      * "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
      * IHmodule -- intersection (co)homology module of an
        irreducible closed subvariety
      * intersectionCohomology -- intersection
        cohomology of an irreducible affine variety
      * "isInMultiplierIdeal" -- see
        isInMultiplierIdeal(RingElement,Ideal,QQ),
        -- multiplier ideal
        membership test
      * "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
      * localizeCharacteristicCycle -- the
        characteristic cycle of the localized $D$-module
      * "logCohomology" -- see logCohomology(RingElement),
        -- logarithmic cohomology groups in two
        variables
      * "multiplierIdeal" -- see multiplierIdeal(Ideal,QQ),
        -- multiplier ideal
      * "paramBpoly" -- see paramBpoly(RingElement,File),
        -- compute the list of all possible
        Bernstein-Sato polynomials for a parametric polynomial
      * polynomialAnnihilator -- annihilator of a
        polynomial in the Weyl algebra
      * polynomialExt -- Ext groups between a holonomic
        module and a polynomial ring
      * polynomialSolutions -- 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
      * rationalFunctionAnnihilator, --
        annihilator of a rational function in Weyl algebra
      * rationalFunctionExt -- Ext(holonomic
        D-module, polynomial ring localized at the singular locus)
      * rationalFunctionSolutions -- rational
        solutions of a holonomic system
      * reiffen -- Reiffen's curve
      * WeylClosure -- Weyl closure of an ideal
  * Methods
      * "AnnFs(RingElement)" -- see AnnFs, -- differential
        annihilator of a polynomial in a Weyl algebra
      * AnnIFs(Ideal,RingElement), --
        the annihilating ideal of f^s for an arbitrary D-module
      * 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
      * "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
      * deRham(Ideal) (missing documentation)
      * deRham(ZZ,Ideal) (missing documentation)
      * 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
      * "diffRatFun(List,RingElement)" -- see diffRatFun, --
        derivative of a rational function in a Weyl algebra
      * "diffRatFun(List,RingElement,RingElement,ZZ)" -- see diffRatFun,
        -- derivative of a rational function in a Weyl algebra
      * "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
      * "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
      * "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
      * "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
      * "ExternalProduct(ChainComplex,ChainComplex)" -- see
        ExternalProduct, -- external product of modules or
        complexes
      * "ExternalProduct(Module,Module)" -- see ExternalProduct,
        -- external product of modules or complexes
      * factorBFunction(RingElement),
        -- factorization of a b-function
      * "generalB(List)" -- see generalB(List,RingElement),
        -- global generalized Bernstein-Sato
        polynomial
      * generalB(List,RingElement), --
        global generalized Bernstein-Sato polynomial
      * getIntRoots(RingElement) -- get
        integer roots of a b-function
      * 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
      * "IHmodule(Ideal)" -- see IHmodule, -- intersection
        (co)homology module of an irreducible closed subvariety
      * "intersectionCohomology(Ideal)" -- see intersectionCohomology,
        -- intersection cohomology of an irreducible
        affine variety
      * "intersectionCohomology(ZZ,Ideal)" -- see intersectionCohomology,
        -- intersection cohomology of an irreducible
        affine variety
      * isInMultiplierIdeal(RingElement,Ideal,QQ)
        -- multiplier ideal
        membership test
      * 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
      * "localizeCharacteristicCycle(Ideal,RingElement)" -- see
        localizeCharacteristicCycle, -- the
        characteristic cycle of the localized $D$-module
      * "localizeCharacteristicCycle(List,RingElement)" -- see
        localizeCharacteristicCycle, -- the
        characteristic cycle of the localized $D$-module
      * logCohomology(RingElement), --
        logarithmic cohomology groups in two variables
      * "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,File),
        -- compute the list of all possible Bernstein-Sato polynomials for a
        parametric polynomial
      * "polynomialAnnihilator(RingElement)" -- see
        polynomialAnnihilator, -- annihilator of a
        polynomial in the Weyl algebra
      * "polynomialExt(Ideal)" -- see polynomialExt, --
        Ext groups between a holonomic module and a polynomial ring
      * "polynomialExt(Module)" -- see polynomialExt, --
        Ext groups between a holonomic module and a polynomial ring
      * "polynomialExt(ZZ,Ideal)" -- see polynomialExt, --
        Ext groups between a holonomic module and a polynomial ring
      * "polynomialExt(ZZ,Module)" -- see polynomialExt,
        -- Ext groups between a holonomic module and a polynomial ring
      * "polynomialSolutions(Ideal)" -- see polynomialSolutions,
        -- polynomial solutions of a holonomic system
      * "polynomialSolutions(Ideal,List)" -- see polynomialSolutions,
        -- polynomial solutions of a holonomic system
      * "polynomialSolutions(Module)" -- see polynomialSolutions,
        -- polynomial solutions of a holonomic system
      * "polynomialSolutions(Module,List)" -- see polynomialSolutions,
        -- 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
      * "rationalFunctionAnnihilator(RingElement)" -- see
        rationalFunctionAnnihilator, --
        annihilator of a rational function in Weyl algebra
      * "rationalFunctionAnnihilator(RingElement,RingElement)" -- see
        rationalFunctionAnnihilator, --
        annihilator of a rational function in Weyl algebra
      * "rationalFunctionExt(Ideal)" -- see rationalFunctionExt,
        -- Ext(holonomic D-module, polynomial ring
        localized at the singular locus)
      * "rationalFunctionExt(Ideal,RingElement)" -- see
        rationalFunctionExt, -- Ext(holonomic D-module,
        polynomial ring localized at the singular locus)
      * "rationalFunctionExt(Module)" -- see rationalFunctionExt,
        -- Ext(holonomic D-module, polynomial ring
        localized at the singular locus)
      * "rationalFunctionExt(Module,RingElement)" -- see
        rationalFunctionExt, -- Ext(holonomic D-module,
        polynomial ring localized at the singular locus)
      * "rationalFunctionExt(ZZ,Ideal)" -- see rationalFunctionExt,
        -- Ext(holonomic D-module, polynomial ring
        localized at the singular locus)
      * "rationalFunctionExt(ZZ,Ideal,RingElement)" -- see
        rationalFunctionExt, -- Ext(holonomic D-module,
        polynomial ring localized at the singular locus)
      * "rationalFunctionExt(ZZ,Module)" -- see rationalFunctionExt,
        -- Ext(holonomic D-module, polynomial ring
        localized at the singular locus)
      * "rationalFunctionExt(ZZ,Module,RingElement)" -- see
        rationalFunctionExt, -- Ext(holonomic D-module,
        polynomial ring localized at the singular locus)
      * "rationalFunctionSolutions(Ideal)" -- see
        rationalFunctionSolutions, -- rational
        solutions of a holonomic system
      * "rationalFunctionSolutions(Ideal,List)" -- see
        rationalFunctionSolutions, -- rational
        solutions of a holonomic system
      * "rationalFunctionSolutions(Ideal,List,List)" -- see
        rationalFunctionSolutions, -- rational
        solutions of a holonomic system
      * "rationalFunctionSolutions(Ideal,RingElement)" -- see
        rationalFunctionSolutions, -- rational
        solutions of a holonomic system
      * "rationalFunctionSolutions(Ideal,RingElement,List)" -- see
        rationalFunctionSolutions, -- rational
        solutions of a holonomic system
      * "reiffen(ZZ,ZZ)" -- see reiffen, -- Reiffen's curve
      * "WeylClosure(Ideal)" -- see WeylClosure, -- Weyl
        closure of an ideal
      * "WeylClosure(Ideal,RingElement)" -- see WeylClosure,
        -- Weyl closure of an ideal
  * Symbols
      * Alg
      * BFunction -- a key in the hashtable created by
        Drestriction/Dintegration
      * "IntRing" -- see bFunction(...,Strategy=>...),
        -- specify strategy for
        computing b-function
      * "NonGeneric" -- see bFunction(...,Strategy=>...),
        -- specify strategy for
        computing b-function
      * "TryGeneric" -- see bFunction(...,Strategy=>...),
        -- specify strategy for
        computing b-function
      * 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
      * "annFS" -- see DlocalizeAll, -- localization of a
        D-module (extended version)
      * "Bfunction" -- see DlocalizeAll, -- localization of
        a D-module (extended version)
      * "GeneratorPower" -- see DlocalizeAll, --
        localization of a D-module (extended version)
      * "IntegrateBfunction" -- see DlocalizeAll, --
        localization of a D-module (extended version)
      * "LocMap" -- see DlocalizeAll, -- localization of a
        D-module (extended version)
      * "LocModule" -- see DlocalizeAll, -- localization of
        a D-module (extended version)
      * Duality -- an option for polynomialSolutions=>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 polynomialSolutions=>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
      * "ReducedB" -- see globalBFunction(...,Strategy=>...),
        -- specify
        strategy for computing global b-function
      * "ViaAnnFs" -- see globalBFunction(...,Strategy=>...),
        -- specify
        strategy for computing global b-function
      * HomologyModules -- a key in a hashtable; an
        option of DExt
      * "LocCohomStrategy" -- see IHmodule, -- intersection
        (co)homology module of an irreducible closed subvariety
      * Info
      * IntegrateComplex -- a key in the hashtable
        created by Dintegration
      * "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
      * LocStrategy
      * None -- an option for DExt=>Special
      * OaTa -- an option for localCohom=>Strategy
      * OaTaWa -- an option for localCohom => LocStrategy
      * OmegaRes -- a key in the hashtable created by deRham
      * Output
      * PreCycles -- a key in the hashtable created by deRham
      * projMap1 -- a key attached by ExternalProduct
      * projMap2 -- a key attached by ExternalProduct
      * Schreyer -- strategy for computing a resolution of a
        D-module
      * Special
      * TransferCycles -- a key in the hashtable created
        by deRham
      * twistInvMap -- a key attached by ExternalProduct
      * TwistMap -- indicates whether TwistMap should be
        computed
      * twistMap -- a key attached by ExternalProduct
      * Vhomogenize -- strategy for computing a resolution
        of a D-module
      * 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
  * Other things
      * IH -- intersection cohomology of an
        irreducible affine variety

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

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

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

The source of this document is in BernsteinSato/DOC/main.m2:52:0.

Alg
***

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

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

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

The object Alg, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:273:0.

AnnFs -- differential annihilator of a polynomial in a Weyl algebra
*******************************************************************

  * Usage:
        AnnFs(f)
  * Inputs:
      * f, a ring element (Macaulay2Doc), polynomial in a
        Weyl algebra $D$
  * Outputs:
      * an ideal (Macaulay2Doc), the differential annihilator of
        $f$ in $D[s]$, for a new variable $s$.

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

This routine computes the ideal of the differential annihilator of a
polynomial. This ideal is a left ideal of the ring $D[s]$.  More details can be
found in [SST (see https://mathscinet.ams.org/mathscinet/pdf/1734566.pdf ),
Chapter 5]. The computation in the case of the element $f$ is via  Algorithm
5.3.6.

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

Caveat
======

Must be over a ring of characteristic $0$.

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

  * "AnnFs(RingElement)"

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

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

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

The source of this document is in BernsteinSato/DOC/annFs.m2:28:0.

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

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

        D-module A /I (the ideal is expected to be f-saturated; one may use
                  n
        WeylClosure, if it is not)
      * 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 variable(s)|
+-----------------------------------------------+
|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 -- differential annihilator of a polynomial in a Weyl
    algebra
  * WeylAlgebra (Macaulay2Doc)
    -- specify differential operators in the ring
  * WeylClosure -- Weyl closure of an ideal

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

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

The source of this document is in BernsteinSato/DOC/annFs.m2:56:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:281:0.

bFunction -- 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).

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:9:0.

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:41:0.

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

  * 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 (WeylAlgebras),(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 variable(s)              |
+-------------------------------------------------------------+
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:80:0.

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

  * 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 variable(s)                  |
+-----------------------------------------------------------------+
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:117:0.

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

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:311:0.

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).

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:341:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:271:0.

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

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

see globalB,

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

The object Bpolynomial, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:346:0.

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).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:297:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:266:0.

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

  * 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 (WeylAlgebras) -- dimension of a D-module
  * Dtransposition (WeylAlgebras) -- standard
    transposition for Weyl algebra

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

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

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

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:144:0.

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

  * 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,
  * 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).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:287:0.

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

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

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:255:0.

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

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

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:260:0.

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

  * Function: deRhamAll,
  * Usage:
        deRhamAll f
  * Inputs:
      * f, a ring element (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Strategy, => ...,
        default value Schreyer,
  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:249:0.

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

  * 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,
      * Output, => ..., default
        value HomologyModules,
      * Special, => ...,
        default value None,
      * Strategy, => ...,
        default value Schreyer,
  * 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 variable(s)|
+-----------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:116:0.

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

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

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

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:74:0.

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

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

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

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:68:0.

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

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

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

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:57:0.

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

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

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:54:0.

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

  * 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,
  * 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 variable(s)|
+-----------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:48:0.

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

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

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:6:0.

diffRatFun -- derivative of a rational function in a Weyl algebra
*****************************************************************

  * Usage:
        diffRatFun(m,f)
        diffRatFun(m,g,f,a)
  * Inputs:
      * f, a ring element (Macaulay2Doc), polynomial in a
        Weyl algebra $D$ in $n$ variables or rational function in the fraction
        field of a polynomial ring in $n$ variables
      * g, a ring element (Macaulay2Doc), polynomial in a
        Weyl algebra $D$ in $n$ variables
      * m, a list (Macaulay2Doc), of nonnegative integers $m =
        \{m_1,...,m_n\}$
      * a, an integer (Macaulay2Doc), an integer
  * Outputs:
      * a ring element (Macaulay2Doc), the result of
        applying the product of the $(dx_i)^{m_i}$ to $f$
      * a list (Macaulay2Doc), the result of applying the product
        of the $(dx_i)^{m_i}$ to $g/f^a$, written as
        (numerator,denominator,power of denominator)

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

Let $D$ be a Weyl algebra in the variables $x_1,..x_n$ and partials
$dx_1,..,dx_n$.  Let $f$ be either a polynomial or rational function in the
$x_i$ and $m = (m_1,..,m_n)$ a list of nonnegative integers.  The function $f$
may be given as an element of a polynomial ring in the $x_i$ or of the fraction
field of that polynomial ring or of $D$.  This method applies the product of
the $dx_i^{m_i}$ to $f$. In the case of the input $(m,g,f,a)$, where $f \neq 0$
and $g$ are both polynomials and $a$ is a nonnegative integer, it applies the
product of the $dx_i^{m_i}$ to $g/f^a$ and returns the resulting derivative as
(numerator,denominator,power of denominator), not necessarily in lowest terms.

+--------------------+
|i1 : QQ[x,y,z]      |
|                    |
|o1 = QQ[x..z]       |
|                    |
|o1 : PolynomialRing |
+--------------------+
|i2 : m = {1,1,0}    |
|                    |
|o2 = {1, 1, 0}      |
|                    |
|o2 : List           |
+--------------------+
|i3 : f = x^2*y+z^5  |
|                    |
|      5    2        |
|o3 = z  + x y       |
|                    |
|o3 : QQ[x..z]       |
+--------------------+
|i4 : diffRatFun(m,f)|
|                    |
|o4 = 2x             |
|                    |
|o4 : QQ[x..z]       |
+--------------------+
+-----------------------------------------------+
|i5 : makeWA(QQ[x,y,z])                         |
|                                               |
|o5 = QQ[x..z, dx, dy, dz]                      |
|                                               |
|o5 : PolynomialRing, 3 differential variable(s)|
+-----------------------------------------------+
|i6 : m = {1,1,0}                               |
|                                               |
|o6 = {1, 1, 0}                                 |
|                                               |
|o6 : List                                      |
+-----------------------------------------------+
|i7 : f = x^2*y+z^5                             |
|                                               |
|      5    2                                   |
|o7 = z  + x y                                  |
|                                               |
|o7 : QQ[x..z, dx, dy, dz]                      |
+-----------------------------------------------+
|i8 : diffRatFun(m,f)                           |
|                                               |
|o8 = 2x                                        |
|                                               |
|o8 : QQ[x..z, dx, dy, dz]                      |
+-----------------------------------------------+
+---------------------+
|i9 : frac(QQ[x,y])   |
|                     |
|o9 = frac(QQ[x..y])  |
|                     |
|o9 : FractionField   |
+---------------------+
|i10 : m = {1,2}      |
|                     |
|o10 = {1, 2}         |
|                     |
|o10 : List           |
+---------------------+
|i11 : f = x/y        |
|                     |
|      x              |
|o11 = -              |
|      y              |
|                     |
|o11 : frac(QQ[x..y]) |
+---------------------+
|i12 : diffRatFun(m,f)|
|                     |
|       2             |
|o12 = --             |
|       3             |
|      y              |
|                     |
|o12 : frac(QQ[x..y]) |
+---------------------+
+------------------------------------------------+
|i13 : makeWA(QQ[x,y,z])                         |
|                                                |
|o13 = QQ[x..z, dx, dy, dz]                      |
|                                                |
|o13 : PolynomialRing, 3 differential variable(s)|
+------------------------------------------------+
|i14 : m = {1,2,1}                               |
|                                                |
|o14 = {1, 2, 1}                                 |
|                                                |
|o14 : List                                      |
+------------------------------------------------+
|i15 : g = z                                     |
|                                                |
|o15 = z                                         |
|                                                |
|o15 : QQ[x..z, dx, dy, dz]                      |
+------------------------------------------------+
|i16 : f = x*y                                   |
|                                                |
|o16 = x*y                                       |
|                                                |
|o16 : QQ[x..z, dx, dy, dz]                      |
+------------------------------------------------+
|i17 : a = 3                                     |
|                                                |
|o17 = 3                                         |
+------------------------------------------------+
|i18 : diffRatFun(m,g,f,a)                       |
|                                                |
|           3 2                                  |
|o18 = (-36x y , x*y, 7)                         |
|                                                |
|o18 : Sequence                                  |
+------------------------------------------------+

Caveat
======

Must be over a ring of characteristic $0$.

Ways to use diffRatFun:
=======================

  * "diffRatFun(List,RingElement)"
  * "diffRatFun(List,RingElement,RingElement,ZZ)"

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

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

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

The source of this document is in BernsteinSato/DOC/annFs.m2:119:0.

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

  * 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,
  * 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 variable(s)              |
+-------------------------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:345:0.

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

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

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:298:0.

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

  * 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,
  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:398:0.

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

  * 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,
  * 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 variable(s)              |
+-------------------------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:458:0.

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

  * 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,
  * 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 variable(s)              |
+-------------------------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:425:0.

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

  * 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,
  * 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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:370:0.

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

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

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)"
  * "DintegrationClasses(...,Strategy=>...)"
  * "DintegrationComplex(...,Strategy=>...)"
  * DintegrationIdeal(...,Strategy=>...)
  * "Drestriction(...,Strategy=>...)"
  * "DrestrictionAll(...,Strategy=>...)"
  * "DrestrictionClasses(...,Strategy=>...)"
  * "DrestrictionComplex(...,Strategy=>...)"
  * "DrestrictionIdeal(...,Strategy=>...)"
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:82:0.

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

  * 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 variable(s)     |
+----------------------------------------------------+
|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 -- differential annihilator of a polynomial in a Weyl
    algebra
  * 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).

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

The source of this document is in BernsteinSato/DOC/Dlocalize.m2:47:0.

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * Dlocalize(...,Strategy=>...)
    -- strategy for computing a
    localization of a D-module
  * "DlocalizeAll(...,Strategy=>...)"
  * "DlocalizeMap(...,Strategy=>...)"
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/Dlocalize.m2:12:0.

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

  * 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 module $M_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$.

The keys of the output HashTable depend on which strategy is used. Common to
each strategy are the keys LocMap and LocModule, which have the localization
map and the localized module, respectively; and GeneratorPower, which is an
integer $s$ such that (the images of) the generators of $M$ are $f^{-s}$ times
the generators of $M_f$.

+-----------------------------------------------------------------------------+
|i1 : W = makeWeylAlgebra(QQ[x,y])                                            |
|                                                                             |
|o1 = W                                                                       |
|                                                                             |
|o1 : PolynomialRing, 2 differential variable(s)                              |
+-----------------------------------------------------------------------------+
|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 : Mfall = 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                                                               |
+-----------------------------------------------------------------------------+
|i5 : gens image Mfall.LocMap == f^(-Mfall.GeneratorPower) * gens             |
|                                                                             |
|o5 = true                                                                    |
|-----------------------------------------------------------------------------|
|Mfall.LocModule                                                              |
+-----------------------------------------------------------------------------+

See also
========

  * Dlocalize -- localization of a D-module
  * AnnFs -- differential annihilator of a polynomial in a Weyl
    algebra
  * 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).

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

The source of this document is in BernsteinSato/DOC/Dlocalize.m2:119:0.

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

  * 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 variable(s)     |
+----------------------------------------------------+
|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 -- differential annihilator of a polynomial in a Weyl
    algebra
  * 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).

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

The source of this document is in BernsteinSato/DOC/Dlocalize.m2:70:0.

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

  * 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 (OldChainComplexes), 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 variable(s)              |
+-------------------------------------------------------------+
|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 (WeylAlgebras) -- compute a Gröbner basis with respect to a
    weight vector
  * 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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:71:0.

Dresolution(...,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.

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

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

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

  * Default value: infinity (Macaulay2Doc),
  * Function: Dresolution, -- resolution of a D-module
  * Option key: LengthLimit (Macaulay2Doc), -- an optional
    argument
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/Drestriction.m2:17:0.

Dresolution(...,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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:11:0.

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

  * 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,
  * 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 variable(s)              |
+-------------------------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:132:0.

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

  * 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,
  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:185:0.

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

  * 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,
  * 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 variable(s)              |
+-------------------------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:245:0.

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

  * 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,
  * 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 variable(s)              |
+-------------------------------------------------------------+
|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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:212:0.

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

  * 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,
  * 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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:157:0.

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

See also
========

  * polynomialSolutions -- polynomial solutions of
    a holonomic system

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

The object Duality, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:291:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:286:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:261:0.

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

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

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

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

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

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

The source of this document is in BernsteinSato/DOC/other.m2:112:0.

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

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

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/other.m2:116:0.

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

  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:285:0.

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

See also
========

  * polynomialSolutions -- polynomial solutions of
    a holonomic system

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

The object GD, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:286:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:256:0.

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

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

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

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

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

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

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:220:0.

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''.

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:215:0.

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

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:203:0.

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

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

see lct,globalBFunction.

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

The object GeneralBernsteinSato, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:255:0.

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

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:298:0.

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

  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:336:0.

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:141:0.

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

  * 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)
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:176:0.

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

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:351:0.

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

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/multiplierIdeals.m2:81:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:251:0.

IHmodule -- intersection (co)homology module of an irreducible closed subvariety
********************************************************************************

  * Usage:
        IHmodule(I)
  * Inputs:
      * I, an ideal (Macaulay2Doc), ideal in the polynomial ring
        $R$
  * Optional inputs (Macaulay2Doc),:
      * LocCohomStrategy => a sequence (Macaulay2Doc), default
        value (Walther,), (String, String); see
        localCohom(...,Strategy=>...),
        and
        localCohom(...,LocStrategy=>...),
      * LocStrategy => a string (Macaulay2Doc), default value
        OTW, see Dlocalize(...,Strategy=>...),
        or for regular
        sequence use CompleteIntersection
  * Outputs:
      * a module (Macaulay2Doc), the intersection cohomology
        $D$-module

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

This routine gives a presentation of the Brylinski-Kashiwara intersection
cohomology $D$-module of the closed subvariety defined by $I$. Via the
Riemann-Hilbert correspondence, this corresponds to the trivial local system on
the smooth locus of the variety.

+------------------------------------------------------------------------+
|i1 : R=QQ[x,y,z]                                                        |
|                                                                        |
|o1 = R                                                                  |
|                                                                        |
|o1 : PolynomialRing                                                     |
+------------------------------------------------------------------------+
|i2 : I=ideal(x^2+y^3)                                                   |
|                                                                        |
|            3    2                                                      |
|o2 = ideal(y  + x )                                                     |
|                                                                        |
|o2 : Ideal of R                                                         |
+------------------------------------------------------------------------+
|i3 : IHmodule(I)                                                        |
|                                                                        |
|o3 = subquotient (| 0  0  |, | dz -x 0  y2 -2ydy-6 0            |)      |
|                  | xy x2 |  | 0  y  dz x  -3ydx   -3xdx-2ydy-8 |       |
|                                                                        |
|                                                                       2|
|o3 : QQ[x..z, dx, dy, dz]-module, subquotient of (QQ[x..z, dx, dy, dz]) |
+------------------------------------------------------------------------+

When the given generators of $I$ form a regular sequence, use
LocStrategy=>CompleteIntersection for a generally faster algorithm, which
implements the determination of the IC module in terms of the fundamental class
as described in: D. Barlet and M. Kashiwara, Le réseau $L^2$ d’un système
holonome régulier, Invent. Math. 86 (1986), no. 1, 35–62.

+----------------------------------------------------------------+
|i4 : R=QQ[x,y]                                                  |
|                                                                |
|o4 = R                                                          |
|                                                                |
|o4 : PolynomialRing                                             |
+----------------------------------------------------------------+
|i5 : I=ideal(x^2+y^3)                                           |
|                                                                |
|            3    2                                              |
|o5 = ideal(y  + x )                                             |
|                                                                |
|o5 : Ideal of R                                                 |
+----------------------------------------------------------------+
|i6 : IHmodule(I, LocStrategy=>CompleteIntersection)             |
|                                                                |
|o6 = subquotient (| x |, | 3xdx+2ydy+6 3y2dx-2xdy y3+x2 |)      |
|                                                                |
|                                                               1|
|o6 : QQ[x..y, dx, dy]-module, subquotient of (QQ[x..y, dx, dy]) |
+----------------------------------------------------------------+

Caveat
======

Must be a ring of characteristic 0. The ideal $I$ should have only 1 minimal
prime.

Ways to use IHmodule:
=====================

  * "IHmodule(Ideal)"

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

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

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

The source of this document is in BernsteinSato/DOC/intersectionCohom.m2:84:0.

Info
****

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

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

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

The object Info, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:77:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:292:0.

intersectionCohomology -- intersection cohomology of an irreducible affine variety
**********************************************************************************

  * Usage:
        IH I
        intersectionCohomology(I)
        IH^d I
        intersectionCohomology(d,I)
  * Inputs:
      * I, an ideal (Macaulay2Doc), in the polynomial ring $R$
      * d, an integer (Macaulay2Doc), the degree
  * Optional inputs (Macaulay2Doc),:
      * Strategy => a string (Macaulay2Doc), default value
        Schreyer, see Dintegration(...,Strategy=>...),
      * LocCohomStrategy => a sequence (Macaulay2Doc), default
        value (Walther,), (String, String); see
        localCohom(...,Strategy=>...),
        and
        localCohom(...,LocStrategy=>...),
      * LocStrategy => a string (Macaulay2Doc), default value
        OTW, see IHmodule(...,LocStrategy=>...),
  * Outputs:
      * a hash table (Macaulay2Doc), a table including the
        intersection cohomology groups of the irreducible variety Spec($R/I$),
      * a module (Macaulay2Doc), the intersection cohomology
        group in degree d

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

This routine computes the middle intersection cohomology groups of the
irreducible variety defined by $I$ in the affine space Spec($R$).

+------------------------------+
|i1 : R=QQ[x,y]                |
|                              |
|o1 = R                        |
|                              |
|o1 : PolynomialRing           |
+------------------------------+
|i2 : I = ideal(x^2+y^3)       |
|                              |
|            3    2            |
|o2 = ideal(y  + x )           |
|                              |
|o2 : Ideal of R               |
+------------------------------+
|i3 : intersectionCohomology(I)|
|                              |
|                      1       |
|o3 = HashTable{0 => QQ }      |
|               1 => 0         |
|                              |
|o3 : HashTable                |
+------------------------------+

Caveat
======

Must be over a ring of characteristic 0. The ideal $I$ should have only 1
minimal prime.

Ways to use intersectionCohomology:
===================================

  * "intersectionCohomology(Ideal)"
  * "intersectionCohomology(ZZ,Ideal)"

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

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

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

The source of this document is in BernsteinSato/DOC/intersectionCohom.m2:84:0.

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

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/multiplierIdeals.m2:115:0.

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

  * 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)"
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/multiplierIdeals.m2:61:0.

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

  * 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 -- differential annihilator of a polynomial in a Weyl
    algebra

Ways to use kappaAnnF1PlanarCurve:
==================================

  * "kappaAnnF1PlanarCurve(RingElement)"

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

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

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

The source of this document is in BernsteinSato/DOC/paco-anton-paper.m2:54:0.

kOrderAnnFa -- k-th order D-annihilator of a power of a polynomial
******************************************************************

  * 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 -- differential annihilator of a polynomial in a Weyl
    algebra

Ways to use kOrderAnnFa:
========================

  * "kOrderAnnFa(ZZ,RingElement,ZZ)"

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

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

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

The source of this document is in BernsteinSato/DOC/paco-anton-paper.m2:88:0.

lct(...,Strategy=>...) -- specify strategy for computing lct
************************************************************

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

  * ViaBFunction -- use bFunction,
  * GeneralBernsteinSato -- use globalB,

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

  * Default value: GeneralBernsteinSato,
  * Function: lct, -- compute the log canonical threshold
    for an ideal
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:250:0.

lct(Ideal) -- compute the log canonical threshold for an ideal
**************************************************************

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:242:0.

localBFunction(RingElement,Ideal) -- local b-function (a.k.a. the local Bernstein-Sato polynomial)
**************************************************************************************************

  * 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)
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:375:0.

localCohom -- 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).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:84:0.

localCohom(...,LocStrategy=>...) -- specify localization strategy for local cohomology
**************************************************************************************

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

These strategies determine how presentations of localization in the Cech
complex are calculated when selecting Walther's strategy. See
localCohom(...,Strategy=>...),

Functions with optional argument named LocStrategy:
===================================================

  * "IHmodule(...,LocStrategy=>...)" -- see IHmodule, --
    intersection (co)homology module of an irreducible closed subvariety
  * "intersectionCohomology(...,LocStrategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * localCohom(...,LocStrategy=>...)
    -- specify localization
    strategy for local cohomology

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

  * Default value: null
  * Function: localCohom, -- local cohomology
  * Option key: LocStrategy,
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:51:0.

localCohom(...,Strategy=>...) -- specify strategy for local cohomology
**********************************************************************

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

There are two main strategies, Walther and OaTa. If the user selects Walther,
which is the default, then LocStrategy, determines the
localization 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 straightforward computation of annihilators
        and b-polynomials as described in [1].
      * LocStrategy => OaTaWa -- localizations are done following
        Oaku-Takayama-Walther method [2].
      * LocStrategy => Oaku -- localizations are done following Oaku's
        algorithm.
  * OaTa -- restriction from the graph embedding is used, which is due to T.
    Oaku and N. Takayama [3]. See Drestriction.
For detailed description of the algorithms see
  * [1] Walther, Algorithmic computation of local cohomology modules and the
    local cohomological dimension of algebraic varieties (JPAA (139), 1999.)
  * [2] Oaku, Takayama, Walther, A Localization Algorithm for D-modules (J.
    Symbolic Computation (29), 2000.)
  * [3] Oaku, Takayama, Algorithms for D-modules -- restriction, tensor
    product, localization, and local cohomology groups (JPAA (156), 2001.)

Caveat
======

localCohom(...Ideal, Module...) with the default strategy computes
presentations for all the terms in the Cech complex regardless of the requested
homological degrees. All strategies use the given generators of the ideal; the
user is advised to call mingens (Macaulay2Doc), before calling
localCohom.

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

  * Default value: Walther,
  * Function: localCohom, -- local cohomology
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:43:0.

localCohom(Ideal) -- local cohomology of a polynomial ring
**********************************************************

  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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 |, | dZ dY dX |)                 |
|               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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:110:0.

localCohom(Ideal,Module) -- local cohomology of a D-module
**********************************************************

  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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})                                |
|                                                                             |
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:173:0.

localCohom(List,Ideal) -- local cohomology of a polynomial ring
***************************************************************

  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:126:0.

localCohom(List,Ideal,Module) -- local cohomology of a D-module
***************************************************************

  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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})                         |
|                                                                             |
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:214:0.

localCohom(ZZ,Ideal) -- local cohomology of a polynomial ring
*************************************************************

  * 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 variable(s)                            |
+---------------------------------------------------------------------------+
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:142:0.

localCohom(ZZ,Ideal,Module) -- local cohomology of a D-module
*************************************************************

  * 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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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})                             |
|                                                                             |
|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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:193:0.

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

  * Usage:
        localizeCharacteristicCycle(cc,f), localizeCharacteristicCycle(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 = localizeCharacteristicCycle(cc,x_1)   -- cc of R_{x_1}       |
|                                                                        |
|o3 = {ideal () => 1, ideal x  => 1}                                     |
|                            1                                           |
|                                                                        |
|o3 : List                                                               |
+------------------------------------------------------------------------+
|i4 : cc12 = localizeCharacteristicCycle(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 (WeylAlgebras),
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 localizeCharacteristicCycle:
========================================

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

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

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

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

The source of this document is in BernsteinSato/DOC/other.m2:35:0.

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).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:307:0.

LocStrategy
***********

Functions with optional argument named LocStrategy:
===================================================

  * "IHmodule(...,LocStrategy=>...)" -- see IHmodule, --
    intersection (co)homology module of an irreducible closed subvariety
  * "intersectionCohomology(...,LocStrategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * localCohom(...,LocStrategy=>...)
    -- specify localization
    strategy for local cohomology

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

The object LocStrategy, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:46:0.

logCohomology(RingElement) -- logarithmic cohomology groups in two variables
****************************************************************************

  * 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/other.m2:107:0.

multiplierIdeal(Ideal,QQ) -- multiplier ideal
*********************************************

  * 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)"
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/multiplierIdeals.m2:38:0.

None -- an option for DExt=>Special
***********************************

See also
========

  * DExt -- Ext groups between holonomic modules

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

The object None, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:66:0.

OaTa -- an option for localCohom=>Strategy
******************************************

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

see localCohom,

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

The object OaTa, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:61:0.

OaTaWa -- an option for localCohom => LocStrategy
*************************************************

See also
========

  * localCohom -- local cohomology

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

The object OaTaWa, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:66:0.

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).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:312:0.

Output
******

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

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

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

The object Output, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:71:0.

paramBpoly(RingElement,File) -- compute the list of all possible Bernstein-Sato polynomials for a parametric polynomial
***********************************************************************************************************************

  * Function: paramBpoly,
  * Usage:
        paramBpoly(f,file)
  * Inputs:
      * f, a ring element (Macaulay2Doc), a polynomial in
        Weyl algebra A_n(Q)
      * file, a file (Macaulay2Doc), a file for TeX output (or
        stdio)
  * Optional inputs (Macaulay2Doc),:
      * ground field
  * Outputs:
      * a list (Macaulay2Doc), all possible Bernstein-Sato
        polynomials

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

This function computes the finite list of all possible Bernstein-Sato
polynomials for a polynomial with parametric coefficients and creates latex
code describing strata in the parameter space corresponding to the B.-S.
polynomials --- each stratum is a constructible set. This is an implementation
of the algorithmic approach in Anton Leykin. Constructibility of the Set of
Polynomials with a Fixed Bernstein-Sato Polynomial: an Algorithmic Approach.
Journal of Symbolic Computation, 32(6):663–675, 2001.
+--------------------------------------------------------------------+
|i1 : A =  (QQ [a,b,c]) [x, y, Dx, Dy, WeylAlgebra => {x=>Dx, y=>Dy}]|
|                                                                    |
|o1 = A                                                              |
|                                                                    |
|o1 : PolynomialRing, 2 differential variable(s)                     |
+--------------------------------------------------------------------+
|i2 : paramBpoly(a*x^2 + b*x*y + c*y^2, stdio)                       |
|\begin{itemize}                                                     |
|\item $b(s)=(S+1)^2$ corresponds to                                 |
|$V(0)$$\setminus$$V(b^2-4*a*c)$                                     |
|\item $b(s)=(S+1/2)*(S+1)$ corresponds to                           |
|$V(b^2-4*a*c)$                                                      |
|\end{itemize}                                                       |
|                                                                    |
|             2       1                                              |
|o2 = {(S + 1) , (S + -)(S + 1)}                                     |
|                     2                                              |
|                                                                    |
|o2 : List                                                           |
+--------------------------------------------------------------------+

Caveat
======

A finite field ZZ/p is used to speed up computations. Option "ground field" may
be used to change the characteristic p. If p=0 the computation will be
attempted over QQ.

See also
========

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

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

  * paramBpoly(RingElement,File), --
    compute the list of all possible Bernstein-Sato polynomials for a
    parametric polynomial
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/bFunctions.m2:407:0.

polynomialAnnihilator -- annihilator of a polynomial in the Weyl algebra
************************************************************************

  * Usage:
        polynomialAnnihilator 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 variable(s)               |
+--------------------------------------------------------------+
|i2 : f = x^2-y^3                                              |
|                                                              |
|        3    2                                                |
|o2 = - y  + x                                                 |
|                                                              |
|o2 : QQ[x..y, dx, dy]                                         |
+--------------------------------------------------------------+
|i3 : I = polynomialAnnihilator 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
========

  * rationalFunctionAnnihilator, --
    annihilator of a rational function in Weyl algebra

Ways to use polynomialAnnihilator:
==================================

  * "polynomialAnnihilator(RingElement)"

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

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

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

The source of this document is in BernsteinSato/DOC/annFs.m2:145:0.

polynomialExt -- Ext groups between a holonomic module and a polynomial ring
****************************************************************************

  * Usage:
        polynomialExt M, polynomialExt I; rationalFunctionExt(i,M), rationalFunctionExt(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,
  * 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 variable(s)|
+-----------------------------------------------+
|i2 : M = W^1/ideal(x^2*D^2)                    |
|                                               |
|o2 = cokernel | x2D2 |                         |
|                                               |
|                            1                  |
|o2 : W-module, quotient of W                   |
+-----------------------------------------------+
|i3 : polynomialExt(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
========

  * polynomialSolutions -- polynomial solutions of
    a holonomic system
  * rationalFunctionExt -- 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 polynomialExt:
==========================

  * "polynomialExt(Ideal)"
  * "polynomialExt(Module)"
  * "polynomialExt(ZZ,Ideal)"
  * "polynomialExt(ZZ,Module)"

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

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:182:0.

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

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

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

  * Default value: Schreyer,
  * Function: polynomialExt, -- Ext groups between a
    holonomic module and a polynomial ring
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/DHom.m2:150:0.

polynomialSolutions -- polynomial solutions of a holonomic system
*****************************************************************

  * Usage:
        polynomialSolutions I
        polynomialSolutions M
        polynomialSolutions(I,w)
        polynomialSolutions(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. If no $w$ is given, then it is
        taken to be the all ones vector.

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öbner 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 variable(s)|
+-----------------------------------------------+
|i2 : I = ideal(dx^2, (x-1)*dx-1)               |
|                                               |
|              2                                |
|o2 = ideal (dx , x*dx - dx - 1)                |
|                                               |
|o2 : Ideal of QQ[x, dx]                        |
+-----------------------------------------------+
|i3 : polynomialSolutions I                     |
|                                               |
|o3 = {x - 1}                                   |
|                                               |
|o3 : List                                      |
+-----------------------------------------------+

See also
========

  * rationalFunctionSolutions -- rational
    solutions of a holonomic system
  * Dintegration -- integration modules of a D-module

Ways to use polynomialSolutions:
================================

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

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

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:271:0.

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

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

  * GD -- uses Groebner deformations
  * Duality -- uses homological duality

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

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

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

  * Default value: GD,
  * Function: polynomialSolutions, -- polynomial
    solutions of a holonomic system
  * Option key: Alg,
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/DHom.m2:281:0.

populateCechComplexCC(Ideal,List) -- Cech complex skeleton for the computation of the characteristic cycles of local cohomology modules
***************************************************************************************************************************************

  * 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 (WeylAlgebras),
there is no algorithm to check the regularity.

See also
========

  * localizeCharacteristicCycle -- 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/other.m2:85:0.

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).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:302:0.

projMap1 -- a key attached by ExternalProduct
*********************************************

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

see ExternalProduct,

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

The object projMap1, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/other.m2:136:0.

projMap2 -- a key attached by ExternalProduct
*********************************************

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

see ExternalProduct,

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

The object projMap2, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/other.m2:141:0.

pruneCechComplexCC(MutableHashTable) -- reduction of the Cech complex that produces characteristic cycles of local cohomology modules
*************************************************************************************************************************************

  * 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 (WeylAlgebras),
there is no algorithm to check the regularity.

See also
========

  * localizeCharacteristicCycle -- 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
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/other.m2:60:0.

pruneLocalCohom(HashTable) -- prunes local cohomology modules
*************************************************************

  * Function: pruneLocalCohom,
  * Usage:
        pruneLocalCohom H
  * Inputs:
      * a hash table (Macaulay2Doc), the output of
        localCohom,
  * Outputs:
      * a hash table (Macaulay2Doc),

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

This function applies Dprune (WeylAlgebras), to all the keys of H.

See also
========

  * localCohom -- local cohomology
  * Dprune (WeylAlgebras) -- prunes a D-module

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

  * pruneLocalCohom(HashTable) -- prunes
    local cohomology modules
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/localCohom.m2:224:0.

rationalFunctionAnnihilator -- annihilator of a rational function in Weyl algebra
*********************************************************************************

  * Usage:
        rationalFunctionAnnihilator f
        rationalFunctionAnnihilator(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
===========

rationalFunctionAnnihilator f computes the annihilator ideal in the Weyl
algebra of th, e rational function $1/f$.  rationalFunctionAnnihilator(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 variable(s)                              |
+-----------------------------------------------------------------------------+
|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 = rationalFunctionAnnihilator (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
========

  * polynomialAnnihilator -- annihilator of a
    polynomial in the Weyl algebra

Ways to use rationalFunctionAnnihilator:
========================================

  * "rationalFunctionAnnihilator(RingElement)"
  * "rationalFunctionAnnihilator(RingElement,RingElement)"

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

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

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

The source of this document is in BernsteinSato/DOC/annFs.m2:182:0.

rationalFunctionExt -- Ext(holonomic D-module, polynomial ring localized at the singular locus)
***********************************************************************************************

  * Usage:
        rationalFunctionExt M, rationalFunctionExt I; rationalFunctionExt(M,f), rationalFunctionExt(I,f);
        rationalFunctionExt(i,M), rationalFunctionExt(i,I); rationalFunctionExt(i,M,f), rationalFunctionExt(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,
  * 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 variable(s)|
+-----------------------------------------------+
|i2 : M = W^1/ideal(x*D+5)                      |
|                                               |
|o2 = cokernel | xD+5 |                         |
|                                               |
|                            1                  |
|o2 : W-module, quotient of W                   |
+-----------------------------------------------+
|i3 : rationalFunctionExt 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 rationalFunctionExt:
================================

  * "rationalFunctionExt(Ideal)"
  * "rationalFunctionExt(Ideal,RingElement)"
  * "rationalFunctionExt(Module)"
  * "rationalFunctionExt(Module,RingElement)"
  * "rationalFunctionExt(ZZ,Ideal)"
  * "rationalFunctionExt(ZZ,Ideal,RingElement)"
  * "rationalFunctionExt(ZZ,Module)"
  * "rationalFunctionExt(ZZ,Module,RingElement)"

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

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:224:0.

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

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

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

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
  * "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
  * "compose(Module,Module,Module,Strategy=>...)" -- see compose (Macaulay2Doc),
    -- composition as a pairing on Hom-modules
  * decompose(Ideal,Strategy=>...) (missing documentation)
  * deRham(...,Strategy=>...)
  * deRhamAll(...,Strategy=>...)
  * determinant(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * DExt(...,Strategy=>...)
  * DHom(...,Strategy=>...)
  * Dintegration(...,Strategy=>...)
  * "DintegrationAll(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationClasses(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * "DintegrationComplex(...,Strategy=>...)" -- see
    DintegrationIdeal(...,Strategy=>...),
  * 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=>...),
  * 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
  * Dresolution(...,Strategy=>...)
    -- strategy for computing
    a resolution of a D-module
  * "dual(MonomialIdeal,List,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * "dual(MonomialIdeal,RingElement,Strategy=>...)" -- see
    dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc),
  * dual(MonomialIdeal,Strategy=>...) (Macaulay2Doc)
  * "End(...,Strategy=>...)" -- see End (Macaulay2Doc), -- module of
    endomorphisms
  * exteriorPower(...,Strategy=>...) (Macaulay2Doc)
    -- choose
    between Bareiss, Cofactor and Dynamic algorithms
  * "gb(...,Strategy=>...)" -- see gb (Macaulay2Doc), -- compute a
    Gröbner basis
  * "gbw(...,Strategy=>...)" -- see gbw (WeylAlgebras), -- compute a
    Gröbner basis with respect to a weight vector
  * 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
  * "Hom(...,Strategy=>...)" -- see Hom (Macaulay2Doc), -- module of
    homomorphisms
  * "homomorphism'(...,Strategy=>...)" -- see homomorphism' (Macaulay2Doc),
    -- get the element of Hom from a homomorphism
  * "hooks(...,Strategy=>...)" -- see hooks (Macaulay2Doc), -- list
    hooks attached to a key
  * "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
  * "intersectionCohomology(...,Strategy=>...)" -- see
    intersectionCohomology, -- intersection cohomology
    of an irreducible affine variety
  * "isInMultiplierIdeal(...,Strategy=>...)" -- see
    isInMultiplierIdeal(RingElement,Ideal,QQ),
    -- multiplier ideal
    membership test
  * isPrime(Ideal,Strategy=>...) (missing documentation)
  * lct(...,Strategy=>...), --
    specify strategy for computing lct
  * localCohom(...,Strategy=>...)
    -- specify strategy for
    local cohomology
  * "match(...,Strategy=>...)" -- see match (Macaulay2Doc), --
    regular expression matching
  * 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
  * normalCone(Ideal,RingElement,Strategy=>...) (missing documentation)
  * normalCone(Ideal,Strategy=>...) (missing documentation)
  * "parallelApply(...,Strategy=>...)" -- see parallelApply (Macaulay2Doc),
    -- apply a function to each element in
    parallel
  * polynomialExt(...,Strategy=>...)
  * "pushForward(...,Strategy=>...)" -- see pushForward(RingMap,Module) (Macaulay2Doc),
    -- compute the pushforward
    of a module along a ring map
  * quotient'(...,Strategy=>...) (missing documentation)
  * quotient(...,Strategy=>...) (missing documentation)
  * rationalFunctionExt(...,Strategy=>...)
  * resolution(...,Strategy=>...) (OldChainComplexes)
  * saturate(...,Strategy=>...) (missing documentation)
  * "syz(...,Strategy=>...)" -- see syz(Matrix) (Macaulay2Doc),
    -- compute the syzygy matrix

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

  * Default value: Schreyer,
  * Function: rationalFunctionExt, -- Ext(holonomic
    D-module, polynomial ring localized at the singular locus)
  * Option key: Strategy (Macaulay2Doc), -- an optional argument
-------------------------------------------------------------------------------

The source of this document is in BernsteinSato/DOC/DHom.m2:188:0.

rationalFunctionSolutions -- rational solutions of a holonomic system
*********************************************************************

  * Usage:
        rationalFunctionSolutions I
        rationalFunctionSolutions(I,f)
        rationalFunctionSolutions(I,f,w)
        rationalFunctionSolutions(I,ff)
        rationalFunctionSolutions(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öbner 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 variable(s)|
+-----------------------------------------------+
|i2 : I = ideal((x+1)*dx+5)                     |
|                                               |
|o2 = ideal(x*dx + dx + 5)                      |
|                                               |
|o2 : Ideal of QQ[x, dx]                        |
+-----------------------------------------------+
|i3 : rationalFunctionSolutions 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 rationalFunctionSolutions(I, ff, w),
where w should be generic enough so that the polynomialSolutions routine will
not complain of a non-generic weight vector.

See also
========

  * polynomialSolutions -- polynomial solutions of
    a holonomic system
  * rationalFunctionExt -- Ext(holonomic D-module,
    polynomial ring localized at the singular locus)
  * DHom -- D-homomorphisms between holonomic D-modules

Ways to use rationalFunctionSolutions:
======================================

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

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

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

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

The source of this document is in BernsteinSato/DOC/DHom.m2:349:0.

reiffen -- Reiffen's curve
**************************

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

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

The source of this document is in BernsteinSato/DOC/paco-anton-paper.m2:21:0.

Schreyer -- strategy for computing a resolution of a D-module
*************************************************************

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

The object Schreyer, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:21:0.

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).

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

The source of this document is in BernsteinSato/DOC/DHom.m2:61:0.

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).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:292:0.

twistInvMap -- a key attached by ExternalProduct
************************************************

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

see ExternalProduct,

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

The object twistInvMap, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/other.m2:131:0.

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).

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

The source of this document is in BernsteinSato/DOC/other.m2:120:0.

twistMap -- a key attached by ExternalProduct
*********************************************

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

see ExternalProduct,

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

The object twistMap, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/other.m2:126:0.

Vhomogenize -- strategy for computing a resolution of a D-module
****************************************************************

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

The object Vhomogenize, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:25:0.

ViaBFunction -- a strategy option for lct
*****************************************

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

see lct,

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

The object ViaBFunction, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:260:0.

ViaColonIdeal
*************

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

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

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

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

ViaElimination
**************

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

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

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

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

ViaLinearAlgebra -- an option for generalB=>Strategy
****************************************************

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

see generalB,

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

The object ViaLinearAlgebra, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/bFunctions.m2:225:0.

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).

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

The source of this document is in BernsteinSato/DOC/Drestriction.m2:276:0.

Walther -- an option for localCohom=>Strategy
*********************************************

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

see localCohom,

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

The object Walther, is a symbol (Macaulay2Doc).

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

The source of this document is in BernsteinSato/DOC/localCohom.m2:56:0.

WeylClosure -- Weyl closure of an ideal
***************************************

  * 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 variable(s) |
+------------------------------------------------+
|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
  * DsingularLocus (WeylAlgebras) -- singular locus of a
    D-module
  * holonomicRank (WeylAlgebras) -- holonomic 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).

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

The source of this document is in BernsteinSato/DOC/WeylClosure.m2:53:0.