This is InvolutiveBases.info, produced by Macaulay2, version 1.20

InvolutiveBases -- Methods for Janet bases and Pommaret bases in Macaulay 2
***************************************************************************

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

InvolutiveBases is a package which provides routines for dealing with Janet and
Pommaret bases.

Janet bases can be constructed from given Gr\"obner bases. It can be checked
whether a Janet basis is a Pommaret basis. Involutive reduction modulo a Janet
basis can be performed. Syzygies and free resolutions can be computed using
Janet bases. A convenient way to use this strategy is to use an optional
argument for resolution (Macaulay2Doc), see Involutive.

Some references:

  * J. Apel, The theory of involutive divisions and an application to Hilbert
    function computations. J. Symb. Comp. 25(6), 1998, pp. 683-704.
  * V. P. Gerdt, Involutive Algorithms for Computing Gr\"obner Bases. In:
    Cojocaru, S. and Pfister, G. and Ufnarovski, V. (eds.), Computational
    Commutative and Non-Commutative Algebraic Geometry, NATO Science Series,
    IOS Press, pp. 199-225.
  * V. P. Gerdt and Y. A. Blinkov, Involutive bases of polynomial ideals.
    Minimal involutive bases. Mathematics and Computers in Simulation 45, 1998,
    pp. 519-541 resp. 543-560.
  * M. Janet, Leçons sur les systèmes des équations aux dérivées
    partielles. Cahiers Scientifiques IV. Gauthiers-Villars, Paris, 1929.
  * J.-F. Pommaret, Partial Differential Equations and Group Theory. Kluwer
    Academic Publishers, 1994.
  * W. Plesken and D. Robertz, Janet's approach to presentations and
    resolutions for polynomials and linear pdes. Archiv der Mathematik 84(1),
    2005, pp. 22-37.
  * D. Robertz, Janet Bases and Applications. In: Rosenkranz, M. and Wang, D.
    (eds.), Gr\"obner Bases in Symbolic Analysis, Radon Series on Computational
    and Applied Mathematics 2, de Gruyter, 2007, pp. 139-168.
  * W. M. Seiler, A Combinatorial Approach to Involution and delta-Regularity:
    I. Involutive Bases in Polynomial Algebras of Solvable Type. II. Structure
    Analysis of Polynomial Modules with Pommaret Bases. Preprints,
    arXiv:math/0208247 and arXiv:math/0208250.

