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

Points -- A package for making and studying points in affine and projective spaces
**********************************************************************************

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

The package has routines for points in affine and projective spaces. The affine
code, some of which uses the Buchberger-Moeller algorithm to more quickly
compute the ideals of points in affine space, was written by Stillman, Smith
and Stromme. The projective code was written separately by Eisenbud and
Popescu.

The purpose of the projective code was to find as many counterexamples as
possible to the minimal resolution conjecture; it was of use in the research
for the paper "Exterior algebra methods for the minimal resolution conjecture",
by  David Eisenbud, Sorin Popescu, Frank-Olaf Schreyer and Charles Walter (Duke
Mathematical Journal. 112 (2002), no.2, 379-395.) The first few of these
counterexamples are: (6,11), (7,12), (8,13), (10,16), where the first integer
denotes the ambient dimension and the second the number of points. Examples are
known in every projective space of dimension >=6 except for P^9.

In version 3.0, F. Galetto and J.W. Skelton added code to compute ideals of fat
points and projective points using the Buchberger-Moeller algorithm.

Authors
=======

  * Mike Stillman (see https://macaulay2.com/ ) <mike@math.cornell.edu>
  * Stein A. Strømme <stromme@math.uib.no>
  * David Eisenbud <de@msri.org>
  * Federico Galetto (see http://math.galetto.org )
    <galetto.federico@gmail.com>
  * Joseph W. Skelton <jskelton@tulane.edu>

Version
=======

This documentation describes version 3.0 of Points, released 29 June 2008,
revised by DE June 2016, revised by FG and JWS June 2018.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{PointsSource,                                                          |
|  title = {{Points: sets of points. Version~3.0}},                           |
|  author = {Mike Stillman and Stein A. Str{\o}mme and David Eisenbud and Fede|
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|rico Galetto and Joseph W. Skelton},                                         |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * affineFatPoints -- produces the ideal and
        initial ideal from the coordinates of a finite set of fat points
      * affineFatPointsByIntersection, --
        computes ideal of fat points by intersecting powers of maximal ideals
      * affineMakeRingMaps -- evaluation on points
      * affinePoints -- produces the ideal and initial
        ideal from the coordinates of a finite set of points
      * affinePointsByIntersection, --
        computes ideal of point set by intersecting maximal ideals
      * affinePointsMat -- produces the matrix of
        values of the standard monomials on a set of points
      * expectedBetti -- The betti table of r points in
        Pn according to the minimal resolution conjecture
      * minMaxResolution -- Min and max conceivable
        Betti tables for generic points
      * omegaPoints -- linear part of the presentation of
        canonical module of points
      * points -- make the ideal of a set of points
      * projectiveFatPoints -- produces the ideal
        and initial ideal from the coordinates of a finite set of fat points
      * projectiveFatPointsByIntersection
        -- computes ideal of fat points by
        intersecting powers of point ideals
      * projectivePoints -- produces the ideal and
        initial ideal from the coordinates of a finite set of projective points
      * projectivePointsByIntersection,
        -- computes ideal of projective points by intersecting point ideals
      * randomPoints -- ideal of a random set of points
      * randomPointsMat -- matrix of homogeneous
        coordinates of random points in projective space
  * Methods
      * "affineFatPoints(Matrix,List,Ring)" -- see affineFatPoints,
        -- produces the ideal and initial ideal from the
        coordinates of a finite set of fat points
      * "affineFatPointsByIntersection(Matrix,List,Ring)" -- see
        affineFatPointsByIntersection, --
        computes ideal of fat points by intersecting powers of maximal ideals
      * "affineMakeRingMaps(Matrix,Ring)" -- see affineMakeRingMaps,
        -- evaluation on points
      * "affinePoints(Matrix,Ring)" -- see affinePoints, --
        produces the ideal and initial ideal from the coordinates of a finite
        set of points
      * "affinePointsByIntersection(Matrix,Ring)" -- see
        affinePointsByIntersection, -- computes
        ideal of point set by intersecting maximal ideals
      * "affinePointsMat(Matrix,Ring)" -- see affinePointsMat,
        -- produces the matrix of values of the standard
        monomials on a set of points
      * "projectiveFatPoints(Matrix,List,Ring)" -- see
        projectiveFatPoints, -- produces the ideal and
        initial ideal from the coordinates of a finite set of fat points
      * "projectiveFatPointsByIntersection(Matrix,List,Ring)" -- see
        projectiveFatPointsByIntersection,
        -- computes ideal of fat points by intersecting powers of point ideals
      * "projectivePoints(Matrix,Ring)" -- see projectivePoints,
        -- produces the ideal and initial ideal from the
        coordinates of a finite set of projective points
      * "projectivePointsByIntersection(Matrix,Ring)" -- see
        projectivePointsByIntersection, --
        computes ideal of projective points by intersecting point ideals
      * "randomPointsMat(Ring,ZZ)" -- see randomPointsMat,
        -- matrix of homogeneous coordinates of random points
        in projective space
  * Symbols
      * AllRandom -- Option to randomPointsMat.
      * VerifyPoints -- Option to projectivePoints.

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

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

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

The source of this document is in Points.m2:730:0.

affineFatPoints -- produces the ideal and initial ideal from the coordinates of a finite set of fat points
**********************************************************************************************************

  * Usage:
        (Q,inG,G) = affineFatPoints(M,mults,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the coordinates of a point
      * mults, a list (Macaulay2Doc), in which each element
        determines the multiplicity of the corresponding point
      * R, a ring (Macaulay2Doc), coordinate ring of the affine
        space containing the points
  * Outputs:
      * Q, a list (Macaulay2Doc), list of standard monomials
      * inG, an ideal (Macaulay2Doc), initial ideal of the set of
        fat points
      * G, a list (Macaulay2Doc), list of generators for Grobner
        basis for ideal of fat points

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

This function uses a modified Buchberger-Moeller algorithm to compute a grobner
basis for the ideal of a finite number of fat points in affine space.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : M = transpose matrix{{0,0},{1,1}}                                       |
|                                                                             |
|o2 = | 0 1 |                                                                 |
|     | 0 1 |                                                                 |
|                                                                             |
|              2       2                                                      |
|o2 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i3 : mults = {3,2}                                                           |
|                                                                             |
|o3 = {3, 2}                                                                  |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : (Q,inG,G) = affineFatPoints(M,mults,R)                                  |
|                                                                             |
|                 2        2   3     2   4           2    3     3   5     2   |
|o4 = ({1, y, x, y , x*y, x , y , x*y , y }, ideal (x y, x , x*y , y ), {x y -|
|     ------------------------------------------------------------------------|
|         2    3   3       2     3     3    4      2    3   5     4    3      |
|     2x*y  + y , x  - 3x*y  + 2y , x*y  - y  - x*y  + y , y  - 2y  + y })    |
|                                                                             |
|o4 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i5 : monomialIdeal G == inG                                                  |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

This algorithm may be faster than computing the intersection of the ideals of
each fat point.

+-----------------------------------------------------------------------------+
|i6 : K = ZZ/32003                                                            |
|                                                                             |
|o6 = K                                                                       |
|                                                                             |
|o6 : QuotientRing                                                            |
+-----------------------------------------------------------------------------+
|i7 : R = K[z_1..z_5]                                                         |
|                                                                             |
|o7 = R                                                                       |
|                                                                             |
|o7 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i8 : M = random(K^5,K^12)                                                    |
|                                                                             |
|o8 = | 107   -5307  10359 -6203  8231  9534   6230  13177  10866 -5326 1031  |
|     | 4376  8570   -7464 12365  5864  -7216  9033  13990  5398  2998  -2036 |
|     | -5570 -15344 -8251 -13508 5026  -10125 5107  -11521 5549  5679  -6325 |
|     | 3187  8444   2653  -9480  10259 7256   -3996 -1309  -7061 -7152 -11740|
|     | 3783  -10480 5071  -11950 -7501 -5321  9398  -1779  2627  15317 -6922 |
|     ------------------------------------------------------------------------|
|     -5080 |                                                                 |
|     1236  |                                                                 |
|     8922  |                                                                 |
|     -5006 |                                                                 |
|     8880  |                                                                 |
|                                                                             |
|             5      12                                                       |
|o8 : Matrix K  <-- K                                                         |
+-----------------------------------------------------------------------------+
|i9 : mults = {1,2,3,1,2,3,1,2,3,1,2,3}                                       |
|                                                                             |
|o9 = {1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3}                                    |
|                                                                             |
|o9 : List                                                                    |
+-----------------------------------------------------------------------------+
|i10 : elapsedTime (Q,inG,G) = affineFatPoints(M,mults,R);                    |
| -- 2.46543s elapsed                                                         |
+-----------------------------------------------------------------------------+
|i11 : elapsedTime H = affineFatPointsByIntersection(M,mults,R);              |
| -- 5.4599s elapsed                                                          |
+-----------------------------------------------------------------------------+
|i12 : G==H                                                                   |
|                                                                             |
|o12 = true                                                                   |
+-----------------------------------------------------------------------------+

Caveat
======

For reduced points, this function may be a bit slower than affinePoints.

See also
========

  * affineFatPointsByIntersection(Matrix,List,Ring)
    -- computes ideal of fat points by
    intersecting powers of maximal ideals

Ways to use affineFatPoints:
============================

  * "affineFatPoints(Matrix,List,Ring)"

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

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

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

The source of this document is in Points.m2:1076:0.

affineFatPointsByIntersection -- computes ideal of fat points by intersecting powers of maximal ideals
******************************************************************************************************

  * Usage:
        affineFatPointsByIntersection(M,mults,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the coordinates of a point
      * mults, a list (Macaulay2Doc), in which each element
        determines the multiplicity of the corresponding point
      * R, a ring (Macaulay2Doc), coordinate ring of the affine
        space containing the points
  * Outputs:
      * a list (Macaulay2Doc), grobner basis for ideal of a finite
        set of fat points

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

This function computes the ideal of a finite set of fat points by intersecting
powers of the maximal ideals of each point.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y]                                                             |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : M = transpose matrix{{0,0},{1,1}}                                       |
|                                                                             |
|o2 = | 0 1 |                                                                 |
|     | 0 1 |                                                                 |
|                                                                             |
|              2       2                                                      |
|o2 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i3 : mults = {3,2}                                                           |
|                                                                             |
|o3 = {3, 2}                                                                  |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : affineFatPointsByIntersection(M,mults,R)                                |
|                                                                             |
|       2        2    3   3       2     3     3    4      2    3   5     4    |
|o4 = {x y - 2x*y  + y , x  - 3x*y  + 2y , x*y  - y  - x*y  + y , y  - 2y  +  |
|     ------------------------------------------------------------------------|
|      3                                                                      |
|     y }                                                                     |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * affineFatPoints(Matrix,List,Ring) -- produces the
    ideal and initial ideal from the coordinates of a finite set of fat points

Ways to use affineFatPointsByIntersection:
==========================================

  * "affineFatPointsByIntersection(Matrix,List,Ring)"

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

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

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

The source of this document is in Points.m2:1110:0.

affineMakeRingMaps -- evaluation on points
******************************************

  * Usage:
        affineMakeRingMaps(M,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the coordinates of a point
      * R, a polynomial ring (Macaulay2Doc), coordinate
        ring of the affine space containing the points
  * Outputs:
      * a list (Macaulay2Doc), of ring maps corresponding to
        evaluations at each point

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

Giving the coordinates of a point in affine space is equivalent to giving a
ring map from the polynomial ring to the ground field: evaluation at the point.
Given a finite collection of points encoded as the columns of a matrix, this
function returns a corresponding list of ring maps.
+-----------------------------------------------------------------------------+
|i1 : M = random(ZZ^3, ZZ^5)                                                  |
|                                                                             |
|o1 = | 8 7 3 8 8 |                                                           |
|     | 1 8 7 5 5 |                                                           |
|     | 3 3 8 7 2 |                                                           |
|                                                                             |
|              3       5                                                      |
|o1 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i2 : R = QQ[x,y,z]                                                           |
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : phi = affineMakeRingMaps(M,R)                                           |
|                                                                             |
|o3 = {map (QQ, R, {8, 1, 3}), map (QQ, R, {7, 8, 3}), map (QQ, R, {3, 7, 8}),|
|     ------------------------------------------------------------------------|
|     map (QQ, R, {8, 5, 7}), map (QQ, R, {8, 5, 2})}                         |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : apply (gens(R),r->phi#2 r)                                              |
|                                                                             |
|o4 = {3, 7, 8}                                                               |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : phi#2                                                                   |
|                                                                             |
|o5 = map (QQ, R, {3, 7, 8})                                                  |
|                                                                             |
|o5 : RingMap QQ <-- R                                                        |
+-----------------------------------------------------------------------------+

Ways to use affineMakeRingMaps:
===============================

  * "affineMakeRingMaps(Matrix,Ring)"

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

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

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

The source of this document is in Points.m2:934:0.

affinePoints -- produces the ideal and initial ideal from the coordinates of a finite set of points
***************************************************************************************************

  * Usage:
        (Q,inG,G) = affinePoints(M,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the coordinates of a point
      * R, a polynomial ring (Macaulay2Doc), coordinate
        ring of the affine space containing the points
  * Outputs:
      * Q, a list (Macaulay2Doc), list of standard monomials
      * inG, an ideal (Macaulay2Doc), initial ideal of the set of
        points
      * G, a list (Macaulay2Doc), list of generators for Grobner
        basis for ideal of points

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

This function uses the Buchberger-Moeller algorithm to compute a grobner basis
for the ideal of a finite number of points in affine space.  Here is a simple
example.
+-----------------------------------------------------------------------------+
|i1 : M = random(ZZ^3, ZZ^5)                                                  |
|                                                                             |
|o1 = | 8 7 3 8 8 |                                                           |
|     | 1 8 7 5 5 |                                                           |
|     | 3 3 8 7 2 |                                                           |
|                                                                             |
|              3       5                                                      |
|o1 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i2 : R = QQ[x,y,z]                                                           |
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : (Q,inG,G) = affinePoints(M,R)                                           |
|                                                                             |
|                    2                     2        2   3          10 2   70  |
|o3 = ({1, z, y, x, z }, ideal (y*z, x*z, y , x*y, x , z ), {y*z - --z  + --x |
|                                                                  39     39  |
|     ------------------------------------------------------------------------|
|       107    35    55        25 2   292    25    179    937   2   31 2   56 |
|     - ---y - --z - --, x*z + --z  - ---x - --y - ---z + ---, y  + --z  + --x|
|        39    13    13        39      39    39     13     13       13     13 |
|     ------------------------------------------------------------------------|
|       109    279    206         5 2   277    307    15    707   2   20 2    |
|     - ---y - ---z + ---, x*y - --z  - ---x - ---y + --z + ---, x  - --z  -  |
|        13     13     13        39      39     39    13     13       39      |
|     ------------------------------------------------------------------------|
|     445    20    60    228   3   166 2   70    10    623    1296            |
|     ---x + --y + --z + ---, z  - ---z  + --x + --y + ---z - ----})          |
|      39    39    13     13        13     13    13     13     13             |
|                                                                             |
|o3 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i4 : monomialIdeal G == inG                                                  |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+

The Buchberger-Moeller algorithm in points may be faster than the alternative
method using the intersection of the ideals for each point.

See also
========

  * affinePointsByIntersection -- computes
    ideal of point set by intersecting maximal ideals

Ways to use affinePoints:
=========================

  * "affinePoints(Matrix,Ring)"

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

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

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

The source of this document is in Points.m2:966:0.

affinePointsByIntersection -- computes ideal of point set by intersecting maximal ideals
****************************************************************************************

  * Usage:
        affinePointsByIntersection(M,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the coordinates of a point
      * R, a polynomial ring (Macaulay2Doc), coordinate
        ring of the affine space containing the points
  * Outputs:
      * a list (Macaulay2Doc), grobner basis for ideal of a finite
        set of points

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

This function computes the ideal of a finite set of points by intersecting the
ideals for each point.  The coordinates of the points are the columns in the
input matrix M.
+-----------------------------------------------------------------------------+
|i1 : M = random(ZZ^3, ZZ^5)                                                  |
|                                                                             |
|o1 = | 8 7 3 8 8 |                                                           |
|     | 1 8 7 5 5 |                                                           |
|     | 3 3 8 7 2 |                                                           |
|                                                                             |
|              3       5                                                      |
|o1 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i2 : R = QQ[x,y,z]                                                           |
|                                                                             |
|o2 = R                                                                       |
|                                                                             |
|o2 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i3 : affinePointsByIntersection(M,R)                                         |
|                                                                             |
|                 2                                       2                   |
|o3 = {39y*z - 10z  + 70x - 107y - 105z - 165, 39x*z + 25z  - 292x - 25y -    |
|     ------------------------------------------------------------------------|
|                     2      2                                      2         |
|     537z + 2811, 13y  + 31z  + 56x - 109y - 279z + 206, 39x*y - 5z  - 277x -|
|     ------------------------------------------------------------------------|
|                           2      2                               3       2  |
|     307y + 45z + 2121, 39x  - 20z  - 445x + 20y + 180z + 684, 13z  - 166z  +|
|     ------------------------------------------------------------------------|
|     70x + 10y + 623z - 1296}                                                |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * affinePoints -- produces the ideal and initial ideal
    from the coordinates of a finite set of points

Ways to use affinePointsByIntersection:
=======================================

  * "affinePointsByIntersection(Matrix,Ring)"

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

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

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

The source of this document is in Points.m2:1017:0.

affinePointsMat -- produces the matrix of values of the standard monomials on a set of points
*********************************************************************************************

  * Usage:
        (A,stds) = affinePointsMat(M,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the coordinates of a point
      * R, a polynomial ring (Macaulay2Doc), coordinate
        ring of the affine space containing the points
  * Outputs:
      * A, a matrix (Macaulay2Doc), standard monomials evaluated
        on points
      * stds, a matrix (Macaulay2Doc), whose entries are the
        standard monomials

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

This function uses the Buchberger-Moeller algorithm to compute a the matrix A
in which the columns are indexed by standard monomials, the rows are indexed by
points, and the entries are given by evaluation.  The ordering of the standard
monomials is recorded in the matrix stds which has a single column. Here is a
simple example.
+------------------------------------+
|i1 : M = random(ZZ^3, ZZ^5)         |
|                                    |
|o1 = | 8 7 3 8 8 |                  |
|     | 1 8 7 5 5 |                  |
|     | 3 3 8 7 2 |                  |
|                                    |
|              3       5             |
|o1 : Matrix ZZ  <-- ZZ              |
+------------------------------------+
|i2 : R = QQ[x,y,z]                  |
|                                    |
|o2 = R                              |
|                                    |
|o2 : PolynomialRing                 |
+------------------------------------+
|i3 : (A,stds) = affinePointsMat(M,R)|
|                                    |
|o3 = (| 1 3 1 8 9  |, {0}  | 1  |)  |
|      | 1 3 8 7 9  |  {-1} | z  |   |
|      | 1 8 7 3 64 |  {-1} | y  |   |
|      | 1 7 5 8 49 |  {-1} | x  |   |
|      | 1 2 5 8 4  |  {-2} | z2 |   |
|                                    |
|o3 : Sequence                       |
+------------------------------------+

Caveat
======

Program does not check that the points are distinct.

See also
========

  * affinePoints -- produces the ideal and initial ideal
    from the coordinates of a finite set of points

Ways to use affinePointsMat:
============================

  * "affinePointsMat(Matrix,Ring)"

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

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

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

The source of this document is in Points.m2:995:0.

AllRandom -- Option to randomPointsMat.
***************************************

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

Default is false, in which case the first (up to) r+1 points returned are the
standard simplex; if true, all the points are random.

See also
========

  * randomPointsMat -- matrix of homogeneous
    coordinates of random points in projective space

Functions with optional argument named AllRandom:
=================================================

  * "randomPointsMat(...,AllRandom=>...)" -- see randomPointsMat,
    -- matrix of homogeneous coordinates of random points in
    projective space

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

The object AllRandom, is a symbol (Macaulay2Doc).

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

The source of this document is in Points.m2:910:0.

expectedBetti -- The betti table of r points in Pn according to the minimal resolution conjecture
*************************************************************************************************

  * Usage:
        L = expectedBetti(r,n)
  * Inputs:
      * r, an integer (Macaulay2Doc), ambient dimension
      * n, an integer (Macaulay2Doc), number of points
  * Outputs:
      * L, a list (Macaulay2Doc),

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

The output is the smallest conceivable betti table for a set of r points in
P^n, which is predicted (incorrectly) by the minimal resolution conjecture.

+-------------------------------------------------------+
|i1 : expectedBetti(11,5)                               |
|                                                       |
|            0 1  2   3   4    5    6    7   8   9 10 11|
|o1 = total: 1 7 66 330 858 1386 1518 1155 605 209 43  4|
|         0: 1 7 11   .   .    .    .    .   .   .  .  .|
|         1: . . 55 330 858 1386 1518 1155 605 209 43  4|
|                                                       |
|o1 : BettiTally                                        |
+-------------------------------------------------------+

Caveat
======

The MRC is false, so these are sometimes not the actual Betti numbers.

See also
========

  * expectedBetti -- The betti table of r points in Pn
    according to the minimal resolution conjecture
  * minMaxResolution -- Min and max conceivable Betti
    tables for generic points

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

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

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

The source of this document is in Points.m2:785:0.

minMaxResolution -- Min and max conceivable Betti tables for generic points
***************************************************************************

  * Usage:
        minMaxResolution(r,n)
  * Inputs:
      * r, an integer (Macaulay2Doc), ambient dimension
      * n, an integer (Macaulay2Doc), number of points

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

prints betti tables corresponding to the minimal resolution conjecture and to
the lex ideal with the same Hilbert function

+--------------------------+
|i1 : minMaxResolution(3,5)|
|min                       |
|       0 1 2 3            |
|total: 1 5 5 1            |
|    0: 1 . . .            |
|    1: . 5 5 .            |
|    2: . . . 1            |
|max                       |
|       0 1 2 3            |
|total: 1 6 8 3            |
|    0: 1 . . .            |
|    1: . 5 6 2            |
|    2: . 1 2 1            |
+--------------------------+

See also
========

  * expectedBetti -- The betti table of r points in Pn
    according to the minimal resolution conjecture

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

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

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

The source of this document is in Points.m2:807:0.

omegaPoints -- linear part of the presentation of canonical module of points
****************************************************************************

  * Usage:
        m = omegaPoints pointsmat
  * Inputs:
      * pointsmat, a matrix (Macaulay2Doc), matrix of ZZ,
        representing a set of points
  * Outputs:
      * m, a matrix (Macaulay2Doc), linear part of the
        presentation matrix of the canonical module

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

given an r+1 x n matrix over a ring with r+1 variables, interpreted as a set of
n points in P^r, the script produces the linear part of the presentation matrix
of w_{>=-1}, where w is the canonical module of the cone over the points.  It
is necessary for this to assume that no subset of n+1 of the points is linearly
dependent.  The presentation is actually a presentation of w if the points do
not lie on a rational normal curve (so there are no quadratic relations on
w_{>=-1}) and impose independent conditions on quadrics (so the homogeneous
coordinate ring is 3-regular, and w is generated in degree -1.

+-----------------------------------------------------------------------------+
|i1 : R = ZZ/101[vars(0..4)]                                                  |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : p = randomPointsMat(R,11)                                               |
|                                                                             |
|o2 = | 1 0 0 0 0 1 24  19  -29 21  -18 |                                     |
|     | 0 1 0 0 0 1 -36 -10 -24 34  -13 |                                     |
|     | 0 0 1 0 0 1 -30 -29 -38 19  -43 |                                     |
|     | 0 0 0 1 0 1 -29 -8  -16 -47 -15 |                                     |
|     | 0 0 0 0 1 1 19  -22 39  -39 -28 |                                     |
|                                                                             |
|             5      11                                                       |
|o2 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i3 : w = omegaPoints p                                                       |
|                                                                             |
|o3 = {-1} | -36a+36b -10a+10b -24a+24b 34a-34b -13a+13b -30a+30c -29a+29c    |
|     {-1} | -49a+b   0        0        0       0        -24a+c   0           |
|     {-1} | 0        -42a+b   0        0       0        0        -41a+c      |
|     {-1} | 0        0        34a+b    0       0        0        0           |
|     {-1} | 0        0        0        8a+b    0        0        0           |
|     {-1} | 0        0        0        0       -40a+b   0        0           |
|     ------------------------------------------------------------------------|
|     -38a+38c 19a-19c -43a+43c -29a+29d -8a+8d -16a+16d -47a+47d -15a+15d    |
|     0        0       0        -3a+d    0      0        0        0           |
|     0        0       0        0        27a+d  0        0        0           |
|     37a+c    0       0        0        0      -11a+d   0        0           |
|     0        -49a+c  0        0        0      0        -17a+d   0           |
|     0        0       -8a+c    0        0      0        0        16a+d       |
|     ------------------------------------------------------------------------|
|     19a-19e -22a+22e 39a-39e -39a+39e -28a+28e |                            |
|     -5a+e   0        0       0        0        |                            |
|     0       49a+e    0       0        0        |                            |
|     0       0        -30a+e  0        0        |                            |
|     0       0        0       -27a+e   0        |                            |
|     0       0        0       0        -24a+e   |                            |
|                                                                             |
|             6      20                                                       |
|o3 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i4 : degree (R^1/(points p))                                                 |
|                                                                             |
|o4 = 11                                                                      |
+-----------------------------------------------------------------------------+
|i5 : degree coker w                                                          |
|                                                                             |
|o5 = 11                                                                      |
+-----------------------------------------------------------------------------+
|i6 : betti res (R^1/(points p))                                              |
|                                                                             |
|            0 1  2  3 4                                                      |
|o6 = total: 1 8 21 20 6                                                      |
|         0: 1 .  .  . .                                                      |
|         1: . 4  .  . .                                                      |
|         2: . 4 21 20 6                                                      |
|                                                                             |
|o6 : BettiTally                                                              |
+-----------------------------------------------------------------------------+
|i7 : betti res coker w                                                       |
|                                                                             |
|            0  1  2 3 4                                                      |
|o7 = total: 6 20 21 8 1                                                      |
|        -1: 6 20 21 4 .                                                      |
|         0: .  .  . 4 .                                                      |
|         1: .  .  . . 1                                                      |
|                                                                             |
|o7 : BettiTally                                                              |
+-----------------------------------------------------------------------------+

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

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

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

The source of this document is in Points.m2:845:0.

points -- make the ideal of a set of points
*******************************************

  * Usage:
        i = points pointsMat
  * Inputs:
      * pointsMat, a matrix (Macaulay2Doc), matrix whose columns
        are the homogeneous coordinates of the points
  * Outputs:
      * i, an ideal (Macaulay2Doc),

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

+-----------------------------------------------------------------------------+
|i1 : R = ZZ/101[vars(0..4)]                                                  |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : pointsMat = randomPointsMat(R,11)                                       |
|                                                                             |
|o2 = | 1 0 0 0 0 1 24  19  -29 21  -18 |                                     |
|     | 0 1 0 0 0 1 -36 -10 -24 34  -13 |                                     |
|     | 0 0 1 0 0 1 -30 -29 -38 19  -43 |                                     |
|     | 0 0 0 1 0 1 -29 -8  -16 -47 -15 |                                     |
|     | 0 0 0 0 1 1 19  -22 39  -39 -28 |                                     |
|                                                                             |
|             5      11                                                       |
|o2 : Matrix R  <-- R                                                         |
+-----------------------------------------------------------------------------+
|i3 : points pointsMat                                                        |
|                                                                             |
|                                                                             |
|o3 = ideal (a*d - 2b*d + 26c*d - 15a*e + 37b*e + 8c*e + 46d*e, b*c - 36b*d + |
|     ------------------------------------------------------------------------|
|                                                                             |
|     23c*d + 48a*e + 48b*e - 50c*e - 34d*e, a*c + 50b*d + 41c*d + 28a*e +    |
|     ------------------------------------------------------------------------|
|                                                                             |
|     50b*e - 42c*e - 27d*e, a*b - 10b*d - 44c*d + 37a*e + 20b*e - 8c*e +     |
|     ------------------------------------------------------------------------|
|                                2         2      2        2        2   2     |
|     4d*e, b*d*e + 20c*d*e + 23d e - 26a*e  - b*e  + 12c*e  - 29d*e , c e +  |
|     ------------------------------------------------------------------------|
|                  2         2        2       2        2   2               2  |
|     19c*d*e + 14d e + 17a*e  - 29b*e  + 7c*e  - 29d*e , b e - 2c*d*e - 3d e |
|     ------------------------------------------------------------------------|
|            2        2        2        2   2               2         2       |
|     - 11a*e  + 25b*e  + 33c*e  - 43d*e , a e - c*d*e - 30d e - 27a*e  +     |
|     ------------------------------------------------------------------------|
|          2       2        2                                                 |
|     11b*e  + 5c*e  + 41d*e )                                                |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+

See also
========

  * randomPointsMat -- matrix of homogeneous
    coordinates of random points in projective space

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

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

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

The source of this document is in Points.m2:897:0.

projectiveFatPoints -- produces the ideal and initial ideal from the coordinates of a finite set of fat points
**************************************************************************************************************

  * Usage:
        (inG,G) = projectiveFatPoints(M,mults,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the projective coordinates of a point
      * mults, a list (Macaulay2Doc), in which each element
        determines the multiplicity of the corresponding point
      * R, a ring (Macaulay2Doc), homogeneous coordinate ring of
        the projective space containing the points
  * Optional inputs (Macaulay2Doc),:
      * VerifyPoints,
        => ..., default value true, Option to projectiveFatPoints.
  * Outputs:
      * inG, an ideal (Macaulay2Doc), initial ideal of the set of
        fat points
      * G, a list (Macaulay2Doc), list of generators for Grobner
        basis for ideal of fat points

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

This function uses a modified Buchberger-Moeller algorithm to compute a grobner
basis for the ideal of a finite number of fat points in projective space.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                                           |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : M = transpose matrix{{1,0,0},{0,1,1}}                                   |
|                                                                             |
|o2 = | 1 0 |                                                                 |
|     | 0 1 |                                                                 |
|     | 0 1 |                                                                 |
|                                                                             |
|              3       2                                                      |
|o2 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i3 : mults = {3,2}                                                           |
|                                                                             |
|o3 = {3, 2}                                                                  |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : (inG,G) = projectiveFatPoints(M,mults,R)                                |
|                                                                             |
|              2    3       2   2 3     2        2    3   3       2     3     |
|o4 = (ideal (y z, y , x*y*z , x z ), {y z - 2y*z  + z , y  - 3y*z  + 2z ,    |
|     ------------------------------------------------------------------------|
|          2      3   2 3                                                     |
|     x*y*z  - x*z , x z })                                                   |
|                                                                             |
|o4 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i5 : monomialIdeal G == inG                                                  |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

For small sets of points and/or multiplicities, this method might be slower
than projectiveFatPointsByIntersection.

See also
========

  * projectiveFatPointsByIntersection(Matrix,List,Ring)
    -- computes ideal of fat points by
    intersecting powers of point ideals

Ways to use projectiveFatPoints:
================================

  * "projectiveFatPoints(Matrix,List,Ring)"

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

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

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

The source of this document is in Points.m2:1290:0.

projectiveFatPoints(...,VerifyPoints=>...) -- Option to projectiveFatPoints.
****************************************************************************

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

Default is true, in which case the function removes zero columns and duplicate
columns giving rise to the same projective point. For duplicate points, a
single instance is retained with the largest multiplicity.

See also
========

  * projectiveFatPoints -- produces the ideal and
    initial ideal from the coordinates of a finite set of fat points

Functions with optional argument named VerifyPoints:
====================================================

  * projectiveFatPoints(...,VerifyPoints=>...)
    -- Option to
    projectiveFatPoints.
  * projectivePoints(...,VerifyPoints=>...)
    -- Option to
    projectivePoints.

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

  * Default value: true (Macaulay2Doc),
  * Function: projectiveFatPoints, -- produces the
    ideal and initial ideal from the coordinates of a finite set of fat points
  * Option key: VerifyPoints, -- Option to
    projectivePoints.
-------------------------------------------------------------------------------

The source of this document is in Points.m2:1186:0.

projectiveFatPointsByIntersection -- computes ideal of fat points by intersecting powers of point ideals
********************************************************************************************************

  * Usage:
        projectiveFatPointsByIntersection(M,mults,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the projective coordinates of a point
      * mults, a list (Macaulay2Doc), in which each element
        determines the multiplicity of the corresponding point
      * R, a ring (Macaulay2Doc), homogeneous coordinate ring of
        the projective space containing the points
  * Outputs:
      * a list (Macaulay2Doc), grobner basis for ideal of a finite
        set of fat points

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

This function computes the ideal of a finite set of fat points by intersecting
powers of the ideals of each point.

+--------------------------------------------------------------+
|i1 : R = QQ[x,y,z]                                            |
|                                                              |
|o1 = R                                                        |
|                                                              |
|o1 : PolynomialRing                                           |
+--------------------------------------------------------------+
|i2 : M = transpose matrix{{1,0,0},{0,1,1}}                    |
|                                                              |
|o2 = | 1 0 |                                                  |
|     | 0 1 |                                                  |
|     | 0 1 |                                                  |
|                                                              |
|              3       2                                       |
|o2 : Matrix ZZ  <-- ZZ                                        |
+--------------------------------------------------------------+
|i3 : mults = {3,2}                                            |
|                                                              |
|o3 = {3, 2}                                                   |
|                                                              |
|o3 : List                                                     |
+--------------------------------------------------------------+
|i4 : projectiveFatPointsByIntersection(M,mults,R)             |
|                                                              |
|       2        2    3   3       2     3       2      3   2 3 |
|o4 = {y z - 2y*z  + z , y  - 3y*z  + 2z , x*y*z  - x*z , x z }|
|                                                              |
|o4 : List                                                     |
+--------------------------------------------------------------+

See also
========

  * projectiveFatPoints(Matrix,List,Ring), --
    produces the ideal and initial ideal from the coordinates of a finite set
    of fat points

Ways to use projectiveFatPointsByIntersection:
==============================================

  * "projectiveFatPointsByIntersection(Matrix,List,Ring)"

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

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

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

The source of this document is in Points.m2:1250:0.

projectivePoints -- produces the ideal and initial ideal from the coordinates of a finite set of projective points
******************************************************************************************************************

  * Usage:
        (inG,G) = projectivePoints(M,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the projective coordinates of a point
      * R, a ring (Macaulay2Doc), homogeneous coordinate ring of
        the projective space containing the points
  * Optional inputs (Macaulay2Doc),:
      * VerifyPoints,
        => ..., default value true, Option to projectivePoints.
  * Outputs:
      * inG, an ideal (Macaulay2Doc), initial ideal of the set of
        projective points
      * G, a list (Macaulay2Doc), list of generators for Grobner
        basis for ideal of projective points

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

This function uses a modified Buchberger-Moeller algorithm to compute a grobner
basis for the ideal of a finite number of points in projective space.

+-----------------------------------------------------------------------------+
|i1 : R = QQ[x_0..x_2]                                                        |
|                                                                             |
|o1 = R                                                                       |
|                                                                             |
|o1 : PolynomialRing                                                          |
+-----------------------------------------------------------------------------+
|i2 : M = random(ZZ^3,ZZ^5)                                                   |
|                                                                             |
|o2 = | 8 7 3 8 8 |                                                           |
|     | 1 8 7 5 5 |                                                           |
|     | 3 3 8 7 2 |                                                           |
|                                                                             |
|              3       5                                                      |
|o2 : Matrix ZZ  <-- ZZ                                                       |
+-----------------------------------------------------------------------------+
|i3 : (inG,G) = projectivePoints(M,R)                                         |
|                                                                             |
|              2   3     2     2   79285       204632 2   152667              |
|o3 = (ideal (x , x , x x ), {x  - -----x x  - ------x  + ------x x  +        |
|              0   1   0 1     0    481  0 1     481  1     481  0 2          |
|     ------------------------------------------------------------------------|
|     817272       589744 2   3   318467         187373 2     77360   2       |
|     ------x x  - ------x , x  + ------x x x  + ------x x  - -----x x  -     |
|       481  1 2     481  2   1    18648 0 1 2    4662  1 2    2331 0 2       |
|     ------------------------------------------------------------------------|
|     804017   2   294415 3     2   881693         273316 2     410665   2    |
|     ------x x  + ------x , x x  - ------x x x  - ------x x  + ------x x  +  |
|      4662  1 2    2331  2   0 1    18648 0 1 2    2331  1 2    4662  0 2    |
|     ------------------------------------------------------------------------|
|     2169827   2   1563095 3                                                 |
|     -------x x  - -------x })                                               |
|       4662  1 2     4662  2                                                 |
|                                                                             |
|o3 : Sequence                                                                |
+-----------------------------------------------------------------------------+
|i4 : monomialIdeal G == inG                                                  |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+

This algorithm may be faster than computing the intersection of the ideals of
each projective point.

Caveat
======

This function removes zero columns of M and duplicate columns giving rise to
the same projective point (which prevent the algorithm from terminating). The
user can bypass this step with the option VerifyPoints.

See also
========

  * projectivePointsByIntersection(Matrix,Ring)
    -- computes ideal of projective points by
    intersecting point ideals

Ways to use projectivePoints:
=============================

  * "projectivePoints(Matrix,Ring)"

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

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

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

The source of this document is in Points.m2:1149:0.

projectivePoints(...,VerifyPoints=>...) -- Option to projectivePoints.
**********************************************************************

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

Default is true, in which case the function removes zero columns and duplicate
columns giving rise to the same projective point.

See also
========

  * projectivePoints -- produces the ideal and initial
    ideal from the coordinates of a finite set of projective points

Functions with optional argument named VerifyPoints:
====================================================

  * projectiveFatPoints(...,VerifyPoints=>...)
    -- Option to
    projectiveFatPoints.
  * projectivePoints(...,VerifyPoints=>...)
    -- Option to
    projectivePoints.

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

  * Default value: true (Macaulay2Doc),
  * Function: projectivePoints, -- produces the ideal
    and initial ideal from the coordinates of a finite set of projective points
  * Option key: VerifyPoints, -- Option to
    projectivePoints.
-------------------------------------------------------------------------------

The source of this document is in Points.m2:1173:0.

projectivePointsByIntersection -- computes ideal of projective points by intersecting point ideals
**************************************************************************************************

  * Usage:
        projectivePointsByIntersection(M,R)
  * Inputs:
      * M, a matrix (Macaulay2Doc), in which each column consists
        of the projective coordinates of a point
      * R, a ring (Macaulay2Doc), homogeneous coordinate ring of
        the projective space containing the points
  * Outputs:
      * a list (Macaulay2Doc), grobner basis for ideal of a finite
        set of projective points

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

This function computes the ideal of a finite set of projective points by
intersecting the ideals of each point.

+------------------------------------------+
|i1 : R = QQ[x,y,z]                        |
|                                          |
|o1 = R                                    |
|                                          |
|o1 : PolynomialRing                       |
+------------------------------------------+
|i2 : M = transpose matrix{{1,0,0},{0,1,1}}|
|                                          |
|o2 = | 1 0 |                              |
|     | 0 1 |                              |
|     | 0 1 |                              |
|                                          |
|              3       2                   |
|o2 : Matrix ZZ  <-- ZZ                    |
+------------------------------------------+
|i3 : projectivePointsByIntersection(M,R)  |
|                                          |
|o3 = {y - z, x*z}                         |
|                                          |
|o3 : List                                 |
+------------------------------------------+

See also
========

  * projectivePoints(Matrix,Ring) -- produces the
    ideal and initial ideal from the coordinates of a finite set of projective
    points

Ways to use projectivePointsByIntersection:
===========================================

  * "projectivePointsByIntersection(Matrix,Ring)"

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

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

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

The source of this document is in Points.m2:1216:0.

randomPoints -- ideal of a random set of points
***********************************************

  * Usage:
        i = randomPoints(r,n)
  * Inputs:
      * r, an integer (Macaulay2Doc), ambient dimension
      * n, an integer (Macaulay2Doc), number of points
  * Outputs:
      * i, an ideal (Macaulay2Doc), ideal of the random points

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

The script defines a ring R with r+1 variables, and calls
points(R,randomPointsMat(R, n))

+---------------------------------------------------------+
|i1 : betti res randomPoints(11,5)                        |
|                                                         |
|            0  1   2   3   4    5    6    7   8   9 10 11|
|o1 = total: 1 17 111 400 914 1414 1526 1156 605 209 43  4|
|         0: 1  7  21  35  35   21    7    1   .   .  .  .|
|         1: . 10  90 365 879 1393 1519 1155 605 209 43  4|
|                                                         |
|o1 : BettiTally                                          |
+---------------------------------------------------------+

See also
========

  * randomPointsMat -- matrix of homogeneous
    coordinates of random points in projective space
  * points -- make the ideal of a set of points

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

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

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

The source of this document is in Points.m2:757:0.

randomPointsMat -- matrix of homogeneous coordinates of random points in projective space
*****************************************************************************************

  * Usage:
        m=randomPointsMat(R,n)
  * Inputs:
      * R, a ring (Macaulay2Doc), homogeneous coordinate ring of
        projective space Pm
      * n, an integer (Macaulay2Doc), number of points
  * Optional inputs (Macaulay2Doc),:
      * AllRandom => ..., default value false
  * Outputs:
      * m, a matrix (Macaulay2Doc), of ZZ

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

Produces a random m+1 x n matrix of scalars, with columns representing the
coordinates of the point. The first m+1 x m+1 submatrix is the identity.

+------------------------------------------+
|i1 : R = ZZ/31991[vars(0..3)]             |
|                                          |
|o1 = R                                    |
|                                          |
|o1 : PolynomialRing                       |
+------------------------------------------+
|i2 : randomPointsMat(R,3)                 |
|                                          |
|o2 = | 1 0 0 |                            |
|     | 0 1 0 |                            |
|     | 0 0 1 |                            |
|     | 0 0 0 |                            |
|                                          |
|             4      3                     |
|o2 : Matrix R  <-- R                      |
+------------------------------------------+
|i3 : randomPointsMat(R,3, AllRandom=>true)|
|                                          |
|o3 = | 107   3783   8444   |              |
|     | 4376  -5295  -10468 |              |
|     | -5558 8570   10359  |              |
|     | 3187  -15332 -7452  |              |
|                                          |
|             4      3                     |
|o3 : Matrix R  <-- R                      |
+------------------------------------------+
|i4 : randomPointsMat(R,7)                 |
|                                          |
|o4 = | 1 0 0 0 1 -8239 12365  |           |
|     | 0 1 0 0 1 2653  -13496 |           |
|     | 0 0 1 0 1 5071  -9468  |           |
|     | 0 0 0 1 1 -6191 -11938 |           |
|                                          |
|             4      7                     |
|o4 : Matrix R  <-- R                      |
+------------------------------------------+

Ways to use randomPointsMat:
============================

  * "randomPointsMat(Ring,ZZ)"

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

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

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

The source of this document is in Points.m2:874:0.

VerifyPoints -- Option to projectivePoints.
*******************************************

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

Default is true, in which case the function removes zero columns and duplicate
columns giving rise to the same projective point.

See also
========

  * projectivePoints -- produces the ideal and initial
    ideal from the coordinates of a finite set of projective points

Functions with optional argument named VerifyPoints:
====================================================

  * projectiveFatPoints(...,VerifyPoints=>...)
    -- Option to
    projectiveFatPoints.
  * projectivePoints(...,VerifyPoints=>...)
    -- Option to
    projectivePoints.

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

The object VerifyPoints, is a symbol (Macaulay2Doc).

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

The source of this document is in Points.m2:1161:0.