This is AdjunctionForSurfaces.info, produced by Macaulay2, version 1.25.05

AdjunctionForSurfaces -- Rational surfaces and extensions
*********************************************************

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

The main functions concerning surfaces are:
  * linearSystemOnRationalSurface, --
    compute a linear system on a rational surface
  * rationalSurface -- compute the ideal I of the
    rational surface
  * expectedDimension -- compute the expected
    dimension of a linear system on a rational surface
  * adjointMatrix -- compute the adjoint matrix
  * slowAdjunctionCalculation -- compute the
    adjoint variety and the presentation of O(1)
  * adjunctionProcess -- perform the adjunction
    process
  * parametrization -- compute a rational
    parametrization
  * specialFamiliesOfSommeseVandeVen,
    -- produce a member of the special family

This realizes the djunction process of Sommese and Van de Ven for smooth
projective surfaces. Given a smooth projectiv surface X in Pn, Sommese and Van
de Ven study X via the morphism  phi=phi_{|H+K|}: X -> X1 subset Pn1  where H
denotes the hyperplane class and K the canonical divisor on X.

 Theorem[SVdV]. Let X subset Pn be a smooth projective curve. Then phi is a
birational map onto a smooth projective surface X1, which blows down all (-1)
lines E of X, i.e., (-1) curves of X which are embedded into Pn as lines, and
is regular otherwise, unless  (1) X is a P2 linearly or quadratically embedded,
or ruled in lines,  (2) X is a anticanonical embedded del Pezzo surface,  (3) X
is a conic bundle in which case phi_{|H+K|}: X -> B maps X to a curve B and the
fibers are conics, or  (4) X is an element of one of the four families of
exceptions where |K+H| defines a finite to 1 map. See
specialFamiliesOfSommeseVandeVen,

Since a (-1) conic on X becomes (-1) line on X1, repeating this process finally
reaches a minimal surface unless X has negative Kodaira dimension.

In case of rational surfaces, repeating the process the process we end in one
of the exceptional cases (1),..,(4). Whether we are in case (3) or (4)  can be
detect from the presentation matrix of O_X(H+K). If this presentation matrix is
not linear, then a smooth hyperplane section C in |H| will be a hyperelliptic
curves by Green's K_{p,1} theorem and phi is no longer birational, because it
induces the canonical system on C which is 2:1. In our function
adjunctionProcess we stop with this last surface.

References:

[DES] W. Decker, L. Ein, F.-O. Schreyer. Construction of surfaces in P4. J.
Alg. Geom. 2 (1993), 185-237.

[SVdV] A. Sommese, A. Van de Ven. On the adjunction mapping, Math. Ann. 278
(1987), 593–603.

[G] M.Green. Koszul cohomology and the geometry of projective varieties. J.
Differ. Geom. 19, 125-167, 168-171 (1984).

Author
======

  * Frank-Olaf Schreyer (see http://www.math.uni-sb.de/ag/schreyer/ )
    <schreyer@math.uni-sb.de>

Version
=======

This documentation describes version 0.5 of AdjunctionForSurfaces.

Citation
========

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

+-----------------------------------------------------------------------------+
|@misc{AdjunctionForSurfacesSource,                                           |
|  title = {{AdjunctionForSurfaces: A \emph{Macaulay2} package. Version~0.5}},|
|  author = {Frank-Olaf Schreyer},                                            |
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/master/M2/Macaulay2/packages}} |
|}                                                                            |
|                                                                             |
+-----------------------------------------------------------------------------+

Exports
=======

  * Functions and commands
      * adjointMatrix -- compute the adjoint matrix
      * adjunctionProcess -- perform the adjunction
        process
      * expectedDimension -- compute the expected
        dimension of a linear system on a rational surface
      * linearSystemOnRationalSurface, --
        compute a linear system on a rational surface
      * parametrization -- compute a rational
        parametrization
      * rationalSurface -- compute the ideal I of the
        rational surface
      * slowAdjunctionCalculation -- compute
        the adjoint variety and the presentation of O(1)
      * specialFamiliesOfSommeseVandeVen
        -- produce a member of the special
        family
  * Methods
      * "adjointMatrix(Matrix,Symbol)" -- see adjointMatrix,
        -- compute the adjoint matrix
      * "adjunctionProcess(Ideal)" -- see adjunctionProcess,
        -- perform the adjunction process
      * "adjunctionProcess(Ideal,ZZ)" -- see adjunctionProcess,
        -- perform the adjunction process
      * "expectedDimension(ZZ,List)" -- see expectedDimension,
        -- compute the expected dimension of a linear system
        on a rational surface
      * "linearSystemOnRationalSurface(List,ZZ,List)" -- see
        linearSystemOnRationalSurface, --
        compute a linear system on a rational surface
      * "linearSystemOnRationalSurface(Ring,ZZ,List)" -- see
        linearSystemOnRationalSurface, --
        compute a linear system on a rational surface
      * "parametrization(Ring,List)" -- see parametrization,
        -- compute a rational parametrization
      * "rationalSurface(List,ZZ,List,Symbol)" -- see rationalSurface,
        -- compute the ideal I of the rational surface
      * "rationalSurface(Ring,ZZ,List,Ring)" -- see rationalSurface,
        -- compute the ideal I of the rational surface
      * "rationalSurface(Ring,ZZ,List,Symbol)" -- see rationalSurface,
        -- compute the ideal I of the rational surface
      * "slowAdjunctionCalculation(Ideal,Matrix,Symbol)" -- see
        slowAdjunctionCalculation, -- compute the
        adjoint variety and the presentation of O(1)
      * "specialFamiliesOfSommeseVandeVen(Ring,ZZ)" -- see
        specialFamiliesOfSommeseVandeVen, --
        produce a member of the special family

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:386:0.

