Programs based upon Double Points paper by Guardo and Van Tuyl

### Adam Van Tuyl

Department of Mathematics and Statistics
McMaster University
L8S 4L8
vantuyl@math.mcmaster.ca ## Programs for Double Points in P1 x P1

In my paper

we described an algorithm to compute the bigraded minimal free resolution of a set of double points Z in P1 x P1 when X, the support of Z, is arithmetically Cohen-Macaulay. The algorithm depends only upon a combinatorial description of X.

As promised in the paper (Section 5) this algorithm has been implemented into the computer algebra systems CoCoA and Macaulay 2. You can find the code below, plus a sample output.

Feel free to borrow and change the code.

# CoCoA code

The following code has been checked on CoCoA 4.5.

 ``` ------------------------------------------------------------ -- -- ResZ(L) -- Resolution of double points In P1 x P1 with ACM support -- -- L is a partition describing ACM support -- These calculations are purely combinatorial And Do Not depend -- upon Grobner Basis Calculations -- -- L:=[L1,L2,...,Ln] is a list with L1 >= L2 >= ... -- -- The algorithm is based upon the paper: -- "The Minimal Resolutions of Double Points In P^1 x P^1 -- with ACM support" -- by Elena Guardo And Adam Van Tuyl -- ----------------------------------------------------------- Define ResZ(L) -- Step 0: Verify For Valid Input If (Check(L) = False) Then PrintLn "Input must be a list of nonincreasing integers"; PrintLn "For example, L:=[5,4,4,2,1]"; Return(0); End; -- Values used throughout program Lambda1:=L; R:=Len(L); DegMat:=NewMat(R,Lambda1,1); For I:=1 To R Do For J:=1 To Lambda1 Do If J <= L[I] Then DegMat[I,J]:=2; End; End; End; --Step 1: Find the bigraded Betti numbers of the completion Y SY0:=[[2*R,0],[R,Lambda1],[0,2*Lambda1]]; For J:=2 To R Do If (L[J]-L[J-1] < 0) Then SY0:=Concat(SY0,[[J-1,Lambda1+L[J]],[J+R-1,L[J]]]); End; End; SY1:=[[2*R,L[R]],[R,Lambda1+L[R]]]; For J:=2 To R Do If (L[J]-L[J-1] < 0) Then SY1:=Concat(SY1,[[J-1,Lambda1+L[J-1]],[J+R-1,L[J-1]]]); End; End; --Step 2: Locate the corners BC:=[]; For I:=2 To R Do If (L[I]-L[I-1] <0) Then Append(BC,[I,L[I]+1]); End; End; SortBy(BC,Function("LexCompare")); C:=[]; For I:=1 To (Len(BC)-1) Do For J:=(I+1) To Len(BC) Do Append(C,[BC[I],BC[J]]); End; End; C:=Concat(C,BC); SortBy(C,Function("LexCompare")); -- Step 3: Compute bigraded Betti numbers SZ0:=[]; -- Degrees of the generators SZ1:=[]; -- Degrees of the first syzygies SZ2:=[]; -- Degrees of the second syzygies For L:= 1 To Len(C) Do I:=C[L]; J:=C[L]; UIJ:=Sum([DegMat[K,J] | K In 1..(I-1)]); VIJ:=Sum([DegMat[I,K] | K In 1..(J-1)]); AIJ:=Sum([DegMat[K,J] | K In I..R]); BIJ:=Sum([DegMat[I,K] | K In J..Lambda1]); Append(SZ0,[UIJ,VIJ]); Append(SZ1,[UIJ+AIJ,VIJ]); Append(SZ1,[UIJ,VIJ+BIJ]); Append(SZ2,[UIJ+AIJ,VIJ+BIJ]); DegMat:=RewriteDegMat(DegMat,I,J); End; -- Step 4: Output the bigraded Betti numbers PrintLn "--Degrees of 0th Syzygies --"; SZ0:=Concat(SZ0,SY0); SortBy(SZ0,Function("LexCompare")); PrintLn SZ0; PrintLn "--Degrees of 1st Syzygies --"; SZ1:=Concat(SZ1,SY1); SortBy(SZ1,Function("LexCompare")); PrintLn SZ1; PrintLn "--Degrees of 2nd Syzygies --"; SortBy(SZ2,Function("LexCompare")); PrintLn SZ2; End; -- ResZ ```

