OpenXM/src/k097/lib/minimal/minimal.k - diff

Return to minimal.k CVS log

Up to [local] / OpenXM / src / k097 / lib / minimal

Diff for /OpenXM/src/k097/lib/minimal/minimal.k between version 1.11 and 1.16

version 1.11, 2000/05/19 11:16:51

version 1.16, 2000/06/15 07:38:36

Line 1

/* $OpenXM: OpenXM/src/k097/lib/minimal/minimal.k,v 1.10 2000/05/07 02:10:44 takayama Exp $ */

/* $OpenXM: OpenXM/src/k097/lib/minimal/minimal.k,v 1.15 2000/06/14 07:44:05 takayama Exp $ */

#define DEBUG 1

/* #define ORDINARY 1 */

/* If you run this program on openxm version 1.1.2 (FreeBSD),

Line 6

ln -s /usr/bin/cpp /lib/cpp

#define OFFSET 0

/* #define TOTAL_STRATEGY */

#define TOTAL_STRATEGY 1

/* #define OFFSET 20*/

/* Test sequences.

Use load["minimal.k"];;

Line 132 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;

nohomog = false;

count = -1;

if (Length(Arglist) >= 2) {

if (IsInteger(opt)) count = opt;

if (IsInteger(opt)) {

count = opt;

}else if (IsString(opt)) {

if (opt == "homogenized") {

nohomog = true;

}else{

Println("Warning: unknown option");

Println(opt);

}

}else{

count = -1;

}

Line 152 def SresolutionFrameWithTower(g,opt) {

Line 164 def SresolutionFrameWithTower(g,opt) {

sm1(" (mmLarger) (matrix) switch_function ");

g = Map(g,"Shomogenize");

if (! nohomog) {

Println("Automatic homogenization.");

g = Map(g,"Shomogenize");

}else{

Println("No automatic homogenization.");

}

if (SonAutoReduce) {

sm1("[ (AutoReduce) ] system_variable /autof set ");

sm1("[ (AutoReduce) 1 ] system_variable ");

Line 192 def SresolutionFrameWithTower(g,opt) {

Line 209 def SresolutionFrameWithTower(g,opt) {

}

HelpAdd(["SresolutionFrameWithTower",

["It returs [resolution of the initial, gbTower, skelton, gbasis]",

"option: \"homogenized\" (no automatic homogenization) ",

"Example: Sweyl(\"x,y\");",

" a=SresolutionFrameWithTower([x^3,x*y,y^3-1]);"]]);

def SresolutionFrame(f,opt) {

local ans;

ans = SresolutionFrameWithTower(f);

ans = SresolutionFrameWithTower(f,opt);

return(ans[0]);

}

/* ---------------------------- */

