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

SegreClasses -- Tests containment of varieties and computes algebraic multiplicity of subvarieties and Fulton-MacPherson intersection products - via a very general Segre class computation
*******************************************************************************************************************************************************************************************

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

This package tests containment of (irreducible) varieties and computes Segre
classes, algebraic multiplicity, and Fulton-MacPherson intersection products.
More generally, for subschemes of  \PP^{n_1}x...x\PP^{n_m}, this package tests
if a top-dimensional irreducible component of the scheme associated to an ideal
is contained in the scheme associated to another ideal. Specialized methods to
test the containment of a variety in the singular locus of another are
provided, these methods work without computing the ideal of the singular locus
and can provide significant speed-ups relative to the standard methods when the
singular locus has a complicated structure. The package works for subschemes of
products of projective spaces. The package implements methods described in [1].
More details and relevant definitions can be found in [1].

References:\break [1] Corey Harris and Martin Helmer. "Segre class computation
and practical applications." arXiv preprint arXiv:1806.07408 (2018). Link:
https://arxiv.org/abs/1806.07408.

Authors
=======

  * Martin Helmer (see http://martin-helmer.com ) <mhelmer@ncsu.edu>
  * Corey Harris (see http://coreyharris.name ) <Corey.Harris@mis.mpg.de>

Version
=======

This documentation describes version 1.03 of SegreClasses, released May 22,
2022.

Citation
========

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

+----------------------------------------------------------------------------+
|@misc{SegreClassesSource,                                                   |
|  title = {{SegreClasses: A \emph{Macaulay2} package. Version~1.03}},       |
|  author = {Martin Helmer and Corey Harris},                                |
|  howpublished = {A \emph{Macaulay2} package available at                   |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}}|
|}                                                                           |
|                                                                            |
+----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * chowClass -- Finds the (fundamental) class of a
        subscheme in the Chow ring of the ambient space
      * containedInSingularLocus -- This
        method tests is an irreducible variety is contained in the singular
        locus of the reduced scheme of an irreducible scheme
      * intersectionProduct -- A class in the Chow
        ring of the ambient space representing the Fulton-MacPherson
        intersection product of two schemes inside a variety
      * isComponentContained -- Tests containment
        of (irreducible) varieties
      * isMultiHom -- Tests if an ideal is multi-homogeneous
        with respect to the grading of its ring
      * makeChowRing -- Makes the Chow ring of a product
        of projective spaces.
      * makeProductRing -- Makes the coordinate ring of
        a product of projective spaces.
      * multiplicity -- This method computes the algebraic
        (Hilbert-Samuel) multiplicity
      * projectiveDegree -- This method computes a
        single projective degree of a scheme X inside a scheme Y, where X,Y are
        subschemes of some product of projective spaces
      * projectiveDegrees -- This method computes the
        projective degrees of a scheme X inside a scheme Y, where X,Y are
        subschemes of some product of projective spaces
      * segre -- This method computes the Segre class of a scheme
        X inside a scheme Y, where X,Y are subschemes of some product of
        projective spaces
      * segreDimX -- This method computes the dimension X
        part of the Segre class of a scheme X inside a scheme Y, where X,Y are
        subschemes of some product of projective spaces
  * Methods
      * "chowClass(Ideal)" -- see chowClass, -- Finds the
        (fundamental) class of a subscheme in the Chow ring of the ambient
        space
      * "chowClass(Ideal,QuotientRing)" -- see chowClass, --
        Finds the (fundamental) class of a subscheme in the Chow ring of the
        ambient space
      * "containedInSingularLocus(Ideal,Ideal)" -- see
        containedInSingularLocus, -- This method
        tests is an irreducible variety is contained in the singular locus of
        the reduced scheme of an irreducible scheme
      * "intersectionProduct(Ideal,Ideal,Ideal)" -- see
        intersectionProduct, -- A class in the Chow ring
        of the ambient space representing the Fulton-MacPherson intersection
        product of two schemes inside a variety
      * "intersectionProduct(Ideal,Ideal,Ideal,QuotientRing)" -- see
        intersectionProduct, -- A class in the Chow ring
        of the ambient space representing the Fulton-MacPherson intersection
        product of two schemes inside a variety
      * "isComponentContained(Ideal,Ideal)" -- see isComponentContained,
        -- Tests containment of (irreducible) varieties
      * "isMultiHom(Ideal)" -- see isMultiHom, -- Tests if an
        ideal is multi-homogeneous with respect to the grading of its ring
      * isMultiHom(RingElement) (missing documentation)
      * "makeChowRing(Ring)" -- see makeChowRing, -- Makes
        the Chow ring of a product of projective spaces.
      * "makeChowRing(Ring,Symbol)" -- see makeChowRing, --
        Makes the Chow ring of a product of projective spaces.
      * "makeProductRing(List)" -- see makeProductRing,
        -- Makes the coordinate ring of a product of projective spaces.
      * "makeProductRing(Ring,List)" -- see makeProductRing,
        -- Makes the coordinate ring of a product of
        projective spaces.
      * makeProductRing(Ring,Symbol,List) (missing documentation)
      * makeProductRing(Symbol,List) (missing documentation)
      * "multiplicity(Ideal,Ideal)" -- see multiplicity, --
        This method computes the algebraic (Hilbert-Samuel) multiplicity
      * "projectiveDegree(Ideal,Ideal,RingElement)" -- see
        projectiveDegree, -- This method computes a single
        projective degree of a scheme X inside a scheme Y, where X,Y are
        subschemes of some product of projective spaces
      * "projectiveDegrees(Ideal,Ideal)" -- see projectiveDegrees,
        -- This method computes the projective degrees of a
        scheme X inside a scheme Y, where X,Y are subschemes of some product of
        projective spaces
      * "projectiveDegrees(Ideal,Ideal,QuotientRing)" -- see
        projectiveDegrees, -- This method computes the
        projective degrees of a scheme X inside a scheme Y, where X,Y are
        subschemes of some product of projective spaces
      * "segre(Ideal,Ideal)" -- see segre, -- This method computes
        the Segre class of a scheme X inside a scheme Y, where X,Y are
        subschemes of some product of projective spaces
      * "segre(Ideal,Ideal,QuotientRing)" -- see segre, -- This
        method computes the Segre class of a scheme X inside a scheme Y, where
        X,Y are subschemes of some product of projective spaces
      * "segreDimX(Ideal,Ideal,QuotientRing)" -- see segreDimX,
        -- This method computes the dimension X part of the Segre
        class of a scheme X inside a scheme Y, where X,Y are subschemes of some
        product of projective spaces

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

The object SegreClasses, is a package (Macaulay2Doc),
defined in SegreClasses.m2.

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

The source of this document is in SegreClasses.m2:941:0.

chowClass -- Finds the (fundamental) class of a subscheme in the Chow ring of the ambient space
***********************************************************************************************

  * Usage:
        chowClass(IX)
        chowClass(IX,A)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), an ideal in the multi-graded
        coordinate ring of \PP^{n_1}x...x\PP^{n_m}; see makeProductRing,
        builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * A, a quotient ring (Macaulay2Doc), the Chow ring of
        \PP^{n_1}x...x\PP^{n_m}. This ring can be built by applying
        makeChowRing, to the coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Strategy (missing documentation) => ..., default value "multidegree",
        multidegree, using "prob" uses a probabilistic method which is
        sometimes faster on large examples
  * Outputs:
      * isMultHom, a ring element (Macaulay2Doc), the class
        [X] in A where X is the subscheme associated to IX

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