To use this code, you will also need to input the following scripts.

 ``` -- Check(L) - Check verifies that the input is valid ------- Define Check(L) If (Type(L) <> LIST) Then Return(False); End; C:=True; For I:=1 To Len(L)-1 Do If L[I] < L[I+1] Then C:=False; End; End; Return(C); End; -- RewriteDegMat - RewriteDegMat changes the DegMatrix at each step Define RewriteDegMat(DegMat,I,J) A:=Len(DegMat); B:=Len(DegMat); For M:=1 To A Do For N:=1 To B Do If (M >= I) And (N >= J) Then DegMat[M,N]:=0; End; End; End; Return(DegMat); End; -- RewriteDegMat -- LexCompare is a sorting function ----------------- Define LexCompare(S,T) If S > T Then Return(True); Else If (S=T) And (S > T) Then Return(True); Else Return(False); End; End; End; -- LexCompare ```

Here is a sample input and output. Our example is the same as the example in the paper.

 ```ResZ([6,5,3,1]); --Degrees of 0th Sygygies -- [[10, 0], [8, 1], [7, 3], [6, 5], [6, 2], [5, 6], [5, 4], [4, 6], [4, 6], [3, 8], [3, 7], [2, 10], [2, 9], [1, 11], [0, 12]] --Degrees of 1st Sygygies -- [[10, 1], [8, 3], [8, 2], [7, 5], [7, 4], [6, 6], [6, 6], [6, 4], [5, 7], [5, 6], [5, 6], [4, 8], [4, 8], [4, 7], [3, 10], [3, 9], [3, 9], [2, 11], [2, 11], [1, 12]] --Degrees of 2nd Sygygies -- [[8, 4], [7, 6], [6, 7], [5, 8], [4, 9], [3, 11]] ```

# Macaulay 2 Code

The following code has been checked on Macaulay 2 version 0.9.8.

 ```-- doublePts is a M2 implementation of the algorthim -- described in the paper of Guardo-Van Tuyl (2006) doublePts = l -> ( sy0 = {(2*#l,0),(#l,first l),(0,2*first l)}; sy1 = {(2*#l,last l),(#l,first l + last l)}; C0 ={}; for k from 1 to #l-1 do ( if (l_k - l_(k-1) < 0) then ( sy0 = join (sy0, {(k,first l + l_k), (k+#l,l_k)}); sy1 = join (sy1, {(k,first l + l_(k-1)),(k+#l,l_(k-1))}); C0 = join (C0, {(k+1,l_k+1)}); ); ); C0 = rsort C0; C1 ={}; for k1 from 0 to #C0-2 do( for k2 from k1+1 to #C0-1 do( C1 = join(C1, {((C0_k1)_0,(C0_k2)_1)}); ); ); C = rsort(join(C0,C1)); M = {}; for i from 0 to #l-1 do ( v = {}; for j from 0 to first l -1 do ( if j < l_i then v = join(v,{2}) else v = join(v,{1}); ); M = join(M,{v}); ); M = matrix M; sz0 = sy0; sz1 = sy1; sz2 = {}; for t from 0 to #C -1 do ( i = (C_t)_0; j = (C_t)_1; uij = sum toList apply(0..i-2, k -> M_(k,j-1)); vij = sum toList apply(0..j-2, k -> M_(i-1,k)); aij = sum toList apply((i-1)..(#l -1), k-> M_(k,j-1)); bij = sum toList apply((j-1)..(first l-1), k-> M_(i-1,k)); sz0 = join(sz0, {(uij,vij)}); sz1 = join(sz1, {(uij+aij,vij),(uij,vij+bij)}); sz2 = join(sz2, {(uij+aij,vij+bij)}); MP={}; for a from 0 to (#l-1) do ( v = {}; for b from 0 to (first l -1) do ( if ((a >= i-1) and (b >=j-1)) then v = join(v,{0}) else v= join(v,{M_(a,b)}); ); MP = join(MP,{v}); ); M = matrix MP; ); print "--Degrees of the 0th syzygies:--"; print sort sz0; print "--Degrees of the 1st syzygies--"; print sort sz1; print "--Degrees of the 2nd syzygies--"; print sort sz2; ); ```
Below, is a sample input with its output. Again, this is the example in our paper.

 ``` i2 : doublePts(6,5,3,1,1); --Degrees of the 0th syzygies:-- {(0, 12), (1, 11), (2, 9), (2, 10), (3, 7), (3, 8), (4, 6), (4, 6), (5, 4), (5, 6), (6, 2), (6, 5), (7, 3), (8, 1), (10, 0)} --Degrees of the 1st syzygies-- {(1, 12), (2, 11), (2, 11), (3, 9), (3, 9), (3, 10), (4, 7), (4, 8), (4, 8), (5, 6), (5, 6), (5, 7), (6, 4), (6, 6), (6, 6), (7, 4), (7, 5), (8, 2), (8, 3), (10, 1)} --Degrees of the 2nd syzygies-- {(3, 11), (4, 9), (5, 8), (6, 7), (7, 6), (8, 4)} ```

Last Updated: March 26, 2007
URL: http://ms.mcmaster.ca/~vantuyl/research/DoublePoints_Guardo_VanTuyl.html