This is RelativeCanonicalResolution.info, produced by Macaulay2, version 1.22

RelativeCanonicalResolution -- construction of relative canonical resolutions and Eagon-Northcott type complexes
****************************************************************************************************************

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

This package provides functions that construct g-nodal canonical curves with a
degree k line bundle that lie on a normalized scroll. It furthermore contains
functions that compute the relative canonical resolution. The construction of
such canonical curves is based on the Macaulay2 package kGonalNodalCurves.
(see https://www.math.uni-sb.de/ag/schreyer/index.php/computeralgebra )This
package can be seen as an upgrade to the  kGonalNodalCurves  (see
https://www.math.uni-sb.de/ag/schreyer/index.php/computeralgebra ) package.

We also provide functions to compute (possibly non-minimal) free resolutions of
such curves by an iterated mapping cone construction, as described in
Schreyer's article Syzygies of Canonical Curves and Special Linear Series (see
http://link.springer.com/article/10.1007%2FBF01458587?LI=true ).

Construction of relative canonical resolutions
==============================================

  * canCurveWithFixedScroll -- Computes a
    g-nodal canonical curve with a degree k line bundle on a normalized scroll
  * curveOnScroll -- Computes the ideal of a canonical
    curve on a normalized scroll in terms of generators of the scroll
  * resCurveOnScroll -- Computes the relative
    canonical resolution

Iterated mapping cones and Eagon-Nortcott type complexes
========================================================

  * eagonNorthcottType -- Computes the
    Eagon-Northcott type resolution
  * liftMatrixToEN -- Lifts a matrix between bundles on
    the scroll to the associated Eagon-Northcott type complexes
  * iteratedCone -- Computes a (possibly non-minimal)
    resolution of C in P^{g-1} starting from the relative canonical resolution
    of C in P(E)

Authors
=======

  * Christian Bopp (see http://www.math.uni-sb.de/ag-schreyer/index.php/people/
    researchers/75-christian-bopp ) <bopp@math.uni-sb.de>
  * Michael Hoff (see http://www.math.uni-sb.de/ag-schreyer/index.php/people/
    researchers/74-michael-hahn ) <hahn@math.uni-sb.de>

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

Version 1.0 of this package was accepted for publication in volume 11 (see
https://msp.org/jsag/2021/11-1/ ) of The Journal of Software for Algebra and
Geometry (see http://j-sag.org/ ) on 28 August 2020, in the article The
relative canonical resolution: Macaulay2-package, experiments and conjectures
(see https://msp.org/jsag/2021/11-1/p03.xhtml ). That version can be obtained
from the journal (see https://msp.org/jsag/2021/11-1/jsag-v11-n1-x03-
RelativeCanonicalResolution.m2 ) or from the Macaulay2 source code repository
(see http://github.com/Macaulay2/M2/blob/
2f0290ad1bf65508e8f3cf63579447ef3153486f/M2/Macaulay2/packages/
RelativeCanonicalResolution.m2 ).

Version
=======

This documentation describes version 1.0 of RelativeCanonicalResolution.

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

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

Exports
=======

  * Functions and commands
      * balancedPartition -- Computes balanced
        partition of n of length d
      * canCurveWithFixedScroll -- Computes a
        g-nodal canonical curve with a degree k line bundle on a normalized
        scroll
      * canonicalMultipliers -- Computes the
        canonical multipliers of a rational curves with nodes
      * coxDegrees -- Computes the degree of a polynomial in
        the Cox ring corresponding to a section of a bundle on the scroll
      * curveOnScroll -- Computes the ideal of a
        canonical curve on a normalized scroll in terms of generators of the
        scroll
      * eagonNorthcottType -- Computes the
        Eagon-Northcott type resolution
      * iteratedCone -- Computes a (possibly non-minimal)
        resolution of C in P^{g-1} starting from the relative canonical
        resolution of C in P(E)
      * liftMatrixToEN -- Lifts a matrix between bundles
        on the scroll to the associated Eagon-Northcott type complexes
      * lineBundleFromPointsAndMultipliers
        -- Computes basis of a line bundle
        from the 2g points P_i, Q_i and the multipliers
      * resCurveOnScroll -- Computes the relative
        canonical resolution
      * rkSyzModules -- Computes the rank of the i-th
        module in the relative canonical resolution
      * scrollDegrees -- Computes the degree of a section
        of a bundle on the scroll ring corresponding to a polynomial in the Cox
        ring
  * Methods
      * "balancedPartition(ZZ,ZZ)" -- see balancedPartition,
        -- Computes balanced partition of n of length d
      * "canCurveWithFixedScroll(ZZ,ZZ,ZZ)" -- see
        canCurveWithFixedScroll, -- Computes a g-nodal
        canonical curve with a degree k line bundle on a normalized scroll
      * "canonicalMultipliers(Matrix,Matrix)" -- see
        canonicalMultipliers, -- Computes the canonical
        multipliers of a rational curves with nodes
      * "coxDegrees(List,List)" -- see coxDegrees, --
        Computes the degree of a polynomial in the Cox ring corresponding to a
        section of a bundle on the scroll
      * "curveOnScroll(Ideal,ZZ,ZZ)" -- see curveOnScroll,
        -- Computes the ideal of a canonical curve on a normalized scroll in
        terms of generators of the scroll
      * "eagonNorthcottType(Matrix,ZZ)" -- see eagonNorthcottType,
        -- Computes the Eagon-Northcott type resolution
      * "iteratedCone(ChainComplex,List)" -- see iteratedCone,
        -- Computes a (possibly non-minimal) resolution of C in
        P^{g-1} starting from the relative canonical resolution of C in P(E)
      * "liftMatrixToEN(Matrix,List)" -- see liftMatrixToEN,
        -- Lifts a matrix between bundles on the scroll to the
        associated Eagon-Northcott type complexes
      * "lineBundleFromPointsAndMultipliers(List,Matrix,Matrix,ZZ)" -- see
        lineBundleFromPointsAndMultipliers,
        -- Computes basis of a line bundle
        from the 2g points P_i, Q_i and the multipliers
      * "resCurveOnScroll(Ideal,ZZ)" -- see resCurveOnScroll,
        -- Computes the relative canonical resolution
      * "resCurveOnScroll(Ideal,ZZ,ZZ)" -- see resCurveOnScroll,
        -- Computes the relative canonical resolution
      * "rkSyzModules(ZZ,ZZ)" -- see rkSyzModules, --
        Computes the rank of the i-th module in the relative canonical
        resolution
      * "scrollDegrees(List,List)" -- see scrollDegrees,
        -- Computes the degree of a section of a bundle on the scroll ring
        corresponding to a polynomial in the Cox ring

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

The object RelativeCanonicalResolution, is a package (Macaulay2Doc).

balancedPartition -- Computes balanced partition of n of length d
*****************************************************************

Synopsis
========

  * Usage:
        e=balancedPartition(d,n)
  * Inputs:
      * d, an integer (Macaulay2Doc), the length of the partition
      * n, an integer (Macaulay2Doc), the natural number we want to
        partition
  * Outputs:
      * e, a list (Macaulay2Doc), the balanced partition

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

This function computes a balanced partition of an integer n of length d

+-------------------------------+
|i1 : (d,n) = (4,7);            |
+-------------------------------+
|i2 : e = balancedPartition(d,n)|
|                               |
|o2 = {2, 2, 2, 1}              |
|                               |
|o2 : List                      |
+-------------------------------+

Ways to use balancedPartition :
===============================

  * "balancedPartition(ZZ,ZZ)"

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

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

canCurveWithFixedScroll -- Computes a g-nodal canonical curve with a degree k line bundle on a normalized scroll
****************************************************************************************************************

Synopsis
========

  * Usage:
        Ican=canCurveWithFixedScroll(g,k,n)
  * Inputs:
      * g, an integer (Macaulay2Doc), the genus of the curve
      * k, an integer (Macaulay2Doc), the degree of the line bundle
        on C
      * n, an integer (Macaulay2Doc), the integer defining the
        characteristic p ($\ge n$) of the ground field
  * Outputs:
      * ICan, an ideal (Macaulay2Doc), the ideal of the canonical
        curve

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

This function computes the ideal of a g-nodal canonical curve with a degree k<g
line bundle that lies on a normalized scroll. The construction of such curves
is based on the Macaulay2 package  kGonalNodalCurves (see
http://www.math.uni-sb.de/ag/schreyer/index.php/people/researchers/75-christian
-bopp )

+------------------------------------------------------+
|i1 : (g,k,n) = (8,5,1000);                            |
+------------------------------------------------------+
|i2 : Ican = canCurveWithFixedScroll(g,k,n);           |
|                                                      |
|               ZZ                                     |
|o2 : Ideal of ----[t ..t ]                            |
|              1009  0   7                             |
+------------------------------------------------------+
|i3 : genus Ican, degree Ican, dim Ican                |
|                                                      |
|o3 = (8, 14, 2)                                       |
|                                                      |
|o3 : Sequence                                         |
+------------------------------------------------------+
|i4 : betti res(Ican, DegreeLimit => 1)                |
|                                                      |
|            0  1  2  3                                |
|o4 = total: 1 15 35 21                                |
|         0: 1  .  .  .                                |
|         1: . 15 35 21                                |
|                                                      |
|o4 : BettiTally                                       |
+------------------------------------------------------+
|i5 : Phi = matrix{{t_0,t_2,t_4,t_6},{t_1,t_3,t_5,t_7}}|
|                                                      |
|o5 = | t_0 t_2 t_4 t_6 |                              |
|     | t_1 t_3 t_5 t_7 |                              |
|                                                      |
|              ZZ          2        ZZ          4      |
|o5 : Matrix (----[t ..t ])  <--- (----[t ..t ])       |
|             1009  0   7          1009  0   7         |
+------------------------------------------------------+
|i6 : Iscroll = minors(2,Phi);                         |
|                                                      |
|               ZZ                                     |
|o6 : Ideal of ----[t ..t ]                            |
|              1009  0   7                             |
+------------------------------------------------------+
|i7 : Ican + Iscroll == Ican                           |
|                                                      |
|o7 = true                                             |
+------------------------------------------------------+

See also
========

  * curveOnScroll -- Computes the ideal of a canonical
    curve on a normalized scroll in terms of generators of the scroll

Ways to use canCurveWithFixedScroll :
=====================================

  * "canCurveWithFixedScroll(ZZ,ZZ,ZZ)"

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

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

canonicalMultipliers -- Computes the canonical multipliers of a rational curves with nodes
******************************************************************************************

Synopsis
========

  * Usage:
        canonicalMultipliers(P,Q)
  * Inputs:
      * P, a matrix (Macaulay2Doc), the coordinate matrix of g
        points in P^1
      * Q, a matrix (Macaulay2Doc), the coordinate matrix of g
        points in P^1
  * Outputs:
      * A, a matrix (Macaulay2Doc), of multipliers

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

This function is identical to the function "canonicalMultipliers" from the
Macaulay2 package  NodalCurves (see
http://www.math.uni-sb.de/ag/schreyer/home/NodalCurves.m2 ). Given g pairs of
points P_i, Q_i, on P^1 computes the canonical series of the corresponding
nodal curve of genus g and determines the g ratios A_i of the glueing data for
the canonical bundle (note that A_i depends on the choice of the homogeneous
coordinates of the point P_i and  Q_i).

Step 1.We compute g quadrics q_i $q_i\ :=det(P_i\ |\ (x_0,x_1)^t)\ *\ det(Q_i\
|\ (x_0,x_1)^t)$ and a basis of $H^0(C,\omega_C)$ by $\{s_i\ :=\prod^g_{j\neq
i,j=1}q_i\ |\ i=1,...,g \}$.

Step 2. We compute the multipliers $a_i=s_i(P_i)$ and $b_i=s_i(Q_i)$

Ways to use canonicalMultipliers :
==================================

  * "canonicalMultipliers(Matrix,Matrix)"

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

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

coxDegrees -- Computes the degree of a polynomial in the Cox ring corresponding to a section of a bundle on the scroll
**********************************************************************************************************************

Synopsis
========

  * Usage:
        coxDegrees(ab,e)
  * Inputs:
      * ab, a list (Macaulay2Doc), containing the twist $a$ of the
        hyperplane class and $b$ of the ruling
      * e, a list (Macaulay2Doc), the type of the scroll
  * Outputs:
      * ab', a list (Macaulay2Doc), containing the bidegree in the
        Cox ring

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

This function computes integers a' and b' such that $H^0(O_{P(E)}(aH+bR))$
corresponds to basis($\{a',b'\}$,S), where S is the Cox ring of the scroll
$P(E)$.

See also
========

  * scrollDegrees -- Computes the degree of a section of
    a bundle on the scroll ring corresponding to a polynomial in the Cox ring

Ways to use coxDegrees :
========================

  * "coxDegrees(List,List)"

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

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

curveOnScroll -- Computes the ideal of a canonical curve on a normalized scroll in terms of generators of the scroll
********************************************************************************************************************

Synopsis
========

  * Usage:
        J=curveOnScroll(Ican,g,k)
  * Inputs:
      * Ican, an ideal (Macaulay2Doc), the ideal of a genus g
        canonical curve with a degree k line bundle on a normalized scroll
      * g, an integer (Macaulay2Doc), the genus
      * k, an integer (Macaulay2Doc), the degree of the line bundle
        on C
  * Outputs:
      * Jcan, an ideal (Macaulay2Doc), the ideal of the canonical
        curve in terms of generators of the scroll

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

Given the ideal of a canonical curve on a normalized scroll, this function
computes the ideal of the curve in terms of generators on the scroll.

+-------------------------------------------+
|i1 : (g,k,n) = (8,5,1000);                 |
+-------------------------------------------+
|i2 : Ican = canCurveWithFixedScroll(g,k,n);|
|                                           |
|               ZZ                          |
|o2 : Ideal of ----[t ..t ]                 |
|              1009  0   7                  |
+-------------------------------------------+
|i3 : Jcan = curveOnScroll(Ican,g,k);       |
|                                           |
|               ZZ                          |
|o3 : Ideal of ----[pp ..pp , v..w]         |
|              1009   0    3                |
+-------------------------------------------+
|i4 : betti Jcan                            |
|                                           |
|            0 1                            |
|o4 = total: 1 5                            |
|         0: 1 .                            |
|         1: . .                            |
|         2: . 4                            |
|         3: . 1                            |
|                                           |
|o4 : BettiTally                            |
+-------------------------------------------+

See also
========

  * canCurveWithFixedScroll -- Computes a
    g-nodal canonical curve with a degree k line bundle on a normalized scroll
  * resCurveOnScroll -- Computes the relative
    canonical resolution

Ways to use curveOnScroll :
===========================

  * "curveOnScroll(Ideal,ZZ,ZZ)"

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

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

eagonNorthcottType -- Computes the Eagon-Northcott type resolution
******************************************************************

Synopsis
========

  * Usage:
        resX=resCurveOnScroll(Phi,b)
  * Inputs:
      * Phi, a matrix (Macaulay2Doc), the matrix whose maximal
        minors define the scroll
      * b, an integer (Macaulay2Doc), the twist
  * Outputs:
      * ENresolution, a chain complex (Macaulay2Doc), the
        Eagon-Northcott type resolution

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

This function computes the Eagon-Northcott type resolution associated to the
matrix Phi defining the scroll and an integer b defining the twist
$O_{P(E)}(bR)$. The way the function works is similar to the way the
"Eagon-Northcott" function by Greg Smith works.

+----------------------------------------+
|i1 : R = ZZ/12347[x_0..x_7]             |
|                                        |
|o1 = R                                  |
|                                        |
|o1 : PolynomialRing                     |
+----------------------------------------+
|i2 : Phi = matrix{{x_0..x_3},{x_4..x_7}}|
|                                        |
|o2 = | x_0 x_1 x_2 x_3 |                |
|     | x_4 x_5 x_6 x_7 |                |
|                                        |
|             2       4                  |
|o2 : Matrix R  <--- R                   |
+----------------------------------------+
|i3 : betti(eagonNorthcottType(Phi,0))   |
|                                        |
|            0 1 2 3                     |
|o3 = total: 1 6 8 3                     |
|         0: 1 . . .                     |
|         1: . 6 8 3                     |
|                                        |
|o3 : BettiTally                         |
+----------------------------------------+
|i4 : betti(eagonNorthcottType(Phi,1))   |
|                                        |
|            0 1 2 3                     |
|o4 = total: 2 4 4 2                     |
|         0: 2 4 . .                     |
|         1: . . 4 2                     |
|                                        |
|o4 : BettiTally                         |
+----------------------------------------+

See also
========

  * liftMatrixToEN -- Lifts a matrix between bundles on
    the scroll to the associated Eagon-Northcott type complexes
  * iteratedCone -- Computes a (possibly non-minimal)
    resolution of C in P^{g-1} starting from the relative canonical resolution
    of C in P(E)

Ways to use eagonNorthcottType :
================================

  * "eagonNorthcottType(Matrix,ZZ)"

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

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

iteratedCone -- Computes a (possibly non-minimal) resolution of C in P^{g-1} starting from the relative canonical resolution of C in P(E)
*****************************************************************************************************************************************

Synopsis
========

  * Usage:
        resC=iteratedCone(resX,e)
  * Inputs:
      * resX, a chain complex (Macaulay2Doc), the relative
        canonical resolution
      * e, a list (Macaulay2Doc), the type of the scroll $P(E)$
  * Outputs:
      * resC, a chain complex (Macaulay2Doc), the
        resolution of C obtained by an iterated mapping cone

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

Given the relative canonical resolution of C on a normalized scroll $P(E)$,
this function computes a (possibly non-minimal) free resolution of C in
$P^{g-1}$ by an iterated mapping cone construction. For gonality k=3,4 the
iterated mapping cone is always minimal. In these cases "iteratedCone" is much
faster (for $g >9$) than computing the resolution via the resolution (Macaulay2Doc),
command.

+---------------------------------------------+
|i1 : (g,k,n) = (8,5,1000)                    |
|                                             |
|o1 = (8, 5, 1000)                            |
|                                             |
|o1 : Sequence                                |
+---------------------------------------------+
|i2 : e = balancedPartition(k-1,g-k+1)        |
|                                             |
|o2 = {1, 1, 1, 1}                            |
|                                             |
|o2 : List                                    |
+---------------------------------------------+
|i3 : Ican = canCurveWithFixedScroll(g,k,n);  |
|                                             |
|               ZZ                            |
|o3 : Ideal of ----[t ..t ]                   |
|              1009  0   7                    |
+---------------------------------------------+
|i4 : betti res(Ican,DegreeLimit=>1)          |
|                                             |
|            0  1  2  3                       |
|o4 = total: 1 15 35 21                       |
|         0: 1  .  .  .                       |
|         1: . 15 35 21                       |
|                                             |
|o4 : BettiTally                              |
+---------------------------------------------+
|i5 : Jcan = curveOnScroll(Ican,g,k);         |
|                                             |
|               ZZ                            |
|o5 : Ideal of ----[pp ..pp , v..w]           |
|              1009   0    3                  |
+---------------------------------------------+
|i6 : betti(resX = resCurveOnScroll(Jcan,g,2))|
|                                             |
|            0 1 2 3                          |
|o6 = total: 1 5 5 1                          |
|         0: 1 . . .                          |
|         1: . . . .                          |
|         2: . 4 1 .                          |
|         3: . 1 4 .                          |
|         4: . . . .                          |
|         5: . . . 1                          |
|                                             |
|o6 : BettiTally                              |
+---------------------------------------------+
|i7 : betti(resC = iteratedCone(resX,e))      |
|                                             |
|            0  1  2  3  4  5 6               |
|o7 = total: 1 15 41 54 41 15 1               |
|         0: 1  .  .  .  .  . .               |
|         1: . 15 35 27  6  . .               |
|         2: .  .  6 27 35 15 .               |
|         3: .  .  .  .  .  . 1               |
|                                             |
|o7 : BettiTally                              |
+---------------------------------------------+

See also
========

  * eagonNorthcottType -- Computes the
    Eagon-Northcott type resolution
  * liftMatrixToEN -- Lifts a matrix between bundles on
    the scroll to the associated Eagon-Northcott type complexes

Ways to use iteratedCone :
==========================

  * "iteratedCone(ChainComplex,List)"

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

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

liftMatrixToEN -- Lifts a matrix between bundles on the scroll to the associated Eagon-Northcott type complexes
***************************************************************************************************************

Synopsis
========

  * Usage:
        A=liftMatrixToEN(Psi,e)
  * Inputs:
      * Psi, a matrix (Macaulay2Doc), the matrix that defines map
        between vector bundles on the scroll.
      * e, a list (Macaulay2Doc), the type of the scroll $P(E)$
  * Outputs:
      * A, a matrix (Macaulay2Doc), the induced map

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

Given a map between vector bundles F and G on a normalized scroll of type e,
this function computes the induced map between the first modules in the
Eagon-Northcott type resolution of F and G.

+---------------------------------------------+
|i1 : (g,k,n) = (8,5,1000)                    |
|                                             |
|o1 = (8, 5, 1000)                            |
|                                             |
|o1 : Sequence                                |
+---------------------------------------------+
|i2 : e = balancedPartition(k-1,g-k+1)        |
|                                             |
|o2 = {1, 1, 1, 1}                            |
|                                             |
|o2 : List                                    |
+---------------------------------------------+
|i3 : Ican = canCurveWithFixedScroll(g,k,n);  |
|                                             |
|               ZZ                            |
|o3 : Ideal of ----[t ..t ]                   |
|              1009  0   7                    |
+---------------------------------------------+
|i4 : Jcan = curveOnScroll(Ican,g,k);         |
|                                             |
|               ZZ                            |
|o4 : Ideal of ----[pp ..pp , v..w]           |
|              1009   0    3                  |
+---------------------------------------------+
|i5 : betti(resX = resCurveOnScroll(Jcan,g,2))|
|                                             |
|            0 1 2 3                          |
|o5 = total: 1 5 5 1                          |
|         0: 1 . . .                          |
|         1: . . . .                          |
|         2: . 4 1 .                          |
|         3: . 1 4 .                          |
|         4: . . . .                          |
|         5: . . . 1                          |
|                                             |
|o5 : BettiTally                              |
+---------------------------------------------+
|i6 : betti(liftMatrixToEN(resX.dd_1,e))      |
|                                             |
|            0 1                              |
|o6 = total: 1 9                              |
|         0: 1 .                              |
|         1: . 9                              |
|                                             |
|o6 : BettiTally                              |
+---------------------------------------------+
|i7 : betti(liftMatrixToEN(resX.dd_2,e))      |
|                                             |
|            0  1                             |
|o7 = total: 9 11                             |
|         2: 9 11                             |
|                                             |
|o7 : BettiTally                              |
+---------------------------------------------+
|i8 : betti(liftMatrixToEN(resX.dd_3,e))      |
|                                             |
|             0 1                             |
|o8 = total: 11 3                             |
|         3: 11 .                             |
|         4:  . 3                             |
|                                             |
|o8 : BettiTally                              |
+---------------------------------------------+

See also
========

  * eagonNorthcottType -- Computes the
    Eagon-Northcott type resolution
  * iteratedCone -- Computes a (possibly non-minimal)
    resolution of C in P^{g-1} starting from the relative canonical resolution
    of C in P(E)

Ways to use liftMatrixToEN :
============================

  * "liftMatrixToEN(Matrix,List)"

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

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

lineBundleFromPointsAndMultipliers -- Computes basis of a line bundle from the 2g points P_i, Q_i and the multipliers
*********************************************************************************************************************

Synopsis
========

  * Usage:
        lineBundleFromPointsAndMultipliers(multL,P,Q,k)
  * Inputs:
      * multL, a list (Macaulay2Doc), containing the normalized
        multipliers a_i (normalized means that b_i=1)
      * P, a matrix (Macaulay2Doc), the coordinate matrix of g
        points in P^1
      * Q, a matrix (Macaulay2Doc), the coordinate matrix of g
        points in P^1
      * k, an integer (Macaulay2Doc), defining the degree of the line
        bundle
  * Outputs:
      * f, a matrix (Macaulay2Doc), a basis of sections of the
        line bundle defined by the points P_i, Q_i and the multipliers

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

If C is a g-nodal canonical curve with normalization $\nu:\  P^1 \to P^{g-1}$
then a line bundle L of degree k on C is given by $\nu^*(O_{P^1}(k))\cong L$
and gluing data $\frac{b_j}{a_j}:O_{P^1}\otimes kk(P_j)\to O_{P^1}\otimes
kk(Q_j)$. Given 2g points P_i, Q_i and the multipliers (a_i,b_i) we can compute
a basis of sections of L as a kernel of the matrix $A=(A)_{ij}$ with
$A_{ij}=b_iB_j(P_i)-a_iB_j(Q_i)$ where $B_j:P^1\to kk,\  (p_0:p_1)\to
p_0^{k-j}p_1^j$.

See also
========

  * canonicalMultipliers -- Computes the canonical
    multipliers of a rational curves with nodes

Ways to use lineBundleFromPointsAndMultipliers :
================================================

  * "lineBundleFromPointsAndMultipliers(List,Matrix,Matrix,ZZ)"

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

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

resCurveOnScroll -- Computes the relative canonical resolution
**************************************************************

Synopsis
========

  * Usage:
        resX=resCurveOnScroll(Jcan,g,l)
        resX=resCurveOnScroll(Jcan,g)
  * Inputs:
      * Jcan, an ideal (Macaulay2Doc), the ideal of a genus g
        curve with a degree k line bundle in terms of generators on the scroll
      * g, an integer (Macaulay2Doc), the genus of C
      * l, an integer (Macaulay2Doc), the length limit of the
        resolution
  * Outputs:
      * resX, a chain complex (Macaulay2Doc), the relative
        canonical resolution

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

This function computes the relative canonical resolution by picking syzygies of
correct degree in each step until the length limit is reached.

+-------------------------------------------+
|i1 : (g,k,n) = (8,5,1000);                 |
+-------------------------------------------+
|i2 : Ican = canCurveWithFixedScroll(g,k,n);|
|                                           |
|               ZZ                          |
|o2 : Ideal of ----[t ..t ]                 |
|              1009  0   7                  |
+-------------------------------------------+
|i3 : Jcan = curveOnScroll(Ican,g,k);       |
|                                           |
|               ZZ                          |
|o3 : Ideal of ----[pp ..pp , v..w]         |
|              1009   0    3                |
+-------------------------------------------+
|i4 : resX = resCurveOnScroll(Jcan,g,2);    |
+-------------------------------------------+
|i5 : betti resX                            |
|                                           |
|            0 1 2 3                        |
|o5 = total: 1 5 5 1                        |
|         0: 1 . . .                        |
|         1: . . . .                        |
|         2: . 4 1 .                        |
|         3: . 1 4 .                        |
|         4: . . . .                        |
|         5: . . . 1                        |
|                                           |
|o5 : BettiTally                            |
+-------------------------------------------+

See also
========

  * curveOnScroll -- Computes the ideal of a canonical
    curve on a normalized scroll in terms of generators of the scroll

Ways to use resCurveOnScroll :
==============================

  * "resCurveOnScroll(Ideal,ZZ)"
  * "resCurveOnScroll(Ideal,ZZ,ZZ)"

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

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

rkSyzModules -- Computes the rank of the i-th module in the relative canonical resolution
*****************************************************************************************

Synopsis
========

  * Usage:
        rk=rkSyzModules(i,k)
  * Inputs:
      * i, an integer (Macaulay2Doc), the position
      * k, an integer (Macaulay2Doc), the degree of the line bundle
        on C
  * Outputs:
      * rk, an integer (Macaulay2Doc), the rank of the i-th module in
        the relative canonical resolution

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

This function computes the rank of the i-th module in the relative canonical
resolution

+---------------------------------------------+
|i1 : k = 5;                                  |
+---------------------------------------------+
|i2 : rks = apply(k-1, i -> rkSyzModules(i,k))|
|                                             |
|o2 = {1, 5, 5, 1}                            |
|                                             |
|o2 : List                                    |
+---------------------------------------------+

Ways to use rkSyzModules :
==========================

  * "rkSyzModules(ZZ,ZZ)"

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

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

scrollDegrees -- Computes the degree of a section of a bundle on the scroll ring corresponding to a polynomial in the Cox ring
******************************************************************************************************************************

Synopsis
========

  * Usage:
        scrollDegrees(ab',e)
  * Inputs:
      * ab', a list (Macaulay2Doc), containing the bidegree of
        polynomial in the Cox ring
      * e, a list (Macaulay2Doc), the type of the scroll
  * Outputs:
      * ab, a list (Macaulay2Doc), containing the bidegree on the
        scroll

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

This function computes integers a and b such that $H^0(O_{P(E)}(aH+bR))$
corresponds to basis($\{a',b'\}$,Rcox), where Rcox is the Cox ring of the
scroll $P(E)$.

See also
========

  * coxDegrees -- Computes the degree of a polynomial in the
    Cox ring corresponding to a section of a bundle on the scroll

Ways to use scrollDegrees :
===========================

  * "scrollDegrees(List,List)"

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

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