Given a subscheme X of \PP^{n_1}x...x\PP^{n_m} this method computes [X] in the
Chow ring of \PP^{n_1}x...x\PP^{n_m}.

+--------------------------------------+
|i1 : R=makeProductRing({6})           |
|                                      |
|o1 = R                                |
|                                      |
|o1 : PolynomialRing                   |
+--------------------------------------+
|i2 : x=gens(R)                        |
|                                      |
|o2 = {a, b, c, d, e, f, g}            |
|                                      |
|o2 : List                             |
+--------------------------------------+
|i3 : J=ideal(x_0*x_2-x_4*x_5)         |
|                                      |
|o3 = ideal(a*c - e*f)                 |
|                                      |
|o3 : Ideal of R                       |
+--------------------------------------+
|i4 : clX=chowClass(J,Strategy=>"prob")|
|                                      |
|o4 = 2H                               |
|       1                              |
|                                      |
|     ZZ[H ]                           |
|         1                            |
|o4 : ------                           |
|        7                             |
|       H                              |
|        1                             |
+--------------------------------------+
|i5 : clX2=chowClass(J,ring(clX))      |
|                                      |
|o5 = 2H                               |
|       1                              |
|                                      |
|     ZZ[H ]                           |
|         1                            |
|o5 : ------                           |
|        7                             |
|       H                              |
|        1                             |
+--------------------------------------+
|i6 : clX==clX2                        |
|                                      |
|o6 = true                             |
+--------------------------------------+

Ways to use chowClass:
======================

  * "chowClass(Ideal)"
  * "chowClass(Ideal,QuotientRing)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

