This is M0nbar.info, produced by Macaulay2, version 1.21

M0nbar -- calculations for divisors and curves on the moduli space of stable n-pointed genus zero curves
********************************************************************************************************

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

This package contains two types for working with divisor classes and curve
classes on $\bar{M}_{0,n}$, the moduli space of stable n-pointed genus zero
curves. The basic types are DivisorClassRepresentativeM0nbar and
CurveClassRepresentativeM0nbar.

+-----------------------------------------------------------------------------+
|i1 : L1= { {{{2,1},{3},{4},{5}},-2}, {{{1,3},{2},{4},{5}},-7},               |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1}};                                                    |
+-----------------------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(5,L1);                                 |
+-----------------------------------------------------------------------------+
|i3 : L2=new HashTable from { {{1,3},1}, {{1,4},1}};                          |
+-----------------------------------------------------------------------------+
|i4 : D=divisorClassRepresentativeM0nbar(5,L2);                               |
+-----------------------------------------------------------------------------+
|i5 : intersection(C,D)                                                       |
|                                                                             |
|o5 = 6                                                                       |
+-----------------------------------------------------------------------------+

Authors
=======

  * Han-Bom Moon <hmoon8@fordham.edu>
  * Dave Swinarski (see http://faculty.fordham.edu/dswinarski )
    <dswinarski@fordham.edu>

Version
=======

This documentation describes version 0.3 of M0nbar.

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

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

Exports
=======

  * Types
      * CurveClassRepresentativeM0nbar,
        -- class implementing curves on the moduli space of stable n-pointed
        genus zero curves
      * DivisorClassRepresentativeM0nbar
        -- class implementing divisors on the
        moduli space of stable n-pointed genus zero curves
  * Functions and commands
      * curveClassRepresentativeM0nbar,
        -- creates an object of type CurveClassRepresentativeM0nbar
      * divisorClassRepresentativeM0nbar
        -- creates an object of type
        DivisorClassRepresentativeM0nbar
      * Fcurves -- lists the F-curves for a given n
      * FcurvesOfGivenShape -- a list of the
        F-curves with the given shape
      * isEffectiveExpression -- determines
        whether a curve class expression is effective
      * isEquivalent -- check whether two curve class
        representatives are numerically equivalent
      * KeelRelationAmongCurves -- write the
        Keel relation among F curves based on the input lists
      * negativeSum -- sum of the negative coefficients in
        CurveClassRepresentativeM0nbar
      * nonadjacentBasis -- computes the nonadjacent
        basis of divisors on M0nbar
      * permute -- compute the image of a curve class
        representative under a permutation of the marked points
      * seekEffectiveExpression -- seeks to
        write a curve class as an effective sum of F-curves
      * singletonSpineBasis -- computes the
        singleton spine basis of curves on M0nbar
      * writeCurveInDualNonadjacentBasis
        -- write a curve in the basis dual to
        the nonadjacent basis
      * writeCurveInSingletonSpineBasis,
        -- write a curve class in the singleton spine basis of curve
      * writeDivisorInNonadjacentBasis,
        -- write a divisor in the nonadjacent basis
  * Methods
      * "curveClassRepresentativeM0nbar(ZZ,List)" -- see
        curveClassRepresentativeM0nbar, --
        creates an object of type CurveClassRepresentativeM0nbar
      * CurveClassRepresentativeM0nbar + CurveClassRepresentativeM0nbar
        -- add
        two curve class representatives on M0nbar
      * CurveClassRepresentativeM0nbar - CurveClassRepresentativeM0nbar,
        --
        subtract two curve class representatives on M0nbar
      * curveClassRepresentativeM0nbar(ZZ,HashTable)
        -- creates an
        object of type CurveClassRepresentativeM0nbar
      * "divisorClassRepresentativeM0nbar(ZZ,List)" -- see
        divisorClassRepresentativeM0nbar, --
        creates an object of type DivisorClassRepresentativeM0nbar
      * DivisorClassRepresentativeM0nbar + DivisorClassRepresentativeM0nbar
        -- add two divisor class
        representatives on M0nbar
      * DivisorClassRepresentativeM0nbar - DivisorClassRepresentativeM0nbar
        -- subtract two divisor class
        representatives on M0nbar
      * divisorClassRepresentativeM0nbar(ZZ,HashTable)
        -- creates an
        object of type DivisorClassRepresentativeM0nbar
      * "Fcurves(ZZ)" -- see Fcurves, -- lists the F-curves for
        a given n
      * "FcurvesOfGivenShape(ZZ,ZZ,ZZ,ZZ)" -- see FcurvesOfGivenShape,
        -- a list of the F-curves with the given shape
      * "intersection(CurveClassRepresentativeM0nbar,
        DivisorClassRepresentativeM0nbar)" -- see intersection,
        -- intersection number of a curve class and divisor class
      * intersection(DivisorClassRepresentativeM0nbar, CurveClassRepresentativeM0nbar)
        -- intersection number of a
        divisor class and curve class
      * "isEffectiveExpression(CurveClassRepresentativeM0nbar)" -- see
        isEffectiveExpression, -- determines whether a
        curve class expression is effective
      * isEffectiveExpression(DivisorClassRepresentativeM0nbar),
        --
        determines whether a divisor class expression is effective
      * "isEquivalent(CurveClassRepresentativeM0nbar,
        CurveClassRepresentativeM0nbar)" -- see isEquivalent,
        -- check whether two curve class representatives are
        numerically equivalent
      * isEquivalent(DivisorClassRepresentativeM0nbar, DivisorClassRepresentativeM0nbar)
        -- check whether two divisor
        class representatives are numerically equivalent
      * "KeelRelationAmongCurves(List)" -- see KeelRelationAmongCurves,
        -- write the Keel relation among F curves
        based on the input lists
      * "negativeSum(CurveClassRepresentativeM0nbar)" -- see negativeSum,
        -- sum of the negative coefficients in
        CurveClassRepresentativeM0nbar
      * "nonadjacentBasis(ZZ)" -- see nonadjacentBasis,
        -- computes the nonadjacent basis of divisors on M0nbar
      * Number * CurveClassRepresentativeM0nbar
        -- multiply a curve class
        representatives on M0nbar by a scalar
      * Number * DivisorClassRepresentativeM0nbar
        -- multiply a divisor class
        representatives on M0nbar by a scalar
      * "permute(List,CurveClassRepresentativeM0nbar)" -- see permute,
        -- compute the image of a curve class representative under a
        permutation of the marked points
      * permute(List,DivisorClassRepresentativeM0nbar)
        -- compute the
        image of a divisor class representative under a permutation of the
        marked points
      * "seekEffectiveExpression(CurveClassRepresentativeM0nbar)" -- see
        seekEffectiveExpression, -- seeks to write a
        curve class as an effective sum of F-curves
      * "singletonSpineBasis(ZZ)" -- see singletonSpineBasis,
        -- computes the singleton spine basis of curves on
        M0nbar
      * tex(CurveClassRepresentativeM0nbar)
        -- convert to TeX format
      * tex(DivisorClassRepresentativeM0nbar)
        -- convert to TeX format
      * "writeCurveInDualNonadjacentBasis(CurveClassRepresentativeM0nbar)" --
        see writeCurveInDualNonadjacentBasis,
        -- write a curve in the basis dual to
        the nonadjacent basis
      * "writeCurveInSingletonSpineBasis(CurveClassRepresentativeM0nbar)" --
        see writeCurveInSingletonSpineBasis,
        -- write a curve class in the
        singleton spine basis of curve
      * writeCurveInSingletonSpineBasis(ZZ,List)
        -- write a curve class
        in the singleton spine basis of curve
      * "writeDivisorInNonadjacentBasis(DivisorClassRepresentativeM0nbar)" --
        see writeDivisorInNonadjacentBasis,
        -- write a divisor in the nonadjacent
        basis

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

The object M0nbar, is a package (Macaulay2Doc).

Bibliography -- Bibliography for the M0nbar package
***************************************************

[Carr] Carr.   A polygonal presentation of $Pic(\bar{M}_{0,n})$,
arXiv:0911.2649. [KM] Keel and McKernan.  Contractible extremal rays. p.
113-128 in Handbook of Moduli, Vol. II.  Higher Education \& International
Press, Beijing-Boston, 2012. [MS] Moon and Swinarski.  Effective curves on
$\bar{M}_{0,n}$ from group actions.  Manuscripta Math.  147 (2015) 239-268. [S]
Swinarski.  A basis of F-curves on $\bar{M}_{0,n}$, available at
http://faculty.fordham.edu/dswinarski/Fcurves/.

Boundary divisors -- irreducible components of the boundary of the moduli space of stable n-pointed genus zero curves
*********************************************************************************************************************

Let $\Delta_I$ be the closure of the locus of curves with two irreducible
components meeting at one node such that the marked points with labels in $I$
lie on the first component, and the marked points with labels in $I^c$ lie on
the second component.  Then $\Delta_I$ is an irreducible effective divisor.