adjointMatrix -- compute the adjoint matrix
*******************************************

  * Usage:
        adj=adjointMatrix(D,z)
  * Inputs:
      * D, a matrix (Macaulay2Doc), the transpose of a linear
        presentation matrix of omega_X(1)
  * Outputs:
      * adj, a matrix (Macaulay2Doc), the presentation matrix of
        O_X(1)

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

compute the presentation matrix of the line bundle O_X(1) as a module on the
adjoint variety

+------------------------------------------------------------------+
|i1 : d=7                                                          |
|                                                                  |
|o1 = 7                                                            |
+------------------------------------------------------------------+
|i2 : L=toList(7:2)|toList(8:1)                                    |
|                                                                  |
|o2 = {2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1}                |
|                                                                  |
|o2 : List                                                         |
+------------------------------------------------------------------+
|i3 : n=expectedDimension(d,L)-1                                   |
|                                                                  |
|o3 = 6                                                            |
+------------------------------------------------------------------+
|i4 : kk=ZZ/nextPrime(10^3)                                        |
|                                                                  |
|o4 = kk                                                           |
|                                                                  |
|o4 : QuotientRing                                                 |
+------------------------------------------------------------------+
|i5 : t=symbol t, x= symbol x                                      |
|                                                                  |
|o5 = (t, x)                                                       |
|                                                                  |
|o5 : Sequence                                                     |
+------------------------------------------------------------------+
|i6 : P2=kk[t_0..t_2]                                              |
|                                                                  |
|o6 = P2                                                           |
|                                                                  |
|o6 : PolynomialRing                                               |
+------------------------------------------------------------------+
|i7 : Pn=kk[x_0..x_n]                                              |
|                                                                  |
|o7 = Pn                                                           |
|                                                                  |
|o7 : PolynomialRing                                               |
+------------------------------------------------------------------+
|i8 : betti(I=rationalSurface(P2,d,L,Pn))                          |
|                                                                  |
|            0  1                                                  |
|o8 = total: 1 14                                                  |
|         0: 1  .                                                  |
|         1: .  2                                                  |
|         2: . 12                                                  |
|                                                                  |
|o8 : BettiTally                                                   |
+------------------------------------------------------------------+
|i9 : c=codim I                                                    |
|                                                                  |
|o9 = 4                                                            |
+------------------------------------------------------------------+
|i10 : elapsedTime fI=res I                                        |
| -- .0343911s elapsed                                             |
|                                                                  |
|        1       14       33       28       8                      |
|o10 = Pn  <-- Pn   <-- Pn   <-- Pn   <-- Pn  <-- 0                |
|                                                                  |
|      0       1        2        3        4       5                |
|                                                                  |
|o10 : ChainComplex                                                |
+------------------------------------------------------------------+
|i11 : betti(omega=presentation coker transpose fI.dd_c**Pn^{-n-1})|
|                                                                  |
|             0  1                                                 |
|o11 = total: 8 28                                                 |
|          1: 8 28                                                 |
|                                                                  |
|o11 : BettiTally                                                  |
+------------------------------------------------------------------+
|i12 : D=transpose omega;                                          |
|                                                                  |
|               28       8                                         |
|o12 : Matrix Pn   <-- Pn                                          |
+------------------------------------------------------------------+
|i13 : z= symbol z                                                 |
|                                                                  |
|o13 = z                                                           |
|                                                                  |
|o13 : Symbol                                                      |
+------------------------------------------------------------------+
|i14 : betti(adj=adjointMatrix(D,z))                               |
|                                                                  |
|             0  1                                                 |
|o14 = total: 7 28                                                 |
|          0: 7 28                                                 |
|                                                                  |
|o14 : BettiTally                                                  |
+------------------------------------------------------------------+
|i15 : support adj                                                 |
|                                                                  |
|o15 = {z , z , z , z , z , z , z , z }                            |
|        0   1   2   3   4   5   6   7                             |
|                                                                  |
|o15 : List                                                        |
+------------------------------------------------------------------+
|i16 : minimalBetti ann coker adj                                  |
|                                                                  |
|             0  1  2  3  4 5                                      |
|o16 = total: 1 12 25 21 10 3                                      |
|          0: 1  .  .  .  . .                                      |
|          1: . 12 25 15  . .                                      |
|          2: .  .  .  6 10 3                                      |
|                                                                  |
|o16 : BettiTally                                                  |
+------------------------------------------------------------------+
|i17 : (numList,adjList,ptsList,J)=adjunctionProcess(I,1);         |
+------------------------------------------------------------------+
|i18 : numList                                                     |
|                                                                  |
|o18 = {(6, 13, 8), 8, (7, 9, 3)}                                  |
|                                                                  |
|o18 : List                                                        |
+------------------------------------------------------------------+
|i19 : betti(adjList_0)                                            |
|                                                                  |
|             0  1                                                 |
|o19 = total: 7 28                                                 |
|          0: 7 28                                                 |
|                                                                  |
|o19 : BettiTally                                                  |
+------------------------------------------------------------------+
|i20 : minimalBetti J                                              |
|                                                                  |
|             0  1  2  3  4 5                                      |
|o20 = total: 1 12 25 21 10 3                                      |
|          0: 1  .  .  .  . .                                      |
|          1: . 12 25 15  . .                                      |
|          2: .  .  .  6 10 3                                      |
|                                                                  |
|o20 : BettiTally                                                  |
+------------------------------------------------------------------+

Ways to use adjointMatrix:
==========================

  * "adjointMatrix(Matrix,Symbol)"

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:554:0.

adjunctionProcess -- perform the adjunction process
***************************************************

  * Usage:
        (numList,adjList,ptsList,J)=adjointMatrix(I)
        (numList,adjList,ptsList,J)=adjointMatrix(I,N)
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a projective surface
      * N, an integer (Macaulay2Doc), number of adjunction steps
  * Outputs:
      * numList, a list (Macaulay2Doc), numerical Data of the
        adjunction process
      * adjList, a list (Macaulay2Doc), list of adjoint matrices
      * ptsList, a list (Macaulay2Doc), list of ideal if the
        exceptional points
      * J, an ideal (Macaulay2Doc), ideal of the final surface in
        the adjunction process

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