containedInSingularLocus -- This method tests is an irreducible variety is contained in the singular locus of the reduced scheme of an irreducible scheme
*********************************************************************************************************************************************************

  * Usage:
        containedInSingularLocus(IX,IY)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), a multi-homogeneous prime
        ideal defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IY, an ideal (Macaulay2Doc), a multi-homogeneous primary
        ideal defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * contSingLoc, a Boolean value (Macaulay2Doc), whether or
        not the variety X associated to IX is contained in the singular locus
        of the variety associated to the radical of IY

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

For a subvariety X of \PP^{n_1}x...x\PP^{n_m} and an irreducible subscheme Y of
\PP^{n_1}x...x\PP^{n_m} this command tests whether X is contained in the
singular locus of the reduced scheme of Y (i.e. the singular locus of the
variety defined by the radical of the ideal defining Y).

+-----------------------------------------------------------------------------+
|i1 : n=6                                                                     |
|                                                                             |
|o1 = 6                                                                       |
+-----------------------------------------------------------------------------+
|i2 : R = makeProductRing({n})                                                |
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : x=gens(R)                                                               |
|                                                                             |
|o3 = {a, b, c, d, e, f, g}                                                   |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : m=matrix{for i from 0 to n-3 list x_i,for i from 0 to n-3 list          |
|                                                                             |
|o4 = | a    b    c    d    |                                                 |
|     | 3d   4e   5f   6g   |                                                 |
|     | c    d    e    f    |                                                 |
|     | a+5b b+6c c+7d d+8e |                                                 |
|                                                                             |
|             4      4                                                        |
|o4 : Matrix R  <-- R                                                         |
|-----------------------------------------------------------------------------|
|(i+3)*x_(i+3),for i from 0 to n-3 list x_(i+2),for i from 0 to n-3 list      |
|-----------------------------------------------------------------------------|
|x_(i)+(5+i)*x_(i+1)}                                                         |
+-----------------------------------------------------------------------------+
|i5 : C=ideal mingens(minors(3,m));                                           |
|                                                                             |
|o5 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i6 : P=ideal(x_0,x_4,x_3,x_2,x_1)                                            |
|                                                                             |
|o6 = ideal (a, e, d, c, b)                                                   |
|                                                                             |
|o6 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i7 : containedInSingularLocus(P,C)                                           |
|                                                                             |
|o7 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use containedInSingularLocus:
=====================================

  * "containedInSingularLocus(Ideal,Ideal)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

intersectionProduct -- A class in the Chow ring of the ambient space representing the Fulton-MacPherson intersection product of two schemes inside a variety
************************************************************************************************************************************************************

  * Usage:
        intersectionProduct(IX,IV,IY)
        intersectionProduct(IX,IV,IY,A)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IV, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IY, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a smooth complete intersection in \PP^{n_1}x...x\PP^{n_m};
        see makeProductRing, builds the graded coordinate
        ring of \PP^{n_1}x...x\PP^{n_m}.
      * A, a quotient ring (Macaulay2Doc), the Chow ring of
        \PP^{n_1}x...x\PP^{n_m}. This ring can be built by applying
        makeChowRing, to the coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * intProd, a ring element (Macaulay2Doc), a class in
        the Chow ring A of \PP^{n_1}x...x\PP^{n_m} representing the
        Fulton-MacPherson intersection product of X with V in Y (where X is the
        scheme associated to IX, etc.).

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

For subschemes X,V of a smooth complete intersection subvariety Y of
\PP^{n_1}x...x\PP^{n_m} this command computes the Fulton-MacPherson
intersection product of X with V in Y as a class in the Chow ring of
\PP^{n_1}x...x\PP^{n_m}. Note that this command requires that Y is a smooth
complete intersection subvariety, however this is not checked internally.

+-----------------------------------------------+
|i1 : R = makeProductRing({3})                  |
|                                               |
|o1 = R                                         |
|                                               |
|o1 : PolynomialRing                            |
+-----------------------------------------------+
|i2 : (x,y,z,w) = toSequence gens R             |
|                                               |
|o2 = (a, b, c, d)                              |
|                                               |
|o2 : Sequence                                  |
+-----------------------------------------------+
|i3 : Q = ideal(x*y-z*w)                        |
|                                               |
|o3 = ideal(a*b - c*d)                          |
|                                               |
|o3 : Ideal of R                                |
+-----------------------------------------------+
|i4 : L1 = ideal(x,w)                           |
|                                               |
|o4 = ideal (a, d)                              |
|                                               |
|o4 : Ideal of R                                |
+-----------------------------------------------+
|i5 : L2 = ideal(y,w)                           |
|                                               |
|o5 = ideal (b, d)                              |
|                                               |
|o5 : Ideal of R                                |
+-----------------------------------------------+
|i6 : intersectionProduct(L1,L2,Q,Verbose=>true)|
|      2 2                                      |
|[Y]= H H , alpha= 2H  + 2H                     |
|      1 2           1     2                    |
|                       3 3                     |
|Projective degrees= {7H H }                    |
|                       1 2                     |
|         3 3                                   |
|s(X,Y)= H H                                    |
|         1 2                                   |
|                              3                |
|Segre pullback to diagonal = H                 |
|                              1                |
|                2                              |
|Chern class = 2H  + 2H  + 1                    |
|                1     1                        |
|                                               |
|      3                                        |
|o6 = H                                         |
|      1                                        |
|                                               |
|     ZZ[H ]                                    |
|         1                                     |
|o6 : ------                                    |
|        4                                      |
|       H                                       |
|        1                                      |
+-----------------------------------------------+
|i7 : intersectionProduct(L1,L1,Q)              |
|                                               |
|o7 = 0                                         |
+-----------------------------------------------+