Let $\delta_I$ be the class of $\Delta_I$.  Then the classes $\{ \delta_I : \#I
\geq 2, \#I \leq n/2, 1 \in I if \#I=n/2\}$ span the Picard group of
$\bar{M}_{0,n}$.  The relations between these classes are called the Keel
relations.

CurveClassRepresentativeM0nbar -- class implementing curves on the moduli space of stable n-pointed genus zero curves
*********************************************************************************************************************

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

This class represents curve classes in $ NS_1(\bar{M}_{0,n}) $.  A curve class
is just a linear combination of F-curves.

+-----------------------------------------------------------------------------+
|i1 : L= { {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1} };                |
+-----------------------------------------------------------------------------+
|i2 : curveClassRepresentativeM0nbar(5,L)                                     |
|                                                                             |
|o2 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o2 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => 1}}                                                        |
|{2}, {4}, {5}} => 1                                                          |
+-----------------------------------------------------------------------------+

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

  * curveClassRepresentativeM0nbar, --
    creates an object of type CurveClassRepresentativeM0nbar
  * KeelRelationAmongCurves -- write the Keel
    relation among F curves based on the input lists
  * writeCurveInSingletonSpineBasis, --
    write a curve class in the singleton spine basis of curve

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

  * CurveClassRepresentativeM0nbar + CurveClassRepresentativeM0nbar
    -- add two
    curve class representatives on M0nbar
  * CurveClassRepresentativeM0nbar - CurveClassRepresentativeM0nbar,
    --
    subtract two curve class representatives on M0nbar
  * "intersection(CurveClassRepresentativeM0nbar,
    DivisorClassRepresentativeM0nbar)" -- see intersection,
    -- intersection number of a curve class and divisor class
  * intersection(DivisorClassRepresentativeM0nbar, CurveClassRepresentativeM0nbar)
    -- intersection number of a divisor
    class and curve class
  * "isEffectiveExpression(CurveClassRepresentativeM0nbar)" -- see
    isEffectiveExpression, -- determines whether a curve
    class expression is effective
  * "isEquivalent(CurveClassRepresentativeM0nbar,CurveClassRepresentativeM0nbar
    )" -- see isEquivalent, -- check whether two curve
    class representatives are numerically equivalent
  * "negativeSum(CurveClassRepresentativeM0nbar)" -- see negativeSum,
    -- sum of the negative coefficients in
    CurveClassRepresentativeM0nbar
  * Number * CurveClassRepresentativeM0nbar
    -- multiply a curve class representatives
    on M0nbar by a scalar
  * "permute(List,CurveClassRepresentativeM0nbar)" -- see permute,
    -- compute the image of a curve class representative under a
    permutation of the marked points
  * "seekEffectiveExpression(CurveClassRepresentativeM0nbar)" -- see
    seekEffectiveExpression, -- seeks to write a curve
    class as an effective sum of F-curves
  * tex(CurveClassRepresentativeM0nbar)
    -- convert to TeX format
  * "writeCurveInDualNonadjacentBasis(CurveClassRepresentativeM0nbar)" -- see
    writeCurveInDualNonadjacentBasis,
    -- write a curve in the basis dual to the nonadjacent basis
  * "writeCurveInSingletonSpineBasis(CurveClassRepresentativeM0nbar)" -- see
    writeCurveInSingletonSpineBasis, --
    write a curve class in the singleton spine basis of curve

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

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

curveClassRepresentativeM0nbar -- creates an object of type CurveClassRepresentativeM0nbar
******************************************************************************************

Synopsis
========

  * Usage:
        curveClassRepresentativeM0nbar(n,H)
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * H, a list (Macaulay2Doc),
  * Outputs:
      * an instance of the type CurveClassRepresentativeM0nbar,

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

This function creates an object of type CurveClassRepresentativeM0nbar.  Here
is a basic example:

+-----------------------------------------------------------------------------+
|i1 : L1= { {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1} };               |
+-----------------------------------------------------------------------------+
|i2 : curveClassRepresentativeM0nbar(5,L1)                                    |
|                                                                             |
|o2 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o2 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => 1}}                                                        |
|{2}, {4}, {5}} => 1                                                          |
+-----------------------------------------------------------------------------+

The input can be a list or a hash table (see the documentation for
(curveClassRepresentativeM0nbar,ZZ,HashTable)) .  The elements of the list
should be pairs {{I1,I2,I3,I4},c}.  This will add $c F_{I_1,I_2,I_3,I_4}$ to
the curve class expression.  Equivalently, you can type {I1,I2,I3,I4}=> instead
of {{I1,I2,I3,I4},c}.

+-----------------------------------------------------------------------------+
|i3 : L2= { {{1,2},{3},{4},{5}}=>1, {{1,3},{2},{4},{5}}=>1 };                 |
+-----------------------------------------------------------------------------+
|i4 : curveClassRepresentativeM0nbar(5,L2)                                    |
|                                                                             |
|o4 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o4 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => 1}}                                                        |
|{2}, {4}, {5}} => 1                                                          |
+-----------------------------------------------------------------------------+

The function does some minimal testing to make sure the expression makes sense.
If you type "L2=new HashTable from \{ \{\{1,7\},\{2\},\{3\},\{4\}\} =>1 \}" and
then run "curveClassRepresentativeM0nbar(6,L2)", you will get an error that
"The curve expression is invalid."

The function sorts the curve class labels.  If sorting creates like terms, they
are combined:

+-----------------------------------------------------------------------------+
|i5 : L3={ {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1},                  |
|-----------------------------------------------------------------------------|
|{{{3},{4},{2,1},{5}},1}};                                                    |
+-----------------------------------------------------------------------------+
|i6 : curveClassRepresentativeM0nbar(5,L3)                                    |
|                                                                             |
|o6 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o6 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => 2}}                                                        |
|{2}, {4}, {5}} => 1                                                          |
+-----------------------------------------------------------------------------+

It deletes terms whose coefficient is zero.

+-----------------------------------------------------------------------------+
|i7 : L4={ {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1},                  |
|-----------------------------------------------------------------------------|
|{{{3},{4},{2,1},{5}},-1}};                                                   |
+-----------------------------------------------------------------------------+
|i8 : curveClassRepresentativeM0nbar(5,L4)                                    |
|                                                                             |
|o8 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o8 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{2}, {4}, {5}} => 1}}                                                        |
+-----------------------------------------------------------------------------+

Ways to use curveClassRepresentativeM0nbar :
============================================

  * "curveClassRepresentativeM0nbar(ZZ,List)"
  * curveClassRepresentativeM0nbar(ZZ,HashTable)
    -- creates an object of
    type CurveClassRepresentativeM0nbar

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

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

CurveClassRepresentativeM0nbar + CurveClassRepresentativeM0nbar -- add two curve class representatives on M0nbar
****************************************************************************************************************

Synopsis
========

  * Operator: + (Macaulay2Doc),
  * Usage:
        C1+C2
  * Inputs:
      * C1, an instance of the type CurveClassRepresentativeM0nbar,
      * C2, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * C3, an instance of the type DivisorClassRepresentativeM0nbar,

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

This function adds two curve class representatives on M0nbar.

+-----------------------------------------------------------------------------+
|i1 : L1= { {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1} };               |
+-----------------------------------------------------------------------------+
|i2 : C1=curveClassRepresentativeM0nbar(5,L1);                                |
+-----------------------------------------------------------------------------+
|i3 : L2= { {{{2,1},{3},{4},{5}},2}, {{{1,4},{2},{3},{5}},1} };               |
+-----------------------------------------------------------------------------+
|i4 : C2=curveClassRepresentativeM0nbar(5,L2);                                |
+-----------------------------------------------------------------------------+
|i5 : C1+C2                                                                   |
|                                                                             |
|o5 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                                                 {{1, 4},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o5 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => 3}}                                                        |
|{2}, {4}, {5}} => 1                                                          |
|{2}, {3}, {5}} => 1                                                          |
+-----------------------------------------------------------------------------+

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

  * CurveClassRepresentativeM0nbar + CurveClassRepresentativeM0nbar
    -- add two
    curve class representatives on M0nbar

CurveClassRepresentativeM0nbar - CurveClassRepresentativeM0nbar -- subtract two curve class representatives on M0nbar
*********************************************************************************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        C1-C2
  * Inputs:
      * C1, an instance of the type CurveClassRepresentativeM0nbar,
      * C2, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * C3, an instance of the type DivisorClassRepresentativeM0nbar,

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

This function subtracts two curve class representatives on M0nbar.

+-----------------------------------------------------------------------------+
|i1 : L1= { {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1} };               |
+-----------------------------------------------------------------------------+
|i2 : C1=curveClassRepresentativeM0nbar(5,L1);                                |
+-----------------------------------------------------------------------------+
|i3 : L2= { {{{2,1},{3},{4},{5}},2}, {{{1,4},{2},{3},{5}},1} };               |
+-----------------------------------------------------------------------------+
|i4 : C2=curveClassRepresentativeM0nbar(5,L2);                                |
+-----------------------------------------------------------------------------+
|i5 : C1-C2                                                                   |
|                                                                             |
|o5 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                                                 {{1, 4},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o5 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => -1}}                                                       |
|{2}, {4}, {5}} => 1                                                          |
|{2}, {3}, {5}} => -1                                                         |
+-----------------------------------------------------------------------------+

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

  * CurveClassRepresentativeM0nbar - CurveClassRepresentativeM0nbar,
    --
    subtract two curve class representatives on M0nbar

curveClassRepresentativeM0nbar(ZZ,HashTable) -- creates an object of type CurveClassRepresentativeM0nbar
********************************************************************************************************

Synopsis
========

  * Function: curveClassRepresentativeM0nbar,
  * Usage:
        curveClassRepresentativeM0nbar(H)
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * H, a hash table (Macaulay2Doc),
  * Outputs:
      * an instance of the type CurveClassRepresentativeM0nbar,

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

This function creates an object of type CurveClassRepresentativeM0nbar from a
hash table.  Here is a basic example:

+-----------------------------------------------------------------------------+
|i1 : H1=new HashTable from { {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1}|
|-----------------------------------------------------------------------------|
|};                                                                           |
+-----------------------------------------------------------------------------+
|i2 : curveClassRepresentativeM0nbar(5,H1)                                    |
|                                                                             |
|o2 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o2 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => 1}}                                                        |
|{2}, {4}, {5}} => 1                                                          |
+-----------------------------------------------------------------------------+

Warning: when you enter a hash table in Macaulay2, if you use a key more than
once, the first instance is discarded.   Here is an example where the behavior
may differ from what you want:

+-----------------------------------------------------------------------------+
|i3 : H=new HashTable from { {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1},|
|                                                                             |
|o3 = HashTable{{{1, 2}, {3}, {4}, {5}} => 2}                                 |
|               {{1, 3}, {2}, {4}, {5}} => 1                                  |
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|{{{1,2},{3},{4},{5}},2}}                                                     |
+-----------------------------------------------------------------------------+

The user probably wanted $F_{\{1,2\},\{3\},\{4\},\{5\}} +
2F_{\{1,2\},\{3\},\{4\},\{5\}}$ to give $3F_{\{1,2\},\{3\},\{4\},\{5\}}$
instead.  So if your expression has two terms that are written exactly alike,
you could either combine them before you create the input hash table, or input
a list instead.