Adjunction determines the image X' of X under the morphism phi: X -> X' defined
by |H+K|. By Sommese and Van de Ven [SVdV] |H+K| is birational and blows down
presisely all (-1) lines of unless

(1) X is a P2 linearly or quadratically embedded, or ruled in lines,

(2) X is a anticanonical embedded Del Pezzo surface,

(3) X is a conic bundle in which case phi_{|H+K|}: X -> B maps X to a curve B
and the fibers are conics, or

(4) X is an element of one of the four families of exceptions where |K+H|
defines a finite to 1 map. See TO "specialFamiliesOfSommeseVandeVen".

Since a (-1) conic on X become (-1) line on X', repeating this process finally
reaches a minimal surface unless X has negative Kodaira dimension.

In case X is a rational surface, and the lucky case that the final surface is
P2, one can use the list adjList to get a rational parametrization.

In case one ends up with a del Pezzo surface or a conic bundle, one has to
identify the exceptional lines, thus one might need an algebraic field
extension, to get a rational parametrization. However, one can always
parametrize X in terms of the final surface in the adjunction process.

The numerical data are collected in a list with an entry

(n,d,pi)= (dim Pn_i, degree X_i, sectional genus of X_i)

for each surface X_i in the adjunction process, starting with X=X_0 and an
entry the integer k if X_i -> X_(i+1) blows down k (-1) lines.

