This is SpaceCurves.info, produced by Macaulay2, version 1.24.11

SpaceCurves -- generation of space curves
*****************************************

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

SpaceCurves is a package dedicated to generation of curves in P3. The 1.0
version of the package generates smooth curves of a given degree and genus, ACM
curves of a given Hilbert function as well as minimal curves in biliaison class
with a given Rao-module.

The method smoothDivisors, produces a list of
Divisor, of a given degree on a given surface. The method
curve(Divisor), produces a random curve in a given divisor class. For a
given degree, as one varies the input surface from  a smooth quadric, a smooth
cubic and a rational quartic surface with a double line, all obtainable genus
of a smooth curve will occur (save that of a plane curve). The methods to
create the said surfaces are: quadricSurface(Ring),
cubicSurface(Ring), and quarticSurfaceRational(Ring).

+-----------------------------------------------------------------------------+
|i1 : R = ZZ/101[x,y,z,w];                                                    |
+-----------------------------------------------------------------------------+
|i2 : X = quadricSurface(R);                                                  |
+-----------------------------------------------------------------------------+
|i3 : Y = cubicSurface(R);                                                    |
+-----------------------------------------------------------------------------+
|i4 : Z = quarticSurfaceRational(R);                                          |
+-----------------------------------------------------------------------------+
|i5 : LD = smoothDivisors(4,X) | smoothDivisors(4,Y) | smoothDivisors(4,Z)    |
|                                                                             |
|o5 = {{1, 3}, {2, 2}, {2, 2, 0, 0, 0, 0, 0}, {2, 1, 1, 0, 0, 0, 0}, {3, 1, 1,|
|     ------------------------------------------------------------------------|
|     1, 1, 1, 0}, {2, 0, 1, 1, 1, 1, 0, 0, 0, 0}, {3, 1, 1, 1, 1, 1, 1, 1, 0,|
|     ------------------------------------------------------------------------|
|     0}}                                                                     |
|                                                                             |
|o5 : List                                                                    |
+-----------------------------------------------------------------------------+
|i6 : LC = apply(LD,D->curve D);                                              |
+-----------------------------------------------------------------------------+

 The method curve(ZZ,ZZ), generates a random curve with the
specified degree and genus.

+---------------------------------------------+
|i7 : C = curve(5,2);                         |
+---------------------------------------------+
|i8 : degree C, genus C, isPrime C, isSmooth C|
|                                             |
|o8 = (5, 2, true, true)                      |
|                                             |
|o8 : Sequence                                |
+---------------------------------------------+

The postulation character of a curve is defined to be the negative of the third
numerical difference of its Hilbert function, and gives equivalent information
as the Hilbert function. The method function positiveChars(ZZ),
generates all possible postulation characters of an ACM curve of
a given degree. The method allACMBetti(List), generates all
Betti tables of ACM curves with a given postulation character. The method
function degreeMatrix(BettiTally), converts the Betti table
of an ACM curve to its Hilbert-Burch degree matrix. Finally
randomDeterminantalIdeal(Ring,Matrix), generates a
random determinantal ideal in a given ring with specified degree format.
Combining all three methods we can generate ACM curves of any degree d,
exhausting all possibilities of Betti tables.

+-----------------------------------------------------------------------------+
|i9 : G = positiveChars(8);                                                   |
+-----------------------------------------------------------------------------+
|i10 : L = G / allACMBetti;                                                   |
+-----------------------------------------------------------------------------+
|i11 : netList L                                                              |
|                                                                             |
|      +------------+------------+                                            |
|      |       0 1 2|            |                                            |
|o11 = |total: 1 3 2|            |                                            |
|      |    0: 1 . .|            |                                            |
|      |    1: . 2 1|            |                                            |
|      |    2: . . .|            |                                            |
|      |    3: . . .|            |                                            |
|      |    4: . . .|            |                                            |
|      |    5: . . .|            |                                            |
|      |    6: . 1 1|            |                                            |
|      +------------+------------+                                            |
|      |       0 1 2|            |                                            |
|      |total: 1 3 2|            |                                            |
|      |    0: 1 . .|            |                                            |
|      |    1: . 1 .|            |                                            |
|      |    2: . 1 1|            |                                            |
|      |    3: . . .|            |                                            |
|      |    4: . . .|            |                                            |
|      |    5: . 1 1|            |                                            |
|      +------------+------------+                                            |
|      |       0 1 2|       0 1 2|                                            |
|      |total: 1 2 1|total: 1 3 2|                                            |
|      |    0: 1 . .|    0: 1 . .|                                            |
|      |    1: . 1 .|    1: . 1 .|                                            |
|      |    2: . . .|    2: . . .|                                            |
|      |    3: . 1 .|    3: . 1 1|                                            |
|      |    4: . . 1|    4: . 1 1|                                            |
|      +------------+------------+                                            |
|      |       0 1 2|            |                                            |
|      |total: 1 4 3|            |                                            |
|      |    0: 1 . .|            |                                            |
|      |    1: . . .|            |                                            |
|      |    2: . 3 2|            |                                            |
|      |    3: . . .|            |                                            |
|      |    4: . 1 1|            |                                            |
|      +------------+------------+                                            |
|      |       0 1 2|       0 1 2|                                            |
|      |total: 1 3 2|total: 1 4 3|                                            |
|      |    0: 1 . .|    0: 1 . .|                                            |
|      |    1: . . .|    1: . . .|                                            |
|      |    2: . 2 .|    2: . 2 1|                                            |
|      |    3: . 1 2|    3: . 2 2|                                            |
|      +------------+------------+                                            |
+-----------------------------------------------------------------------------+
|i12 : apply(L, g                                                             |
|          -> apply(g, B -> randomDeterminantalIdeal(ZZ/101[x,y,z,w],         |
|-----------------------------------------------------------------------------|
|degreeMatrix B)));                                                           |
+-----------------------------------------------------------------------------+

The method minimalCurve(Module), produces a minimal curve
in the biliaison class specified by the finite length module. The method
minimalCurve(Ideal), produces a random minimal curve in the
biliaison class of a given curve.

+--------------------------------------------------------+
|i13 : I = monomialCurveIdeal(R,{1,3,4})                 |
|                                                        |
|                         3      2     2    2    3    2  |
|o13 = ideal (y*z - x*w, z  - y*w , x*z  - y w, y  - x z)|
|                                                        |
|o13 : Ideal of R                                        |
+--------------------------------------------------------+
|i14 : M = raoModule(I)                                  |
|                                                        |
|o14 = cokernel {1} | w -z y -x |                        |
|                                                        |
|                             1                          |
|o14 : R-module, quotient of R                           |
+--------------------------------------------------------+
|i15 : J = minimalCurve M;                               |
|                                                        |
|o15 : Ideal of R                                        |
+--------------------------------------------------------+
|i16 : betti res J                                       |
|                                                        |
|             0 1 2 3                                    |
|o16 = total: 1 4 4 1                                    |
|          0: 1 . . .                                    |
|          1: . 4 4 1                                    |
|                                                        |
|o16 : BettiTally                                        |
+--------------------------------------------------------+

Surfaces
========

  * QuadricSurface -- type of HashTable
  * IntersectionPairing -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * CanonicalClass -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * HyperplaneClass -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * quadricSurface -- creates a QuadricSurface
  * CubicSurface -- type of HashTable
  * BlowUpPoints -- key for CubicSurface and
    QuarticSurfaceRational
  * MapToP3 -- key for CubicSurface and QuarticSurfaceRational
  * cubicSurface -- creates a cubicSurface
  * QuarticSurfaceRational -- type of HashTable
  * quarticSurfaceRational -- creates a
    QuarticSurfaceRational

Divisors
========

  * Divisor -- divisors
  * Coordinate -- key of Divisor
  * Surface -- key of Divisor
  * divisor -- creates a Divisor
  * surface -- the surface key of a Divisor or a Curve

Curves
======

  * Curve -- type of HashTable
  * curve -- generates a random curve
  * isSmooth(Curve) -- checks smoothness of an
    ideal or of a Curve