+-----------------------------------------------------------------------------+
|i4 : L= { {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1}, {{{1,2},{3},{4},{|
|                                                                             |
|o4 = {{{{1, 2}, {3}, {4}, {5}}, 1}, {{{1, 3}, {2}, {4}, {5}}, 1}, {{{1, 2},  |
|     ------------------------------------------------------------------------|
|     {3}, {4}, {5}}, 2}}                                                     |
|                                                                             |
|o4 : List                                                                    |
|-----------------------------------------------------------------------------|
|5}},2}}                                                                      |
+-----------------------------------------------------------------------------+
|i5 : curveClassRepresentativeM0nbar(5,L)                                     |
|                                                                             |
|o5 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o5 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => 3}}                                                        |
|{2}, {4}, {5}} => 1                                                          |
+-----------------------------------------------------------------------------+

For this reason, most users will probably prefer to enter curves via lists,
rather than hash tables.

The function curveClassRepresentative does the same minimal testing if you
enter a hash table that it does if you enter a list.  See the documentation for
curveClassRepresentativeM0nbar(ZZ,List).

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

  * curveClassRepresentativeM0nbar(ZZ,HashTable)
    -- creates an object of
    type CurveClassRepresentativeM0nbar

DivisorClassRepresentativeM0nbar -- class implementing divisors on the moduli space of stable n-pointed genus zero curves
*************************************************************************************************************************

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

This class represents divisor classes in $ NS^1(\bar{M}_{0,n}) $.  A divisor
class is just a linear combination of the boundary divisors $ \delta_I $.

+-----------------------------------------------------------------------------+
|i1 : H=new HashTable from { {{1,3},1}, {{1,4},1} };                          |
+-----------------------------------------------------------------------------+
|i2 : divisorClassRepresentativeM0nbar(6,H)                                   |
|                                                                             |
|o2 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o2 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 1}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

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

  * divisorClassRepresentativeM0nbar,
    -- creates an object of type DivisorClassRepresentativeM0nbar
  * writeDivisorInNonadjacentBasis, --
    write a divisor in the nonadjacent basis

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

  * DivisorClassRepresentativeM0nbar + DivisorClassRepresentativeM0nbar
    -- add
    two divisor class representatives on M0nbar
  * DivisorClassRepresentativeM0nbar - DivisorClassRepresentativeM0nbar,
    --
    subtract two divisor class representatives on M0nbar
  * "intersection(CurveClassRepresentativeM0nbar,
    DivisorClassRepresentativeM0nbar)" -- see intersection,
    -- intersection number of a curve class and divisor class
  * intersection(DivisorClassRepresentativeM0nbar, CurveClassRepresentativeM0nbar)
    -- intersection number of a divisor
    class and curve class
  * isEffectiveExpression(DivisorClassRepresentativeM0nbar)
    -- determines
    whether a divisor class expression is effective
  * isEquivalent(DivisorClassRepresentativeM0nbar, DivisorClassRepresentativeM0nbar)
    -- check whether two divisor class
    representatives are numerically equivalent
  * Number * DivisorClassRepresentativeM0nbar
    -- multiply a divisor class
    representatives on M0nbar by a scalar
  * permute(List,DivisorClassRepresentativeM0nbar)
    -- compute the image
    of a divisor class representative under a permutation of the marked points
  * tex(DivisorClassRepresentativeM0nbar)
    -- convert to TeX format
  * "writeDivisorInNonadjacentBasis(DivisorClassRepresentativeM0nbar)" -- see
    writeDivisorInNonadjacentBasis, --
    write a divisor in the nonadjacent basis

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

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

divisorClassRepresentativeM0nbar -- creates an object of type DivisorClassRepresentativeM0nbar
**********************************************************************************************

Synopsis
========

  * Usage:
        divisorClassRepresentativeM0nbar(n,H)
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * L, a list (Macaulay2Doc),
  * Outputs:
      * an instance of the type DivisorClassRepresentativeM0nbar,

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

This function creates an object of type DivisorClassRepresentativeM0nbar.
Here is a basic example:

+-----------------------------------------------------------------------------+
|i1 : L1= { {{1,3},1}, {{1,4},1} }                                            |
|                                                                             |
|o1 = {{{1, 3}, 1}, {{1, 4}, 1}}                                              |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+
|i2 : divisorClassRepresentativeM0nbar(6,L1)                                  |
|                                                                             |
|o2 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o2 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 1}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

The input can be a list or a hash table (see the documentation for
(divisorClassRepresentativeM0nbar,ZZ,HashTable)) .  The elements of the list
should be pairs {I,c}.  This will add $c \delta_{I}$ to the divisor class
expression.  Equivalently, you can type I=>c instead of {I,c}.

+-----------------------------------------------------------------------------+
|i3 : L2= { {1,3}=>1, {1,4}=>1 }                                              |
|                                                                             |
|o3 = {{1, 3} => 1, {1, 4} => 1}                                              |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : divisorClassRepresentativeM0nbar(6,L2)                                  |
|                                                                             |
|o4 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o4 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 1}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

The function divisorClassRepresentative does some minimal testing to make sure
the expression makes sense.  For instance, if you type "L=\{ {1,7\}=>1 \}" and
then run "divisorClassRepresentativeM0nbar(6,L)" you will get an error that
"The divisor expression is invalid."

The function sorts the divisor class labels.  If sorting creates like terms,
they are combined:

+-----------------------------------------------------------------------------+
|i5 : L3={ {{1,3},1}, {{1,4},1}, {{3,1},1} };                                 |
+-----------------------------------------------------------------------------+
|i6 : divisorClassRepresentativeM0nbar(6,L3)                                  |
|                                                                             |
|o6 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o6 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 2}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

If $\#I^c < \# I$ the function will replace $\delta_I$ by $\delta_{I^c}$.

+-----------------------------------------------------------------------------+
|i7 : L4= { {{1,3},1}, {{1,4},1}, {{2,4,5,6},1} };                            |
+-----------------------------------------------------------------------------+
|i8 : divisorClassRepresentativeM0nbar(6,L4)                                  |
|                                                                             |
|o8 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o8 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 2}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

If $\#I = n/2$ and 1 is not in $I$ it will replace $\delta_I$ by
$\delta_{I^c}$.

+-----------------------------------------------------------------------------+
|i9 : L5= { {{1,3},1}, {{1,4},1}, {{4,5,6},1} };                              |
+-----------------------------------------------------------------------------+
|i10 : divisorClassRepresentativeM0nbar(6,L5)                                 |
|                                                                             |
|o10 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 2, |
|                                                                      {1, 3} |
|                                                                      {1, 4} |
|                                       NumberOfMarkedPoints => 6             |
|                                                                             |
|o10 : DivisorClassRepresentativeM0nbar                                       |
|-----------------------------------------------------------------------------|
|3} => 1}}                                                                    |
|=> 1                                                                         |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

It deletes terms whose coefficient is zero.

+-----------------------------------------------------------------------------+
|i11 : L6= { {{1,3},1}, {{1,4},1}, {{4,5,6},1},{{1,2,3},-1} };                |
+-----------------------------------------------------------------------------+
|i12 : divisorClassRepresentativeM0nbar(6,L6)                                 |
|                                                                             |
|o12 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3} |
|                                                                      {1, 4} |
|                                       NumberOfMarkedPoints => 6             |
|                                                                             |
|o12 : DivisorClassRepresentativeM0nbar                                       |
|-----------------------------------------------------------------------------|
|=> 1}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

Ways to use divisorClassRepresentativeM0nbar :
==============================================

  * "divisorClassRepresentativeM0nbar(ZZ,List)"
  * divisorClassRepresentativeM0nbar(ZZ,HashTable)
    -- creates an object
    of type DivisorClassRepresentativeM0nbar

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

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

DivisorClassRepresentativeM0nbar + DivisorClassRepresentativeM0nbar -- add two divisor class representatives on M0nbar
**********************************************************************************************************************

Synopsis
========

  * Operator: + (Macaulay2Doc),
  * Usage:
        D1+D2
  * Inputs:
      * D1, an instance of the type DivisorClassRepresentativeM0nbar,
      * D2, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * D3, an instance of the type DivisorClassRepresentativeM0nbar,

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

This function adds two divisor class representatives on M0nbar.

+-----------------------------------------------------------------------------+
|i1 : L1= { {{1,3},1}, {{1,4},2}};                                            |
+-----------------------------------------------------------------------------+
|i2 : D1=divisorClassRepresentativeM0nbar(6,L1);                              |
+-----------------------------------------------------------------------------+
|i3 : L2={ {{1,2},7}, {{1,3},2}, {{2,3,5,6},1}};                              |
+-----------------------------------------------------------------------------+
|i4 : D2=divisorClassRepresentativeM0nbar(6,L2);                              |
+-----------------------------------------------------------------------------+
|i5 : D1+D2                                                                   |
|                                                                             |
|o5 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 2}  |
|                                                                     {1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o5 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 7}}                                                                       |
|=> 3                                                                         |
|=> 3                                                                         |
+-----------------------------------------------------------------------------+

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

  * DivisorClassRepresentativeM0nbar + DivisorClassRepresentativeM0nbar
    -- add
    two divisor class representatives on M0nbar

DivisorClassRepresentativeM0nbar - DivisorClassRepresentativeM0nbar -- subtract two divisor class representatives on M0nbar
***************************************************************************************************************************

Synopsis
========

  * Operator: - (Macaulay2Doc),
  * Usage:
        D1+D2
  * Inputs:
      * D1, an instance of the type DivisorClassRepresentativeM0nbar,
      * D2, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * D3, an instance of the type DivisorClassRepresentativeM0nbar,

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

This function subtracts two divisor class representatives on M0nbar.