+--------------------------------------------------------+
|i1 : d=7                                                |
|                                                        |
|o1 = 7                                                  |
+--------------------------------------------------------+
|i2 : L=toList(8:2)|toList(5:1)                          |
|                                                        |
|o2 = {2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1}            |
|                                                        |
|o2 : List                                               |
+--------------------------------------------------------+
|i3 : n=expectedDimension(d,L)-1                         |
|                                                        |
|o3 = 6                                                  |
+--------------------------------------------------------+
|i4 : kk=ZZ/nextPrime(10^3)                              |
|                                                        |
|o4 = kk                                                 |
|                                                        |
|o4 : QuotientRing                                       |
+--------------------------------------------------------+
|i5 : t=symbol t, x= symbol x                            |
|                                                        |
|o5 = (t, x)                                             |
|                                                        |
|o5 : Sequence                                           |
+--------------------------------------------------------+
|i6 : P2=kk[t_0..t_2]                                    |
|                                                        |
|o6 = P2                                                 |
|                                                        |
|o6 : PolynomialRing                                     |
+--------------------------------------------------------+
|i7 : Pn=kk[x_0..x_n]                                    |
|                                                        |
|o7 = Pn                                                 |
|                                                        |
|o7 : PolynomialRing                                     |
+--------------------------------------------------------+
|i8 : betti(I=rationalSurface(P2,d,L,Pn))                |
|                                                        |
|            0  1                                        |
|o8 = total: 1 11                                        |
|         0: 1  .                                        |
|         1: .  3                                        |
|         2: .  8                                        |
|                                                        |
|o8 : BettiTally                                         |
+--------------------------------------------------------+
|i9 : minimalBetti I                                     |
|                                                        |
|            0  1  2  3 4                                |
|o9 = total: 1 11 27 24 7                                |
|         0: 1  .  .  . .                                |
|         1: .  3  .  . .                                |
|         2: .  8 27 24 7                                |
|                                                        |
|o9 : BettiTally                                         |
+--------------------------------------------------------+
|i10 : (numList,adjList,ptsList,J)=adjunctionProcess(I); |
+--------------------------------------------------------+
|i11 : numList                                           |
|                                                        |
|o11 = {(6, 12, 7), 5, (6, 8, 3), 8, (2, 1, 0)}          |
|                                                        |
|o11 : List                                              |
+--------------------------------------------------------+
|i12 : P2=ring J                                         |
|                                                        |
|o12 = P2                                                |
|                                                        |
|o12 : PolynomialRing                                    |
+--------------------------------------------------------+
|i13 : betti(H=parametrization(P2,adjList))              |
|                                                        |
|             0 1                                        |
|o13 = total: 1 7                                        |
|          0: 1 .                                        |
|          1: . .                                        |
|          2: . .                                        |
|          3: . .                                        |
|          4: . .                                        |
|          5: . .                                        |
|          6: . 7                                        |
|                                                        |
|o13 : BettiTally                                        |
+--------------------------------------------------------+
|i14 : phi=map(P2,Pn,H);                                 |
|                                                        |
|o14 : RingMap P2 <-- Pn                                 |
+--------------------------------------------------------+
|i15 : elapsedTime betti(I'=trim ker phi)                |
| -- 1.18862s elapsed                                    |
|                                                        |
|             0  1                                       |
|o15 = total: 1 11                                       |
|          0: 1  .                                       |
|          1: .  3                                       |
|          2: .  8                                       |
|                                                        |
|o15 : BettiTally                                        |
+--------------------------------------------------------+
|i16 : I'== I                                            |
|                                                        |
|o16 = true                                              |
+--------------------------------------------------------+
|i17 : elapsedTime basePts=primaryDecomposition ideal H; |
| -- 7.66743s elapsed                                    |
+--------------------------------------------------------+
|i18 : tally apply(basePts,c->(dim c, degree c, betti c))|
|                                                        |
|                          0 1                           |
|o18 = Tally{(1, 1, total: 1 2) => 5}                    |
|                       0: 1 2                           |
|                          0 1                           |
|            (1, 3, total: 1 3) => 8                     |
|                       0: 1 .                           |
|                       1: . 3                           |
|                                                        |
|o18 : Tally                                             |
+--------------------------------------------------------+

Ways to use adjunctionProcess:
==============================

  * "adjunctionProcess(Ideal)"
  * "adjunctionProcess(Ideal,ZZ)"

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:678:0.

expectedDimension -- compute the expected dimension of a linear system on a rational surface
********************************************************************************************

  * Usage:
        expectedDimension(d,L)
  * Inputs:
      * d, an integer (Macaulay2Doc), degree of the desired forms
      * L, a list (Macaulay2Doc), {r_1,...,r_s} of multiplicities
  * Outputs:
      * an integer (Macaulay2Doc), the expected dimension of
        L(d;r_1p_1,...,r_sp_s)

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

computes the expected dimension max(0,binomial(d+2,2)-sum binomial(r_i+1,2)) of
a linear system with assigned base points on P2

+---------------------------------------------------+
|i1 : d=8                                           |
|                                                   |
|o1 = 8                                             |
+---------------------------------------------------+
|i2 : L=toList(3:3)|toList(2:4)|{1}                 |
|                                                   |
|o2 = {3, 3, 3, 4, 4, 1}                            |
|                                                   |
|o2 : List                                          |
+---------------------------------------------------+
|i3 : expectedDimension(d,L)                        |
|                                                   |
|o3 = 6                                             |
+---------------------------------------------------+
|i4 : kk=ZZ/nextPrime(10^3)                         |
|                                                   |
|o4 = kk                                            |
|                                                   |
|o4 : QuotientRing                                  |
+---------------------------------------------------+
|i5 : t=symbol t                                    |
|                                                   |
|o5 = t                                             |
|                                                   |
|o5 : Symbol                                        |
+---------------------------------------------------+
|i6 : P2=kk[t_0..t_2]                               |
|                                                   |
|o6 = P2                                            |
|                                                   |
|o6 : PolynomialRing                                |
+---------------------------------------------------+
|i7 : betti(H=linearSystemOnRationalSurface(P2,d,L))|
|                                                   |
|            0 1                                    |
|o7 = total: 1 6                                    |
|         0: 1 .                                    |
|         1: . .                                    |
|         2: . .                                    |
|         3: . .                                    |
|         4: . .                                    |
|         5: . .                                    |
|         6: . .                                    |
|         7: . 6                                    |
|                                                   |
|o7 : BettiTally                                    |
+---------------------------------------------------+

Ways to use expectedDimension:
==============================

  * "expectedDimension(ZZ,List)"

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:456:0.

linearSystemOnRationalSurface -- compute a linear system on a rational surface
******************************************************************************

  * Usage:
        H=linearSystemOnRationalSurface(P2,d,L)
        H=linearSystemOnRationalSurface(points,d,L)
  * Inputs:
      * P2, a ring (Macaulay2Doc), homogeneous coordinate ring of
        P2
      * points, a list (Macaulay2Doc), a list of ideals defining
        points in P2
      * d, an integer (Macaulay2Doc), degree of the desired forms
      * L, a list (Macaulay2Doc), {r_1,...,r_s} of multiplicities
  * Outputs:
      * H, a matrix (Macaulay2Doc), a 1xn matrix whose entries
        are a bases of L(d;r_1p_1,...,r_sp_s)

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

The function chooses randomly s point p_i in P2 and computes the linear system
of form of degree d which have multiplicity r_i at the point p_i

+---------------------------------------------------+
|i1 : kk=ZZ/nextPrime(10^3)                         |
|                                                   |
|o1 = kk                                            |
|                                                   |
|o1 : QuotientRing                                  |
+---------------------------------------------------+
|i2 : t=symbol t                                    |
|                                                   |
|o2 = t                                             |
|                                                   |
|o2 : Symbol                                        |
+---------------------------------------------------+
|i3 : P2=kk[t_0..t_2]                               |
|                                                   |
|o3 = P2                                            |
|                                                   |
|o3 : PolynomialRing                                |
+---------------------------------------------------+
|i4 : d=8                                           |
|                                                   |
|o4 = 8                                             |
+---------------------------------------------------+
|i5 : L=toList(3:3)|toList(2:4)|{1}                 |
|                                                   |
|o5 = {3, 3, 3, 4, 4, 1}                            |
|                                                   |
|o5 : List                                          |
+---------------------------------------------------+
|i6 : expectedDimension(d,L)                        |
|                                                   |
|o6 = 6                                             |
+---------------------------------------------------+
|i7 : betti(H=linearSystemOnRationalSurface(P2,d,L))|
|                                                   |
|            0 1                                    |
|o7 = total: 1 6                                    |
|         0: 1 .                                    |
|         1: . .                                    |
|         2: . .                                    |
|         3: . .                                    |
|         4: . .                                    |
|         5: . .                                    |
|         6: . .                                    |
|         7: . 6                                    |
|                                                   |
|o7 : BettiTally                                    |
+---------------------------------------------------+

Ways to use linearSystemOnRationalSurface:
==========================================

  * "linearSystemOnRationalSurface(List,ZZ,List)"
  * "linearSystemOnRationalSurface(Ring,ZZ,List)"

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:424:0.

parametrization -- compute a rational parametrization
*****************************************************

  * Usage:
        H=parametrization(PJ,adjList)
  * Inputs:
      * PJ, a ring (Macaulay2Doc), coordinate ring of the last
        adjoint surface
      * adjList, a list (Macaulay2Doc), list of adjoint matrices
  * Outputs:
      * H, a matrix (Macaulay2Doc), parametrization of the
        rational surface X

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

Let adjList be the list of adjoint matrices coming out of the adjunction
process of a rational surface X. If the final surface is a P2 then the function
computes the rational parametrization of X. In other cases the function returns
rational parametrization from the final surface X'' in the adjunction process.

+--------------------------------------------------------+
|i1 : d=4                                                |
|                                                        |
|o1 = 4                                                  |
+--------------------------------------------------------+
|i2 : L=toList(7:1)                                      |
|                                                        |
|o2 = {1, 1, 1, 1, 1, 1, 1}                              |
|                                                        |
|o2 : List                                               |
+--------------------------------------------------------+
|i3 : n=expectedDimension(d,L)-1                         |
|                                                        |
|o3 = 7                                                  |
+--------------------------------------------------------+
|i4 : kk=ZZ/nextPrime(10^3)                              |
|                                                        |
|o4 = kk                                                 |
|                                                        |
|o4 : QuotientRing                                       |
+--------------------------------------------------------+
|i5 : t=symbol t, x= symbol x                            |
|                                                        |
|o5 = (t, x)                                             |
|                                                        |
|o5 : Sequence                                           |
+--------------------------------------------------------+
|i6 : P2=kk[t_0..t_2]                                    |
|                                                        |
|o6 = P2                                                 |
|                                                        |
|o6 : PolynomialRing                                     |
+--------------------------------------------------------+
|i7 : Pn=kk[x_0..x_n]                                    |
|                                                        |
|o7 = Pn                                                 |
|                                                        |
|o7 : PolynomialRing                                     |
+--------------------------------------------------------+
|i8 : betti(I=rationalSurface(P2,d,L,Pn))                |
|                                                        |
|            0  1                                        |
|o8 = total: 1 12                                        |
|         0: 1  .                                        |
|         1: . 12                                        |
|                                                        |
|o8 : BettiTally                                         |
+--------------------------------------------------------+
|i9 : minimalBetti I                                     |
|                                                        |
|            0  1  2  3  4 5                             |
|o9 = total: 1 12 25 21 10 3                             |
|         0: 1  .  .  .  . .                             |
|         1: . 12 25 15  . .                             |
|         2: .  .  .  6 10 3                             |
|                                                        |
|o9 : BettiTally                                         |
+--------------------------------------------------------+
|i10 : (numList,adjList,ptsList,J)=adjunctionProcess(I); |
+--------------------------------------------------------+
|i11 : numList                                           |
|                                                        |
|o11 = {(7, 9, 3), 7, (2, 1, 0)}                         |
|                                                        |
|o11 : List                                              |
+--------------------------------------------------------+
|i12 : P2=ring J                                         |
|                                                        |
|o12 = P2                                                |
|                                                        |
|o12 : PolynomialRing                                    |
+--------------------------------------------------------+
|i13 : betti(H=parametrization(P2,adjList))              |
|                                                        |
|             0 1                                        |
|o13 = total: 1 8                                        |
|          0: 1 .                                        |
|          1: . .                                        |
|          2: . .                                        |
|          3: . 8                                        |
|                                                        |
|o13 : BettiTally                                        |
+--------------------------------------------------------+
|i14 : elapsedTime sub(I,H)                              |
| -- .0278661s elapsed                                   |
|                                                        |
|o14 = ideal (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)        |
|                                                        |
|o14 : Ideal of P2                                       |
+--------------------------------------------------------+
|i15 : phi=map(P2,Pn,H);                                 |
|                                                        |
|o15 : RingMap P2 <-- Pn                                 |
+--------------------------------------------------------+
|i16 : elapsedTime betti(I'=trim ker phi)                |
| -- .145194s elapsed                                    |
|                                                        |
|             0  1                                       |
|o16 = total: 1 12                                       |
|          0: 1  .                                       |
|          1: . 12                                       |
|                                                        |
|o16 : BettiTally                                        |
+--------------------------------------------------------+
|i17 : I'== I                                            |
|                                                        |
|o17 = true                                              |
+--------------------------------------------------------+
|i18 : elapsedTime basePts=primaryDecomposition ideal H; |
| -- 2.52539s elapsed                                    |
+--------------------------------------------------------+
|i19 : tally apply(basePts,c->(dim c, degree c, betti c))|
|                                                        |
|                           0  1                         |
|o19 = Tally{(0, 34, total: 1 15) => 1}                  |
|                        0: 1  .                         |
|                        1: .  .                         |
|                        2: .  .                         |
|                        3: .  8                         |
|                        4: .  .                         |
|                        5: .  7                         |
|                          0 1                           |
|            (1, 1, total: 1 2) => 7                     |
|                       0: 1 2                           |
|                                                        |
|o19 : Tally                                             |
+--------------------------------------------------------+

Ways to use parametrization:
============================

  * "parametrization(Ring,List)"

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:725:0.

rationalSurface -- compute the ideal I of the rational surface
**************************************************************

  * Usage:
        I=rationalSurface(P2,d,L,Pn)
        I=rationalSurface(P2,d,L,x)
        I=rationalSurface(points,d,L,x)
  * Inputs:
      * P2, a ring (Macaulay2Doc), homogeneous coordinate ring of
        P2,
      * points, a list (Macaulay2Doc), list of ideals of points in
        P2
      * d, an integer (Macaulay2Doc), degree of the desired forms
      * L, a list (Macaulay2Doc), {r_1,...,r_s} of multiplicities
      * Pn, a ring (Macaulay2Doc), coordinate ring of Pn
      * x, a symbol (Macaulay2Doc), variable name
  * Outputs:
      * I, an ideal (Macaulay2Doc), of a rational surface

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

The function chooses randomly s point p_i in P2 and computes the linear system
H=L(d;L) of form of degree d which have multiplicity r_i at the point p_i.

Then the ideal of the image of P2 of under the rational map defined by the
linear system H is computed.

+-------------------------------------------------------+
|i1 : d=6                                               |
|                                                       |
|o1 = 6                                                 |
+-------------------------------------------------------+
|i2 : L=toList(6:2)|toList(2:1)                         |
|                                                       |
|o2 = {2, 2, 2, 2, 2, 2, 1, 1}                          |
|                                                       |
|o2 : List                                              |
+-------------------------------------------------------+
|i3 : n=expectedDimension(d,L)-1                        |
|                                                       |
|o3 = 7                                                 |
+-------------------------------------------------------+
|i4 : kk=ZZ/nextPrime(10^3)                             |
|                                                       |
|o4 = kk                                                |
|                                                       |
|o4 : QuotientRing                                      |
+-------------------------------------------------------+
|i5 : t=symbol t                                        |
|                                                       |
|o5 = t                                                 |
|                                                       |
|o5 : Symbol                                            |
+-------------------------------------------------------+
|i6 : P2=kk[t_0..t_2]                                   |
|                                                       |
|o6 = P2                                                |
|                                                       |
|o6 : PolynomialRing                                    |
+-------------------------------------------------------+
|i7 : y=symbol y                                        |
|                                                       |
|o7 = y                                                 |
|                                                       |
|o7 : Symbol                                            |
+-------------------------------------------------------+
|i8 : betti(I=rationalSurface(P2,d,L,y))                |
|                                                       |
|            0  1                                       |
|o8 = total: 1 11                                       |
|         0: 1  .                                       |
|         1: . 11                                       |
|                                                       |
|o8 : BettiTally                                        |
+-------------------------------------------------------+
|i9 : x = symbol x                                      |
|                                                       |
|o9 = x                                                 |
|                                                       |
|o9 : Symbol                                            |
+-------------------------------------------------------+
|i10 : Pn=kk[x_0..x_n]                                  |
|                                                       |
|o10 = Pn                                               |
|                                                       |
|o10 : PolynomialRing                                   |
+-------------------------------------------------------+
|i11 : betti(I=rationalSurface(P2,d,L,Pn))              |
|                                                       |
|             0  1                                      |
|o11 = total: 1 11                                      |
|          0: 1  .                                      |
|          1: . 11                                      |
|                                                       |
|o11 : BettiTally                                       |
+-------------------------------------------------------+
|i12 : degree I, genus I, dim I                         |
|                                                       |
|o12 = (10, 0, 3)                                       |
|                                                       |
|o12 : Sequence                                         |
+-------------------------------------------------------+
|i13 : minimalBetti I                                   |
|                                                       |
|             0  1  2  3  4 5                           |
|o13 = total: 1 11 24 25 15 4                           |
|          0: 1  .  .  .  . .                           |
|          1: . 11 20  9  . .                           |
|          2: .  .  4 16 15 4                           |
|                                                       |
|o13 : BettiTally                                       |
+-------------------------------------------------------+
|i14 : d^2-sum(L,r->r^2)== degree I                     |
|                                                       |
|o14 = true                                             |
+-------------------------------------------------------+
|i15 : (numList,adjList,ptsList,J)=adjunctionProcess(I);|
+-------------------------------------------------------+
|i16 : numList                                          |
|                                                       |
|o16 = {(7, 10, 4), 2, (3, 3, 1)}                       |
|                                                       |
|o16 : List                                             |
+-------------------------------------------------------+
|i17 : minimalBetti J                                   |
|                                                       |
|             0 1                                       |
|o17 = total: 1 1                                       |
|          0: 1 .                                       |
|          1: . .                                       |
|          2: . 1                                       |
|                                                       |
|o17 : BettiTally                                       |
+-------------------------------------------------------+

Ways to use rationalSurface:
============================

  * "rationalSurface(List,ZZ,List,Symbol)"
  * "rationalSurface(Ring,ZZ,List,Ring)"
  * "rationalSurface(Ring,ZZ,List,Symbol)"

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:513:0.

slowAdjunctionCalculation -- compute the adjoint variety and the presentation of O(1)
*************************************************************************************

  * Usage:
        (I1,adj)=slowAdjunctionCalculation(I,D,z)
  * Inputs:
      * I, an ideal (Macaulay2Doc), of a smooth projective surface
        X
      * D, a matrix (Macaulay2Doc), the transpose of a linear
        presentation matrix of omega_X(1)
      * z, a symbol (Macaulay2Doc), variable name
  * Outputs:
      * I1, an ideal (Macaulay2Doc), of the adjoint surface in a
        Pn
      * adj, a matrix (Macaulay2Doc), the presentation matrix of
        O_X(1) as O_Pn-module

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

compute the ideal of the adjoint variety and the presentation matrix of the
line bundle O_X(1) as a module on the adjoint variety

+--------------------------------------------------------------------------+
|i1 : kk=ZZ/101                                                            |
|                                                                          |
|o1 = kk                                                                   |
|                                                                          |
|o1 : QuotientRing                                                         |
+--------------------------------------------------------------------------+
|i2 : P2=kk[x_0..x_2]                                                      |
|                                                                          |
|o2 = P2                                                                   |
|                                                                          |
|o2 : PolynomialRing                                                       |
+--------------------------------------------------------------------------+
|i3 : betti(Y=rationalSurface(P2,8,toList(4:3)|toList(4:2)|{1,1},symbol z))|
|                                                                          |
|            0 1                                                           |
|o3 = total: 1 7                                                           |
|         0: 1 .                                                           |
|         1: . 5                                                           |
|         2: . 2                                                           |
|                                                                          |
|o3 : BettiTally                                                           |
+--------------------------------------------------------------------------+
|i4 : P6=ring Y, dim P6==7                                                 |
|                                                                          |
|o4 = (P6, true)                                                           |
|                                                                          |
|o4 : Sequence                                                             |
+--------------------------------------------------------------------------+
|i5 : betti(fY=res Y)                                                      |
|                                                                          |
|            0 1  2  3 4                                                   |
|o5 = total: 1 7 17 16 5                                                   |
|         0: 1 .  .  . .                                                   |
|         1: . 5  2  . .                                                   |
|         2: . 2 15 16 5                                                   |
|                                                                          |
|o5 : BettiTally                                                           |
+--------------------------------------------------------------------------+
|i6 : betti(omegaY=coker transpose fY.dd_4**P6^{-dim P6})                  |
|                                                                          |
|            0  1                                                          |
|o6 = total: 5 16                                                          |
|         1: 5 16                                                          |
|                                                                          |
|o6 : BettiTally                                                           |
+--------------------------------------------------------------------------+
|i7 : betti(D=transpose presentation omegaY)                               |
|                                                                          |
|             0 1                                                          |
|o7 = total: 16 5                                                          |
|        -2: 16 5                                                          |
|                                                                          |
|o7 : BettiTally                                                           |
+--------------------------------------------------------------------------+
|i8 : (I,adj)=slowAdjunctionCalculation(Y,D,symbol x);                     |
+--------------------------------------------------------------------------+
|i9 : betti adj                                                            |
|                                                                          |
|            0  1                                                          |
|o9 = total: 7 16                                                          |
|         0: 7 16                                                          |
|                                                                          |
|o9 : BettiTally                                                           |
+--------------------------------------------------------------------------+
|i10 : P4=ring I, dim P4==5                                                |
|                                                                          |
|o10 = (P4, true)                                                          |
|                                                                          |
|o10 : Sequence                                                            |
+--------------------------------------------------------------------------+
|i11 : PI=P4/I                                                             |
|                                                                          |
|o11 = PI                                                                  |
|                                                                          |
|o11 : QuotientRing                                                        |
+--------------------------------------------------------------------------+
|i12 : m=adj**PI;                                                          |
|                                                                          |
|               7       16                                                 |
|o12 : Matrix PI  <-- PI                                                   |
+--------------------------------------------------------------------------+
|i13 : betti(sm=syz transpose m)                                           |
|                                                                          |
|             0 1                                                          |
|o13 = total: 7 2                                                          |
|          0: 7 .                                                          |
|          1: . 2                                                          |
|                                                                          |
|o13 : BettiTally                                                          |
+--------------------------------------------------------------------------+
|i14 : rank sm==1                                                          |
|                                                                          |
|o14 = true                                                                |
+--------------------------------------------------------------------------+
|i15 : (numList,adjList,ptsList,I)=adjunctionProcess Y;                    |
+--------------------------------------------------------------------------+
|i16 : numList, minimalBetti I                                             |
|                                                                          |
|                                          0 1 2                           |
|o16 = ({(6, 10, 5), 2, (4, 5, 2)}, total: 1 3 2)                          |
|                                       0: 1 . .                           |
|                                       1: . 1 .                           |
|                                       2: . 2 2                           |
|                                                                          |
|o16 : Sequence                                                            |
+--------------------------------------------------------------------------+

Ways to use slowAdjunctionCalculation:
======================================

  * "slowAdjunctionCalculation(Ideal,Matrix,Symbol)"

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:598:0.

specialFamiliesOfSommeseVandeVen -- produce a member of the special family
**************************************************************************

  * Usage:
        Y=specialFamiliesOfSommeseVandeVen(kk,fam)
  * Inputs:
      * kk, a ring (Macaulay2Doc), the ground field
      * fam, an integer (Macaulay2Doc), number of the family
  * Outputs:
      * Y, an ideal (Macaulay2Doc), the ideal of a surface

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

By [SVdV] four families of smooth surfaces Y behave differently in the
adjunction process: |H+K_Y| defines a morphism Y -> Y_1 which is generically
finite to 1 instead of birational. These families are

1) P2(6;2p_1,...,2p_7)

2) P2(6;2p_1,...,2p_7,p_8)