Ways to use intersectionProduct:
================================

  * "intersectionProduct(Ideal,Ideal,Ideal)"
  * "intersectionProduct(Ideal,Ideal,Ideal,QuotientRing)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

isComponentContained -- Tests containment of (irreducible) varieties
********************************************************************

  * Usage:
        isComponentContained(IX,IY)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IY, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * isCompCont, a Boolean value (Macaulay2Doc), whether or
        not a top-dimensional irreducible (and reduced) component of the scheme
        X associated to IX is contained in the scheme Y associated to IY

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

For a subschemes X of an irreducible subscheme Y of \PP^{n_1}x...x\PP^{n_m}
this command tests whether or not a top-dimensional irreducible (and reduced)
component of X is contained in Y

+-----------------------------------------------------------------------------+
|i1 : R = makeProductRing({2,2,2})                                            |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : x=(gens R)_{0..2}                                                       |
|                                                                             |
|o2 = {a, b, c}                                                               |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : y=(gens R)_{3..5}                                                       |
|                                                                             |
|o3 = {d, e, f}                                                               |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : z=(gens R)_{6..8}                                                       |
|                                                                             |
|o4 = {g, h, i}                                                               |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : m1=matrix{{x_0,x_1,5*x_2},y_{0..2},{2*z_0,7*z_1,25*z_2}}                |
|                                                                             |
|o5 = | a  b  5c  |                                                           |
|     | d  e  f   |                                                           |
|     | 2g 7h 25i |                                                           |
|                                                                             |
|             3      3                                                        |
|o5 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i6 : m2=matrix{{9*z_0,4*z_1,3*z_2},y_{0..2},x_{0..2}}                        |
|                                                                             |
|o6 = | 9g 4h 3i |                                                            |
|     | d  e  f  |                                                            |
|     | a  b  c  |                                                            |
|                                                                             |
|             3      3                                                        |
|o6 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i7 : W=minors(3,m1)+minors(3,m2);                                            |
|                                                                             |
|o7 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i8 : f=random({1,1,1},R);                                                    |
+-----------------------------------------------------------------------------+
|i9 : Y=ideal (z_0*W_0-z_1*W_1)+ideal(f);                                     |
|                                                                             |
|o9 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i10 : X=((W)*ideal(y)+ideal(f));                                             |
|                                                                             |
|o10 : Ideal of R                                                             |
+-----------------------------------------------------------------------------+
|i11 : time isComponentContained(X,Y)                                         |
| -- used 4.54083s (cpu); 3.9632s (thread); 0s (gc)                           |
|                                                                             |
|o11 = true                                                                   |
+-----------------------------------------------------------------------------+
|i12 : print "we could confirm this with the computation:"                    |
|we could confirm this with the computation:                                  |
+-----------------------------------------------------------------------------+
|i13 : B=ideal(x)*ideal(y)*ideal(z)                                           |
|                                                                             |
|o13 = ideal (a*d*g, a*d*h, a*d*i, a*e*g, a*e*h, a*e*i, a*f*g, a*f*h, a*f*i,  |
|      -----------------------------------------------------------------------|
|      b*d*g, b*d*h, b*d*i, b*e*g, b*e*h, b*e*i, b*f*g, b*f*h, b*f*i, c*d*g,  |
|      -----------------------------------------------------------------------|
|      c*d*h, c*d*i, c*e*g, c*e*h, c*e*i, c*f*g, c*f*h, c*f*i)                |
|                                                                             |
|o13 : Ideal of R                                                             |
+-----------------------------------------------------------------------------+
|i14 : time isSubset(saturate(Y,B),saturate(X,B))                             |
| -- used 75.9793s (cpu); 72.8864s (thread); 0s (gc)                          |
|                                                                             |
|o14 = true                                                                   |
+-----------------------------------------------------------------------------+

Ways to use isComponentContained:
=================================

  * "isComponentContained(Ideal,Ideal)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