+-----------------------------------------------------------------------------+
|i1 : L1= { {{1,3},1}, {{1,4},2}};                                            |
+-----------------------------------------------------------------------------+
|i2 : D1=divisorClassRepresentativeM0nbar(6,L1);                              |
+-----------------------------------------------------------------------------+
|i3 : L2= { {{1,2},7}, {{1,3},2}, {{2,3,5,6},1}};                             |
+-----------------------------------------------------------------------------+
|i4 : D2=divisorClassRepresentativeM0nbar(6,L2);                              |
+-----------------------------------------------------------------------------+
|i5 : D1-D2                                                                   |
|                                                                             |
|o5 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 2}  |
|                                                                     {1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o5 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> -7}}                                                                      |
|=> -1                                                                        |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

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

  * DivisorClassRepresentativeM0nbar - DivisorClassRepresentativeM0nbar,
    --
    subtract two divisor class representatives on M0nbar

divisorClassRepresentativeM0nbar(ZZ,HashTable) -- creates an object of type DivisorClassRepresentativeM0nbar
************************************************************************************************************

Synopsis
========

  * Function: divisorClassRepresentativeM0nbar,
  * Usage:
        divisorClassRepresentativeM0nbar(n,H)
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * H, a hash table (Macaulay2Doc),
  * Outputs:
      * an instance of the type DivisorClassRepresentativeM0nbar,

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

This function creates an object of type DivisorClassRepresentativeM0nbar from a
hash table.  Here is a basic example:

+-----------------------------------------------------------------------------+
|i1 : H1=new HashTable from { {{1,3},1}, {{1,4},1} };                         |
+-----------------------------------------------------------------------------+
|i2 : divisorClassRepresentativeM0nbar(6,H1)                                  |
|                                                                             |
|o2 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o2 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 1}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

Warning: when you enter a hash table in Macaulay2, if you use a key more than
once, the first instance is discarded.  Here is an example where the behavior
may differ from what you want:

+------------------------------------------------------------+
|i3 : H=new HashTable from { {{1,3},1}, {{1,4},1}, {{1,3},2}}|
|                                                            |
|o3 = HashTable{{1, 3} => 2}                                 |
|               {1, 4} => 1                                  |
|                                                            |
|o3 : HashTable                                              |
+------------------------------------------------------------+

The user probably wanted $\delta_{\{1,3\}} + 2\delta_{\{1,3\}}$ to give
$3\delta_{\{1,3\}}$ instead.  The moral of the story: if your expression has
two terms that are written exactly alike, you could either combine them before
you create the input hash table, or input a list instead:

+-----------------------------------------------------------------------------+
|i4 : L= { {{1,3},1}, {{1,4},1}, {{1,3},2}}                                   |
|                                                                             |
|o4 = {{{1, 3}, 1}, {{1, 4}, 1}, {{1, 3}, 2}}                                 |
|                                                                             |
|o4 : List                                                                    |
+-----------------------------------------------------------------------------+
|i5 : divisorClassRepresentativeM0nbar(6,L)                                   |
|                                                                             |
|o5 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o5 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 3}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

For this reason, most users will probably prefer to enter divisors via lists,
rather than hash tables.

The function divisorClassRepresentative does the same minimal testing if you
enter a hash table that it does if you enter a list.  See the documentation for
divisorClassRepresentativeM0nbar(ZZ,List).

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

  * divisorClassRepresentativeM0nbar(ZZ,HashTable)
    -- creates an object
    of type DivisorClassRepresentativeM0nbar

F curves -- effective curves in the moduli space of stable n-pointed genus zero curves
**************************************************************************************

Let $P={P_0,P_1,P_2,P_3}$ be a partition of $\{1,...,n\}$ into four nonempty
subsets.  Fix four (arithmetic) genus zero at worst nodal curves $C_j$ for
$j=0,1,2,3$, and $\#(P_j)$ marked points on each curve.  We call the curves
$C_j$ the tails.  Mark one additional point $x_j$ on each tail. Next, consider
$\mathbb{P}^1$ with four marked points, $y_0,...,y_3$; we call this the spine.
Glue the four tails to the spine by identifying $x_j$ and $y_j$.  Then, as the
cross ratio of $y_0,...,y_3$ varies, we sweep out a curve $F_{P}$ in
$\bar{M}_{0,n}$.

The homology class of $F_{P}$ only depends on the partition $P$, and not on the
choice of the tails $C_j$ or the choices of marked points.  The classes of the
F-curves span $H_2(\bar{M}_{0,n},Q)$.

Fcurves -- lists the F-curves for a given n
*******************************************

Synopsis
========

  * Usage:
        Fcurves n
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc),

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

Given an integer $n$, this function returns a list of the F-curves on
$\bar{M}_{0,n}$.

+-----------------------------------------------------------------------------+
|i1 : Fcurves(6)                                                              |
|                                                                             |
|o1 = {CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 3},|
|                                     NumberOfMarkedPoints => 6               |
|     ------------------------------------------------------------------------|
|     {4}, {5}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                  |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 2, 4}, {3}, {5}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 5}, |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3}, {4}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                  |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 2, 6}, {3}, {4}, {5}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3, 4}, |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {5}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                  |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 3, 5}, {2}, {4}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3, 6}, |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {4}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                  |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 4, 5}, {2}, {3}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4, 6}, |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                  |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 5, 6}, {2}, {3}, {4}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 3,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {5}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1}, {2, 3, 5}, {4}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 3,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {4}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1}, {2, 4, 5}, {3}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 4,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1}, {2, 5, 6}, {3}, {4}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 4, 5}, {6}} => 1}},                                                 |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 4, 6}, {5}} => 1}},                                                 |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 5, 6}, {4}} => 1}},                                                 |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3}, {4, 5, 6}} => 1}},                                                 |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2}, {3,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {5}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 2}, {3, 5}, {4}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2}, {3,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {4}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 2}, {3}, {4, 5}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3}, {4, 6}, {5}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3}, {4}, {5, 6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {5}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 3}, {2, 5}, {4}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {4}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 3}, {2}, {4, 5}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {4, 6}, {5}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {4}, {5, 6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {5}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 4}, {2, 5}, {3}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 4}, {2}, {3, 5}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3, 6}, {5}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3}, {5, 6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 5}, {2, 4}, {3}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {4}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 5}, {2}, {3, 4}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3, 6}, {4}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3}, {4, 6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 6}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 6}, {2, 4}, {3}, {5}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 6}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {3}, {4}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 6}, {2}, {3, 4}, {5}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 6},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3, 5}, {4}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 6},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3}, {4, 5}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4, 5}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4, 6}, {5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4}, {5, 6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {3, 5}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {3, 6}, {5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {3}, {5, 6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {3, 4}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {3, 6}, {4}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {3}, {4, 6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3, 4}, {5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3, 5}, {4}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {4, 5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 4}, {5, 6}} => 1}},                                                 |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 5}, {4, 6}} => 1}},                                                 |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 6}, {4, 5}} => 1}}}                                                 |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use Fcurves :
=====================

  * "Fcurves(ZZ)"

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

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

FcurvesOfGivenShape -- a list of the F-curves with the given shape
******************************************************************

Synopsis
========

  * Usage:
        FcurvesOfGivenShape(a,b,c,d)
  * Inputs:
      * a, an integer (Macaulay2Doc),
      * b, an integer (Macaulay2Doc),
      * c, an integer (Macaulay2Doc),
      * d, an integer (Macaulay2Doc),
  * Outputs:
      * L, a list (Macaulay2Doc),

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

Given four positive integers $a$, $b$, $c$, $d$ with $a+b+c+d=n$, this function
lists the F-curves $F_{I_1,I_2,I_3,I_4}$ with $\#I_1=a$,  $\#I_2=b$,
$\#I_3=c$,  $\#I_4=d$.

+-----------------------------------------------------------------------------+
|i1 : FcurvesOfGivenShape(2,2,1,1)                                            |
|                                                                             |
|o1 = {CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},   |
|                                     NumberOfMarkedPoints => 6               |
|     ------------------------------------------------------------------------|
|     {3, 4}, {5}, {6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2}, {3,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {4}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 2}, {3, 6}, {4}, {5}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3}, {4, 5}, {6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3}, {4, 6}, {5}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3}, {4}, {5, 6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {5}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 3}, {2, 5}, {4}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {4}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 3}, {2}, {4, 5}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {4, 6}, {5}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {4}, {5, 6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {5}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 4}, {2, 5}, {3}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 4}, {2}, {3, 5}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3, 6}, {5}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3}, {5, 6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4}, {6}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 5}, {2, 4}, {3}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {4}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 5}, {2}, {3, 4}, {6}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3, 6}, {4}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3}, {4, 6}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 6}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4}, {5}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 6}, {2, 4}, {3}, {5}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 6}, {2,|
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {3}, {4}} => 1}}, CurveClassRepresentativeM0nbar{                   |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveExpression => HashTable{{{1, 6}, {2}, {3, 4}, {5}} => 1}},         |
|     NumberOfMarkedPoints => 6                                               |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 6},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3, 5}, {4}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 6},    |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {2}, {3}, {4, 5}} => 1}},                                               |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4, 5}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4, 6}, {5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     3}, {4}, {5, 6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {3, 5}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {3, 6}, {5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     4}, {3}, {5, 6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {3, 4}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {3, 6}, {4}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     5}, {3}, {4, 6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3, 4}, {5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3, 5}, {4}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {4, 5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 4}, {5, 6}} => 1}},                                                 |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 5}, {4, 6}} => 1}},                                                 |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 6                |
|     ------------------------------------------------------------------------|
|     {3, 6}, {4, 5}} => 1}}}                                                 |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use FcurvesOfGivenShape :
=================================

  * "FcurvesOfGivenShape(ZZ,ZZ,ZZ,ZZ)"

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

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

intersection -- intersection number of a curve class and divisor class
**********************************************************************

Synopsis
========

  * Usage:
        intersection(C,D)
  * Inputs:
      * C, an instance of the type CurveClassRepresentativeM0nbar,
      * D, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * a rational number (Macaulay2Doc),

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

The basic formula for intersecting a boundary divisor with an F-curve is found
in Keel and McKernan's paper.