3) P2(9;3p_1,...,3p_8)

4) Y=P(E) where E is a indecomposabe rank 2 vector bundle over an elliptic
curve and H=3B, where B in Y is the section with B^2=1.

+-------------------------------------------------------+
|i1 : kk=ZZ/nextPrime(10^3)                             |
|                                                       |
|o1 = kk                                                |
|                                                       |
|o1 : QuotientRing                                      |
+-------------------------------------------------------+
|i2 : Y=specialFamiliesOfSommeseVandeVen(kk,1);         |
|                                                       |
|o2 : Ideal of kk[x ..x ]                               |
|                  0   6                                |
+-------------------------------------------------------+
|i3 : betti(fY= res Y)                                  |
|                                                       |
|            0 1  2  3 4                                |
|o3 = total: 1 7 14 11 3                                |
|         0: 1 .  .  . .                                |
|         1: . 7  8  3 .                                |
|         2: . .  6  8 3                                |
|                                                       |
|o3 : BettiTally                                        |
+-------------------------------------------------------+
|i4 : betti (fib=trim(ideal(fY.dd_4*random(kk^3,kk^1))))|
|                                                       |
|            0 1                                        |
|o4 = total: 1 6                                        |
|         0: 1 5                                        |
|         1: . 1                                        |
|                                                       |
|o4 : BettiTally                                        |
+-------------------------------------------------------+
|i5 : dim fib, degree fib                               |
|                                                       |
|o5 = (1, 2)                                            |
|                                                       |
|o5 : Sequence                                          |
+-------------------------------------------------------+
|i6 : ll=adjunctionProcess Y;                           |
+-------------------------------------------------------+
|i7 : ll_0,ll_1,ll_2, minimalBetti ll_3                 |
|                                                       |
|                                  0 1  2  3 4          |
|o7 = ({(6, 8, 3)}, {}, {}, total: 1 7 14 11 3)         |
|                               0: 1 .  .  . .          |
|                               1: . 7  8  3 .          |
|                               2: . .  6  8 3          |
|                                                       |
|o7 : Sequence                                          |
+-------------------------------------------------------+

