SpaceCurves -- generation of space curves

Description

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

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

i1 : R = ZZ/101[x,y,z,w];

i2 : X = quadricSurface(R);

i3 : Y = cubicSurface(R);

i4 : Z = quarticSurfaceRational(R);

i5 : LD = smoothDivisors(4,X) | smoothDivisors(4,Y) | smoothDivisors(4,Z)

o5 = {{1, 3}, {2, 2}, {2, 2, 0, 0, 0, 0, 0}, {2, 1, 1, 0, 0, 0, 0}, {3, 1, 1,
     ------------------------------------------------------------------------
     1, 1, 1, 0}, {2, 0, 1, 1, 1, 1, 0, 0, 0, 0}, {3, 1, 1, 1, 1, 1, 1, 1, 0,
     ------------------------------------------------------------------------
     0}}

o5 : List

i6 : LC = apply(LD,D->curve D);

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

i7 : C = curve(5,2);

i8 : degree C, genus C, isPrime C, isSmooth C

o8 = (5, 2, true, true)

o8 : Sequence

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

i9 : G = positiveChars(8);

i10 : L = G / allACMBetti;

i11 : netList L

      +------------+------------+
      |       0 1 2|            |
o11 = |total: 1 3 2|            |
      |    0: 1 . .|            |
      |    1: . 2 1|            |
      |    2: . . .|            |
      |    3: . . .|            |
      |    4: . . .|            |
      |    5: . . .|            |
      |    6: . 1 1|            |
      +------------+------------+
      |       0 1 2|            |
      |total: 1 3 2|            |
      |    0: 1 . .|            |
      |    1: . 1 .|            |
      |    2: . 1 1|            |
      |    3: . . .|            |
      |    4: . . .|            |
      |    5: . 1 1|            |
      +------------+------------+
      |       0 1 2|       0 1 2|
      |total: 1 2 1|total: 1 3 2|
      |    0: 1 . .|    0: 1 . .|
      |    1: . 1 .|    1: . 1 .|
      |    2: . . .|    2: . . .|
      |    3: . 1 .|    3: . 1 1|
      |    4: . . 1|    4: . 1 1|
      +------------+------------+
      |       0 1 2|            |
      |total: 1 4 3|            |
      |    0: 1 . .|            |
      |    1: . . .|            |
      |    2: . 3 2|            |
      |    3: . . .|            |
      |    4: . 1 1|            |
      +------------+------------+
      |       0 1 2|       0 1 2|
      |total: 1 3 2|total: 1 4 3|
      |    0: 1 . .|    0: 1 . .|
      |    1: . . .|    1: . . .|
      |    2: . 2 .|    2: . 2 1|
      |    3: . 1 2|    3: . 2 2|
      +------------+------------+

i12 : apply(L, g 
          -> apply(g, B -> randomDeterminantalIdeal(ZZ/101[x,y,z,w], degreeMatrix B)));

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

i13 : I = monomialCurveIdeal(R,{1,3,4})

                         3      2     2    2    3    2
o13 = ideal (y*z - x*w, z  - y*w , x*z  - y w, y  - x z)

o13 : Ideal of R

i14 : M = raoModule(I)

o14 = cokernel {1} | w -z y -x |

                             1
o14 : R-module, quotient of R

i15 : J = minimalCurve M;

o15 : Ideal of R

i16 : betti res J

             0 1 2 3
o16 = total: 1 4 4 1
          0: 1 . . .
          1: . 4 4 1

o16 : BettiTally

Surfaces

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

Divisors

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

Curves

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

Minimal curves

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

ACM Curves

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