+-----------------------------------------------------------------------------+
|i1 : L1={ {{{2,1},{3},{4},{5}},-2}, {{{1,3},{2},{4},{5}},-7},                |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1}};                                                    |
+-----------------------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(5,L1);                                 |
+-----------------------------------------------------------------------------+
|i3 : L2={ {{1,3},1}, {{1,4},1}};                                             |
+-----------------------------------------------------------------------------+
|i4 : D=divisorClassRepresentativeM0nbar(5,L2);                               |
+-----------------------------------------------------------------------------+
|i5 : intersection(C,D)                                                       |
|                                                                             |
|o5 = 6                                                                       |
+-----------------------------------------------------------------------------+

Ways to use intersection :
==========================

  * "intersection(CurveClassRepresentativeM0nbar,
    DivisorClassRepresentativeM0nbar)"
  * intersection(DivisorClassRepresentativeM0nbar, CurveClassRepresentativeM0nbar)
    -- intersection number of a divisor
    class and curve class
  * intersection(RRi,RRi) (Macaulay2Doc), --
    computes intersection of input intervals

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

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

intersection(DivisorClassRepresentativeM0nbar,CurveClassRepresentativeM0nbar) -- intersection number of a divisor class and curve class
***************************************************************************************************************************************

Synopsis
========

  * Function: intersection (Macaulay2Doc),
  * Usage:
        intersection(D,C)
  * Inputs:
      * D, an instance of the type DivisorClassRepresentativeM0nbar,
      * C, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * a rational number (Macaulay2Doc),

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

The basic formula for intersecting a boundary divisor with an F-curve is found
in Keel and McKernan's paper.

+-----------------------------------------------------------------------------+
|i1 : L1={ {{{2,1},{3},{4},{5}},-2}, {{{1,3},{2},{4},{5}},-7},                |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1}};                                                    |
+-----------------------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(5,L1);                                 |
+-----------------------------------------------------------------------------+
|i3 : L2={ {{1,3},1}, {{1,4},1}};                                             |
+-----------------------------------------------------------------------------+
|i4 : D=divisorClassRepresentativeM0nbar(5,L2);                               |
+-----------------------------------------------------------------------------+
|i5 : intersection(D,C)                                                       |
|                                                                             |
|o5 = 6                                                                       |
+-----------------------------------------------------------------------------+

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

  * intersection(DivisorClassRepresentativeM0nbar, CurveClassRepresentativeM0nbar)
    -- intersection number of a divisor
    class and curve class

isEffectiveExpression -- determines whether a curve class expression is effective
*********************************************************************************

Synopsis
========

  * Usage:
        isEffectiveExpression(C)
  * Inputs:
      * C, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

This function tests whether the coefficients in an object of type
CurveClassRepresentativeM0nbar are all nonnegative.

Warning: this function tests only the input representative of a curve class.
That is, it answers whether the input is an effective expression, not whether
there exists an effective expression equivalent to the input.

+-----------------------------------------------------------------------------+
|i1 : L1= { {{{2,1},{3},{4},{5}},-2}, {{{1,3},{2},{4},{5}},-7},               |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1}};                                                    |
+-----------------------------------------------------------------------------+
|i2 : C1=curveClassRepresentativeM0nbar(5,L1);                                |
+-----------------------------------------------------------------------------+
|i3 : isEffectiveExpression(C1)                                               |
|                                                                             |
|o3 = false                                                                   |
+-----------------------------------------------------------------------------+
|i4 : L2={ {{{2,1},{3},{4},{5}},2}, {{{1,3},{2},{4},{5}},7},                  |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1}};                                                    |
+-----------------------------------------------------------------------------+
|i5 : C2=curveClassRepresentativeM0nbar(5,L2);                                |
+-----------------------------------------------------------------------------+
|i6 : isEffectiveExpression(C2)                                               |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use isEffectiveExpression :
===================================

  * "isEffectiveExpression(CurveClassRepresentativeM0nbar)"
  * isEffectiveExpression(DivisorClassRepresentativeM0nbar)
    -- determines
    whether a divisor class expression is effective

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

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

isEffectiveExpression(DivisorClassRepresentativeM0nbar) -- determines whether a divisor class expression is effective
*********************************************************************************************************************

Synopsis
========

  * Function: isEffectiveExpression,
  * Usage:
        isEffectiveExpression(D)
  * Inputs:
      * D, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * a Boolean value (Macaulay2Doc),

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

This function tests whether the coefficients in an object of type
DivisorClassRepresentativeM0nbar are all nonnegative.

Warning: this function tests only the input representative of a divisor class.
That is, it answers whether the input is an effective expression, not whether
there exists an effective expression equivalent to the input.

+-----------------------------------------------------------------------------+
|i1 : L1= { {{3,1},-1}, {{1,4},1} };                                          |
+-----------------------------------------------------------------------------+
|i2 : D1=divisorClassRepresentativeM0nbar(6,L1)                               |
|                                                                             |
|o2 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o2 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> -1}}                                                                      |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+
|i3 : isEffectiveExpression(D1)                                               |
|                                                                             |
|o3 = false                                                                   |
+-----------------------------------------------------------------------------+
|i4 : L2= { {{3,1},1}, {{1,4},1} };                                           |
+-----------------------------------------------------------------------------+
|i5 : D2=divisorClassRepresentativeM0nbar(6,L2)                               |
|                                                                             |
|o5 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o5 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 1}}                                                                       |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+
|i6 : isEffectiveExpression(D2)                                               |
|                                                                             |
|o6 = true                                                                    |
+-----------------------------------------------------------------------------+

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

  * isEffectiveExpression(DivisorClassRepresentativeM0nbar)
    -- determines
    whether a divisor class expression is effective

isEquivalent -- check whether two curve class representatives are numerically equivalent
****************************************************************************************

Synopsis
========

  * Usage:
        isEquivalent(C1,C2)
  * Inputs:
      * C1, an instance of the type CurveClassRepresentativeM0nbar,
      * C2, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

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

This function checks whether two curve class representatives C1 and C2 are
equivalent.

To do so, it checks whether the vector of intersection numbers with the
nonadjacent basis of divisors is the same for C1 and C2.

+-----------------------------------------------------------------------------+
|i1 : L1={ {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1}};                 |
+-----------------------------------------------------------------------------+
|i2 : C1=curveClassRepresentativeM0nbar(5,L1);                                |
+-----------------------------------------------------------------------------+
|i3 : L2={ {{{1},{2},{3},{4,5}},-1}, {{{1},{2,5},{3},{4}},1},                 |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1},{{{1,3},{2},{4},{5}},1}};                            |
+-----------------------------------------------------------------------------+
|i4 : C2=curveClassRepresentativeM0nbar(5,L2);                                |
+-----------------------------------------------------------------------------+
|i5 : isEquivalent(C1,C2)                                                     |
|                                                                             |
|o5 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use isEquivalent :
==========================

  * "isEquivalent(CurveClassRepresentativeM0nbar,CurveClassRepresentativeM0nbar
    )"
  * isEquivalent(DivisorClassRepresentativeM0nbar, DivisorClassRepresentativeM0nbar)
    -- check whether two divisor class
    representatives are numerically equivalent

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

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

isEquivalent(DivisorClassRepresentativeM0nbar,DivisorClassRepresentativeM0nbar) -- check whether two divisor class representatives are numerically equivalent
*************************************************************************************************************************************************************

Synopsis
========

  * Function: isEquivalent,
  * Usage:
        isEquivalent(D1,D2)
  * Inputs:
      * D1, an instance of the type DivisorClassRepresentativeM0nbar,
      * D2, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * b, a Boolean value (Macaulay2Doc),

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

This function checks whether two divisor class representatives D1 and D2 are
equivalent.

To do so, it checks whether their expressions in the nonadjacent basis of
divisors are the same.

+-----------------------------------------------+
|i1 : L1= { {{1,2},1}};                         |
+-----------------------------------------------+
|i2 : D1=divisorClassRepresentativeM0nbar(5,L1);|
+-----------------------------------------------+
|i3 : L2={ {{1,3},1}, {{2,4},1}, {{3,4},-1} };  |
+-----------------------------------------------+
|i4 : D2=divisorClassRepresentativeM0nbar(5,L2);|
+-----------------------------------------------+
|i5 : isEquivalent(D1,D2)                       |
|                                               |
|o5 = true                                      |
+-----------------------------------------------+

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

  * isEquivalent(DivisorClassRepresentativeM0nbar, DivisorClassRepresentativeM0nbar)
    -- check whether two divisor class
    representatives are numerically equivalent

KeelRelationAmongCurves -- write the Keel relation among F curves based on the input lists
******************************************************************************************

Synopsis
========

  * Usage:
        KeelRelationAmongCurves(P)
  * Inputs:
      * P, a list (Macaulay2Doc),
  * Outputs:
      * C, an instance of the type CurveClassRepresentativeM0nbar,

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

This function writes a Keel relation among curves.  It is an expression
supported on four F-curves that is equivalent to zero.

Specifically, let $P = I_1 \cup \cdots \cup I_5$ be a partition of
$\{1,...,n\}$ into five nonempty subsets.  Then this function returns the curve
class representative $ F_{I_1,I_2,I_3,I_4 \cup I_5} + F_{I_1 \cup I_2,
I_3,I_4,I_5} - F_{I_1, I_4, I_3, I_2 \cup I_5} - F_{I_1 \cup I_4, I_3, I_2,
I_5}$.

+-----------------------------------------------------------------------------+
|i1 : C1=KeelRelationAmongCurves({{1},{2},{3},{4},{5}})                       |
|                                                                             |
|o1 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2}, {3 |
|                                                                 {{1, 4}, {2 |
|                                                                 {{1}, {2, 5 |
|                                                                 {{1}, {2},  |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o1 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|}, {4}, {5}} => 1 }}                                                         |
|}, {3}, {5}} => -1                                                           |
|}, {3}, {4}} => -1                                                           |
|{3}, {4, 5}} => 1                                                            |
+-----------------------------------------------------------------------------+
|i2 : L={  };                                                                 |
+-----------------------------------------------------------------------------+
|i3 : C2=curveClassRepresentativeM0nbar(5,L);                                 |
+-----------------------------------------------------------------------------+
|i4 : isEquivalent(C1,C2)                                                     |
|                                                                             |
|o4 = true                                                                    |
+-----------------------------------------------------------------------------+

