=================================================================== RCS file: /home/cvs/OpenXM/src/k097/lib/minimal/minimal.k,v retrieving revision 1.2 retrieving revision 1.24 diff -u -p -r1.2 -r1.24 --- OpenXM/src/k097/lib/minimal/minimal.k 2000/05/03 07:50:38 1.2 +++ OpenXM/src/k097/lib/minimal/minimal.k 2000/08/02 03:23:36 1.24 @@ -1,6 +1,12 @@ -/* $OpenXM: OpenXM/src/k097/lib/minimal/minimal.k,v 1.1 2000/05/03 06:42:07 takayama Exp $ */ +/* $OpenXM: OpenXM/src/k097/lib/minimal/minimal.k,v 1.23 2000/08/01 08:51:03 takayama Exp $ */ #define DEBUG 1 -/* #define ORDINARY 1 */ +Sordinary = false; +/* If you run this program on openxm version 1.1.2 (FreeBSD), + make a symbolic link by the command + ln -s /usr/bin/cpp /lib/cpp +*/ +#define OFFSET 0 +/* #define OFFSET 20*/ /* Test sequences. Use load["minimal.k"];; @@ -28,8 +34,10 @@ def load_tower() { if (Boundp("k0-tower.sm1.loaded")) { }else{ sm1(" [(parse) (k0-tower.sm1) pushfile ] extension "); + sm1(" [(parse) (new.sm1) pushfile ] extension "); sm1(" /k0-tower.sm1.loaded 1 def "); } + sm1(" oxNoX "); } load_tower(); SonAutoReduce = true; @@ -42,6 +50,86 @@ def Reverse(f) { def Sgroebner(f) { sm1(" [f] groebner /FunctionValue set"); } + +def Sinvolutive(f,w) { + local g,m; + if (IsArray(f[0])) { + m = NewArray(Length(f[0])); + }else{ + m = [0]; + } + g = Sgroebner(f); + /* This is a temporary code. */ + sm1(" g 0 get { w m init_w} map /FunctionValue set "); +} + + + +def Error(s) { + sm1(" s error "); +} + +def IsNull(s) { + if (Stag(s) == 0) return(true); + else return(false); +} + +def MonomialPart(f) { + sm1(" [(lmonom) f] gbext /FunctionValue set "); +} + +def Warning(s) { + Print("Warning: "); + Println(s); +} +def RingOf(f) { + local r; + if (IsPolynomial(f)) { + if (f != Poly("0")) { + sm1(f," (ring) dc /r set "); + }else{ + sm1(" [(CurrentRingp)] system_variable /r set "); + } + }else{ + Warning("RingOf(f): the argument f must be a polynomial. Return the current ring."); + sm1(" [(CurrentRingp)] system_variable /r set "); + } + return(r); +} + +def Ord_w_m(f,w,m) { + sm1(" f w m ord_w { (universalNumber) dc } map /FunctionValue set "); +} +HelpAdd(["Ord_w_m", +["Ord_w_m(f,w,m) returns the order of f with respect to w with the shift m.", + "Note that the order of the ring and the weight w must be the same.", + "When f is zero, it returns -intInfinity = -999999999.", + "Example: Sweyl(\"x,y\",[[\"x\",-1,\"Dx\",1]]); ", + " Ord_w_m([x*Dx+1,Dx^2+x^5],[\"x\",-1,\"Dx\",1],[2,0]):"]]); + +def Init_w_m(f,w,m) { + sm1(" f w m init_w /FunctionValue set "); +} +HelpAdd(["Init_w_m", +["Init_w_m(f,w,m) returns the initial of f with respect to w with the shift m.", + "Note that the order of the ring and the weight w must be the same.", + "Example: Sweyl(\"x,y\",[[\"x\",-1,\"Dx\",1]]); ", + " Init_w_m([x*Dx+1,Dx^2+x^5],[\"x\",-1,\"Dx\",1],[2,0]):"]]); + +def Max(v) { + local i,t,n; + n = Length(v); + if (n == 0) return(null); + t = v[0]; + for (i=0; i t) { t = v[i];} + } + return(t); +} +HelpAdd(["Max", +["Max(v) returns the maximal element in v."]]); + +/* End of standard functions that should be moved to standard libraries. */ def test0() { local f; Sweyl("x,y,z"); @@ -124,15 +212,39 @@ sm1(" [(AvoidTheSameRing)] pushEnv [ [(AvoidTheSameRing) 0] system_variable [(gbListTower) tower (list) dc] system_variable ] pop popEnv "); + /* sm1("(hoge) message show_ring "); */ } def SresolutionFrameWithTower(g,opt) { local gbTower, ans, ff, count, startingGB, opts, skelton,withSkel, autof, - gbasis; + gbasis, nohomog,i,n; + /* extern Sordinary */ + nohomog = false; + count = -1; Sordinary = false; /* default value for options. */ if (Length(Arglist) >= 2) { - if (IsInteger(opt)) count = opt; - }else{ - count = -1; + if (IsArray(opt)) { + n = Length(opt); + for (i=0; i SresolutionFrameWithTower */ + + ScheckIfSchreyer("Sminimal:0"); + r = SlaScala(g,opt); /* Should I turn off the tower?? */ + ScheckIfSchreyer("Sminimal:1"); freeRes = r[0]; redundantTable = r[1]; reducer = r[2]; + bettiTable = SbettiTable(redundantTable); + Println("Betti numbers are ------"); + sm1_pmat(bettiTable); minRes = SnewArrayOfFormat(freeRes); seq = 0; maxSeq = SgetMaxSeq(redundantTable); @@ -822,9 +1033,24 @@ def Sminimal(g) { } } } - return([Stetris(minRes,redundantTable), - [ minRes, redundantTable, reducer,r[3],r[4]]]); + tminRes = Stetris(minRes,redundantTable); + ansSminimal = [SpruneZeroRow(tminRes), tminRes, + [ minRes, redundantTable, reducer,r[3],r[4]],r[0],r[5]]; + Println("------------ Note -----------------------------"); + Println("To get shift vectors, use Reparse and SgetShifts(resmat,w)"); + Println("To get initial of the complex, use Reparse and Sinit_w(resmat,w)"); + Println("0: minimal resolution, 3: Schreyer resolution "); + Println("------------ Resolution Summary --------------"); + Print("Betti numbers : "); + Println(Map(ansSminimal[0],"Length")); + Print("Betti numbers of the Schreyer frame: "); + Println(Map(ansSminimal[3],"Length")); + Println("-----------------------------------------------"); + + return(ansSminimal); /* r[4] is the redundantTable_ordinary */ + /* r[0] is the freeResolution */ + /* r[5] is the skelton */ } @@ -933,6 +1159,7 @@ In(20)=SvDegree(x,tt,2,ww): def SvDegree(f,tower,level,w) { local i,ans; if (IsZero(f)) return(null); + f = Init(f); if (level <= 0) { return(Sord_w(f,w)); } @@ -955,16 +1182,353 @@ def Sannfs(f,v) { def Sannfs2(f) { local p,pp; p = Sannfs(f,"x,y"); - Sweyl("x,y",[["x",-1,"y",-1,"Dx",1,"Dy",1]]); - pp = Map(p[0],"Spoly"); - return(Sminimal(pp)); + sm1(" p 0 get { [(x) (y) (Dx) (Dy)] laplace0 } map /p set "); + Sweyl("x,y",[["x",-1,"y",-1,"Dx",1,"Dy",1]]); + pp = Map(p,"Spoly"); + return(Sminimal(pp)); } -/* +HelpAdd(["Sannfs2", +["Sannfs2(f) constructs the V-minimal free resolution for the weight (-1,1)", + "of the Laplace transform of the annihilating ideal of the polynomial f in x,y.", + "See also Sminimal, Sannfs3.", + "Example: a=Sannfs2(\"x^3-y^2\");", + " b=a[0]; sm1_pmat(b);", + " b[1]*b[0]:", + "Example: a=Sannfs2(\"x*y*(x-y)*(x+y)\");", + " b=a[0]; sm1_pmat(b);", + " b[1]*b[0]:" +]]); +/* Some samples. The betti numbers of most examples are 2,1. (0-th and 1-th). a=Sannfs2("x*y*(x+y-1)"); ==> The betti numbers are 3, 2. - a=Sannfs2("x^3-y^2-x"); : it causes an error. It should be fixed. - + a=Sannfs2("x^3-y^2-x"); + a=Sannfs2("x*y*(x-y)"); */ + + +def Sannfs3(f) { + local p,pp; + p = Sannfs(f,"x,y,z"); + sm1(" p 0 get { [(x) (y) (z) (Dx) (Dy) (Dz)] laplace0 } map /p set "); + Sweyl("x,y,z",[["x",-1,"y",-1,"z",-1,"Dx",1,"Dy",1,"Dz",1]]); + pp = Map(p,"Spoly"); + return(Sminimal(pp)); +} + +HelpAdd(["Sannfs3", +["Sannfs3(f) constructs the V-minimal free resolution for the weight (-1,1)", + "of the Laplace transform of the annihilating ideal of the polynomial f in x,y,z.", + "See also Sminimal, Sannfs2.", + "Example: a=Sannfs3(\"x^3-y^2*z^2\");", + " b=a[0]; sm1_pmat(b);", + " b[1]*b[0]: b[2]*b[1]:"]]); + - + +/* Sannfs2("x*y*(x-y)*(x+y)"); is a test problem */ +/* x y (x+y-1)(x-2), x^3-y^2, x^3 - y^2 z^2, + x y z (x+y+z-1) seems to be interesting, because the first syzygy + contains 1. +*/ + +def CopyArray(m) { + local ans,i,n; + if (IsArray(m)) { + n = Length(m); + ans = NewArray(n); + for (i=0; i (homogenized Weyl algebra)", + "cf. ReParse" +]]); + +def IsSameIdeal_h(ii,jj,v) { + local a; + v = ToString_array(v); + a = [ii,jj,v]; + sm1(a," isSameIdeal_h /FunctionValue set "); +} +HelpAdd(["IsSameIdeal_h", +["IsSameIdeal_h(ii,jj,var): bool", + "It checks the given ideals are the same or not in D (homogenized Weyl algebra)", + "cf. ReParse" +]]); + +def ReParse(a) { + local c; + if (IsArray(a)) { + c = Map(a,"ReParse"); + }else{ + sm1(a," toString . /c set"); + } + return(c); +} +HelpAdd(["ReParse", +["Reparse(obj): obj", + "It parses the given object in the current ring.", + "Outputs from SlaScala, Sschreyer may cause a trouble in other functions,", + "because it uses the Schreyer order.", + "In this case, ReParse the outputs from these functions.", + "cf. IsExaxt_h" +]]); + +def ScheckIfSchreyer(s) { + local ss; + sm1(" (report) (grade) switch_function /ss set "); + if (ss != "module1v") { + Print("ScheckIfSchreyer: from "); Println(s); + Error("grade is not module1v"); + } + /* + sm1(" (report) (mmLarger) switch_function /ss set "); + if (ss != "tower") { + Print("ScheckIfSchreyer: from "); Println(s); + Error("mmLarger is not tower"); + } + */ + sm1(" [(Schreyer)] system_variable (universalNumber) dc /ss set "); + if (ss != 1) { + Print("ScheckIfSchreyer: from "); Println(s); + Error("Schreyer order is not set."); + } + /* More check will be necessary. */ + return(true); +} + +def SgetShift(mat,w,m) { + local omat; + sm1(" mat { w m ord_w {(universalNumber) dc}map } map /omat set"); + return(Map(omat,"Max")); +} +HelpAdd(["SgetShift", +["SgetShift(mat,w,m) returns the shift vector of mat with respect to w with the shift m.", + "Note that the order of the ring and the weight w must be the same.", + "Example: Sweyl(\"x,y\",[[\"x\",-1,\"Dx\",1]]); ", + " SgetShift([[x*Dx+1,Dx^2+x^5],[Poly(\"0\"),x],[x,x]],[\"x\",-1,\"Dx\",1],[2,0]):"]]); + +def SgetShifts(resmat,w) { + local i,n,ans,m0; + n = Length(resmat); + ans = NewArray(n); + m0 = NewArray(Length(resmat[0,0])); + ans[0] = m0; + for (i=0; i