Minimal curves
==============

  * minimalCurve -- generates a minimal curve in the
    biliaison class
  * raoModule -- computes the Rao module of a curve

ACM Curves
==========

  * positiveChars -- generates all positive characters of
    a given degree
  * generalACMBetti -- the most general Betti table of
    an ACM curve with a given Hilbert function
  * specializeACMBetti -- lists all 1-specialization
    of a Betti table of an ACM curve
  * allACMBetti -- lists all Betti tables of ACM curves
    with a given Hilbert function
  * isACMBetti -- checks whether a Betti table is that of an
    ACM curve
  * isSmoothACMBetti -- checks whether a Betti table
    is that of a smooth ACM curve
  * degreeMatrix -- computes the Hilbert-Burch degree
    matrix from a Betti table of ACM curves
  * randomDeterminantalIdeal -- produces a
    random determinantal ideal

Authors
=======

  * Frank-Olaf Schreyer (see https://www.math.uni-sb.de/ag/schreyer/ )
    <schreyer@math.uni-sb.de>
  * Mike Stillman (see http://www.math.cornell.edu/~mike/ )
    <mike@math.cornell.edu>
  * Mengyuan Zhang (see https://math.berkeley.edu/~myzhang/ )
    <myzhang@berkeley.edu>

Certification a gold star
=========================

Version 1.0 of this package was accepted for publication in volume 8 (see
https://msp.org/jsag/2018/8-1/ ) of The Journal of Software for Algebra and
Geometry (see https://msp.org/jsag/ ) on 18 May 2018, in the article The
SpaceCurves package in Macaulay2 (see https://msp.org/jsag/2018/8-1/p04.xhtml )
(DOI: 10.2140/jsag.2018.8.31 (see https://doi.org/10.2140/jsag.2018.8.31 )).
That version can be obtained from the journal (see
https://msp.org/jsag/2018/8-1/jsag-v8-n1-x04-SpaceCurves.m2 ) or from the
Macaulay2 source code repository (see
https://github.com/Macaulay2/M2/blob/7853d911a8a484766a7828dc8e17aed701ce9fd6/
M2/Macaulay2/packages/SpaceCurves.m2 ).

Version
=======

This documentation describes version 1.0 of SpaceCurves.

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

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

Exports
=======

  * Types
      * CubicSurface -- type of HashTable
      * Curve -- type of HashTable
      * Divisor -- type of HashTable
      * QuadricSurface -- type of HashTable
      * QuarticSurfaceRational -- type of
        HashTable
  * Functions and commands
      * allACMBetti -- lists all Betti tables of ACM curves
        with a given Hilbert function
      * cubicSurface -- creates a cubicSurface
      * curve -- generates a random curve
      * degreeMatrix -- computes the Hilbert-Burch degree
        matrix from a Betti table of ACM curves
      * dgTable -- prints the table of (degree,genus) pairs
      * divisor -- creates a Divisor
      * generalACMBetti -- the most general Betti table
        of an ACM curve with a given Hilbert function
      * isACMBetti -- checks whether a Betti table is that
        of an ACM curve
      * isSmoothACMBetti -- checks whether a Betti
        table is that of a smooth ACM curve
      * minimalCurve -- generates a minimal curve in the
        biliaison class
      * minimalCurveBetti -- computes the Betti
        diagram of the minimal curve
      * positiveChars -- generates all positive
        characters of a given degree
      * quadricSurface -- creates a QuadricSurface
      * quarticSurfaceRational -- creates a
        QuarticSurfaceRational
      * randomDeterminantalIdeal -- produces a
        random determinantal ideal
      * raoModule -- computes the Rao module of a curve
      * smoothDivisors -- produces a list of smooth
        divisors of a given degree on a surface
      * specializeACMBetti -- lists all
        1-specialization of a Betti table of an ACM curve
      * surface -- the surface key of a Divisor or a Curve
  * Methods
      * "allACMBetti(List)" -- see allACMBetti, -- lists all
        Betti tables of ACM curves with a given Hilbert function
      * "cubicSurface(Ring)" -- see cubicSurface, --
        creates a cubicSurface
      * "curve(Divisor)" -- see curve, -- generates a random curve
      * "curve(ZZ,ZZ)" -- see curve, -- generates a random curve
      * "curve(ZZ,ZZ,Ring)" -- see curve, -- generates a random
        curve
      * degree(Curve) -- computes the degree of a
        Curve
      * degree(Divisor) -- computes the degree of a
        Divisor
      * "degreeMatrix(BettiTally)" -- see degreeMatrix, --
        computes the Hilbert-Burch degree matrix from a Betti table of ACM
        curves
      * "dgTable(List)" -- see dgTable, -- prints the table of
        (degree,genus) pairs
      * "divisor(List,CubicSurface)" -- see divisor, -- creates
        a Divisor
      * "divisor(List,QuadricSurface)" -- see divisor, --
        creates a Divisor
      * "divisor(List,QuarticSurfaceRational)" -- see divisor,
        -- creates a Divisor
      * Divisor * Divisor -- intersection number of
        two Divisors
      * Divisor + Divisor -- sum of two Divisors
      * Divisor - Divisor -- difference of two
        Divisors
      * divisor(Curve) -- extracts the Divisor of a
        Curve
      * "generalACMBetti(List)" -- see generalACMBetti,
        -- the most general Betti table of an ACM curve with a given Hilbert
        function
      * genus(Curve) -- computes the genus of a Curve
      * genus(Divisor) -- computes the genus of a
        Divisor
      * ideal(Curve) -- extracts the ideal of a Curve
      * "ideal(CubicSurface)" -- see ideal(QuadricSurface),
        -- extracts the ideal of a surface
      * ideal(QuadricSurface) -- extracts the
        ideal of a surface
      * "ideal(QuarticSurfaceRational)" -- see ideal(QuadricSurface),
        -- extracts the ideal of a surface
      * "isACMBetti(BettiTally)" -- see isACMBetti, -- checks
        whether a Betti table is that of an ACM curve
      * isPrime(Curve) -- checks if the ideal of a
        Curve is prime
      * "isSmooth(Curve)" -- see isSmooth(Ideal), --
        checks smoothness of an ideal or of a Curve
      * isSmooth(Ideal) -- checks smoothness of an
        ideal or of a Curve
      * "isSmoothACMBetti(BettiTally)" -- see isSmoothACMBetti,
        -- checks whether a Betti table is that of a smooth
        ACM curve
      * "minimalCurve(Curve)" -- see minimalCurve, --
        generates a minimal curve in the biliaison class
      * "minimalCurve(Ideal)" -- see minimalCurve, --
        generates a minimal curve in the biliaison class
      * "minimalCurve(Module)" -- see minimalCurve, --
        generates a minimal curve in the biliaison class
      * "minimalCurveBetti(Curve)" -- see minimalCurveBetti,
        -- computes the Betti diagram of the minimal curve
      * "minimalCurveBetti(Ideal)" -- see minimalCurveBetti,
        -- computes the Betti diagram of the minimal curve
      * "minimalCurveBetti(Module)" -- see minimalCurveBetti,
        -- computes the Betti diagram of the minimal curve
      * net(CubicSurface) -- displays the ideal
        of the CubicSurface
      * net(Curve) -- displays the ideal of the curve
      * net(Divisor) -- displays the coordinates of
        the Divisor
      * net(QuadricSurface) -- displays the
        ideal of the QuadricSurface
      * net(QuarticSurfaceRational), --
        displays the ideal of the QuarticSurfaceRational
      * "positiveChars(ZZ)" -- see positiveChars, --
        generates all positive characters of a given degree
      * "positiveChars(ZZ,ZZ)" -- see positiveChars, --
        generates all positive characters of a given degree
      * "quadricSurface(Ring)" -- see quadricSurface, --
        creates a QuadricSurface
      * "quarticSurfaceRational(Ring)" -- see quarticSurfaceRational,
        -- creates a QuarticSurfaceRational
      * "randomDeterminantalIdeal(Ring,Matrix)" -- see
        randomDeterminantalIdeal, -- produces a
        random determinantal ideal
      * "raoModule(Curve)" -- see raoModule, -- computes the
        Rao module of a curve
      * "raoModule(Ideal)" -- see raoModule, -- computes the
        Rao module of a curve
      * "smoothDivisors(ZZ,CubicSurface)" -- see smoothDivisors,
        -- produces a list of smooth divisors of a given degree
        on a surface
      * "smoothDivisors(ZZ,QuadricSurface)" -- see smoothDivisors,
        -- produces a list of smooth divisors of a given degree
        on a surface
      * "smoothDivisors(ZZ,QuarticSurfaceRational)" -- see
        smoothDivisors, -- produces a list of smooth divisors
        of a given degree on a surface
      * smoothDivisors(ZZ,ZZ) -- produces a
        list of smooth divisors of given degree and genus
      * "smoothDivisors(ZZ,ZZ,Ring)" -- see smoothDivisors(ZZ,ZZ),
        -- produces a list of smooth divisors of
        given degree and genus
      * "specializeACMBetti(BettiTally)" -- see specializeACMBetti,
        -- lists all 1-specialization of a Betti table of
        an ACM curve
      * "surface(Curve)" -- see surface, -- the surface key of a
        Divisor or a Curve
      * "surface(Divisor)" -- see surface, -- the surface key of
        a Divisor or a Curve
      * ZZ * Divisor -- multiply a Divisor by an integer
  * Symbols
      * BlowUpPoints -- key for CubicSurface and
        QuarticSurfaceRational
      * CanonicalClass -- key for QuadricSurface,
        CubicSurface and QuarticSurfaceRational
      * Coordinate -- key of Divisor
      * HyperplaneClass -- key for QuadricSurface,
        CubicSurface and QuarticSurfaceRational
      * IntersectionPairing -- key for
        QuadricSurface, CubicSurface and QuarticSurfaceRational
      * MapToP3 -- key for CubicSurface and
        QuarticSurfaceRational
      * Surface -- key of Divisor

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

The object SpaceCurves, is a package (Macaulay2Doc).

allACMBetti -- lists all Betti tables of ACM curves with a given Hilbert function
*********************************************************************************

Synopsis
========

  * Usage:
        L = allACMBetti gamma
  * Inputs:
      * gamma, a list (Macaulay2Doc), positive character
  * Outputs:
      * L, a list (Macaulay2Doc), of BettiTally

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

Given a positive character, it outputs all possible Betti tables of ACM curves
that have this character as its postulation character.
+---------------------------------+
|i1 : allACMBetti {-1,-1,-1,2,1}  |
|                                 |
|             0 1 2         0 1 2 |
|o1 = {total: 1 3 2, total: 1 4 3}|
|          0: 1 . .      0: 1 . . |
|          1: . . .      1: . . . |
|          2: . 3 1      2: . 3 2 |
|          3: . . 1      3: . 1 1 |
|                                 |
|o1 : List                        |
+---------------------------------+

Ways to use allACMBetti:
========================

  * "allACMBetti(List)"

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

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

BlowUpPoints -- key for CubicSurface and QuarticSurfaceRational
***************************************************************

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

The symbol BlowUpPoints is a key for CubicSurface, and
QuarticSurfaceRational. It stores a list of
ideals encoding the points on P2 whose blowup produces the surface.

See also
========

  * MapToP3 -- key for CubicSurface and QuarticSurfaceRational

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

The object BlowUpPoints, is a symbol (Macaulay2Doc).

CanonicalClass -- key for QuadricSurface, CubicSurface and QuarticSurfaceRational
*********************************************************************************

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

The symbol CanonicalClass is a key for QuadricSurface,
CubicSurface, and QuarticSurfaceRational.
It stores a List encoding the coordinates of the
canonical divisor.

See also
========

  * HyperplaneClass -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * IntersectionPairing -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * BlowUpPoints -- key for CubicSurface and
    QuarticSurfaceRational
  * MapToP3 -- key for CubicSurface and QuarticSurfaceRational

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

The object CanonicalClass, is a symbol (Macaulay2Doc).

Coordinate -- key of Divisor
****************************

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

See Coordinate, is a key of Divisor, storing
a List encoding the coordinates of the divisor class.

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

The object Coordinate, is a symbol (Macaulay2Doc).

CubicSurface -- type of HashTable
*********************************

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

CubicSurface is a type of HashTable storing information about a smooth cubic
surface in P^3. The keys of a QuadricSurface are: IntersectionPairing,
HyperplaneClass, CanonicalClass, Ideal, BlowUpPoints, MapToP3.

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

  * "divisor(List,CubicSurface)" -- see divisor, -- creates a
    Divisor
  * "ideal(CubicSurface)" -- see ideal(QuadricSurface),
    -- extracts the ideal of a surface
  * net(CubicSurface) -- displays the ideal of
    the CubicSurface
  * "smoothDivisors(ZZ,CubicSurface)" -- see smoothDivisors,
    -- produces a list of smooth divisors of a given degree on
    a surface

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

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

cubicSurface -- creates a cubicSurface
**************************************

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

This function takes a polynomial ring in 4 variables over a field as the
coordinate ring of P3 and creates a CubicSurface, in this
ring. The equation of the cubic surface is computed from the blowup of 6 points
in P2, listed in the key BlowUpPoints, along with a rational map P2 -> P3 whose
base loci is the 6 given points.

Synopsis
========

  * Usage:
        X = quadricSurface(R)
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * X, an instance of the type CubicSurface,
+-----------------------------------------------------------------------------+
|i1 : cubicSurface(ZZ/32003[x,y,z,w])                                         |
|                                                                             |
|                            2           2        2         2                 |
|o1 = ideal(2495x*y*z + 4036y z - 5934y*z  - 2495x w - 4289y w - 1194y*z*w +  |
|                                                                             |
|o1 : CubicSurface                                                            |
|-----------------------------------------------------------------------------|
|      2           2         2          2         3                           |
|10682z w - 8366x*w  + 214y*w  + 4197z*w  - 11134w )                          |
+-----------------------------------------------------------------------------+

See also
========

  * quadricSurface -- creates a QuadricSurface
  * quarticSurfaceRational -- creates a
    QuarticSurfaceRational

Ways to use cubicSurface:
=========================

  * "cubicSurface(Ring)"

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

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

Curve -- type of HashTable
**************************

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

Curve is a type of HashTable that stores information about a curve. It has keys
Divisor and Ideal.

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

  * degree(Curve) -- computes the degree of a Curve
  * divisor(Curve) -- extracts the Divisor of a
    Curve
  * genus(Curve) -- computes the genus of a Curve
  * ideal(Curve) -- extracts the ideal of a Curve
  * isPrime(Curve) -- checks if the ideal of a Curve
    is prime
  * "isSmooth(Curve)" -- see isSmooth(Ideal), --
    checks smoothness of an ideal or of a Curve
  * "minimalCurve(Curve)" -- see minimalCurve, -- generates
    a minimal curve in the biliaison class
  * "minimalCurveBetti(Curve)" -- see minimalCurveBetti,
    -- computes the Betti diagram of the minimal curve
  * net(Curve) -- displays the ideal of the curve
  * "raoModule(Curve)" -- see raoModule, -- computes the Rao
    module of a curve
  * "surface(Curve)" -- see surface, -- the surface key of a
    Divisor or a Curve

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

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

curve -- generates a random curve
*********************************

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

The method curve generates a random curve with given input.

Synopsis
========

  * Usage:
        C = curve(D)
  * Inputs:
      * D, an instance of the type Divisor,
  * Outputs:
      * C, an instance of the type Curve,
+-----------------------------------------------------------------------------+
|i1 : X = quadricSurface(ZZ/101[x_0..x_3]);                                   |
+-----------------------------------------------------------------------------+
|i2 : D = divisor({1,2},X);                                                   |
+-----------------------------------------------------------------------------+
|i3 : C = curve D                                                             |
|                                                                             |
|                                   2                              2   2      |
|o3 = ideal (x x  - x x , x x  + 49x  + 24x x  + 3x x  + 5x x  + 5x , x  +    |
|             1 2    0 3   0 1      1      0 3     1 3     2 3     3   0      |
|                                                                             |
|o3 : Curve                                                                   |
|-----------------------------------------------------------------------------|
|   2              2                                 2                        |
|23x  + 24x x  + 5x  + 39x x  - 46x x  - 38x x  - 43x )                       |
|   1      0 2     2      0 3      1 3      2 3      3                        |
+-----------------------------------------------------------------------------+

Synopsis
========

  * Usage:
        C = curve(d,g)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree
      * g, an integer (Macaulay2Doc), genus
  * Outputs:
      * C, an instance of the type Curve,
+----------------------+
|i4 : I = curve(5,2);  |
+----------------------+
|i5 : degree I, genus I|
|                      |
|o5 = (5, 2)           |
|                      |
|o5 : Sequence         |
+----------------------+

Synopsis
========

  * Usage:
        C = curve(d,g,R)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree
      * g, an integer (Macaulay2Doc), genus
      * R, a ring (Macaulay2Doc), ambient ring of P^3
  * Outputs:
      * C, an instance of the type Curve,

Ways to use curve:
==================

  * "curve(Divisor)"
  * "curve(ZZ,ZZ)"
  * "curve(ZZ,ZZ,Ring)"

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

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

degree(Curve) -- computes the degree of a Curve
***********************************************

Synopsis
========

  * Function: degree (Macaulay2Doc),

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

Computes the degree of a Curve.
+--------------------+
|i1 : C = curve(5,2);|
+--------------------+
|i2 : degree C       |
|                    |
|o2 = 5              |
+--------------------+

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

  * degree(Curve) -- computes the degree of a Curve

degree(Divisor) -- computes the degree of a Divisor
***************************************************

Synopsis
========

  * Function: degree (Macaulay2Doc),

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

Computes the degree of a Divisor using IntersectionPairing.
+---------------------------+
|i1 : R = ZZ/101[x,y,z,w];  |
+---------------------------+
|i2 : Q = quadricSurface(R);|
+---------------------------+
|i3 : D = divisor({3,4},Q); |
+---------------------------+
|i4 : degree D              |
|                           |
|o4 = 7                     |
+---------------------------+

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

  * degree(Divisor) -- computes the degree of a
    Divisor

degreeMatrix -- computes the Hilbert-Burch degree matrix from a Betti table of ACM curves
*****************************************************************************************

Synopsis
========

  * Usage:
        M = degreeMatrix B
  * Inputs:
      * B, a Betti tally (Macaulay2Doc), of an ACM curve
  * Outputs:
      * M, a matrix (Macaulay2Doc),

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

Given the Betti table of an ACM curve, this function returns the Hilbert-Burch
degree matrix.
+----------------------------------+
|i1 : B = generalACMBetti {-1,-1,2}|
|                                  |
|            0 1 2                 |
|o1 = total: 1 3 2                 |
|         0: 1 . .                 |
|         1: . 3 2                 |
|                                  |
|o1 : BettiTally                   |
+----------------------------------+
|i2 : degreeMatrix B               |
|                                  |
|o2 = | 1 1 |                      |
|     | 1 1 |                      |
|     | 1 1 |                      |
|                                  |
|              3       2           |
|o2 : Matrix ZZ  <-- ZZ            |
+----------------------------------+

Ways to use degreeMatrix:
=========================

  * "degreeMatrix(BettiTally)"

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

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

dgTable -- prints the table of (degree,genus) pairs
***************************************************

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

dgTable prints the table of (degree,genus) pairs, where the horizontal axis is
the degree and the vertical is the genus. The input can be a List (Macaulay2Doc),
of Divisor, Curve,
PostulationChar or Ideal (Macaulay2Doc).

Ways to use dgTable:
====================

  * "dgTable(List)"

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

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

Divisor -- type of HashTable
****************************

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

See Divisor, is a type of HashTable that specifies a divisor
class on a surface. The keys are Coordinate, and
Surface.

See also
========

  * Curve -- type of HashTable

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

  * "curve(Divisor)" -- see curve, -- generates a random curve
  * degree(Divisor) -- computes the degree of a
    Divisor
  * Divisor * Divisor -- intersection number of two
    Divisors
  * Divisor + Divisor -- sum of two Divisors
  * Divisor - Divisor -- difference of two Divisors
  * genus(Divisor) -- computes the genus of a
    Divisor
  * net(Divisor) -- displays the coordinates of the
    Divisor
  * "surface(Divisor)" -- see surface, -- the surface key of a
    Divisor or a Curve
  * ZZ * Divisor -- multiply a Divisor by an integer

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

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

divisor -- creates a Divisor
****************************

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

Creates a Divisor, from a given List of coordinates and a
surface.

Synopsis
========

  * Usage:
        D = divisor(L,X)
  * Inputs:
      * L, a list (Macaulay2Doc),  of coordinate
      * X, an instance of the type QuadricSurface,
  * Outputs:
      * D, an instance of the type Divisor,
+-----------------------------------------+
|i1 : X = quadricSurface(ZZ/101[x,y,z,w]);|
+-----------------------------------------+
|i2 : D = divisor({3,2},X)                |
|                                         |
|o2 = {3, 2}                              |
|                                         |
|o2 : Divisor                             |
+-----------------------------------------+

Synopsis
========

  * Usage:
        D = divisor(L,X)
  * Inputs:
      * L, a list (Macaulay2Doc),  of coordinate
      * X, an instance of the type CubicSurface,
  * Outputs:
      * D, an instance of the type Divisor,
+---------------------------------------+
|i3 : X = cubicSurface(ZZ/101[x,y,z,w]);|
+---------------------------------------+
|i4 : D = divisor({3,1,1,1,1,1,1},X)    |
|                                       |
|o4 = {3, 1, 1, 1, 1, 1, 1}             |
|                                       |
|o4 : Divisor                           |
+---------------------------------------+

Synopsis
========

  * Usage:
        D = divisor(L,X)
  * Inputs:
      * L, a list (Macaulay2Doc),  of coordinate
      * X, an instance of the type QuarticSurfaceRational,
  * Outputs:
      * D, an instance of the type Divisor,
+-------------------------------------------------+
|i5 : X = quarticSurfaceRational(ZZ/101[x,y,z,w]);|
+-------------------------------------------------+
|i6 : D = divisor(splice{3,9:1},X)                |
|                                                 |
|o6 = {3, 1, 1, 1, 1, 1, 1, 1, 1, 1}              |
|                                                 |
|o6 : Divisor                                     |
+-------------------------------------------------+

Ways to use divisor:
====================

  * "divisor(List,CubicSurface)"
  * "divisor(List,QuadricSurface)"
  * "divisor(List,QuarticSurfaceRational)"
  * divisor(Curve) -- extracts the Divisor of a
    Curve

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

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

Divisor * Divisor -- intersection number of two Divisors
********************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),

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

Returns the intersection number of two Divisors.
+-----------------------------------------+
|i1 : Q = quadricSurface(ZZ/101[x,y,z,w]);|
+-----------------------------------------+
|i2 : C = divisor({1,0},Q);               |
+-----------------------------------------+
|i3 : D = divisor({0,1},Q);               |
+-----------------------------------------+
|i4 : C*D                                 |
|                                         |
|o4 = 1                                   |
+-----------------------------------------+

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

  * Divisor * Divisor -- intersection number of two
    Divisors

Divisor + Divisor -- sum of two Divisors
****************************************

Synopsis
========

  * Operator: + (Macaulay2Doc),

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

Returns the sum of two Divisors.
+-----------------------------------------+
|i1 : Q = quadricSurface(ZZ/101[x,y,z,w]);|
+-----------------------------------------+
|i2 : C = divisor({1,0},Q);               |
+-----------------------------------------+
|i3 : D = divisor({0,1},Q);               |
+-----------------------------------------+
|i4 : C+D                                 |
|                                         |
|o4 = {1, 1}                              |
|                                         |
|o4 : Divisor                             |
+-----------------------------------------+

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

  * Divisor + Divisor -- sum of two Divisors

Divisor - Divisor -- difference of two Divisors
***********************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),

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

Returns the difference of two Divisors.
+-----------------------------------------+
|i1 : Q = quadricSurface(ZZ/101[x,y,z,w]);|
+-----------------------------------------+
|i2 : C = divisor({1,0},Q);               |
+-----------------------------------------+
|i3 : D = divisor({0,1},Q);               |
+-----------------------------------------+
|i4 : C-D                                 |
|                                         |
|o4 = {1, -1}                             |
|                                         |
|o4 : Divisor                             |
+-----------------------------------------+

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

  * Divisor - Divisor -- difference of two Divisors

divisor(Curve) -- extracts the Divisor of a Curve
*************************************************

Synopsis
========

  * Function: divisor,

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

Outputs the key Divisor of a Curve
+--------------------+
|i1 : C = curve(5,2);|
+--------------------+
|i2 : D = divisor C  |
|                    |
|o2 = {2, 3}         |
|                    |
|o2 : Divisor        |
+--------------------+

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

  * divisor(Curve) -- extracts the Divisor of a
    Curve

generalACMBetti -- the most general Betti table of an ACM curve with a given Hilbert function
*********************************************************************************************

Synopsis
========

  * Usage:
        B = generalACMBetti gamma
  * Inputs:
      * gamma, a list (Macaulay2Doc), positive character
  * Outputs:
      * B, a Betti tally (Macaulay2Doc),

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

Given a positive character, it outputs the Betti table of a general ACM curve
that has this character as its postulation character.
+------------------------------+
|i1 : generalACMBetti {-1,-1,2}|
|                              |
|            0 1 2             |
|o1 = total: 1 3 2             |
|         0: 1 . .             |
|         1: . 3 2             |
|                              |
|o1 : BettiTally               |
+------------------------------+

Ways to use generalACMBetti:
============================

  * "generalACMBetti(List)"

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

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

genus(Curve) -- computes the genus of a Curve
*********************************************

Synopsis
========

  * Function: genus (Varieties),

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

Computes the genus of a Curve.
+--------------------+
|i1 : C = curve(5,2);|
+--------------------+
|i2 : genus C        |
|                    |
|o2 = 2              |
+--------------------+

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

  * genus(Curve) -- computes the genus of a Curve

genus(Divisor) -- computes the genus of a Divisor
*************************************************

Synopsis
========

  * Function: genus (Varieties),

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

Computes the genus of a Divisor using the adjunction formula.
+---------------------------+
|i1 : R = ZZ/101[x,y,z,w];  |
+---------------------------+
|i2 : Q = quadricSurface(R);|
+---------------------------+
|i3 : D = divisor({3,4},Q); |
+---------------------------+
|i4 : genus D               |
|                           |
|o4 = 6                     |
|                           |
|o4 : QQ                    |
+---------------------------+

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

  * genus(Divisor) -- computes the genus of a
    Divisor

HyperplaneClass -- key for QuadricSurface, CubicSurface and QuarticSurfaceRational
**********************************************************************************

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

The symbol HyperplaneClass is a key for QuadricSurface,
CubicSurface, and QuarticSurfaceRational.
It stores a List encoding the coordinates of a
globally generated divisor used to map the surface to P^3.

See also
========

  * CanonicalClass -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * IntersectionPairing -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * BlowUpPoints -- key for CubicSurface and
    QuarticSurfaceRational
  * MapToP3 -- key for CubicSurface and QuarticSurfaceRational

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

The object HyperplaneClass, is a symbol (Macaulay2Doc).

ideal(Curve) -- extracts the ideal of a Curve
*********************************************

Synopsis
========

  * Function: ideal (Macaulay2Doc),

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

Extracts the key Ideal of a Curve.
+-----------------------------------------------------------------------------+
|i1 : C = curve(5,2);                                                         |
+-----------------------------------------------------------------------------+
|i2 : ideal C                                                                 |
|                                                                             |
|                          2            2        3       2                    |
|o2 = ideal (x x  - x x , x x  - 1835x x  - 9264x  - 400x x  + 9657x x x  -   |
|             1 2    0 3   0 1        0 1        1       0 3        0 1 3     |
|     ------------------------------------------------------------------------|
|           2                        2             2       2           2      |
|     13435x x  - 3772x x x  - 10219x x  + 13402x x  + 4x x  - 10014x x  +    |
|           1 3        0 2 3         2 3         0 3     1 3         2 3      |
|     ------------------------------------------------------------------------|
|          3   3           2        3       2            2         3          |
|     5772x , x  + 15829x x  - 5847x  - 400x x  - 3772x x  - 10219x  +        |
|          3   0         0 1        1       0 2        0 2         2          |
|     ------------------------------------------------------------------------|
|           2                        2                       2             2  |
|     11726x x  + 9501x x x  - 10915x x  + 4430x x x  - 8121x x  + 14370x x  +|
|           0 3        0 1 3         1 3        0 2 3        2 3         0 3  |
|     ------------------------------------------------------------------------|
|            2         2        3                                             |
|     7340x x  - 196x x  - 1373x )                                            |
|          1 3       2 3        3                                             |
|                                                                             |
|                ZZ                                                           |
|o2 : Ideal of -----[x ..x ]                                                  |
|              32003  0   3                                                   |
+-----------------------------------------------------------------------------+

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

  * ideal(Curve) -- extracts the ideal of a Curve

ideal(QuadricSurface) -- extracts the ideal of a surface
********************************************************

Synopsis
========

  * Function: ideal (Macaulay2Doc),

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

Extracts the key Ideal of a QuadricSurface, a
CubicSurface, or a QuarticSurfaceRational.
+-----------------------------------------+
|i1 : X = quadricSurface(ZZ/101[x,y,z,w]);|
+-----------------------------------------+
|i2 : ideal X                             |
|                                         |
|o2 = ideal(- y*z + x*w)                  |
|                                         |
|               ZZ                        |
|o2 : Ideal of ---[x..z, w]               |
|              101                        |
+-----------------------------------------+

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

  * "ideal(CubicSurface)"
  * ideal(QuadricSurface) -- extracts the
    ideal of a surface
  * "ideal(QuarticSurfaceRational)"

IntersectionPairing -- key for QuadricSurface, CubicSurface and QuarticSurfaceRational
**************************************************************************************

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

The symbol IntersectionPairing is a key for QuadricSurface,
see CubicSurface, and
QuarticSurfaceRational. It stores a Matrix encoding
the intersection pairing of the surface.

See also
========

  * CanonicalClass -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * HyperplaneClass -- key for QuadricSurface,
    CubicSurface and QuarticSurfaceRational
  * BlowUpPoints -- key for CubicSurface and
    QuarticSurfaceRational
  * MapToP3 -- key for CubicSurface and QuarticSurfaceRational

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

The object IntersectionPairing, is a symbol (Macaulay2Doc).

isACMBetti -- checks whether a Betti table is that of an ACM curve
******************************************************************

Synopsis
========

  * Usage:
        b = isACMBetti B
  * Inputs:
      * B, a Betti tally (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

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

Given a BettiTally, returns true or false depending on whether there exists an
ACM curve in P3 having that Betti table.
+----------------------------------+
|i1 : B = generalACMBetti {-1,-1,2}|
|                                  |
|            0 1 2                 |
|o1 = total: 1 3 2                 |
|         0: 1 . .                 |
|         1: . 3 2                 |
|                                  |
|o1 : BettiTally                   |
+----------------------------------+
|i2 : isACMBetti B                 |
|                                  |
|o2 = true                         |
+----------------------------------+

Ways to use isACMBetti:
=======================

  * "isACMBetti(BettiTally)"

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

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

isPrime(Curve) -- checks if the ideal of a Curve is prime
*********************************************************

Synopsis
========

  * Function: isPrime (Macaulay2Doc),
  * Usage:
        B = isPrime(C)
  * Inputs:
      * C, an instance of the type Curve,
  * Outputs:
      * B, a Boolean value (Macaulay2Doc),

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

+--------------------+
|i1 : C = curve(5,2);|
+--------------------+
|i2 : isPrime C      |
|                    |
|o2 = true           |
+--------------------+

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

  * isPrime(Curve) -- checks if the ideal of a Curve
    is prime

isSmooth(Ideal) -- checks smoothness of an ideal or of a Curve
**************************************************************

Synopsis
========

  * Function: isSmooth (Macaulay2Doc),

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

The method isSmooth uses Jacobian criterion to check the smoothness of an ideal
or a Curve.

Synopsis
========

  * Usage:
        B = isSmooth(I)
  * Inputs:
      * I, an ideal (Macaulay2Doc),
  * Outputs:
      * B, a Boolean value (Macaulay2Doc),

Synopsis
========

  * Usage:
        B = isSmooth(C)
  * Inputs:
      * C, an instance of the type Curve,
  * Outputs:
      * B, a Boolean value (Macaulay2Doc),
+--------------------+
|i1 : C = curve(5,2);|
+--------------------+
|i2 : isSmooth C     |
|                    |
|o2 = true           |
+--------------------+

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

  * "isSmooth(Curve)"
  * isSmooth(Ideal) -- checks smoothness of an
    ideal or of a Curve

isSmoothACMBetti -- checks whether a Betti table is that of a smooth ACM curve
******************************************************************************

Synopsis
========

  * Usage:
        b = isSmoothACMBetti B
  * Inputs:
      * B, a Betti tally (Macaulay2Doc),
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

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

Given a BettiTally, returns true or false depending on whether there exists a
smooth ACM curve in P3 having that Betti table.
+----------------------------------+
|i1 : B = generalACMBetti {-1,-1,2}|
|                                  |
|            0 1 2                 |
|o1 = total: 1 3 2                 |
|         0: 1 . .                 |
|         1: . 3 2                 |
|                                  |
|o1 : BettiTally                   |
+----------------------------------+
|i2 : isSmoothACMBetti B           |
|                                  |
|o2 = true                         |
+----------------------------------+

Ways to use isSmoothACMBetti:
=============================

  * "isSmoothACMBetti(BettiTally)"

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

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

MapToP3 -- key for CubicSurface and QuarticSurfaceRational
**********************************************************

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

The symbol MapToP3 is a key for CubicSurface, and
QuarticSurfaceRational. It stores a map specifying a
rational map from P^2 to P^3 obtained by the restriction of the embedding of
the blown-up surface to P^3.

See also
========

  * BlowUpPoints -- key for CubicSurface and
    QuarticSurfaceRational

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

The object MapToP3, is a symbol (Macaulay2Doc).

minimalCurve -- generates a minimal curve in the biliaison class
****************************************************************

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

A finite length module M determines a unique biliaison class. Curves of minimal
degrees in this class are called minimal curves. Given the ideal of a curve J,
this function generates a random minimal curve in the biliaison class of J.
Given a finite length module M, this function generates a random minimal curve
in the biliaison class specified by M.

Synopsis
========

  * Usage:
        I = minimalCurve(M)
  * Inputs:
      * M, a module (Macaulay2Doc),
  * Outputs:
      * I, an ideal (Macaulay2Doc),
+-----------------------------------------------------------------------------+
|i1 : R = ZZ/101[x,y,z,w];                                                    |
+-----------------------------------------------------------------------------+
|i2 : M = coker vars R;                                                       |
+-----------------------------------------------------------------------------+
|i3 : I = minimalCurve M                                                      |
|                                                                             |
|              2             2                     2                          |
|o3 = ideal (4x  + 3x*y + 23y  + 7x*z - 38y*z + 11z  - 41x*w - 43y*w - 19z*w +|
|     ------------------------------------------------------------------------|
|        2     2              2                      2                        |
|     44w , 47x  - 12x*y - 49y  + 35x*z - 25y*z + 18z  - 9x*w + 39y*w + 30z*w |
|     ------------------------------------------------------------------------|
|          2       2                              2                           |
|     + 46w , - 33x  - 47x*y - 21x*z - 48y*z + 18z  - 4x*w + 4y*w + 35z*w -   |
|     ------------------------------------------------------------------------|
|       2   2             2                     2                    2        |
|     2w , x  + 18x*y - 9y  + 12x*z + 45y*z + 5z  - 26x*w + z*w - 43w )       |
|                                                                             |
|o3 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+

Synopsis
========

  * Usage:
        I = minimalCurve(J)
  * Inputs:
      * J, an ideal (Macaulay2Doc), of a pure dimension one
        subscheme
  * Outputs:
      * I, an ideal (Macaulay2Doc), of a minimal curve in the
        biliaison class
+-----------------------------------------------------------------------------+
|i4 : R = ZZ/101[x,y,z,w];                                                    |
+-----------------------------------------------------------------------------+
|i5 : J = monomialCurveIdeal(R,{1,3,4});                                      |
|                                                                             |
|o5 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+
|i6 : I = minimalCurve J                                                      |
|                                                                             |
|               2              2              2                               |
|o6 = ideal (34x  - 25x*y - 11y  + 43y*z - 36z  + 18x*w - 45y*w + 40z*w -     |
|     ------------------------------------------------------------------------|
|        2     2              2                      2                        |
|     42w , 44x  + 47x*y - 25y  - 40x*z + 21y*z + 45z  - 45x*w - 13y*w - 4z*w |
|     ------------------------------------------------------------------------|
|         2       2              2                      2                     |
|     + 2w , - 50x  - 14x*y - 30y  + 39x*z - 41y*z - 27z  + 29x*w - 50y*w +   |
|     ------------------------------------------------------------------------|
|               2   2              2                     2                    |
|     34z*w - 7w , x  + 15x*y - 24y  + 3x*z + 29y*z + 31z  + 6x*w - 38y*w -   |
|     ------------------------------------------------------------------------|
|     41z*w)                                                                  |
|                                                                             |
|o6 : Ideal of R                                                              |
+-----------------------------------------------------------------------------+

See also
========

  * minimalCurveBetti -- computes the Betti diagram
    of the minimal curve

Ways to use minimalCurve:
=========================

  * "minimalCurve(Curve)"
  * "minimalCurve(Ideal)"
  * "minimalCurve(Module)"

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

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

minimalCurveBetti -- computes the Betti diagram of the minimal curve
********************************************************************

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

A finite length module M determines a unique biliaison class. Curves of minimal
degrees in this class are called minimal curves. Given the ideal of a curve J,
this function returns the Betti tally of any minimal curve of J. Given a finite
length module M, this function returns the Betti tally of any minimal curve in
the biliaison class specified by M.

Synopsis
========

  * Usage:
        T = minimalCurveBetti(M)
  * Inputs:
      * M, a module (Macaulay2Doc),
  * Outputs:
      * T, a Betti tally (Macaulay2Doc),
+----------------------------+
|i1 : R = ZZ/101[x,y,z,w];   |
+----------------------------+
|i2 : M = coker vars R;      |
+----------------------------+
|i3 : I = minimalCurveBetti M|
|                            |
|            0 1 2 3         |
|o3 = total: 1 4 4 1         |
|         0: 1 . . .         |
|         1: . 4 4 1         |
|                            |
|o3 : BettiTally             |
+----------------------------+

Synopsis
========

  * Usage:
        T = minimalCurve(J)
  * Inputs:
      * J, an ideal (Macaulay2Doc), of a pure dimension one
        subscheme
  * Outputs:
      * T, a Betti tally (Macaulay2Doc), of a minimal curve
        in the biliaison class
+---------------------------------------+
|i4 : R = ZZ/101[x,y,z,w];              |
+---------------------------------------+
|i5 : J = monomialCurveIdeal(R,{1,3,4});|
|                                       |
|o5 : Ideal of R                        |
+---------------------------------------+
|i6 : I = minimalCurveBetti J           |
|                                       |
|            0 1 2 3                    |
|o6 = total: 1 4 4 1                    |
|         0: 1 . . .                    |
|         1: . 4 4 1                    |
|                                       |
|o6 : BettiTally                        |
+---------------------------------------+

See also
========

  * degree(BettiTally) (missing documentation)

Ways to use minimalCurveBetti:
==============================

  * "minimalCurveBetti(Curve)"
  * "minimalCurveBetti(Ideal)"
  * "minimalCurveBetti(Module)"

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

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

net(CubicSurface) -- displays the ideal of the CubicSurface
***********************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),

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

  * net(CubicSurface) -- displays the ideal of
    the CubicSurface

net(Curve) -- displays the ideal of the curve
*********************************************

Synopsis
========

  * Function: net (Macaulay2Doc),

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

  * net(Curve) -- displays the ideal of the curve

net(Divisor) -- displays the coordinates of the Divisor
*******************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),

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

  * net(Divisor) -- displays the coordinates of the
    Divisor

net(QuadricSurface) -- displays the ideal of the QuadricSurface
***************************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),

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

  * net(QuadricSurface) -- displays the ideal
    of the QuadricSurface

net(QuarticSurfaceRational) -- displays the ideal of the QuarticSurfaceRational
*******************************************************************************

Synopsis
========

  * Function: net (Macaulay2Doc),

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

  * net(QuarticSurfaceRational), --
    displays the ideal of the QuarticSurfaceRational

positiveChars -- generates all positive characters of a given degree
********************************************************************

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

produces all positive characters of a given degree, equivalently, these are
exactly all the possible postulation characters of an ACM curve in P3 of that
degree

Synopsis
========

  * Usage:
        L = positiveChars(d)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree
  * Outputs:
      * L, a list (Macaulay2Doc),
+----------------------------------------+
|i1 : positiveChars(5)                   |
|                                        |
|o1 = {{-1, -1, 1, 0, 1}, {-1, -1, 0, 2}}|
|                                        |
|o1 : List                               |
+----------------------------------------+

Synopsis
========

  * Usage:
        L = positiveChars(d,s)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree
      * s, an integer (Macaulay2Doc), least degree surface
  * Outputs:
      * L, a list (Macaulay2Doc),
+----------------------------------------+
|i2 : positiveChars(5)                   |
|                                        |
|o2 = {{-1, -1, 1, 0, 1}, {-1, -1, 0, 2}}|
|                                        |
|o2 : List                               |
+----------------------------------------+

Ways to use positiveChars:
==========================

  * "positiveChars(ZZ)"
  * "positiveChars(ZZ,ZZ)"

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

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

QuadricSurface -- type of HashTable
***********************************

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

QuadricSurface is a type of HashTable storing information about a smooth
quadric surface in P^3. The keys of a QuadricSurface are: IntersectionPairing,
HyperplaneClass, CanonicalClass, Ideal.

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

  * "divisor(List,QuadricSurface)" -- see divisor, -- creates a
    Divisor
  * ideal(QuadricSurface) -- extracts the
    ideal of a surface
  * net(QuadricSurface) -- displays the ideal
    of the QuadricSurface
  * "smoothDivisors(ZZ,QuadricSurface)" -- see smoothDivisors,
    -- produces a list of smooth divisors of a given degree on
    a surface

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

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

quadricSurface -- creates a QuadricSurface
******************************************

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

This function takes a polynomial ring in 4 variables over a field as the
coordinate ring of P3 and creates a QuadricSurface, in
this ring.

Synopsis
========

  * Usage:
        Q = quadricSurface(R)
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * Q, an instance of the type QuadricSurface,
+--------------------------------------+
|i1 : quadricSurface(ZZ/32003[x,y,z,w])|
|                                      |
|o1 = ideal(- y*z + x*w)               |
|                                      |
|o1 : QuadricSurface                   |
+--------------------------------------+

See also
========

  * cubicSurface -- creates a cubicSurface
  * quarticSurfaceRational -- creates a
    QuarticSurfaceRational

Ways to use quadricSurface:
===========================

  * "quadricSurface(Ring)"

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

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

QuarticSurfaceRational -- type of HashTable
*******************************************

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

QuarticSurfaceRational is a type of HashTable storing information about a
rational quartic surface with a double line in P^3. The keys of a
QuadricSurface are: IntersectionPairing, HyperplaneClass, CanonicalClass,
Ideal, BlowUpPoints, MapToP3.

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

  * "divisor(List,QuarticSurfaceRational)" -- see divisor, --
    creates a Divisor
  * "ideal(QuarticSurfaceRational)" -- see ideal(QuadricSurface),
    -- extracts the ideal of a surface
  * net(QuarticSurfaceRational), --
    displays the ideal of the QuarticSurfaceRational
  * "smoothDivisors(ZZ,QuarticSurfaceRational)" -- see smoothDivisors,
    -- produces a list of smooth divisors of a given degree on
    a surface

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

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

quarticSurfaceRational -- creates a QuarticSurfaceRational
**********************************************************

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

This function takes a polynomial ring in 4 variables over a field as the
coordinate ring of P3 and creates a rational quartic surface with a double line
as a QuarticSurfaceRational, in this ring. To do
this We blow up P2 at 10 points, listed in BlowUpPoints, and map the blownup
surface to P3. The map is specified as a rational map P2->P3 given in MapToP3.

Synopsis
========

  * Usage:
        X = quadricSurface(R)
  * Inputs:
      * R, a ring (Macaulay2Doc),
  * Outputs:
      * X, an instance of the type QuarticSurfaceRational,
+-----------------------------------------------------------------------------+
|i1 : X = quarticSurfaceRational(ZZ/32003[x,y,z,w])                           |
|                                                                             |
|            4        3          2 2          3        4        3         2   |
|o1 = ideal(x  + 9724x y - 14728x y  + 4857x*y  - 3225y  + 5278x z + 1636x y*z|
|                                                                             |
|o1 : QuarticSurfaceRational                                                  |
|-----------------------------------------------------------------------------|
|         2         3         2 2            2        2 2           3         |
|- 5528x*y z + 1012y z - 7898x z  + 2192x*y*z  + 8097y z  - 13288x*z  -       |
|-----------------------------------------------------------------------------|
|      3       3          2             2         3          2                |
|914y*z  - 813x w - 12824x y*w - 6277x*y w + 1492y w + 13647x z*w +           |
|-----------------------------------------------------------------------------|
|                    2            2           2          2 2             2    |
|1491x*y*z*w + 12452y z*w - 914x*z w + 9994y*z w - 14516x w  + 10106x*y*w  +  |
|-----------------------------------------------------------------------------|
|      2 2            2            2          3                               |
|14105y w  - 7003x*z*w  + 6180y*z*w  - 6180x*w )                              |
+-----------------------------------------------------------------------------+

See also
========

  * quadricSurface -- creates a QuadricSurface
  * cubicSurface -- creates a cubicSurface

Ways to use quarticSurfaceRational:
===================================

  * "quarticSurfaceRational(Ring)"

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

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

randomDeterminantalIdeal -- produces a random determinantal ideal
*****************************************************************

Synopsis
========

  * Usage:
        I = randomDeterminantalIdeal(R,M)
  * Inputs:
      * R, a ring (Macaulay2Doc),
      * M, a matrix (Macaulay2Doc), of integers
  * Outputs:
      * I, an ideal (Macaulay2Doc), in the ring R

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

Given a ring and a degree matrix, we produce a random determinantal ideal with
forms in prescribed degree. Forms of non-positive degrees are taken as 0 to
ensure minimality of presentation.
+-----------------------------------------------------------------------------+
|i1 : randomDeterminantalIdeal(ZZ/101[x,y,z],matrix{{1,1},{1,1},{1,1}})       |
|                                                                             |
|                 2              2                      2    2              2 |
|o1 = ideal (- 10x  - 50x*y - 21y  + 42x*z + 13y*z - 37z , 8x  + 15x*y - 11y  |
|     ------------------------------------------------------------------------|
|                         2       2              2                     2      |
|     - 38x*z - 20y*z + 2z , - 36x  + 21x*y - 36y  - 8x*z + 25y*z - 24z )     |
|                                                                             |
|               ZZ                                                            |
|o1 : Ideal of ---[x..z]                                                      |
|              101                                                            |
+-----------------------------------------------------------------------------+

Ways to use randomDeterminantalIdeal:
=====================================

  * "randomDeterminantalIdeal(Ring,Matrix)"

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

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

raoModule -- computes the Rao module of a curve
***********************************************

Synopsis
========

  * Usage:
        M = raoModule I
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a pure dimension one
        subscheme
  * Outputs:
      * M, a module (Macaulay2Doc),

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

Given I the homogeneous ideal of a pure dimension one subscheme in P^3, the
function computes its Rao module.
+---------------------------------------+
|i1 : R = ZZ/101[x,y,z,w];              |
+---------------------------------------+
|i2 : I = monomialCurveIdeal(R,{1,3,4});|
|                                       |
|o2 : Ideal of R                        |
+---------------------------------------+
|i3 : M = raoModule I                   |
|                                       |
|o3 = cokernel {1} | w -z y -x |        |
|                                       |
|                            1          |
|o3 : R-module, quotient of R           |
+---------------------------------------+

Ways to use raoModule:
======================

  * "raoModule(Curve)"
  * "raoModule(Ideal)"

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

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

smoothDivisors -- produces a list of smooth divisors of a given degree on a surface
***********************************************************************************

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

Produces a List of Divisor, of a given degree on a given
surface. On the CubicSurface, and the
QuarticSurfaceRational, the list is not exhaustive, but
will include a divisor for each possible genus that a smooth curve can obtain.

Synopsis
========

  * Usage:
        L = smoothDiviors(d,X)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree
      * X, an instance of the type QuadricSurface,
  * Outputs:
      * L, a list (Macaulay2Doc), of Divisors
+-----------------------------------------+
|i1 : X = quadricSurface(ZZ/101[x,y,z,w]);|
+-----------------------------------------+
|i2 : L = smoothDivisors(5,X)             |
|                                         |
|o2 = {{1, 4}, {2, 3}}                    |
|                                         |
|o2 : List                                |
+-----------------------------------------+

Synopsis
========

  * Usage:
        L = smoothDiviors(d,X)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree
      * X, an instance of the type CubicSurface,
  * Outputs:
      * L, a list (Macaulay2Doc), of Divisors
+--------------------------------------------------------------------------+
|i3 : X = cubicSurface(ZZ/101[x,y,z,w]);                                   |
+--------------------------------------------------------------------------+
|i4 : L = smoothDivisors(5,X)                                              |
|                                                                          |
|o4 = {{2, 1, 0, 0, 0, 0, 0}, {3, 1, 1, 1, 1, 0, 0}, {4, 2, 1, 1, 1, 1, 1}}|
|                                                                          |
|o4 : List                                                                 |
+--------------------------------------------------------------------------+

Synopsis
========

  * Usage:
        L = smoothDiviors(d,X)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree
      * X, an instance of the type QuarticSurfaceRational,
  * Outputs:
      * L, a list (Macaulay2Doc), of Divisors
+-----------------------------------------------------------------------------+
|i5 : X = quarticSurfaceRational(ZZ/101[x,y,z,w]);                            |
+-----------------------------------------------------------------------------+
|i6 : L = smoothDivisors(5,X)                                                 |
|                                                                             |
|o6 = {{3, 0, 2, 1, 1, 1, 1, 1, 0, 0}, {3, 0, 1, 1, 1, 1, 1, 1, 1, 0}, {4, 1, |
|     ------------------------------------------------------------------------|
|     2, 1, 1, 1, 1, 1, 1, 1}}                                                |
|                                                                             |
|o6 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use smoothDivisors:
===========================

  * "smoothDivisors(ZZ,CubicSurface)"
  * "smoothDivisors(ZZ,QuadricSurface)"
  * "smoothDivisors(ZZ,QuarticSurfaceRational)"
  * smoothDivisors(ZZ,ZZ) -- produces a
    list of smooth divisors of given degree and genus
  * "smoothDivisors(ZZ,ZZ,Ring)" -- see smoothDivisors(ZZ,ZZ),
    -- produces a list of smooth divisors of given
    degree and genus

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

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

smoothDivisors(ZZ,ZZ) -- produces a list of smooth divisors of given degree and genus
*************************************************************************************

Synopsis
========

  * Function: smoothDivisors,
  * Usage:
        L = smoothdivisors(d,g)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree
      * g, an integer (Macaulay2Doc), genus

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

This method produces a list of Divisors of a given degree and genus, one may
also pass Ring as the ambient ring of P3.
+--------------------------------------------------------------------+
|i1 : smoothDivisors(5,2)                                            |
|                                                                    |
|o1 = {{2, 3}, {4, 2, 1, 1, 1, 1, 1}, {4, 1, 2, 1, 1, 1, 1, 1, 1, 1}}|
|                                                                    |
|o1 : List                                                           |
+--------------------------------------------------------------------+
|i2 : smoothDivisors(5,2,ZZ/101[x,y,z,w])                            |
|                                                                    |
|o2 = {{2, 3}, {4, 2, 1, 1, 1, 1, 1}, {4, 1, 2, 1, 1, 1, 1, 1, 1, 1}}|
|                                                                    |
|o2 : List                                                           |
+--------------------------------------------------------------------+

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

  * smoothDivisors(ZZ,ZZ) -- produces a
    list of smooth divisors of given degree and genus
  * "smoothDivisors(ZZ,ZZ,Ring)"

specializeACMBetti -- lists all 1-specialization of a Betti table of an ACM curve
*********************************************************************************

Synopsis
========

  * Usage:
        L = specializeACM B
  * Inputs:
      * B, a Betti tally (Macaulay2Doc),
  * Outputs:
      * L, a list (Macaulay2Doc), of BettiTally

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

Given a Betti table of an ACM curve, produces all possible Betti tables of ACM
curves with one more generator and syzygy of equal degree than the given one.
+---------------------------------------+
|i1 : B = generalACMBetti {-1,-1,-1,2,1}|
|                                       |
|            0 1 2                      |
|o1 = total: 1 3 2                      |
|         0: 1 . .                      |
|         1: . . .                      |
|         2: . 3 1                      |
|         3: . . 1                      |
|                                       |
|o1 : BettiTally                        |
+---------------------------------------+
|i2 : specializeACMBetti B              |
|                                       |
|             0 1 2                     |
|o2 = {total: 1 4 3}                    |
|          0: 1 . .                     |
|          1: . . .                     |
|          2: . 3 2                     |
|          3: . 1 1                     |
|                                       |
|o2 : List                              |
+---------------------------------------+

Ways to use specializeACMBetti:
===============================

  * "specializeACMBetti(BettiTally)"

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

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

Surface -- key of Divisor
*************************

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

See Surface, is a key of Divisor, storing a
HashTable which can be QuadricSurface,
CubicSurface, or QuarticSurfaceRational.

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

The object Surface, is a symbol (Macaulay2Doc).

surface -- the surface key of a Divisor or a Curve
**************************************************

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

Returns the key Surface, of a Divisor.
+-------------------------+
|i1 : C = curve(5,2);     |
+-------------------------+
|i2 : D = divisor C       |
|                         |
|o2 = {2, 3}              |
|                         |
|o2 : Divisor             |
+-------------------------+
|i3 : Q = surface D       |
|                         |
|o3 = ideal(- x x  + x x )|
|              1 2    0 3 |
|                         |
|o3 : QuadricSurface      |
+-------------------------+

Ways to use surface:
====================

  * "surface(Curve)"
  * "surface(Divisor)"

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

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

ZZ * Divisor -- multiply a Divisor by an integer
************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),

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

Multiplies a Divisors by an integer.
+-----------------------------------------+
|i1 : Q = quadricSurface(ZZ/101[x,y,z,w]);|
+-----------------------------------------+
|i2 : C = divisor({1,0},Q);               |
+-----------------------------------------+
|i3 : 3*C                                 |
|                                         |
|o3 = {3, 0}                              |
|                                         |
|o3 : Divisor                             |
+-----------------------------------------+

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

  * ZZ * Divisor -- multiply a Divisor by an integer