Ways to use KeelRelationAmongCurves :
=====================================

  * "KeelRelationAmongCurves(List)"

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

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

negativeSum -- sum of the negative coefficients in CurveClassRepresentativeM0nbar
*********************************************************************************

Synopsis
========

  * Usage:
        negativeSum C
  * Inputs:
      * C, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * an integer (Macaulay2Doc),

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

This function sums the negative coefficients in an object of type
CurveClassRepresentativeM0nbar.  This is a measure of how far the expression is
from being an effective sum of F curves.

+-----------------------------------------------------------------------------+
|i1 : L= { {{{2,1},{3},{4},{5}},-2}, {{{1,3},{2},{4},{5}},-7},                |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1}};                                                    |
+-----------------------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(5,L);                                  |
+-----------------------------------------------------------------------------+
|i3 : negativeSum C                                                           |
|                                                                             |
|o3 = -9                                                                      |
+-----------------------------------------------------------------------------+

Ways to use negativeSum :
=========================

  * "negativeSum(CurveClassRepresentativeM0nbar)"

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

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

nonadjacentBasis -- computes the nonadjacent basis of divisors on M0nbar
************************************************************************

Synopsis
========

  * Usage:
        nonadjacentBasis n
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc),

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

The nonadjacent basis is described in Carr, A polygonal presentation of
$Pic(\bar{M}_{0,n})$, arXiv:0911.2649.

+-----------------------------------------------------------------------------+
|i1 : B5=nonadjacentBasis(5)                                                  |
|                                                                             |
|o1 = {DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3} |
|                                       NumberOfMarkedPoints => 5             |
|     ------------------------------------------------------------------------|
|     => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>           |
|                                              NumberOfMarkedPoints           |
|     ------------------------------------------------------------------------|
|     HashTable{{1, 4} => 1}},                                                |
|     => 5                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{2, 4}  |
|                                      NumberOfMarkedPoints => 5              |
|     ------------------------------------------------------------------------|
|     => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>           |
|                                              NumberOfMarkedPoints           |
|     ------------------------------------------------------------------------|
|     HashTable{{2, 5} => 1}},                                                |
|     => 5                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{3, 5}  |
|                                      NumberOfMarkedPoints => 5              |
|     ------------------------------------------------------------------------|
|     => 1}}}                                                                 |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+
|i2 : print toString B5                                                       |
|{new DivisorClassRepresentativeM0nbar from {DivisorExpression => new         |
|-----------------------------------------------------------------------------|
|HashTable from {{1, 3} => 1}, NumberOfMarkedPoints => 5}, new                |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 4} => 1}, NumberOfMarkedPoints => 5}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{2, 4} => 1}, NumberOfMarkedPoints => 5}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{2, 5} => 1}, NumberOfMarkedPoints => 5}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{3, 5} => 1}, NumberOfMarkedPoints => 5}}                              |
+-----------------------------------------------------------------------------+
|i3 : B6=nonadjacentBasis(6)                                                  |
|                                                                             |
|o3 = {DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3} |
|                                       NumberOfMarkedPoints => 6             |
|     ------------------------------------------------------------------------|
|     => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>           |
|                                              NumberOfMarkedPoints           |
|     ------------------------------------------------------------------------|
|     HashTable{{1, 4} => 1}},                                                |
|     => 6                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 5}  |
|                                      NumberOfMarkedPoints => 6              |
|     ------------------------------------------------------------------------|
|     => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>           |
|                                              NumberOfMarkedPoints           |
|     ------------------------------------------------------------------------|
|     HashTable{{2, 4} => 1}},                                                |
|     => 6                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{2, 5}  |
|                                      NumberOfMarkedPoints => 6              |
|     ------------------------------------------------------------------------|
|     => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>           |
|                                              NumberOfMarkedPoints           |
|     ------------------------------------------------------------------------|
|     HashTable{{2, 6} => 1}},                                                |
|     => 6                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{3, 5}  |
|                                      NumberOfMarkedPoints => 6              |
|     ------------------------------------------------------------------------|
|     => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>           |
|                                              NumberOfMarkedPoints           |
|     ------------------------------------------------------------------------|
|     HashTable{{3, 6} => 1}},                                                |
|     => 6                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{4, 6}  |
|                                      NumberOfMarkedPoints => 6              |
|     ------------------------------------------------------------------------|
|     => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>           |
|                                              NumberOfMarkedPoints           |
|     ------------------------------------------------------------------------|
|     HashTable{{1, 2, 4} => 1}},                                             |
|     => 6                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 2,  |
|                                      NumberOfMarkedPoints => 6              |
|     ------------------------------------------------------------------------|
|     5} => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>        |
|                                                 NumberOfMarkedPoints        |
|     ------------------------------------------------------------------------|
|     HashTable{{1, 3, 4} => 1}},                                             |
|     => 6                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3,  |
|                                      NumberOfMarkedPoints => 6              |
|     ------------------------------------------------------------------------|
|     5} => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>        |
|                                                 NumberOfMarkedPoints        |
|     ------------------------------------------------------------------------|
|     HashTable{{1, 3, 6} => 1}},                                             |
|     => 6                                                                    |
|     ------------------------------------------------------------------------|
|     DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 4,  |
|                                      NumberOfMarkedPoints => 6              |
|     ------------------------------------------------------------------------|
|     5} => 1}}, DivisorClassRepresentativeM0nbar{DivisorExpression =>        |
|                                                 NumberOfMarkedPoints        |
|     ------------------------------------------------------------------------|
|     HashTable{{1, 4, 6} => 1}}}                                             |
|     => 6                                                                    |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+
|i4 : print toString B6                                                       |
|{new DivisorClassRepresentativeM0nbar from {DivisorExpression => new         |
|-----------------------------------------------------------------------------|
|HashTable from {{1, 3} => 1}, NumberOfMarkedPoints => 6}, new                |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 4} => 1}, NumberOfMarkedPoints => 6}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 5} => 1}, NumberOfMarkedPoints => 6}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{2, 4} => 1}, NumberOfMarkedPoints => 6}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{2, 5} => 1}, NumberOfMarkedPoints => 6}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{2, 6} => 1}, NumberOfMarkedPoints => 6}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{3, 5} => 1}, NumberOfMarkedPoints => 6}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{3, 6} => 1}, NumberOfMarkedPoints => 6}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{4, 6} => 1}, NumberOfMarkedPoints => 6}, new                          |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 2, 4} => 1}, NumberOfMarkedPoints => 6}, new                       |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 2, 5} => 1}, NumberOfMarkedPoints => 6}, new                       |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 3, 4} => 1}, NumberOfMarkedPoints => 6}, new                       |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 3, 5} => 1}, NumberOfMarkedPoints => 6}, new                       |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 3, 6} => 1}, NumberOfMarkedPoints => 6}, new                       |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 4, 5} => 1}, NumberOfMarkedPoints => 6}, new                       |
|-----------------------------------------------------------------------------|
|DivisorClassRepresentativeM0nbar from {DivisorExpression => new HashTable    |
|-----------------------------------------------------------------------------|
|from {{1, 4, 6} => 1}, NumberOfMarkedPoints => 6}}                           |
+-----------------------------------------------------------------------------+

Ways to use nonadjacentBasis :
==============================

  * "nonadjacentBasis(ZZ)"

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

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

Number * CurveClassRepresentativeM0nbar -- multiply a curve class representatives on M0nbar by a scalar
*******************************************************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        c*C1
  * Inputs:
      * c, a number (Macaulay2Doc),
      * C1, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * C2, an instance of the type CurveClassRepresentativeM0nbar,

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

This function multiplies a curve class representatives on M0nbar by a scalar

+-----------------------------------------------------------------------------+
|i1 : L1= { {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1} };               |
+-----------------------------------------------------------------------------+
|i2 : C1=curveClassRepresentativeM0nbar(5,L1);                                |
+-----------------------------------------------------------------------------+
|i3 : 3*C1                                                                    |
|                                                                             |
|o3 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                                                 {{1, 3},    |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o3 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|{3}, {4}, {5}} => 3}}                                                        |
|{2}, {4}, {5}} => 3                                                          |
+-----------------------------------------------------------------------------+

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

  * Number * CurveClassRepresentativeM0nbar
    -- multiply a curve class representatives
    on M0nbar by a scalar

Number * DivisorClassRepresentativeM0nbar -- multiply a divisor class representatives on M0nbar by a scalar
***********************************************************************************************************

Synopsis
========

  * Operator: * (Macaulay2Doc),
  * Usage:
        c*D
  * Inputs:
      * c, a number (Macaulay2Doc),
      * D, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * E, an instance of the type DivisorClassRepresentativeM0nbar,

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

This function multiplies a divisor class representatives on M0nbar by a scalar

+-----------------------------------------------------------------------------+
|i1 : L1= { {{1,3},1}, {{1,4},2}};                                            |
+-----------------------------------------------------------------------------+
|i2 : D1=divisorClassRepresentativeM0nbar(6,L1);                              |
+-----------------------------------------------------------------------------+
|i3 : 3*D1                                                                    |
|                                                                             |
|o3 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {1, 4}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o3 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 3}}                                                                       |
|=> 6                                                                         |
+-----------------------------------------------------------------------------+

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

  * Number * DivisorClassRepresentativeM0nbar
    -- multiply a divisor class
    representatives on M0nbar by a scalar

permute -- compute the image of a curve class representative under a permutation of the marked points
*****************************************************************************************************

Synopsis
========

  * Usage:
        permute(sigma,C)
  * Inputs:
      * sigma, a list (Macaulay2Doc),
      * C, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * C2, an instance of the type CurveClassRepresentativeM0nbar,

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

The symmetric group $S_n$ acts on $\bar{M}_{0,n}$ by permuting the marked
points.

This function computes the image of a curve class representative $C$ under a
permutation $\sigma$ of the marked points.