isMultiHom -- Tests if an ideal is multi-homogeneous with respect to the grading of its ring
********************************************************************************************

  * Usage:
        isMultiHom(X)
  * Inputs:
      * X, an ideal (Macaulay2Doc), an ideal in the multi-graded
        coordinate ring of \PP^{n_1}x...x\PP^{n_m}; see makeProductRing,
        builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Outputs:
      * isMultHom, a Boolean value (Macaulay2Doc), whether the
        input ideal is multi-homogeneous with respect to the grading of its
        ring

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

Given an ideal in the coordinate R ring of \PP^{n_1}x...x\PP^{n_m} this method
tests if whether the input ideal is multi-homogeneous with respect to the
grading on R.

+---------------------------------------------------------------+
|i1 : R = makeProductRing({1,2})                                |
|                                                               |
|o1 = R                                                         |
|                                                               |
|o1 : PolynomialRing                                            |
+---------------------------------------------------------------+
|i2 : x=gens R                                                  |
|                                                               |
|o2 = {a, b, c, d, e}                                           |
|                                                               |
|o2 : List                                                      |
+---------------------------------------------------------------+
|i3 : degrees R                                                 |
|                                                               |
|o3 = {{1, 0}, {1, 0}, {0, 1}, {0, 1}, {0, 1}}                  |
|                                                               |
|o3 : List                                                      |
+---------------------------------------------------------------+
|i4 : isMultiHom ideal(x_0^2*x_2+x_1*x_2^2)                     |
|Input term below is not homogeneous with respect to the grading|
| 2       2                                                     |
|a c + b*c                                                      |
|                                                               |
|o4 = false                                                     |
+---------------------------------------------------------------+
|i5 : isMultiHom ideal(x_0^2*x_2+x_1^2*x_3)                     |
|                                                               |
|o5 = true                                                      |
+---------------------------------------------------------------+

Ways to use isMultiHom:
=======================

  * "isMultiHom(Ideal)"
  * isMultiHom(RingElement) (missing documentation)

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

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

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

The source of this document is in SegreClasses.m2:941:0.

makeChowRing -- Makes the Chow ring of a product of projective spaces.
**********************************************************************

  * Usage:
        makeChowRing(R)
        makeChowRing(R,h)
  * Inputs:
      * n, a list (Macaulay2Doc), a multi-graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * h, a symbol (Macaulay2Doc), the symbol to be used as the
        variable in the Chow ring
  * Outputs:
      * a quotient ring (Macaulay2Doc), the Chow ring of
        \PP^{n_1}x...x\PP^{n_m}.

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

Builds the Chow ring Z[H_1,...,H_m]/(H_1^{n_1+1},...,H_m^{n_m+1}) of
\PP^{n_1}x...x\PP^{n_m}.

+-------------------------------+
|i1 : R = makeProductRing({3,4})|
|                               |
|o1 = R                         |
|                               |
|o1 : PolynomialRing            |
+-------------------------------+
|i2 : R = makeChowRing(R)       |
|                               |
|o2 = R                         |
|                               |
|o2 : QuotientRing              |
+-------------------------------+
|i3 : describe R                |
|                               |
|     ZZ[H ..H ]                |
|         1   2                 |
|o3 = ----------                |
|        4   5                  |
|      (H , H )                 |
|        1   2                  |
+-------------------------------+

Ways to use makeChowRing:
=========================

  * "makeChowRing(Ring)"
  * "makeChowRing(Ring,Symbol)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

makeProductRing -- Makes the coordinate ring of a product of projective spaces.
*******************************************************************************

  * Usage:
        makeProductRing(n)
        makeProductRing(kk,n)
  * Inputs:
      * n, a list (Macaulay2Doc), a list {n_1,...,n_m} of the
        dimensions of the m projective spaces in the product
        \PP^{n_1}x...x\PP^{n_m}.
      * kk, a ring (Macaulay2Doc), the coefficient ring to be used
  * Outputs:
      * a ring (Macaulay2Doc), the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.

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

Builds the multi-graded coordinate ring of \PP^{n_1}x...x\PP^{n_m}.

+-----------------------------------------------------------------------------+
|i1 : R = makeProductRing(QQ,{3,4})                                           |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : R = makeProductRing({3,4})                                              |
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : degrees R                                                               |
|                                                                             |
|o3 = {{1, 0}, {1, 0}, {1, 0}, {1, 0}, {0, 1}, {0, 1}, {0, 1}, {0, 1}, {0, 1}}|
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : gens R                                                                  |
|                                                                             |
|o4 = {a, b, c, d, e, f, g, h, i}                                             |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use makeProductRing:
============================

  * "makeProductRing(List)"
  * "makeProductRing(Ring,List)"
  * makeProductRing(Ring,Symbol,List) (missing documentation)
  * makeProductRing(Symbol,List) (missing documentation)

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

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

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