Author
======

  * Daniel Robertz (see http://wwwb.math.rwth-aachen.de/~daniel/ )
    <daniel@momo.math.rwth-aachen.de>

Version
=======

This documentation describes version 1.10 of InvolutiveBases.

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

The source code from which this documentation is derived is in the file
InvolutiveBases.m2 (see common/share/Macaulay2/InvolutiveBases.m2 ).

Exports
=======

  * Types
      * FactorModuleBasis -- the class of all factor
        module bases
      * InvolutiveBasis -- the class of all involutive
        bases
  * Functions and commands
      * basisElements -- extract the matrix of generators
        from an involutive basis or factor module basis
      * factorModuleBasis -- enumerate standard
        monomials
      * invNoetherNormalization -- Noether
        normalization
      * invReduce -- compute normal form modulo involutive
        basis by involutive reduction
      * invSyzygies -- compute involutive basis of syzygies
      * isPommaretBasis -- check whether or not a given
        Janet basis is also a Pommaret basis
      * janetBasis -- compute Janet basis for an ideal or a
        submodule of a free module
      * janetMultVar -- return table of multiplicative
        variables for given module elements as determined by Janet division
      * janetResolution -- construct a free resolution
        for a given ideal or module using Janet bases
      * multVar -- extract the sets of multiplicative variables
        for each generator (in several contexts)
      * pommaretMultVar -- return table of
        multiplicative variables for given module elements as determined by
        Pommaret division
  * Methods
      * "basisElements(FactorModuleBasis)" -- see basisElements,
        -- extract the matrix of generators from an involutive
        basis or factor module basis
      * "basisElements(InvolutiveBasis)" -- see basisElements,
        -- extract the matrix of generators from an involutive
        basis or factor module basis
      * "factorModuleBasis(InvolutiveBasis)" -- see factorModuleBasis,
        -- enumerate standard monomials
      * "invNoetherNormalization(GroebnerBasis)" -- see
        invNoetherNormalization, -- Noether
        normalization
      * "invNoetherNormalization(Ideal)" -- see invNoetherNormalization,
        -- Noether normalization
      * "invNoetherNormalization(InvolutiveBasis)" -- see
        invNoetherNormalization, -- Noether
        normalization
      * "invNoetherNormalization(Matrix)" -- see invNoetherNormalization,
        -- Noether normalization
      * "invNoetherNormalization(Module)" -- see invNoetherNormalization,
        -- Noether normalization
      * "invReduce(Matrix,InvolutiveBasis)" -- see invReduce,
        -- compute normal form modulo involutive basis by involutive reduction
      * "invReduce(RingElement,InvolutiveBasis)" -- see invReduce,
        -- compute normal form modulo involutive basis by involutive
        reduction
      * "invSyzygies(InvolutiveBasis)" -- see invSyzygies,
        -- compute involutive basis of syzygies
      * "isPommaretBasis(InvolutiveBasis)" -- see isPommaretBasis,
        -- check whether or not a given Janet basis is also a
        Pommaret basis
      * "janetBasis(ChainComplex,ZZ)" -- see janetBasis, --
        compute Janet basis for an ideal or a submodule of a free module
      * "janetBasis(GroebnerBasis)" -- see janetBasis, --
        compute Janet basis for an ideal or a submodule of a free module
      * "janetBasis(Ideal)" -- see janetBasis, -- compute
        Janet basis for an ideal or a submodule of a free module
      * "janetBasis(Matrix)" -- see janetBasis, -- compute
        Janet basis for an ideal or a submodule of a free module
      * "janetMultVar(List)" -- see janetMultVar, -- return
        table of multiplicative variables for given module elements as
        determined by Janet division
      * "janetMultVar(Matrix)" -- see janetMultVar, --
        return table of multiplicative variables for given module elements as
        determined by Janet division
      * "janetResolution(Ideal)" -- see janetResolution,
        -- construct a free resolution for a given ideal or module using Janet
        bases
      * "janetResolution(InvolutiveBasis)" -- see janetResolution,
        -- construct a free resolution for a given ideal or
        module using Janet bases
      * "janetResolution(Matrix)" -- see janetResolution,
        -- construct a free resolution for a given ideal or
        module using Janet bases
      * "janetResolution(Module)" -- see janetResolution,
        -- construct a free resolution for a given ideal or
        module using Janet bases
      * "multVar(ChainComplex,ZZ)" -- see multVar, -- extract
        the sets of multiplicative variables for each generator (in several
        contexts)
      * "multVar(FactorModuleBasis)" -- see multVar, -- extract
        the sets of multiplicative variables for each generator (in several
        contexts)
      * "multVar(InvolutiveBasis)" -- see multVar, -- extract
        the sets of multiplicative variables for each generator (in several
        contexts)
      * "pommaretMultVar(List)" -- see pommaretMultVar,
        -- return table of multiplicative variables for given module elements
        as determined by Pommaret division
      * "pommaretMultVar(Matrix)" -- see pommaretMultVar,
        -- return table of multiplicative variables for given
        module elements as determined by Pommaret division
  * Symbols
      * Involutive -- compute a (usually non-minimal)
        resolution using involutive bases
      * multVars -- key in the cache table of a differential
        in a Janet resolution
      * PermuteVariables -- ensure that the last
        dim(I) var's are algebraically independent modulo I

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

The object InvolutiveBases, is a package (Macaulay2Doc).

basisElements -- extract the matrix of generators from an involutive basis or factor module basis
*************************************************************************************************

Synopsis
========

  * Usage:
        B = basisElements J
        B = basisElements F
  * Inputs:
      * J, an instance of the type InvolutiveBasis,
      * F, an instance of the type FactorModuleBasis,
  * Outputs:
      * B, a matrix (Macaulay2Doc),

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

If the argument of basisElements is an instance of the type
InvolutiveBasis, then the columns of B are generators for the
module spanned by the involutive basis. These columns form a Gr\"obner basis
for this module.

If the argument of basisElements is an instance of the type
FactorModuleBasis, then the columns of B are generators for
the monomial cones in the factor module basis.

+------------------------+
|i1 : R = QQ[x,y];       |
+------------------------+
|i2 : I = ideal(x^3,y^2);|
|                        |
|o2 : Ideal of R         |
+------------------------+
|i3 : J = janetBasis I;  |
+------------------------+
|i4 : basisElements J    |
|                        |
|o4 = | y2 xy2 x3 x2y2 | |
|                        |
|             1       4  |
|o4 : Matrix R  <--- R   |
+------------------------+
+---------------------------------------------+
|i5 : R = QQ[x,y,z];                          |
+---------------------------------------------+
|i6 : M = matrix {{x*y,x^3*z}};               |
|                                             |
|             1       2                       |
|o6 : Matrix R  <--- R                        |
+---------------------------------------------+
|i7 : J = janetBasis M;                       |
+---------------------------------------------+
|i8 : F = factorModuleBasis J                 |
|                                             |
|     +--+------+                             |
|o8 = |1 |{z, y}|                             |
|     +--+------+                             |
|     |x |{z}   |                             |
|     +--+------+                             |
|     | 2|      |                             |
|     |x |{z}   |                             |
|     +--+------+                             |
|     | 3|      |                             |
|     |x |{x}   |                             |
|     +--+------+                             |
|                                             |
|o8 : FactorModuleBasis                       |
+---------------------------------------------+
|i9 : basisElements F                         |
|                                             |
|o9 = | 1 x x2 x3 |                           |
|                                             |
|             1       4                       |
|o9 : Matrix R  <--- R                        |
+---------------------------------------------+
|i10 : multVar F                              |
|                                             |
|o10 = {set {y, z}, set {z}, set {z}, set {x}}|
|                                             |
|o10 : List                                   |
+---------------------------------------------+

See also
========

  * multVar -- extract the sets of multiplicative variables for
    each generator (in several contexts)
  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * factorModuleBasis -- enumerate standard monomials

Ways to use basisElements :
===========================

  * "basisElements(FactorModuleBasis)"
  * "basisElements(InvolutiveBasis)"

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

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

FactorModuleBasis -- the class of all factor module bases
*********************************************************

Functions and methods returning an object of class FactorModuleBasis :
======================================================================

  * factorModuleBasis -- enumerate standard monomials

Methods that use an object of class FactorModuleBasis :
=======================================================

  * "basisElements(FactorModuleBasis)" -- see basisElements,
    -- extract the matrix of generators from an involutive basis
    or factor module basis
  * "multVar(FactorModuleBasis)" -- see multVar, -- extract the
    sets of multiplicative variables for each generator (in several contexts)

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

The object FactorModuleBasis, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

factorModuleBasis -- enumerate standard monomials
*************************************************

Synopsis
========

  * Usage:
        F = factorModuleBasis(J)
  * Inputs:
      * J, an instance of the type InvolutiveBasis,
  * Outputs:
      * F, an instance of the type FactorModuleBasis,
        a partition of the set of monomials that are not leading monomial of
        any element of the module spanned by J, into monomial cones

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

The result represents a collection of finitely many cones of monomials, each
cone being the set of multiples of a certain monomial by all monomials in
certain variables; the generating monomials are accessed by
basisElements,; the sets of variables for each cone are obtained
from multVar.

+--------------------------------------------+
|i1 : R = QQ[x,y,z];                         |
+--------------------------------------------+
|i2 : M = matrix {{x*y,x^3*z}};              |
|                                            |
|             1       2                      |
|o2 : Matrix R  <--- R                       |
+--------------------------------------------+
|i3 : J = janetBasis M;                      |
+--------------------------------------------+
|i4 : F = factorModuleBasis J                |
|                                            |
|     +--+------+                            |
|o4 = |1 |{z, y}|                            |
|     +--+------+                            |
|     |x |{z}   |                            |
|     +--+------+                            |
|     | 2|      |                            |
|     |x |{z}   |                            |
|     +--+------+                            |
|     | 3|      |                            |
|     |x |{x}   |                            |
|     +--+------+                            |
|                                            |
|o4 : FactorModuleBasis                      |
+--------------------------------------------+
|i5 : basisElements F                        |
|                                            |
|o5 = | 1 x x2 x3 |                          |
|                                            |
|             1       4                      |
|o5 : Matrix R  <--- R                       |
+--------------------------------------------+
|i6 : multVar F                              |
|                                            |
|o6 = {set {y, z}, set {z}, set {z}, set {x}}|
|                                            |
|o6 : List                                   |
+--------------------------------------------+
+-----------------------------------------------------------------------------+
|i7 : R = QQ[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i8 : M = matrix {{x*y-y^3, x*y^2, x*y-x}, {x, y^2, x}};                      |
|                                                                             |
|             2       3                                                       |
|o8 : Matrix R  <--- R                                                        |
+-----------------------------------------------------------------------------+
|i9 : J = janetBasis M                                                        |
|                                                                             |
|     +--------------+------+                                                 |
|o9 = || y3-x |      |{y}   |                                                 |
|     ||   0  |      |      |                                                 |
|     +--------------+------+                                                 |
|     || xy-x |      |{y}   |                                                 |
|     ||   x  |      |      |                                                 |
|     +--------------+------+                                                 |
|     || x2y-x2 |    |{y}   |                                                 |
|     ||   x2   |    |      |                                                 |
|     +--------------+------+                                                 |
|     || x3 |        |{y, x}|                                                 |
|     || x2 |        |      |                                                 |
|     +--------------+------+                                                 |
|     ||    -x   |   |{y}   |                                                 |
|     || xy-y2+x |   |      |                                                 |
|     +--------------+------+                                                 |
|     || x2 |        |{y}   |                                                 |
|     || y3 |        |      |                                                 |
|     +--------------+------+                                                 |
|     ||     -x2    ||{y}   |                                                 |
|     || x2y-xy2+x2 ||      |                                                 |
|     +--------------+------+                                                 |
|     ||     0     | |{y, x}|                                                 |
|     || x3+2x2+y2 | |      |                                                 |
|     +--------------+------+                                                 |
|                                                                             |
|o9 : InvolutiveBasis                                                         |
+-----------------------------------------------------------------------------+
|i10 : F = factorModuleBasis J                                                |
|                                                                             |
|      +------+--+                                                            |
|o10 = || 1 | |{}|                                                            |
|      || 0 | |  |                                                            |
|      +------+--+                                                            |
|      || y | |{}|                                                            |
|      || 0 | |  |                                                            |
|      +------+--+                                                            |
|      || y2 ||{}|                                                            |
|      ||  0 ||  |                                                            |
|      +------+--+                                                            |
|      || x | |{}|                                                            |
|      || 0 | |  |                                                            |
|      +------+--+                                                            |
|      || x2 ||{}|                                                            |
|      ||  0 ||  |                                                            |
|      +------+--+                                                            |
|      || 0 | |{}|                                                            |
|      || 1 | |  |                                                            |
|      +------+--+                                                            |
|      || 0 | |{}|                                                            |
|      || y | |  |                                                            |
|      +------+--+                                                            |
|      ||  0 ||{}|                                                            |
|      || y2 ||  |                                                            |
|      +------+--+                                                            |
|      || 0 | |{}|                                                            |
|      || x | |  |                                                            |
|      +------+--+                                                            |
|      ||  0 ||{}|                                                            |
|      || x2 ||  |                                                            |
|      +------+--+                                                            |
|                                                                             |
|o10 : FactorModuleBasis                                                      |
+-----------------------------------------------------------------------------+
|i11 : basisElements F                                                        |
|                                                                             |
|o11 = | 1 y y2 x x2 0 0 0  0 0  |                                            |
|      | 0 0 0  0 0  1 y y2 x x2 |                                            |
|                                                                             |
|              2       10                                                     |
|o11 : Matrix R  <--- R                                                       |
+-----------------------------------------------------------------------------+
|i12 : multVar F                                                              |
|                                                                             |
|o12 = {set {}, set {}, set {}, set {}, set {}, set {}, set {}, set {}, set   |
|      -----------------------------------------------------------------------|
|      {}, set {}}                                                            |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * basisElements -- extract the matrix of generators
    from an involutive basis or factor module basis
  * multVar -- extract the sets of multiplicative variables for
    each generator (in several contexts)

Ways to use factorModuleBasis :
===============================

  * "factorModuleBasis(InvolutiveBasis)"

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

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

invNoetherNormalization -- Noether normalization
************************************************

Synopsis
========

  * Usage:
        N = invNoetherNormalization I
  * Inputs:
      * I, an instance of the type InvolutiveBasis,
      * I, a Gröbner basis (Macaulay2Doc),
      * I, an ideal (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * PermuteVariables (missing documentation) => ..., default value false,
        null
  * Outputs:
      * N, a list (Macaulay2Doc), the first entry of which is a
        list defining an invertible coordinate transformation in terms of the
        images of the variables of the polynomial ring; the second entry is a
        list of variables whose residue classes modulo the ideal in the new
        coordinates are (maximally) algebraically independent

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

invNoetherNormalization constructs an automorphism of the polynomial ring in
which I defines an ideal, such that the image of I under this automorphism is
in Noether normal position.

The automorphism is defined by the first list returned: the i-th variable of
the polynomial ring is mapped to the i-th entry of that list.

In the new coordinates, the residue class ring is an integral ring extension of
the polynomial ring in the variables given in the second list returned.

If the option PermuteVariables, is set to true, the
second list consists of the last d variables, where d is the Krull dimension of
the residue class ring.

Reference: D. Robertz, Noether normalization guided by monomial cone
decompositions, Journal of Symbolic Computation 44, 2009, pp. 1359-1373.

+------------------------------------+
|i1 : R = QQ[x,y,z];                 |
+------------------------------------+
|i2 : I = ideal(x*y*z);              |
|                                    |
|o2 : Ideal of R                     |
+------------------------------------+
|i3 : J = janetBasis I;              |
+------------------------------------+
|i4 : N = invNoetherNormalization J  |
|                                    |
|o4 = {{x, - x + y, - x + z}, {z, y}}|
|                                    |
|o4 : List                           |
+------------------------------------+
+------------------------------------------------------------+
|i5 : R = QQ[w,x,y,z];                                       |
+------------------------------------------------------------+
|i6 : I = ideal(y^2*z-w*x*y^2, x*y*z-w*z^2, y^2*z-w*x^2*y*z);|
|                                                            |
|o6 : Ideal of R                                             |
+------------------------------------------------------------+
|i7 : J = janetBasis I;                                      |
+------------------------------------------------------------+
|i8 : N = invNoetherNormalization J                          |
|                                                            |
|o8 = {{w, x, - x + y, - w - x + z}, {z, y}}                 |
|                                                            |
|o8 : List                                                   |
+------------------------------------------------------------+

See also
========

  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * factorModuleBasis -- enumerate standard monomials

Ways to use invNoetherNormalization :
=====================================

  * "invNoetherNormalization(GroebnerBasis)"
  * "invNoetherNormalization(Ideal)"
  * "invNoetherNormalization(InvolutiveBasis)"
  * "invNoetherNormalization(Matrix)"
  * "invNoetherNormalization(Module)"

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

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

Involutive -- compute a (usually non-minimal) resolution using involutive bases
*******************************************************************************

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

The symbol Involutive is allowed as value for the optional argument
Strategy (Macaulay2Doc), for resolution (Macaulay2Doc).
If provided, the resolution is constructed using
janetResolution.

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

The object Involutive, is a symbol (Macaulay2Doc).

InvolutiveBasis -- the class of all involutive bases
****************************************************

Functions and methods returning an object of class InvolutiveBasis :
====================================================================

  * invSyzygies -- compute involutive basis of syzygies
  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module

Methods that use an object of class InvolutiveBasis :
=====================================================

  * "basisElements(InvolutiveBasis)" -- see basisElements,
    -- extract the matrix of generators from an involutive basis or factor
    module basis
  * "factorModuleBasis(InvolutiveBasis)" -- see factorModuleBasis,
    -- enumerate standard monomials
  * "invNoetherNormalization(InvolutiveBasis)" -- see
    invNoetherNormalization, -- Noether normalization
  * "invReduce(Matrix,InvolutiveBasis)" -- see invReduce, --
    compute normal form modulo involutive basis by involutive reduction
  * "invReduce(RingElement,InvolutiveBasis)" -- see invReduce,
    -- compute normal form modulo involutive basis by involutive reduction
  * "invSyzygies(InvolutiveBasis)" -- see invSyzygies, --
    compute involutive basis of syzygies
  * "isPommaretBasis(InvolutiveBasis)" -- see isPommaretBasis,
    -- check whether or not a given Janet basis is also a
    Pommaret basis
  * "janetResolution(InvolutiveBasis)" -- see janetResolution,
    -- construct a free resolution for a given ideal or module
    using Janet bases
  * "multVar(InvolutiveBasis)" -- see multVar, -- extract the
    sets of multiplicative variables for each generator (in several contexts)

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

The object InvolutiveBasis, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

invReduce -- compute normal form modulo involutive basis by involutive reduction
********************************************************************************

Synopsis
========

  * Usage:
        (r,c) = invReduce(p,J)
  * Inputs:
      * p, a matrix (Macaulay2Doc), the columns are to be reduced
        modulo J
      * J, an instance of the type InvolutiveBasis,
  * Outputs:
      * r, a matrix (Macaulay2Doc), the normal form of (the
        columns of) p modulo J
      * c, a matrix (Macaulay2Doc), the reduction coefficients
  * Consequences:
      * the columns of r are in normal form modulo J, and p = r + J#0 * c,
        where * is matrix multiplication

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

+------------------------------------------------+
|i1 : R = QQ[x,y,z];                             |
+------------------------------------------------+
|i2 : M = matrix {{x+y+z, x*y+y*z+z*x, x*y*z-1}};|
|                                                |
|             1       3                          |
|o2 : Matrix R  <--- R                           |
+------------------------------------------------+
|i3 : J = janetBasis M;                          |
+------------------------------------------------+
|i4 : p = matrix {{y,y^2,y^3}}                   |
|                                                |
|o4 = | y y2 y3 |                                |
|                                                |
|             1       3                          |
|o4 : Matrix R  <--- R                           |
+------------------------------------------------+
|i5 : invReduce(p,J)                             |
|                                                |
|o5 = (| y -yz-z2 1 |, | 0 0 0   |)              |
|                      | 0 1 y-z |               |
|                      | 0 0 1   |               |
|                      | 0 0 0   |               |
|                                                |
|o5 : Sequence                                   |
+------------------------------------------------+

See also
========

  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * invSyzygies -- compute involutive basis of syzygies

Ways to use invReduce :
=======================

  * "invReduce(Matrix,InvolutiveBasis)"
  * "invReduce(RingElement,InvolutiveBasis)"

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

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

invSyzygies -- compute involutive basis of syzygies
***************************************************

Synopsis
========

  * Usage:
        invSyzygies J
  * Inputs:
      * J, an instance of the type InvolutiveBasis,
  * Outputs:
      * an instance of the type InvolutiveBasis, an
        involutive basis for the syzygies of J

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

+-----------------------+
|i1 : R = QQ[x,y,z];    |
+-----------------------+
|i2 : I = ideal(x,y,z); |
|                       |
|o2 : Ideal of R        |
+-----------------------+
|i3 : J = janetBasis I  |
|                       |
|     +-+---------+     |
|o3 = |z|{z}      |     |
|     +-+---------+     |
|     |y|{z, y}   |     |
|     +-+---------+     |
|     |x|{z, y, x}|     |
|     +-+---------+     |
|                       |
|o3 : InvolutiveBasis   |
+-----------------------+
|i4 : invSyzygies J     |
|                       |
|     +------+---------+|
|o4 = ||  x ||{z, y, x}||
|     ||  0 ||         ||
|     || -z ||         ||
|     +------+---------+|
|     ||  y ||{z, y}   ||
|     || -z ||         ||
|     ||  0 ||         ||
|     +------+---------+|
|     ||  0 ||{z, y, x}||
|     ||  x ||         ||
|     || -y ||         ||
|     +------+---------+|
|                       |
|o4 : InvolutiveBasis   |
+-----------------------+

Caveat
======

cannot be iterated because schreyerOrder (Macaulay2Doc), is
not used; call janetResolution, instead

See also
========

  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * janetResolution -- construct a free resolution for
    a given ideal or module using Janet bases

Ways to use invSyzygies :
=========================

  * "invSyzygies(InvolutiveBasis)"

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

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

isPommaretBasis -- check whether or not a given Janet basis is also a Pommaret basis
************************************************************************************

Synopsis
========

  * Usage:
        P = isPommaretBasis J
  * Inputs:
      * J, an instance of the type InvolutiveBasis, a
        Janet basis as returned by janetBasis,
  * Outputs:
      * P, a Boolean value (Macaulay2Doc), the result equals
        true if and only if J is a Pommaret basis

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

+------------------------+
|i1 : R = QQ[x,y];       |
+------------------------+
|i2 : I = ideal(x^3,y^2);|
|                        |
|o2 : Ideal of R         |
+------------------------+
|i3 : J = janetBasis I   |
|                        |
|     +----+------+      |
|     | 2  |      |      |
|o3 = |y   |{y}   |      |
|     +----+------+      |
|     |   2|      |      |
|     |x*y |{y}   |      |
|     +----+------+      |
|     | 3  |      |      |
|     |x   |{y, x}|      |
|     +----+------+      |
|     | 2 2|      |      |
|     |x y |{y}   |      |
|     +----+------+      |
|                        |
|o3 : InvolutiveBasis    |
+------------------------+
|i4 : isPommaretBasis J  |
|                        |
|o4 = true               |
+------------------------+
+------------------------+
|i5 : R = QQ[x,y];       |
+------------------------+
|i6 : I = ideal(x*y,y^2);|
|                        |
|o6 : Ideal of R         |
+------------------------+
|i7 : J = janetBasis I   |
|                        |
|     +---+------+       |
|     | 2 |      |       |
|o7 = |y  |{y}   |       |
|     +---+------+       |
|     |x*y|{y, x}|       |
|     +---+------+       |
|                        |
|o7 : InvolutiveBasis    |
+------------------------+
|i8 : isPommaretBasis J  |
|                        |
|o8 = false              |
+------------------------+

See also
========

  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * basisElements -- extract the matrix of generators
    from an involutive basis or factor module basis
  * multVar -- extract the sets of multiplicative variables for
    each generator (in several contexts)
  * janetMultVar -- return table of multiplicative
    variables for given module elements as determined by Janet division
  * pommaretMultVar -- return table of multiplicative
    variables for given module elements as determined by Pommaret division

Ways to use isPommaretBasis :
=============================

  * "isPommaretBasis(InvolutiveBasis)"

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

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

janetBasis -- compute Janet basis for an ideal or a submodule of a free module
******************************************************************************

Synopsis
========

  * Usage:
        J = janetBasis M or J = janetBasis(C,n)
  * Inputs:
      * M, an instance of the type InvolutiveBasis,
      * M, an ideal (Macaulay2Doc),
      * M, a Gröbner basis (Macaulay2Doc),
      * C, a chain complex (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * J, an instance of the type InvolutiveBasis,

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

If the argument for janetBasis is a matrix (Macaulay2Doc), or an
ideal (Macaulay2Doc), or a Gröbner basis (Macaulay2Doc),
then J is a Janet basis for (the module generated
by) M.

If the arguments for janetBasis are a chain complex (Macaulay2Doc),
and an integer (Macaulay2Doc), where C is
the result of either janetResolution, or
resolution (Macaulay2Doc), called with the optional argument
'Strategy => Involutive', then J is the Janet basis extracted from the n-th
differential of C.

+--------------------------------------------+
|i1 : R = QQ[x,y];                           |
+--------------------------------------------+
|i2 : I = ideal(x^3,y^2);                    |
|                                            |
|o2 : Ideal of R                             |
+--------------------------------------------+
|i3 : J = janetBasis I;                      |
+--------------------------------------------+
|i4 : basisElements J                        |
|                                            |
|o4 = | y2 xy2 x3 x2y2 |                     |
|                                            |
|             1       4                      |
|o4 : Matrix R  <--- R                       |
+--------------------------------------------+
|i5 : multVar J                              |
|                                            |
|o5 = {set {y}, set {y}, set {x, y}, set {y}}|
|                                            |
|o5 : List                                   |
+--------------------------------------------+
+-----------------------------------------------------------------------------+
|i6 : R = QQ[x,y];                                                            |
+-----------------------------------------------------------------------------+
|i7 : M = matrix {{x*y-y^3, x*y^2, x*y-x}, {x, y^2, x}};                      |
|                                                                             |
|             2       3                                                       |
|o7 : Matrix R  <--- R                                                        |
+-----------------------------------------------------------------------------+
|i8 : J = janetBasis M;                                                       |
+-----------------------------------------------------------------------------+
|i9 : basisElements J                                                         |
|                                                                             |
|o9 = | y3-x xy-x x2y-x2 x3 -x      x2 -x2        0         |                 |
|     | 0    x    x2     x2 xy-y2+x y3 x2y-xy2+x2 x3+2x2+y2 |                 |
|                                                                             |
|             2       8                                                       |
|o9 : Matrix R  <--- R                                                        |
+-----------------------------------------------------------------------------+
|i10 : multVar J                                                              |
|                                                                             |
|o10 = {set {y}, set {y}, set {y}, set {x, y}, set {y}, set {y}, set {y}, set |
|      -----------------------------------------------------------------------|
|      {x, y}}                                                                |
|                                                                             |
|o10 : List                                                                   |
+-----------------------------------------------------------------------------+
+----------------------------------------+
|i11 : R = QQ[x,y,z];                    |
+----------------------------------------+
|i12 : I = ideal(x,y,z);                 |
|                                        |
|o12 : Ideal of R                        |
+----------------------------------------+
|i13 : C = res(I, Strategy => Involutive)|
|                                        |
|       1      3      3      1           |
|o13 = R  <-- R  <-- R  <-- R  <-- 0     |
|                                        |
|      0      1      2      3      4     |
|                                        |
|o13 : ChainComplex                      |
+----------------------------------------+
|i14 : janetBasis(C, 2)                  |
|                                        |
|      +------+---------+                |
|o14 = || -y ||{z, y, x}|                |
|      ||  x ||         |                |
|      ||  0 ||         |                |
|      +------+---------+                |
|      || -z ||{z, y, x}|                |
|      ||  0 ||         |                |
|      ||  x ||         |                |
|      +------+---------+                |
|      ||  0 ||{z, y}   |                |
|      || -z ||         |                |
|      ||  y ||         |                |
|      +------+---------+                |
|                                        |
|o14 : InvolutiveBasis                   |
+----------------------------------------+

See also
========

  * janetMultVar -- return table of multiplicative
    variables for given module elements as determined by Janet division
  * pommaretMultVar -- return table of multiplicative
    variables for given module elements as determined by Pommaret division
  * isPommaretBasis -- check whether or not a given
    Janet basis is also a Pommaret basis
  * invReduce -- compute normal form modulo involutive basis
    by involutive reduction
  * invSyzygies -- compute involutive basis of syzygies
  * janetResolution -- construct a free resolution for
    a given ideal or module using Janet bases

Ways to use janetBasis :
========================

  * "janetBasis(ChainComplex,ZZ)"
  * "janetBasis(GroebnerBasis)"
  * "janetBasis(Ideal)"
  * "janetBasis(Matrix)"
  * janetBasis(Module) (missing documentation)

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

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

janetMultVar -- return table of multiplicative variables for given module elements as determined by Janet division
******************************************************************************************************************

Synopsis
========

  * Usage:
        janetMultVar M
  * Inputs:
      * M, a matrix (Macaulay2Doc), or a list (Macaulay2Doc),
  * Outputs:
      * list of sets of variables of the polynomial ring; the i-th set consists
        of the multiplicative variables for the i-th generator in J

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

+----------------------------------------------------+
|i1 : R = QQ[x1,x2,x3];                              |
+----------------------------------------------------+
|i2 : M = matrix {{ x1*x2*x3, x2^2*x3, x1*x2*x3^2 }};|
|                                                    |
|             1       3                              |
|o2 : Matrix R  <--- R                               |
+----------------------------------------------------+
|i3 : janetMultVar M                                 |
|                                                    |
|o3 = {set {x1, x2}, set {x2, x3}, set {x1, x2, x3}} |
|                                                    |
|o3 : List                                           |
+----------------------------------------------------+

See also
========

  * pommaretMultVar -- return table of multiplicative
    variables for given module elements as determined by Pommaret division
  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * multVar -- extract the sets of multiplicative variables for
    each generator (in several contexts)
  * isPommaretBasis -- check whether or not a given
    Janet basis is also a Pommaret basis

Ways to use janetMultVar :
==========================

  * "janetMultVar(List)"
  * "janetMultVar(Matrix)"

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

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

janetResolution -- construct a free resolution for a given ideal or module using Janet bases
********************************************************************************************

Synopsis
========

  * Usage:
        C = janetResolution M
  * Inputs:
      * M, a matrix (Macaulay2Doc), or an ideal (Macaulay2Doc),
        or a module (Macaulay2Doc),
  * Outputs:
      * C, a chain complex (Macaulay2Doc), a (non-minimal)
        free resolution of (the module generated by) M

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

The computed Janet basis for each homological degree can be extracted with
janetBasis.

The sets of multiplicative variables can also be extracted from the Janet basis
in each homological degree with multVar.

Note that janetResolution can be combined with resolution (Macaulay2Doc),:
when providing the option 'Strategy => Involutive'
to resolution (Macaulay2Doc), janetResolution constructs the
resolution.

+-----------------------------------------------+
|i1 : R = QQ[x,y,z];                            |
+-----------------------------------------------+
|i2 : M = matrix {{x,y,z}};                     |
|                                               |
|             1       3                         |
|o2 : Matrix R  <--- R                          |
+-----------------------------------------------+
|i3 : C = janetResolution M                     |
|                                               |
|      1      3      3      1                   |
|o3 = R  <-- R  <-- R  <-- R  <-- 0             |
|                                               |
|     0      1      2      3      4             |
|                                               |
|o3 : ChainComplex                              |
+-----------------------------------------------+
|i4 : janetBasis(C, 2)                          |
|                                               |
|     +------+---------+                        |
|o4 = || -y ||{z, y, x}|                        |
|     ||  x ||         |                        |
|     ||  0 ||         |                        |
|     +------+---------+                        |
|     || -z ||{z, y, x}|                        |
|     ||  0 ||         |                        |
|     ||  x ||         |                        |
|     +------+---------+                        |
|     ||  0 ||{z, y}   |                        |
|     || -z ||         |                        |
|     ||  y ||         |                        |
|     +------+---------+                        |
|                                               |
|o4 : InvolutiveBasis                           |
+-----------------------------------------------+
|i5 : multVar(C, 2)                             |
|                                               |
|o5 = {set {x, y, z}, set {x, y, z}, set {y, z}}|
|                                               |
|o5 : List                                      |
+-----------------------------------------------+
+-----------------------------------+
|i6 : R = QQ[x,y,z];                |
+-----------------------------------+
|i7 : I = ideal(x,y,z);             |
|                                   |
|o7 : Ideal of R                    |
+-----------------------------------+
|i8 : res(I, Strategy => Involutive)|
|                                   |
|      1      3      3      1       |
|o8 = R  <-- R  <-- R  <-- R  <-- 0 |
|                                   |
|     0      1      2      3      4 |
|                                   |
|o8 : ChainComplex                  |
+-----------------------------------+

See also
========

  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * multVar -- extract the sets of multiplicative variables for
    each generator (in several contexts)
  * invSyzygies -- compute involutive basis of syzygies

Ways to use janetResolution :
=============================

  * "janetResolution(Ideal)"
  * "janetResolution(InvolutiveBasis)"
  * "janetResolution(Matrix)"
  * "janetResolution(Module)"

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

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

multVar -- extract the sets of multiplicative variables for each generator (in several contexts)
************************************************************************************************

Synopsis
========

  * Usage:
        m = multVar(J) or m = multVar(C,n) or m = multVar(F)
  * Inputs:
      * J, an instance of the type InvolutiveBasis,
      * C, a chain complex (Macaulay2Doc),
      * n, an integer (Macaulay2Doc),
      * F, an instance of the type FactorModuleBasis,
  * Outputs:
      * m, a list (Macaulay2Doc), list of sets of variables of the
        polynomial ring

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

If the argument of multVar is an instance of the type InvolutiveBasis,
then the i-th set in m consists of the multiplicative
variables for the i-th generator in J.

If the arguments of multVar are a chain complex (Macaulay2Doc),
and an integer (Macaulay2Doc), where C is
the result of either janetResolution, or
resolution (Macaulay2Doc), called with the optional argument
'Strategy => Involutive', then the i-th set in m consists of the multiplicative
variables for the i-th generator in the n-th differential of C.

If the argument of multVar is an instance of the type FactorModuleBasis,
then the i-th set in m consists of the multiplicative
variables for the i-th monomial cone in F.

+--------------------------------------------+
|i1 : R = QQ[x,y];                           |
+--------------------------------------------+
|i2 : I = ideal(x^3,y^2);                    |
|                                            |
|o2 : Ideal of R                             |
+--------------------------------------------+
|i3 : J = janetBasis I;                      |
+--------------------------------------------+
|i4 : multVar J                              |
|                                            |
|o4 = {set {y}, set {y}, set {x, y}, set {y}}|
|                                            |
|o4 : List                                   |
+--------------------------------------------+
+-----------------------------------------------+
|i5 : R = QQ[x,y,z];                            |
+-----------------------------------------------+
|i6 : I = ideal(x,y,z);                         |
|                                               |
|o6 : Ideal of R                                |
+-----------------------------------------------+
|i7 : C = res(I, Strategy => Involutive)        |
|                                               |
|      1      3      3      1                   |
|o7 = R  <-- R  <-- R  <-- R  <-- 0             |
|                                               |
|     0      1      2      3      4             |
|                                               |
|o7 : ChainComplex                              |
+-----------------------------------------------+
|i8 : multVar(C, 2)                             |
|                                               |
|o8 = {set {x, y, z}, set {x, y, z}, set {y, z}}|
|                                               |
|o8 : List                                      |
+-----------------------------------------------+
+---------------------------------------------+
|i9 : R = QQ[x,y,z];                          |
+---------------------------------------------+
|i10 : M = matrix {{x*y,x^3*z}};              |
|                                             |
|              1       2                      |
|o10 : Matrix R  <--- R                       |
+---------------------------------------------+
|i11 : J = janetBasis M                       |
|                                             |
|      +---+---------+                        |
|o11 = |x*y|{z, y}   |                        |
|      +---+---------+                        |
|      | 2 |         |                        |
|      |x y|{z, y}   |                        |
|      +---+---------+                        |
|      | 3 |         |                        |
|      |x z|{z, x}   |                        |
|      +---+---------+                        |
|      | 3 |         |                        |
|      |x y|{z, y, x}|                        |
|      +---+---------+                        |
|                                             |
|o11 : InvolutiveBasis                        |
+---------------------------------------------+
|i12 : F = factorModuleBasis J                |
|                                             |
|      +--+------+                            |
|o12 = |1 |{z, y}|                            |
|      +--+------+                            |
|      |x |{z}   |                            |
|      +--+------+                            |
|      | 2|      |                            |
|      |x |{z}   |                            |
|      +--+------+                            |
|      | 3|      |                            |
|      |x |{x}   |                            |
|      +--+------+                            |
|                                             |
|o12 : FactorModuleBasis                      |
+---------------------------------------------+
|i13 : basisElements F                        |
|                                             |
|o13 = | 1 x x2 x3 |                          |
|                                             |
|              1       4                      |
|o13 : Matrix R  <--- R                       |
+---------------------------------------------+
|i14 : multVar F                              |
|                                             |
|o14 = {set {y, z}, set {z}, set {z}, set {x}}|
|                                             |
|o14 : List                                   |
+---------------------------------------------+

See also
========

  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * janetMultVar -- return table of multiplicative
    variables for given module elements as determined by Janet division
  * pommaretMultVar -- return table of multiplicative
    variables for given module elements as determined by Pommaret division
  * basisElements -- extract the matrix of generators
    from an involutive basis or factor module basis
  * janetResolution -- construct a free resolution for
    a given ideal or module using Janet bases
  * Involutive -- compute a (usually non-minimal) resolution
    using involutive bases
  * factorModuleBasis -- enumerate standard monomials

Ways to use multVar :
=====================

  * "multVar(ChainComplex,ZZ)"
  * "multVar(FactorModuleBasis)"
  * "multVar(InvolutiveBasis)"

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

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

multVars -- key in the cache table of a differential in a Janet resolution
**************************************************************************

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

The symbol multVars is used as a key in the cache table of a differential in a
resolution if it is constructed using janetResolution.
In that case it stores the sets of multiplicative variables for the Janet basis
given by that differential.

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

The object multVars, is a symbol (Macaulay2Doc).

PermuteVariables -- ensure that the last dim(I) var's are algebraically independent modulo I
********************************************************************************************

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

The symbol PermuteVariables is an option for invNoetherNormalization.

The default value for this option is false. If set to true, the second list of
the result of invNoetherNormalization, consists
of the last d variables in the new coordinates, where d is the Krull dimension
of the ring under consideration.

In the new coordinates defined by invNoetherNormalization,
the residue class ring is an integral ring extension
of the polynomial ring in the last d variables.

+--------------------------------------------------------------+
|i1 : R = QQ[x,y,z];                                           |
+--------------------------------------------------------------+
|i2 : I = ideal(x*y^2+2*x^2*y, z^3);                           |
|                                                              |
|o2 : Ideal of R                                               |
+--------------------------------------------------------------+
|i3 : J = janetBasis I;                                        |
+--------------------------------------------------------------+
|i4 : N1 = invNoetherNormalization J                           |
|                                                              |
|o4 = {{x, - x + y, z}, {y}}                                   |
|                                                              |
|o4 : List                                                     |
+--------------------------------------------------------------+
|i5 : N2 = invNoetherNormalization(J, PermuteVariables => true)|
|                                                              |
|o5 = {{x, - x + z, y}, {z}}                                   |
|                                                              |
|o5 : List                                                     |
+--------------------------------------------------------------+
+-----------------------------------------------------------------------------+
|i6 : R = QQ[w,x,y,z];                                                        |
+-----------------------------------------------------------------------------+
|i7 : I = ideal(w*x-y^2, y*z-x^2)                                             |
|                                                                             |
|                   2     2                                                   |
|o7 = ideal (w*x - y , - x  + y*z)                                            |
|                                                                             |
|o7 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i8 : J = janetBasis I;                                                       |
+-----------------------------------------------------------------------------+
|i9 : N1 = invNoetherNormalization J                                          |
|                                                                             |
|o9 = {{w, x, y, z}, {z, w}}                                                  |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+
|i10 : J1 = janetBasis substitute(gens I, for i in toList(0..numgens(R)-1)    |
|-----------------------------------------------------------------------------|
|list R_i => N1#0#i);                                                         |
+-----------------------------------------------------------------------------+
|i11 : F1 = factorModuleBasis(J1)                                             |
|                                                                             |
|      +----+------+                                                          |
|o11 = |1   |{z}   |                                                          |
|      +----+------+                                                          |
|      |y   |{z}   |                                                          |
|      +----+------+                                                          |
|      | 2  |      |                                                          |
|      |y   |{z}   |                                                          |
|      +----+------+                                                          |
|      | 3  |      |                                                          |
|      |y   |{z}   |                                                          |
|      +----+------+                                                          |
|      |x   |{z}   |                                                          |
|      +----+------+                                                          |
|      |x*y |{z}   |                                                          |
|      +----+------+                                                          |
|      |w   |{z, w}|                                                          |
|      +----+------+                                                          |
|      |w*y |{z, w}|                                                          |
|      +----+------+                                                          |
|      |   2|      |                                                          |
|      |w*y |{z, w}|                                                          |
|      +----+------+                                                          |
|      |   3|      |                                                          |
|      |w*y |{z, w}|                                                          |
|      +----+------+                                                          |
|                                                                             |
|o11 : FactorModuleBasis                                                      |
+-----------------------------------------------------------------------------+
|i12 : N2 = invNoetherNormalization(J, PermuteVariables => true)              |
|                                                                             |
|o12 = {{y, x, w, z}, {z, y}}                                                 |
|                                                                             |
|o12 : List                                                                   |
+-----------------------------------------------------------------------------+
|i13 : J2 = janetBasis substitute(gens I, for i in toList(0..numgens(R)-1)    |
|-----------------------------------------------------------------------------|
|list R_i => N2#0#i);                                                         |
+-----------------------------------------------------------------------------+
|i14 : F2 = factorModuleBasis(J2)                                             |
|                                                                             |
|      +---+------+                                                           |
|o14 = |1  |{z, y}|                                                           |
|      +---+------+                                                           |
|      |x  |{z, y}|                                                           |
|      +---+------+                                                           |
|      |w  |{z, y}|                                                           |
|      +---+------+                                                           |
|      |w*x|{z, y}|                                                           |
|      +---+------+                                                           |
|                                                                             |
|o14 : FactorModuleBasis                                                      |
+-----------------------------------------------------------------------------+

Functions with optional argument named PermuteVariables :
=========================================================

  * invNoetherNormalization(...,PermuteVariables=>...) (missing documentation)

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

The object PermuteVariables, is a symbol (Macaulay2Doc).

pommaretMultVar -- return table of multiplicative variables for given module elements as determined by Pommaret division
************************************************************************************************************************

Synopsis
========

  * Usage:
        pommaretMultVar M
  * Inputs:
      * M, a matrix (Macaulay2Doc), or a list (Macaulay2Doc),
  * Outputs:
      * list of sets of variables of the polynomial ring; the i-th set consists
        of the multiplicative variables for the i-th generator in J

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

+----------------------------------------------------+
|i1 : R = QQ[x1,x2,x3];                              |
+----------------------------------------------------+
|i2 : M = matrix {{ x1*x2*x3, x2^2*x3, x1*x2*x3^2 }};|
|                                                    |
|             1       3                              |
|o2 : Matrix R  <--- R                               |
+----------------------------------------------------+
|i3 : pommaretMultVar M                              |
|                                                    |
|o3 = {set {x3}, set {x3}, set {x3}}                 |
|                                                    |
|o3 : List                                           |
+----------------------------------------------------+

See also
========

  * janetMultVar -- return table of multiplicative
    variables for given module elements as determined by Janet division
  * janetBasis -- compute Janet basis for an ideal or a
    submodule of a free module
  * multVar -- extract the sets of multiplicative variables for
    each generator (in several contexts)
  * isPommaretBasis -- check whether or not a given
    Janet basis is also a Pommaret basis

Ways to use pommaretMultVar :
=============================

  * "pommaretMultVar(List)"
  * "pommaretMultVar(Matrix)"

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

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