Enter $\sigma$ as a list $\{ \sigma(1),\sigma(2),\ldots,\sigma(n)\}$.  Cycle
class notation is not supported for this function.

+-----------------------------------------------------------------------------+
|i1 : L= { {{{2,1},{3},{4},{5}},-2}, {{{1,3},{2},{4},{5}},-7},                |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1}};                                                    |
+-----------------------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(5,L);                                  |
+-----------------------------------------------------------------------------+
|i3 : permute({5,2,1,3,4}, C)                                                 |
|                                                                             |
|o3 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5}, {2 |
|                                                                 {{1}, {2, 5 |
|                                                                 {{1}, {2},  |
|                                    NumberOfMarkedPoints => 5                |
|                                                                             |
|o3 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|}, {3}, {4}} => -7}}                                                         |
|}, {3}, {4}} => -2                                                           |
|{3, 5}, {4}} => 1                                                            |
+-----------------------------------------------------------------------------+

Ways to use permute :
=====================

  * "permute(List,CurveClassRepresentativeM0nbar)"
  * permute(List,DivisorClassRepresentativeM0nbar)
    -- compute the image
    of a divisor class representative under a permutation of the marked points

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

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

permute(List,DivisorClassRepresentativeM0nbar) -- compute the image of a divisor class representative under a permutation of the marked points
**********************************************************************************************************************************************

Synopsis
========

  * Function: permute,
  * Usage:
        permute(sigma,D)
  * Inputs:
      * sigma, a list (Macaulay2Doc),
      * D, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * D2, an instance of the type DivisorClassRepresentativeM0nbar,

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

The symmetric group $S_n$ acts on $\bar{M}_{0,n}$ by permuting the marked
points.

This function computes the image of a divisor class representative $C$ under a
permutation $\sigma$ of the marked points.

Enter $\sigma$ as a list $\{ \sigma(1),\sigma(2),\ldots,\sigma(n)\}$.  Cycle
class notation is not supported for this function.

+-----------------------------------------------------------------------------+
|i1 : L= { {{1,3},1}, {{1,4},-3}};                                            |
+-----------------------------------------------------------------------------+
|i2 : D=divisorClassRepresentativeM0nbar(5,L);                                |
+-----------------------------------------------------------------------------+
|i3 : permute({5,2,1,3,4}, D)                                                 |
|                                                                             |
|o3 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 5}  |
|                                                                     {3, 5}  |
|                                      NumberOfMarkedPoints => 5              |
|                                                                             |
|o3 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 1 }}                                                                      |
|=> -3                                                                        |
+-----------------------------------------------------------------------------+

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

  * permute(List,DivisorClassRepresentativeM0nbar)
    -- compute the image
    of a divisor class representative under a permutation of the marked points

seekEffectiveExpression -- seeks to write a curve class as an effective sum of F-curves
***************************************************************************************

Synopsis
========

  * Usage:
        seekEffectiveExpression(C)
  * Inputs:
      * C, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * H, a hash table (Macaulay2Doc),

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

This function seeks to write a curve class representative as an effective sum
of F-curves.  See Moon and Swinarski, "Subvarieties of $\bar{M}_{0,n}$ from
group actions" for a description of the strategy used.

Important note: the strategy used by this function is not an algorithm because
it is not guaranteed to terminate.

+-----------------------------------------------------------------------------+
|i1 : L1= {{{1, 2}, {3}, {4}, {5}} => 2, {{1}, {2, 5}, {3}, {4}} => -1, {{1,  |
|-----------------------------------------------------------------------------|
|4}, {2}, {3}, {5}} => -1, {{1}, {2}, {3}, {4, 5}} => 1};                     |
+-----------------------------------------------------------------------------+
|i2 : C1=curveClassRepresentativeM0nbar(5,L1);                                |
+-----------------------------------------------------------------------------+
|i3 : seekEffectiveExpression(C1)                                             |
|New sum of negative coefficients: 0                                          |
|New curve expression: new CurveClassRepresentativeM0nbar from {CurveExpressio|
|Keel relations added:                                                        |
|    F_{{1}, {2, 5}, {3}, {4}} - F_{{1, 2}, {3}, {4}, {5}} - F_{{1}, {2}, {3},|
|                                                                             |
|o3 = HashTable{CurveClassRepresentative => CurveClassRepresentativeM0nbar{Cur|
|                                                                          Num|
|               TotalPath => {{CurveClassRepresentativeM0nbar{CurveExpression |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                             NumberOfMarkedPo|
|                                                                             |
|o3 : HashTable                                                               |
|-----------------------------------------------------------------------------|
|n => new HashTable from {{{1, 2}, {3}, {4}, {5}} => 1}, NumberOfMarkedPoints |
|                                                                             |
| {4, 5}} + F_{{1, 4}, {2}, {3}, {5}}                                         |
|                                                                             |
|veExpression => HashTable{{{1, 2}, {3}, {4}, {5}} => 1}}}                    |
|berOfMarkedPoints => 5                                                       |
|=> HashTable{{{1, 2}, {3}, {4}, {5}} => -1}}}}                               |
|             {{1, 4}, {2}, {3}, {5}} => 1                                    |
|             {{1}, {2, 5}, {3}, {4}} => 1                                    |
|             {{1}, {2}, {3}, {4, 5}} => -1                                   |
|ints => 5                                                                    |
|-----------------------------------------------------------------------------|
|=> 5}                                                                        |
+-----------------------------------------------------------------------------+

Ways to use seekEffectiveExpression :
=====================================

  * "seekEffectiveExpression(CurveClassRepresentativeM0nbar)"

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

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

singletonSpineBasis -- computes the singleton spine basis of curves on M0nbar
*****************************************************************************

Synopsis
========

  * Usage:
        singletonSpineBasis(n)
  * Inputs:
      * n, an integer (Macaulay2Doc),
  * Outputs:
      * a list (Macaulay2Doc),

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

The singleton spine basis of F-curves is described in notes by Swinarski, A
basis of F-curves on $\bar{M}_{0,n}$, available at
http://faculty.fordham.edu/dswinarski/Fcurves/.

It is defined for n>=7.

+-----------------------------------------------------------------------------+
|i1 : B7=singletonSpineBasis(7)                                               |
|                                                                             |
|o1 = {CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2}, |
|                                     NumberOfMarkedPoints => 7               |
|     ------------------------------------------------------------------------|
|     {3}, {4, 5, 6, 7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     {3, 4, 5, 6}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     {3, 4, 5, 7}, {6}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     {3, 4, 6, 7}, {5}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2},  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     {3, 5, 6, 7}, {4}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2,   |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     3}, {4, 5}, {6, 7}} => 1}},                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 3,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     4, 5}, {6}, {7}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 3,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     4, 6}, {5}, {7}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 3,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     4, 7}, {5}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 3,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     5, 6}, {4}, {7}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 3,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     5, 7}, {4}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 3,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6, 7}, {4}, {5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 4,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     5, 6}, {3}, {7}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 4,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     5, 7}, {3}, {6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 4,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6, 7}, {3}, {5}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1}, {2, 5,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6, 7}, {3}, {4}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2},    |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     {3}, {4, 5}, {6, 7}} => 1}},                                            |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2}, {3,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     4}, {5}, {6, 7}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2}, {3,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     4}, {5, 6}, {7}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 3,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     4}, {5}, {6}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 3,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     5}, {4}, {6}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 3,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6}, {4}, {5}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 3,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {4}, {5}, {6}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 4,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     5}, {3}, {6}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 4,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {5}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 4,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {3}, {5}, {6}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 5,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6}, {3}, {4}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 5,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {3}, {4}, {6}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2, 6,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {3}, {4}, {5}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3, 4,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     5}, {2}, {6}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3, 4,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6}, {2}, {5}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3, 4,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {2}, {5}, {6}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3, 5,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6}, {2}, {4}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3, 5,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {2}, {4}, {6}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 3, 6,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {2}, {4}, {5}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4, 5,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     6}, {2}, {3}, {7}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4, 5,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {2}, {3}, {6}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 4, 6,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {2}, {3}, {5}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 5, 6,  |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     7}, {2}, {3}, {4}} => 1}},                                              |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 7},    |
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     {2}, {3, 4}, {5, 6}} => 1}},                                            |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 7}, {2,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     3}, {4}, {5, 6}} => 1}},                                                |
|                                                                             |
|     ------------------------------------------------------------------------|
|     CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 7}, {2,|
|                                    NumberOfMarkedPoints => 7                |
|     ------------------------------------------------------------------------|
|     3}, {4, 5}, {6}} => 1}}}                                                |
|                                                                             |
|o1 : List                                                                    |
+-----------------------------------------------------------------------------+

Ways to use singletonSpineBasis :
=================================

  * "singletonSpineBasis(ZZ)"

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

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

tex(CurveClassRepresentativeM0nbar) -- convert to TeX format
************************************************************

Synopsis
========

  * Function: tex (Macaulay2Doc),
  * Usage:
        tex C
  * Inputs:
      * C, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * a string (Macaulay2Doc),

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

+-----------------------------------------------------------------------------+
|i1 : L= { {{{1},{2},{3},{4,5}},-1}, {{{1},{2,5},{3},{4}},1},                 |
|-----------------------------------------------------------------------------|
|{{{1,4},{2},{3},{5}},1},{{{1,3},{2},{4},{5}},1}};                            |
+-----------------------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(5,L);                                  |
+-----------------------------------------------------------------------------+
|i3 : tex C                                                                   |
|                                                                             |
|o3 = -1F_{\{1\}, \{2\}, \{3\}, \{4, 5\}} + F_{\{1, 4\}, \{2\}, \{3\}, \{5\}} |
|     + F_{\{1\}, \{2, 5\}, \{3\}, \{4\}} + F_{\{1, 3\}, \{2\}, \{4\}, \{5\}} |
+-----------------------------------------------------------------------------+

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

  * tex(CurveClassRepresentativeM0nbar)
    -- convert to TeX format

tex(DivisorClassRepresentativeM0nbar) -- convert to TeX format
**************************************************************

Synopsis
========

  * Function: tex (Macaulay2Doc),
  * Usage:
        tex D
  * Inputs:
      * D, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * a string (Macaulay2Doc),

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