The source of this document is in SegreClasses.m2:941:0.

multiplicity -- This method computes the algebraic (Hilbert-Samuel) multiplicity
********************************************************************************

  * Usage:
        multiplicity(IX,IY)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), a multi-homogeneous prime
        ideal defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IY, an ideal (Macaulay2Doc), a multi-homogeneous primary
        ideal defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * eXY, an integer (Macaulay2Doc), the algebraic
        (Hilbert-Samuel) multiplicity e_XY of the variety X associated to IX in
        the scheme Y associated to IY.

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

For a subvariety X of an irreducible subscheme Y of \PP^{n_1}x...x\PP^{n_m}
this command computes the algebraic multiplicity e_XY of X in Y. Let R be the
coordinate ring of \PP^{n_1}x...x\PP^{n_m}, let O_{X,Y}=(R/I_Y)_{I_X} be the
local ring obtained by localizing (R/I_Y) at the prime ideal I_X, and let len
denote the length of a local ring. Let M be the unique maximal ideal of
O_{X,Y}. The Hilbert-Samuel polynomial is the polynomial
P_{HS}(t)=len(O_{X,Y}/M^t) for t large. In different words, this command
computes the leading coefficient of the Hilbert-Samuel polynomial P_{HS}(t)
associated to O_{X,Y}. Below we have an example of the multiplicity of the
twisted cubic in a double twisted cubic.

+------------------------------------------------+
|i1 : R = ZZ/32749[x,y,z,w]                      |
|                                                |
|o1 = R                                          |
|                                                |
|o1 : PolynomialRing                             |
+------------------------------------------------+
|i2 : X = ideal(-z^2+y*w,-y*z+x*w,-y^2+x*z)      |
|                                                |
|               2                        2       |
|o2 = ideal (- z  + y*w, - y*z + x*w, - y  + x*z)|
|                                                |
|o2 : Ideal of R                                 |
+------------------------------------------------+
|i3 : Y = ideal(-z^3+2*y*z*w-x*w^2,-y^2+x*z)     |
|                                                |
|               3               2     2          |
|o3 = ideal (- z  + 2y*z*w - x*w , - y  + x*z)   |
|                                                |
|o3 : Ideal of R                                 |
+------------------------------------------------+
|i4 : multiplicity(X,Y)                          |
|                                                |
|o4 = 2                                          |
|                                                |
|o4 : QQ                                         |
+------------------------------------------------+

Ways to use multiplicity:
=========================

  * "multiplicity(Ideal,Ideal)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

projectiveDegree -- This method computes a single projective degree of a scheme X inside a scheme Y, where X,Y are subschemes of some product of projective spaces
******************************************************************************************************************************************************************

  * Usage:
        projectiveDegree(IX,IY,h)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IY, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * h, a ring element (Macaulay2Doc), an element of the
        Chow ring of \PP^{n_1}x...x\PP^{n_m}. This ring can be built by
        applying makeChowRing, to the coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * pd, a ring element (Macaulay2Doc), a projective
        degree associated to h of a subscheme X defined by IX in the subscheme
        Y defined by IY as classes in the Chow ring A of
        \PP^{n_1}x...x\PP^{n_m}.

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

For subschemes X, Y of \PP^{n_1}x...x\PP^{n_m} this command computes a
projective degree associated to h of a subscheme X in the subscheme Y as
classes in the Chow ring of \PP^{n_1}x...x\PP^{n_m}. The value returned is an
integer. This method is faster if only one projective degree is needed.

+-----------------------------------------------------------------------------+
|i1 : R = makeProductRing({3,3})                                              |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : x = gens(R)                                                             |
|                                                                             |
|o2 = {a, b, c, d, e, f, g, h}                                                |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : D = minors(2,matrix{{x_0..x_3},{x_4..x_7}})                             |
|                                                                             |
|o3 = ideal (- b*e + a*f, - c*e + a*g, - c*f + b*g, - d*e + a*h, - d*f + b*h, |
|     ------------------------------------------------------------------------|
|     - d*g + c*h)                                                            |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i4 : X = ideal(x_0*x_1,x_1*x_2,x_0*x_2)                                      |
|                                                                             |
|o4 = ideal (a*b, b*c, a*c)                                                   |
|                                                                             |
|o4 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i5 : A = makeChowRing(R)                                                     |
|                                                                             |
|o5 = A                                                                       |
|                                                                             |
|o5 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i6 : pd = projectiveDegrees(X,D,A)                                           |
|                                                                             |
|         3 3    2 3    3 2      3    2 2    3                                |
|o6 = {10H H , 6H H , 6H H , 3H H , 3H H , 3H H }                             |
|         1 2    1 2    1 2    1 2    1 2    1 2                              |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+
|i7 : h=A_0^2*A_1^2                                                           |
|                                                                             |
|      2 2                                                                    |
|o7 = H H                                                                     |
|      1 2                                                                    |
|                                                                             |
|o7 : A                                                                       |
+-----------------------------------------------------------------------------+
|i8 : pdh=projectiveDegree(X,D,h)                                             |
|                                                                             |
|o8 = 3                                                                       |
+-----------------------------------------------------------------------------+
|i9 : (sum pd)_h==pdh                                                         |
|                                                                             |
|o9 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use projectiveDegree:
=============================

  * "projectiveDegree(Ideal,Ideal,RingElement)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