Line 291 def Sres0FrameWithSkelton(g) {

Line 309 def Sres0FrameWithSkelton(g) {

def StotalDegree(f) {

sm1(" [(grade) f] gbext (universalNumber) dc /FunctionValue set ");

local d0;

sm1(" [(grade) f] gbext (universalNumber) dc /d0 set ");

/* Print("degree of "); Print(f); Print(" is "); Println(d0); */

return(d0);

}

/* Sord_w(x^2*Dx*Dy,[x,-1,Dx,1]); */

Line 359 def Sdegree(f,tower,level) {

Line 380 def Sdegree(f,tower,level) {

def SgenerateTable(tower) {

local height, n,i,j, ans, ans_at_each_floor;

Print("SgenerateTable: tower=");Println(tower);

sm1(" print_switch_status "); */

height = Length(tower);

ans = NewArray(height);

for (i=0; i<height; i++) {

Line 434 def SmaxOfStrategy(a) {

Line 459 def SmaxOfStrategy(a) {

}

def SlaScala(g) {

def SlaScala(g,opt) {

local rf, tower, reductionTable, skel, redundantTable, bases,

strategy, maxOfStrategy, height, level, n, i,

freeRes,place, f, reducer,pos, redundant_seq,bettiTable,freeResV,ww,

Line 443 def SlaScala(g) {

Line 468 def SlaScala(g) {

/* extern WeightOfSweyl; */

ww = WeightOfSweyl;

Print("WeightOfSweyl="); Println(WeightOfSweyl);

rf = SresolutionFrameWithTower(g);

rf = SresolutionFrameWithTower(g,opt);

Print("rf="); sm1_pmat(rf);

redundant_seq = 1; redundant_seq_ordinary = 1;

tower = rf[1];

Println("Generating reduction table which gives an order of reduction.");

Print("WeghtOfSweyl="); Println(WeightOfSweyl);

Print("tower"); Println(tower);

reductionTable = SgenerateTable(tower);

Print("reductionTable="); sm1_pmat(reductionTable);

skel = rf[2];

redundantTable = SnewArrayOfFormat(rf[1]);

redundantTable_ordinary = SnewArrayOfFormat(rf[1]);

Line 467 def SlaScala(g) {

Line 499 def SlaScala(g) {

Println([level,i]);

reductionTable_tmp[i] = -200000;

if (reductionTable[level,i] == strategy) {

Print("Processing "); Print([level,i]);

Print("Processing [level,i]= "); Print([level,i]);

Print(" Strategy = "); Println(strategy);

if (level == 0) {

if (IsNull(redundantTable[level,i])) {

Line 661 def MonomialPart(f) {

Line 693 def MonomialPart(f) {

sm1(" [(lmonom) f] gbext /FunctionValue set ");

}

/* WARNING:

When you use SwhereInTower, you have to change gbList

as below. Ofcourse, you should restrore the gbList

SsetTower(StowerOf(tower,level));

pos = SwhereInTower(syzHead,tower[level]);

def SwhereInTower(f,tower) {

local i,n,p,q;

if (f == Poly("0")) return(-1);

Line 697 def SpairAndReduction(skel,level,ii,freeRes,tower,ww)

Line 735 def SpairAndReduction(skel,level,ii,freeRes,tower,ww)

tower2 = StowerOf(tower,level-1);

SsetTower(tower2);

Println(["level=",level]);

Println(["tower2=",tower2]);

/** sm1(" show_ring "); */

gi = Stoes_vec(bases[i]);

Line 730 def SpairAndReduction(skel,level,ii,freeRes,tower,ww)

Line 770 def SpairAndReduction(skel,level,ii,freeRes,tower,ww)

sj = sj*tmp[1]+t_syz[j];

t_syz[i] = si;

t_syz[j] = sj;

SsetTower(StowerOf(tower,level));

pos = SwhereInTower(syzHead,tower[level]);

SsetTower(StowerOf(tower,level-1));

pos2 = SwhereInTower(tmp[0],tower[level-1]);

ans = [tmp[0],t_syz,pos,pos2,vdeg,vdeg_reduced];

/* pos is the place to put syzygy at level. */

Line 843 def Sbases_to_vec(bases,size) {

Line 887 def Sbases_to_vec(bases,size) {

return(newbases);

}

def Sminimal(g) {

HelpAdd(["Sminimal",

["It constructs the V-minimal free resolution by LaScala-Stillman's algorithm",

"option: \"homogenized\" (no automatic homogenization ",

"Example: Sweyl(\"x,y\",[[\"x\",-1,\"y\",-1,\"Dx\",1,\"Dy\",1]]);",

" v=[[2*x*Dx + 3*y*Dy+6, 0],",

" [3*x^2*Dy + 2*y*Dx, 0],",

" [0, x^2+y^2],",

" [0, x*y]];",

" a=Sminimal(v);",

" Sweyl(\"x,y\",[[\"x\",-1,\"y\",-1,\"Dx\",1,\"Dy\",1]]);",

" b = ReParse(a[0]); sm1_pmat(b); ",

" IsExact_h(b,[x,y]):",

"Note: a[0] is the V-minimal resolution. a[3] is the Schreyer resolution."]]);

def Sminimal(g,opt) {

local r, freeRes, redundantTable, reducer, maxLevel,

minRes, seq, maxSeq, level, betti, q, bases, dr,

betti_levelplus, newbases, i, j,qq;

betti_levelplus, newbases, i, j,qq, tminRes;

r = SlaScala(g);

if (Length(Arglist) < 2) {

opt = null;

}

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];

Line 904 def Sminimal(g) {

Line 967 def Sminimal(g) {

}

return([Stetris(minRes,redundantTable),

tminRes = Stetris(minRes,redundantTable);

return([SpruneZeroRow(tminRes), tminRes,

[ minRes, redundantTable, reducer,r[3],r[4]],r[0]]);

/* r[4] is the redundantTable_ordinary */

/* r[0] is the freeResolution */

Line 1136 def Sschreyer(g) {

Line 1200 def Sschreyer(g) {

rf = SresolutionFrameWithTower(g);

redundant_seq = 1; redundant_seq_ordinary = 1;

tower = rf[1];

Println("Generating reduction table which gives an order of reduction.");

Println("But, you are in Sschreyer...., you may not use LaScala-Stillman");

Print("WeghtOfSweyl="); Println(WeightOfSweyl);

Print("tower"); Println(tower);

reductionTable = SgenerateTable(tower);

skel = rf[2];

redundantTable = SnewArrayOfFormat(rf[1]);

Line 1315 def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,

Line 1383 def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,

tower2 = StowerOf(tower,level-1);

SsetTower(tower2);

Println(["level=",level]);

Println(["tower2=",tower2]);

/** sm1(" show_ring "); */

gi = Stoes_vec(bases[i]);

Line 1381 def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,

Line 1451 def SpairAndReduction2(skel,level,ii,freeRes,tower,ww,

}

SsetTower(StowerOf(tower,level));

pos = SwhereInTower(syzHead,tower[level]);

SsetTower(StowerOf(tower,level-1));

pos2 = SwhereInTower(tmp[0],tower[level-1]);

ans = [tmp[0],t_syz,pos,pos2,vdeg,vdeg_reduced,c2];

/* pos is the place to put syzygy at level. */

/* pos2 is the place to put a new GB at level-1. */

Println(ans);

Println(" ");

Println("--- end of SpairAndReduction2 ");

return(ans);

}

HelpAdd(["Sminimal_v",

["It constructs the V-minimal free resolution from the Schreyer resolution",

"step by step.",

"This code still contains bugs. It sometimes outputs wrong answer.",

"Example: Sweyl(\"x,y\",[[\"x\",-1,\"y\",-1,\"Dx\",1,\"Dy\",1]]);",

" v=[[2*x*Dx + 3*y*Dy+6, 0],",

" [3*x^2*Dy + 2*y*Dx, 0],",

Line 1404 HelpAdd(["Sminimal_v",

Line 1477 HelpAdd(["Sminimal_v",

" sm1_pmat(a[0]); b=a[0]; b[1]*b[0]:",

"Note: a[0] is the V-minimal resolution. a[3] is the Schreyer resolution."]]);

/* This code still contains bugs. It sometimes outputs wrong answer. */

/* See test12() in minimal-test.k. */

/* There may be remaining 1, too */

def Sminimal_v(g) {

local r, freeRes, redundantTable, reducer, maxLevel,

minRes, seq, maxSeq, level, betti, q, bases, dr,

Line 1641 def sm1_gb(f,v) {

Line 1716 def sm1_gb(f,v) {

sm1(" [f v] gb /FunctionValue set ");

}

def test5() {

local a,b,c,cc,v;

def SisComplex(a) {

a = Sannfs3_laScala2("x^3-y^2*z^2");

local n,i,j,k,b,p,q;

b = a[0];

n = Length(a);

v = [x,y,z];

for (i=0; i<n-1; i++) {

c = Skernel(b[0],v);

if (Length(a[i+1]) != 0) {

c = c[0];

b = a[i+1]*a[i];

sm1_pmat([c,b[1],v]);

p = Length(b); q = Length(b[0]);

Println("-----------------------------------");

for (j=0; j<p; j++) {

cc = sm1_res_div(c,b[1],v);

for (k=0; k<q; k++) {

sm1_pmat(sm1_gb(cc,v));

if (!IsZero(b[j,k])) {

c = Skernel(b[1],v);

Print("Is is not complex at ");

c = c[0];

Println([i,j,k]);

cc = sm1_res_div(c,b[2],v);

return(false);

sm1_pmat(sm1_gb(cc,v));

}

return(a);

}

return(true);

}

def test6() {

local a,b,c,cc,v;

def IsExact_h(c,v) {

a = Sannfs3("x^3-y^2*z^2");

local a;

b = a[0];

v = ToString_array(v);

v = [x,y,z];

a = [c,v];

c = Skernel(b[0],v);

sm1(a," isExact_h /FunctionValue set ");

c = c[0];

}

sm1_pmat([c,b[1],v]);

HelpAdd(["IsExact_h",

Println("-------ker = im for minimal ?---------------------");

["IsExact_h(complex,var): bool",

cc = sm1_res_div(c,b[1],v);

"It checks the given complex is exact or not in D<h> (homogenized Weyl algebra)",

sm1_pmat(sm1_gb(cc,v));

"cf. ReParse"

c = Skernel(b[1],v);

]]);

c = c[0];

cc = sm1_res_div(c,b[2],v);

def ReParse(a) {

sm1_pmat(sm1_gb(cc,v));

local c;

Println("------ ker=im for Schreyer ?------------------");

if (IsArray(a)) {

b = a[3];

c = Map(a,"ReParse");

c = Skernel(b[0],v);

}else{

c = c[0];

sm1(a," toString . /c set");

sm1_pmat([c,b[1],v]);

}

cc = sm1_res_div(c,b[1],v);

return(c);

sm1_pmat(sm1_gb(cc,v));

}

c = Skernel(b[1],v);

HelpAdd(["ReParse",

c = c[0];

["Reparse(obj): obj",

cc = sm1_res_div(c,b[2],v);

"It parses the given object in the current ring.",

sm1_pmat(sm1_gb(cc,v));

"Outputs from SlaScala, Sschreyer may cause a trouble in other functions,",

return(a);

"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);

}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>