+----------------------------------------------------------------+
|i1 : L= { {{1,2},7}, {{1,3},2}, {{2,3,5,6},1}};                 |
+----------------------------------------------------------------+
|i2 : D=divisorClassRepresentativeM0nbar(6,L);                   |
+----------------------------------------------------------------+
|i3 : tex D                                                      |
|                                                                |
|o3 = 2\delta_{\{1, 3\}} + \delta_{\{1, 4\}} + 7\delta_{\{1, 2\}}|
+----------------------------------------------------------------+

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

  * tex(DivisorClassRepresentativeM0nbar)
    -- convert to TeX format

writeCurveInDualNonadjacentBasis -- write a curve in the basis dual to the nonadjacent basis
********************************************************************************************

Synopsis
========

  * Usage:
        writeCurveInDualNonadjacentBasis C
  * Inputs:
      * C, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * v, a list (Macaulay2Doc),

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

The nonadjacent basis is described in Carr, A polygonal presentation of
$Pic(\bar{M}_{0,n})$, arXiv:0911.2649.

This function takes a curve class and returns the vector of its intersection
numbers with the nonadjacent basis of divisors.  These intersection numbers are
the coefficients in the basis of curves that is dual to the nonadjacent basis.

+------------------------------------------------------------+
|i1 : L1={ {{{1,2},{3},{4},{5}},1}, {{{1,3},{2},{4},{5}},1}};|
+------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(5,L1);                |
+------------------------------------------------------------+
|i3 : writeCurveInDualNonadjacentBasis(C)                    |
|                                                            |
|o3 = {-1, 0, 1, 1, 1}                                       |
|                                                            |
|o3 : List                                                   |
+------------------------------------------------------------+

Ways to use writeCurveInDualNonadjacentBasis :
==============================================

  * "writeCurveInDualNonadjacentBasis(CurveClassRepresentativeM0nbar)"

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

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

writeCurveInSingletonSpineBasis -- write a curve class in the singleton spine basis of curve
********************************************************************************************

Synopsis
========

  * Usage:
        writeCurveInSingletonSpineBasis(C1)
  * Inputs:
      * C1, an instance of the type CurveClassRepresentativeM0nbar,
  * Outputs:
      * C2, an instance of the type CurveClassRepresentativeM0nbar,

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

This function writes a curve class in the singleton spine basis of curves.

Recall that the singleton spine basis of curves is only defined on
$\bar{M}_{0,n}$ if $n \geq 7$.

+-----------------------------------------------------------------------------+
|i1 : L= { {{1,2},{3,4},{5,6},{7,8}}=>1 };                                    |
+-----------------------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(8,L);                                  |
+-----------------------------------------------------------------------------+
|i3 : writeCurveInSingletonSpineBasis(C)                                      |
|                                                                             |
|o3 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2}, {3 |
|                                                                 {{1, 3, 4,  |
|                                                                 {{1, 3, 4,  |
|                                                                 {{1, 3, 4,  |
|                                                                 {{1, 8}, {2 |
|                                                                 {{1}, {2, 3 |
|                                                                 {{1}, {2, 3 |
|                                                                 {{1}, {2},  |
|                                                                 {{1}, {2},  |
|                                                                 {{1}, {2},  |
|                                                                 {{1}, {2},  |
|                                    NumberOfMarkedPoints => 8                |
|                                                                             |
|o3 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|, 4}, {5}, {6, 7, 8}} => 1 }}                                                |
|5, 6}, {2}, {7}, {8}} => -1                                                  |
|5, 8}, {2}, {6}, {7}} => 1                                                   |
|7, 8}, {2}, {5}, {6}} => -1                                                  |
|}, {3, 4, 5}, {6, 7}} => 1                                                   |
|, 4, 5}, {6}, {7, 8}} => 1                                                   |
|, 4, 7, 8}, {5}, {6}} => -1                                                  |
|{3, 4, 5, 6, 7}, {8}} => 1                                                   |
|{3, 4, 5, 6}, {7, 8}} => -1                                                  |
|{3, 4, 6, 7, 8}, {5}} => 1                                                   |
|{3, 4, 7, 8}, {5, 6}} => -1                                                  |
+-----------------------------------------------------------------------------+

Ways to use writeCurveInSingletonSpineBasis :
=============================================

  * "writeCurveInSingletonSpineBasis(CurveClassRepresentativeM0nbar)"
  * writeCurveInSingletonSpineBasis(ZZ,List)
    -- write a curve class in
    the singleton spine basis of curve

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

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

writeCurveInSingletonSpineBasis(ZZ,List) -- write a curve class in the singleton spine basis of curve
*****************************************************************************************************

Synopsis
========

  * Function: writeCurveInSingletonSpineBasis,
  * Usage:
        writeCurveInSingletonSpineBasis(n,L)
  * Inputs:
      * n, an integer (Macaulay2Doc),
      * L, a list (Macaulay2Doc),
  * Outputs:
      * C2, an instance of the type CurveClassRepresentativeM0nbar,

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

This function writes a curve class in the singleton spine basis of curves.  The
input is the number of marked points n, and a list of the intersection numbers
with the nonadjacent basis of divisors.

Recall that the singleton spine basis of curves is only defined on
$\bar{M}_{0,n}$ if $n \geq 7$.

+-----------------------------------------------------------------------------+
|i1 : L= { {{1,2},{3,4},{5,6},{7,8}}=>1 };                                    |
+-----------------------------------------------------------------------------+
|i2 : C=curveClassRepresentativeM0nbar(8,L);                                  |
+-----------------------------------------------------------------------------+
|i3 : v=writeCurveInDualNonadjacentBasis(C);                                  |
+-----------------------------------------------------------------------------+
|i4 : writeCurveInSingletonSpineBasis(8,v)                                    |
|                                                                             |
|o4 = CurveClassRepresentativeM0nbar{CurveExpression => HashTable{{{1, 2}, {3 |
|                                                                 {{1, 3, 4,  |
|                                                                 {{1, 3, 4,  |
|                                                                 {{1, 3, 4,  |
|                                                                 {{1, 8}, {2 |
|                                                                 {{1}, {2, 3 |
|                                                                 {{1}, {2, 3 |
|                                                                 {{1}, {2},  |
|                                                                 {{1}, {2},  |
|                                                                 {{1}, {2},  |
|                                                                 {{1}, {2},  |
|                                    NumberOfMarkedPoints => 8                |
|                                                                             |
|o4 : CurveClassRepresentativeM0nbar                                          |
|-----------------------------------------------------------------------------|
|, 4}, {5}, {6, 7, 8}} => 1 }}                                                |
|5, 6}, {2}, {7}, {8}} => -1                                                  |
|5, 8}, {2}, {6}, {7}} => 1                                                   |
|7, 8}, {2}, {5}, {6}} => -1                                                  |
|}, {3, 4, 5}, {6, 7}} => 1                                                   |
|, 4, 5}, {6}, {7, 8}} => 1                                                   |
|, 4, 7, 8}, {5}, {6}} => -1                                                  |
|{3, 4, 5, 6, 7}, {8}} => 1                                                   |
|{3, 4, 5, 6}, {7, 8}} => -1                                                  |
|{3, 4, 6, 7, 8}, {5}} => 1                                                   |
|{3, 4, 7, 8}, {5, 6}} => -1                                                  |
+-----------------------------------------------------------------------------+

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

  * writeCurveInSingletonSpineBasis(ZZ,List)
    -- write a curve class in
    the singleton spine basis of curve

writeDivisorInNonadjacentBasis -- write a divisor in the nonadjacent basis
**************************************************************************

Synopsis
========

  * Usage:
        writeDivisorInNonadjacentBasis(D)
  * Inputs:
      * D, an instance of the type DivisorClassRepresentativeM0nbar,
  * Outputs:
      * E, an instance of the type DivisorClassRepresentativeM0nbar,

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

The nonadjacent basis is described in Carr, A polygonal presentation of
$Pic(\bar{M}_{0,n})$, arXiv:0911.2649.

This function takes a divisor class and writes it in the nonadjacent basis.

Needs more advanced tests!

+-----------------------------------------------------------------------------+
|i1 : L= {{1,2}=>1};                                                          |
+-----------------------------------------------------------------------------+
|i2 : D=divisorClassRepresentativeM0nbar(5,L);                                |
+-----------------------------------------------------------------------------+
|i3 : writeDivisorInNonadjacentBasis(D)                                       |
|                                                                             |
|o3 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3}  |
|                                                                     {2, 5}  |
|                                                                     {3, 5}  |
|                                      NumberOfMarkedPoints => 5              |
|                                                                             |
|o3 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|=> 1 }}                                                                      |
|=> 1                                                                         |
|=> -1                                                                        |
+-----------------------------------------------------------------------------+
|i4 : L= {{1,5,6}=>1};                                                        |
+-----------------------------------------------------------------------------+
|i5 : D=divisorClassRepresentativeM0nbar(6,L);                                |
+-----------------------------------------------------------------------------+
|i6 : writeDivisorInNonadjacentBasis(D)                                       |
|                                                                             |
|o6 = DivisorClassRepresentativeM0nbar{DivisorExpression => HashTable{{1, 3,  |
|                                                                     {1, 3,  |
|                                                                     {1, 4,  |
|                                                                     {1, 4}  |
|                                                                     {1, 5}  |
|                                                                     {2, 4}  |
|                                                                     {2, 5}  |
|                                      NumberOfMarkedPoints => 6              |
|                                                                             |
|o6 : DivisorClassRepresentativeM0nbar                                        |
|-----------------------------------------------------------------------------|
|4} => 1 }}                                                                   |
|5} => -1                                                                     |
|6} => 1                                                                      |
|=> 1                                                                         |
|=> -1                                                                        |
|=> -1                                                                        |
|=> 1                                                                         |
+-----------------------------------------------------------------------------+

Ways to use writeDivisorInNonadjacentBasis :
============================================

  * "writeDivisorInNonadjacentBasis(DivisorClassRepresentativeM0nbar)"

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

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