projectiveDegrees -- This method computes the projective degrees of a scheme X inside a scheme Y, where X,Y are subschemes of some product of projective spaces
***************************************************************************************************************************************************************

  * Usage:
        projectiveDegrees(IX,IY)
        projectiveDegrees(IX,IY,A)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IY, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * A, a quotient ring (Macaulay2Doc), the Chow ring of
        \PP^{n_1}x...x\PP^{n_m}. This ring can be built by applying
        makeChowRing, to the coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * pd, a list (Macaulay2Doc), a list of the projective degrees
        of a subscheme X defined by IX in the subscheme Y defined by IY as
        classes in the Chow ring of \PP^{n_1}x...x\PP^{n_m}.

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

For subschemes X,Y of \PP^{n_1}x...x\PP^{n_m} this command computes  a list of
the projective degrees of a subscheme X in the subscheme Y as classes in the
Chow ring of \PP^{n_1}x...x\PP^{n_m}.

+-----------------------------------------------------------------------------+
|i1 : R = makeProductRing({3,3})                                              |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : x = gens(R)                                                             |
|                                                                             |
|o2 = {a, b, c, d, e, f, g, h}                                                |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : D = minors(2,matrix{{x_0..x_3},{x_4..x_7}})                             |
|                                                                             |
|o3 = ideal (- b*e + a*f, - c*e + a*g, - c*f + b*g, - d*e + a*h, - d*f + b*h, |
|     ------------------------------------------------------------------------|
|     - d*g + c*h)                                                            |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i4 : X = ideal(x_0*x_1,x_1*x_2,x_0*x_2)                                      |
|                                                                             |
|o4 = ideal (a*b, b*c, a*c)                                                   |
|                                                                             |
|o4 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i5 : projectiveDegrees(X,D)                                                  |
|                                                                             |
|         3 3    2 3    3 2      3    2 2    3                                |
|o5 = {10H H , 6H H , 6H H , 3H H , 3H H , 3H H }                             |
|         1 2    1 2    1 2    1 2    1 2    1 2                              |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : A = makeChowRing(R)                                                     |
|                                                                             |
|o6 = A                                                                       |
|                                                                             |
|o6 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i7 : pd = projectiveDegrees(X,D,A)                                           |
|                                                                             |
|         3 3    2 3    3 2      3    2 2    3                                |
|o7 = {10H H , 6H H , 6H H , 3H H , 3H H , 3H H }                             |
|         1 2    1 2    1 2    1 2    1 2    1 2                              |
|                                                                             |
|o7 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use projectiveDegrees:
==============================

  * "projectiveDegrees(Ideal,Ideal)"
  * "projectiveDegrees(Ideal,Ideal,QuotientRing)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

segre -- This method computes the Segre class of a scheme X inside a scheme Y, where X,Y are subschemes of some product of projective spaces
********************************************************************************************************************************************

  * Usage:
        segre(IX,IY)
        segre(IX,IY,A)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IY, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * A, a quotient ring (Macaulay2Doc), the Chow ring of
        \PP^{n_1}x...x\PP^{n_m}. This ring can be built by applying
        makeChowRing, to the coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * s, a ring element (Macaulay2Doc), the Segre class of
        the subscheme X defined by IX in the subscheme Y defined by IY as a
        class in the Chow ring of \PP^{n_1}x...x\PP^{n_m}.

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

For subschemes X,Y of \PP^{n_1}x...x\PP^{n_m} this command computes the Segre
class s(X,Y) of X in Y as a class in the Chow ring of \PP^{n_1}x...x\PP^{n_m}.

