-------------------------------------------------------------------------- -- PURPOSE : Compute the ideals in "Ideals with Larger Projective -- Dimension and Regularity" by J. Beder, J. McCullough, L. Nunez-Betancourt, -- A. Seceleanu, B. Snapp and B. Stone -- -- Copyright (C) 2011 Jesse Beder, Jason McCullough, Luis Nunez-Betancourt, -- Alexandra Seceleanu, Bart Snapp and Branden Stone -- -- This program is free software; you can redistribute it and/or -- modify it under the terms of the GNU General Public License version 2 -- as published by the Free Software Foundation. -- -- This program is distributed in the hope that it will be useful, -- but WITHOUT ANY WARRANTY; without even the implied warranty of -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -- GNU General Public License for more details. -------------------------------------------------------------------------- -- -- newPackage( "BigIdeal", Version => "1.1", Date => "January 13, 2011", Authors => {{Name => "Jesse Beder"}, {Name => "Jason McCullough"}, {Name => "Luis Nunez-Betancourt"}, {Name => "Alexandra Seceleanu"}, {Name => "Bart Snapp"}, {Name => "Branden Stone"}}, Headline => "Ideals with Large Projective Dimension and Regularity", DebuggingMode => true ) export{bigIdeal, jasonIdeal, socleCheck, BaseField} -- Usage: Type "load bigIdeal.m2" to load the commands in this file. -- Then the command "bigIdeal(g,{m_1,...,m_n})" generates the ideal $I_{g,(m_1,...,m_n)}$ in the paper. -- -- input: g = number of generators -- M = list -- output: Ideal with high prjective dimension -- -- Note: if #M = 1 then us function K below -- g >= 2, #M >= 2 bigIdeal = method( Options => { BaseField => QQ } ) bigIdeal(ZZ,List) := opt -> (g,M) -> ( n := #M; if n == 1 then ( return jasonIdeal(g,1,M_0+1, BaseField=>opt.BaseField); ) else ( d := i -> sum(take(M, -(n - i)-1))+1; t := symbol t; C := ZZ[t_1..t_g]; m := last M; ind := (g,M) -> apply(apply( toList fold((i,j) -> i**j, append( apply(drop(M,-1), m -> set flatten apply(select(terms product(1..g, j -> sum(m, i -> t_j^i)), i -> first degree i == m),exponents)), set flatten apply(select(terms product(1..g, j -> sum(m+1, i -> t_j^i)), i -> first degree i == m),exponents)))/deepSplice,toList),i -> transpose matrix i); front := (g,M) ->if #M == 1 then apply(flatten apply(M, m -> flatten apply(select(terms product(1..g, j -> sum(m, i -> t_j^i)), i -> first degree i == m), exponents)),i->transpose matrix {i}) else apply(apply( toList fold((i,j) -> i**j, apply(M, m -> set flatten apply(select(terms product(1..g, j -> sum(m, i -> t_j^i)), i -> first degree i == m), exponents))) /deepSplice,toList),i -> transpose matrix i); middle := (i,g,M) -> ( A := mutableMatrix(ZZ,g,2); A_(0,0) = M_(i); A_(0,1) = d(i+2); {matrix A}|toList(apply (0..g-2, i-> matrix rowSwap(A,i,i+1))) ); matrixListPre := flatten toList apply(1..n-2, i -> flatten apply(front(g,take(M,i)),j -> flatten apply(middle(i,g,M), k -> j|k))); matrixList := apply(middle(0,g,M)|matrixListPre, i -> i | map(ZZ^g, ZZ^(n-rank source i), 0)); k := opt.BaseField; indList := ind(g,M); xvarlist := flatten for j from 1 to n list for i from 1 to g list (i,j); x := symbol x; y := symbol y; B := k[apply(xvarlist, i -> x_i), apply(indList, i -> y_i),MonomialOrder =>GRevLex]; I := ideal(apply(x_(1,1)..x_(g,1), i -> i^(d 1)),sum apply(matrixList,m-> product flatten for i to g-1 list ( for j to n-1 list x_(i+1,j+1)^(m_(i,j))))+sum apply(indList,m-> (product flatten for i to g-1 list ( for j to n-1 list x_(i+1,j+1)^(m_(i,j))))*y_m)); ); I ) -- Gives ideals defined by J. McCullough and is the special case of function bigIdeal above. -- See http://arxiv.org/abs/1005.3361 or Proc. of the AMS article "A Family of Ideals with Few Generators in Low Degree and Large Projective Dimension" -- -- input: m = number of generators minus n ( m = g ) -- n = number of times to include y's -- d = degree of the generators -- output: ideal with large progective dimension. -- jasonIdeal = method( Options => { BaseField => QQ } ) jasonIdeal(ZZ,ZZ,ZZ) := opt -> (m,n,d) -> ( x := symbol x; F := opt.BaseField; A := F[x_1..x_m]; L := flatten entries basis(d-1,A); l := length L; y := symbol y; B := F[x_1..x_m,y_(1,1)..y_(l,n)]; -- not a local variable I := ideal apply(x_1..x_m, i -> i^d) + ideal apply(1..n, k -> sum(1..l, j -> sub(L_(j-1),B)*y_(j,k))); I ) -- input: I = an ideal -- s = a ring element -- output: a boolean value representing whether or not s is a nonzero socle element of R/I. -- If so, then it follows that R/I has maximal projective dimension. socleCheck = method() socleCheck(Ideal,RingElement) := (I,s) -> ( if (s%I) == 0 then r := false; if (s%I) == 0 then return false; all(gens ring I, i -> ((i*s)%I) == 0) ); ------------------------------------------------------------------ beginDocumentation() needsPackage "SimpleDoc" debug SimpleDoc doc /// Key BigIdeal Headline Ideals with Large Projective Dimension and Regularity. Description Text The goal of this package is to provide commands to generate the ideals in "Ideals with Larger Projective Dimension and Regularity" by Beder, McCullough, Nunez, Seceleanu, Snapp and Stone. /// doc /// Key bigIdeal (bigIdeal,ZZ,List) BaseField Headline Constructs one of the family of ideals with large projective dimension and regularity. Usage bigIdeal(g,L) bigIdeal(g,{2,1,3}) Inputs g:ZZ Assumed to be at least 2. L:List List of integers {m_1,...m_n} such that m_n is nonnegative, m_{n-1} > 0 and all other m_i > 1. Outputs I:Ideal An ideal with g+1 generators in degree m_1+...+m_n+1. Description Text The ideal returned has g generators of the form x_i^d and 1 generator using the remaining variables. Note that the y variables are indexed by matrices with entries prescribed by the entries of L. The special case where L contains a single integer reverts to the ideals defined by the jasonIdeal command. Example bigIdeal(2,{3,1}) bigIdeal(2,{2,1,2}) bigIdeal(3,{2}) /// doc /// Key jasonIdeal (jasonIdeal,ZZ,ZZ,ZZ) Headline Constructs one of the family of ideals in "A Family of Ideals with Few Generators in Low Degree and Large Projective Dimension" by Jason McCullough. Usage x = jasonIdeal(m,n,d) Inputs m:ZZ Assumed to be at least 2. n:ZZ Assumed to be at least 1. d:ZZ Assumed to be at least 1. Outputs I:Ideal An ideal with m+n generators in degree d and with pd(R/I) = (m + d - 2)!/((m-1)!(d-1)!). Description Text The ideal returned has m generators of the form x_i^d and n generators each of which are a sum of the y_i variables times each of the degree-(d-1) monomials in the x_is. Example jasonIdeal(3,1,3) /// doc /// Key socleCheck (socleCheck,Ideal,RingElement) Headline Checks where a ring element is nonzero is nonzero in socle(R/I) for an ideal I. Usage socleCheck(I,s) Inputs I:Ideal s:RingElement Outputs x:Boolean True if s is in (I:m) - I. False otherwise. Description Text This function merely checks whether every variable multiplies s into I and that s is not already in I. Example R = QQ[x,y]; I = ideal(x^2,y^2); socleCheck(I,x*y); socleCheck(I,x^2); socleCheck(I,x); ///