The adjunction map |H+K_Y|: Y -> P2 is 2:1 in case of family 1.

+--------------------------------------------------------+
|i8 : Y=specialFamiliesOfSommeseVandeVen(kk,2);          |
|                                                        |
|o8 : Ideal of kk[x ..x ]                                |
|                  0   5                                 |
+--------------------------------------------------------+
|i9 : betti(fY= res Y)                                   |
|                                                        |
|            0 1 2 3                                     |
|o9 = total: 1 6 8 3                                     |
|         0: 1 . . .                                     |
|         1: . 3 2 .                                     |
|         2: . 3 6 3                                     |
|                                                        |
|o9 : BettiTally                                         |
+--------------------------------------------------------+
|i10 : betti (fib=trim(ideal(fY.dd_3*random(kk^3,kk^1))))|
|                                                        |
|             0 1                                        |
|o10 = total: 1 5                                        |
|          0: 1 4                                        |
|          1: . 1                                        |
|                                                        |
|o10 : BettiTally                                        |
+--------------------------------------------------------+
|i11 : dim fib, degree fib                               |
|                                                        |
|o11 = (1, 2)                                            |
|                                                        |
|o11 : Sequence                                          |
+--------------------------------------------------------+

The adjunction map |H+K_Y|: Y -> P2 is 2:1 in case of family 2.