+-----------------------------------------------------------------------------+
|i1 : R = makeProductRing({3,3})                                              |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : x = gens(R)                                                             |
|                                                                             |
|o2 = {a, b, c, d, e, f, g, h}                                                |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+
|i3 : D = minors(2,matrix{{x_0..x_3},{x_4..x_7}})                             |
|                                                                             |
|o3 = ideal (- b*e + a*f, - c*e + a*g, - c*f + b*g, - d*e + a*h, - d*f + b*h, |
|     ------------------------------------------------------------------------|
|     - d*g + c*h)                                                            |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i4 : X = ideal(x_0*x_1,x_1*x_2,x_0*x_2)                                      |
|                                                                             |
|o4 = ideal (a*b, b*c, a*c)                                                   |
|                                                                             |
|o4 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i5 : segre(X,D)                                                              |
|                                                                             |
|          3 3     3 2     2 3                                                |
|o5 = - 10H H  + 3H H  + 3H H                                                 |
|          1 2     1 2     1 2                                                |
|                                                                             |
|     ZZ[H ..H ]                                                              |
|         1   2                                                               |
|o5 : ----------                                                              |
|        4   4                                                                |
|      (H , H )                                                               |
|        1   2                                                                |
+-----------------------------------------------------------------------------+
|i6 : A = makeChowRing(R)                                                     |
|                                                                             |
|o6 = A                                                                       |
|                                                                             |
|o6 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i7 : s = segre(X,D,A)                                                        |
|                                                                             |
|          3 3     3 2     2 3                                                |
|o7 = - 10H H  + 3H H  + 3H H                                                 |
|          1 2     1 2     1 2                                                |
|                                                                             |
|o7 : A                                                                       |
+-----------------------------------------------------------------------------+

Ways to use segre:
==================

  * "segre(Ideal,Ideal)"
  * "segre(Ideal,Ideal,QuotientRing)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.

segreDimX -- This method computes the dimension X part of the Segre class of a scheme X inside a scheme Y, where X,Y are subschemes of some product of projective spaces
************************************************************************************************************************************************************************

  * Usage:
        segreDimX(IX,IY,A)
  * Inputs:
      * IX, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * IY, an ideal (Macaulay2Doc), a multi-homogeneous ideal
        defining a closed subscheme of \PP^{n_1}x...x\PP^{n_m}; see
        makeProductRing, builds the graded coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
      * A, a quotient ring (Macaulay2Doc), the Chow ring of
        \PP^{n_1}x...x\PP^{n_m}. This ring can be built by applying
        makeChowRing, to the coordinate ring of
        \PP^{n_1}x...x\PP^{n_m}.
  * Optional inputs (Macaulay2Doc),:
      * Verbose (missing documentation) => a Boolean value (Macaulay2Doc),
        default value false,
  * Outputs:
      * s, a ring element (Macaulay2Doc), the dimension X
        part of the Segre class of the subscheme X defined by IX in the
        subscheme Y defined by IY as a class in the Chow ring of
        \PP^{n_1}x...x\PP^{n_m}.

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

For subschemes X,Y of \PP^{n_1}x...x\PP^{n_m} this command computes the
dimension X part of the Segre class s(X,Y) of X in Y as a class in the Chow
ring of \PP^{n_1}x...x\PP^{n_m}. This is faster than computing the entire Segre
class.

+-----------------------------------------------------+
|i1 : R = makeProductRing({2,2})                      |
|                                                     |
|o1 = R                                               |
|                                                     |
|o1 : PolynomialRing                                  |
+-----------------------------------------------------+
|i2 : x = gens(R)                                     |
|                                                     |
|o2 = {a, b, c, d, e, f}                              |
|                                                     |
|o2 : List                                            |
+-----------------------------------------------------+
|i3 : Y = ideal(random({2,2},R));                     |
|                                                     |
|o3 : Ideal of R                                      |
+-----------------------------------------------------+
|i4 : X = Y+ideal(x_0*x_3+x_1*x_4);                   |
|                                                     |
|o4 : Ideal of R                                      |
+-----------------------------------------------------+
|i5 : A = makeChowRing(R)                             |
|                                                     |
|o5 = A                                               |
|                                                     |
|o5 : QuotientRing                                    |
+-----------------------------------------------------+
|i6 : time s = segreDimX(X,Y,A)                       |
| -- used 0.252754s (cpu); 0.186137s (thread); 0s (gc)|
|                                                     |
|       2             2                               |
|o6 = 2H  + 4H H  + 2H                                |
|       1     1 2     2                               |
|                                                     |
|o6 : A                                               |
+-----------------------------------------------------+
|i7 : time segre(X,Y,A)                               |
| -- used 0.160057s (cpu); 0.121474s (thread); 0s (gc)|
|                                                     |
|        2 2     2         2     2             2      |
|o7 = 12H H  - 6H H  - 6H H  + 2H  + 4H H  + 2H       |
|        1 2     1 2     1 2     1     1 2     2      |
|                                                     |
|o7 : A                                               |
+-----------------------------------------------------+

Ways to use segreDimX:
======================

  * "segreDimX(Ideal,Ideal,QuotientRing)"

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

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

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

The source of this document is in SegreClasses.m2:941:0.