+------------------------------------------------------------+
|i12 : Y=specialFamiliesOfSommeseVandeVen(kk,3);             |
|                                                            |
|o12 : Ideal of kk[x ..x ]                                   |
|                   0   6                                    |
+------------------------------------------------------------+
|i13 : betti(fY=res Y)                                       |
|                                                            |
|             0  1  2  3 4                                   |
|o13 = total: 1 10 20 15 4                                   |
|          0: 1  .  .  . .                                   |
|          1: .  6  8  3 .                                   |
|          2: .  4 12 12 4                                   |
|                                                            |
|o13 : BettiTally                                            |
+------------------------------------------------------------+
|i14 : P6=ring Y,dim P6==7                                   |
|                                                            |
|o14 = (P6, true)                                            |
|                                                            |
|o14 : Sequence                                              |
+------------------------------------------------------------+
|i15 : (Q,adj)=slowAdjunctionCalculation(Y,fY.dd_4,symbol u);|
+------------------------------------------------------------+
|i16 : dim Q, degree Q                                       |
|                                                            |
|o16 = (3, 2)                                                |
|                                                            |
|o16 : Sequence                                              |
+------------------------------------------------------------+
|i17 : P3=ring Q; dim P3==4                                  |
|                                                            |
|o18 = true                                                  |
+------------------------------------------------------------+
|i19 : while (L=ideal random(P3^1,P3^{2:-1});                |
|          pts=decompose (L+Q);                              |
|          #pts<2) do ()                                     |
+------------------------------------------------------------+
|i20 : pt=sub(syz transpose jacobian first pts,kk)           |
|                                                            |
|o20 = | -233 |                                              |
|      | -191 |                                              |
|      | 362  |                                              |
|      | 1    |                                              |
|                                                            |
|               4       1                                    |
|o20 : Matrix kk  <-- kk                                     |
+------------------------------------------------------------+
|i21 : betti(fib= trim ideal(fY.dd_4*pt))                    |
|                                                            |
|             0 1                                            |
|o21 = total: 1 6                                            |
|          0: 1 5                                            |
|          1: . 1                                            |
|                                                            |
|o21 : BettiTally                                            |
+------------------------------------------------------------+
|i22 : dim fib, degree fib                                   |
|                                                            |
|o22 = (1, 2)                                                |
|                                                            |
|o22 : Sequence                                              |
+------------------------------------------------------------+

The adjunction map |H+K_Y|: Y -> Q is 2:1 onto a quadric in P3 in case of
family 3.

+-------------------------------------------------------------------+
|i23 : Y=specialFamiliesOfSommeseVandeVen(kk,4);                    |
|                                                                   |
|o23 : Ideal of kk[x ..x ]                                          |
|                   0   5                                           |
+-------------------------------------------------------------------+
|i24 : betti(fY=res Y)                                              |
|                                                                   |
|             0  1  2 3 4                                           |
|o24 = total: 1 11 18 9 1                                           |
|          0: 1  .  . . .                                           |
|          1: .  .  . . .                                           |
|          2: . 11 18 9 1                                           |
|                                                                   |
|o24 : BettiTally                                                   |
+-------------------------------------------------------------------+
|i25 : P5=ring Y, dim P5==6                                         |
|                                                                   |
|o25 = (P5, true)                                                   |
|                                                                   |
|o25 : Sequence                                                     |
+-------------------------------------------------------------------+
|i26 : betti(omegaY=prune Ext^2(module Y,P5^{-6}))                  |
|                                                                   |
|             0  1                                                  |
|o26 = total: 3 12                                                  |
|          1: 3  3                                                  |
|          2: .  9                                                  |
|                                                                   |
|o26 : BettiTally                                                   |
+-------------------------------------------------------------------+
|i27 : betti(fib=trim ideal (random(kk^1,kk^3)*presentation omegaY))|
|                                                                   |
|             0 1                                                   |
|o27 = total: 1 6                                                   |
|          0: 1 3                                                   |
|          1: . 3                                                   |
|                                                                   |
|o27 : BettiTally                                                   |
+-------------------------------------------------------------------+
|i28 : dim fib, degree fib                                          |
|                                                                   |
|o28 = (1, 3)                                                       |
|                                                                   |
|o28 : Sequence                                                     |
+-------------------------------------------------------------------+

The adjunction map |H+K_Y|: Y -> P2 is 3:1 in case of family 4.

Ways to use specialFamiliesOfSommeseVandeVen:
=============================================

  * "specialFamiliesOfSommeseVandeVen(Ring,ZZ)"

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

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

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

The source of this document is in AdjunctionForSurfaces.m2:805:0.