OpenXM/src/asir-contrib/testing/noro/new_pd.rr - diff

Return to new_pd.rr CVS log

Up to [local] / OpenXM / src / asir-contrib / testing / noro

Diff for /OpenXM/src/asir-contrib/testing/noro/Attic/new_pd.rr between version 1.3 and 1.10

version 1.3, 2011/01/19 04:52:03

version 1.10, 2014/09/19 00:48:50

Line 1

/* $OpenXM$ */

/* $OpenXM: OpenXM/src/asir-contrib/testing/noro/new_pd.rr,v 1.9 2014/09/05 11:55:19 ohara Exp $ */

import("gr")$

module noro_pd$

static GBCheck,F4,EProcs,Procs,SatHomo,GBRat$

static GBCheck,F4,EProcs,Procs,SatHomo,GBRat,SuccSat,RepColon$

localf get_lc,tomonic$

localf radical_membership_sat$

localf para_exec,nd_gr_rat,competitive_exec,call_func$

localf witness$

localf get_lc,tomonic,aa,ideal_intersection_m,redbase$

localf para_exec,nd_gr_rat,competitive_exec,call_func,call_func_serial$

localf call_ideal_list_intersection$

localf call_colon,call_prime_dec$

localf prime_dec2, prime_dec_main2$

localf first_second$

localf third$

localf locsat,iso_comp_para,extract_qj,colon_prime_dec,extract_comp$

localf separator$

localf member,mingen,compute_gbsyz,redcoef,recompute_trace3,dtop,topnum$

localf member,mingen,compute_gbsyz,redcoef,recompute_trace,dtop,topnum$

localf ideal_colon1$

localf prepost$

localf monodec0,monodec,prod$

localf extract_qd,primary_check$

localf second$

localf gbrat,comp_third_tdeg,comp_tord$

localf gbrat,succsat,repcolon,comp_third_tdeg,comp_tord$

localf power$

localf syci_dec, syc_dec$

Line 35 localf complete_qdecomp, partial_qdecomp, partial_qdec

Line 37 localf complete_qdecomp, partial_qdecomp, partial_qdec

localf partial_decomp, partial_decomp0, zprimacomp, zprimecomp$

localf fast_gb, incremental_gb, elim_gb, ldim, make_mod_subst$

localf rsgn, find_npos, gen_minipoly, indepset$

localf maxindep, contraction, ideal_list_intersection, ideal_intersection$

localf maxindep, maxindep2, contraction, contraction_m, ideal_list_intersection, ideal_intersection$

localf radical_membership, modular_radical_membership$

localf radical_membership_rep, ideal_product, saturation$

localf sat, satind, sat_ind, colon$

localf sat, satind, sat_ind, colon, isat$

localf ideal_colon, ideal_sat, ideal_inclusion, qd_simp_comp, qd_remove_redundant_comp$

localf pd_simp_comp$

localf pd_simp_comp, remove_identical_comp$

localf pd_remove_redundant_comp, ppart, sq, gen_fctr, gen_nf, gen_gb_comp$

localf gen_mptop, lcfactor, compute_deg0, compute_deg, member$

localf elimination, setintersection, setminus, sep_list$

Line 50 localf gbcheck,f4,sathomo,qd_check,qdb_check$

Line 52 localf gbcheck,f4,sathomo,qd_check,qdb_check$

SatHomo=0$

GBCheck=1$

GBRat=0$

SuccSat=0$

RepColon=0$

#define MAX(a,b) ((a)>(b)?(a):(b))

#define ACCUM_TIME(C,R) {T1 = time(); C += (T1[0]-T0[0])+(T1[1]-T0[1]); R += (T1[3]-T0[3]); }

def gbrat(A)

{

if ( A ) GBRat = 1;

GBRat = A;

else GBRat = 0;

}

def succsat(A)

{

SuccSat = A;

}

def repcolon(A)

{

RepColon = A;

}

def gbcheck(A)

{

if ( A ) GBCheck = 1;

Line 165 def qdb_check(B,V,QD)

Line 178 def qdb_check(B,V,QD)

for ( I = 0, Q = [1]; I < N; I++ )

for ( J = 0, QL = map(first,QD[I]), L = length(QL);

J < L; J++ )

Q = ideal_intersection(Q,QL[J],V,0|mod=Mod);

Q = ideal_intersection_m(Q,QL[J],V,0|mod=Mod);

Q = nd_gr(Q,V,0,0);

if ( !gen_gb_comp(G,Q,Mod) )

return 0;

for ( I = 0; I < N; I++ ) {

Line 197 def extract_qd(QD,V,Ind)

Line 211 def extract_qd(QD,V,Ind)

def syc_dec(B,V)

{

if ( type(SI=getopt(si)) == -1 ) SI = 2;

SIFList=[find_ssi0, find_ssi1,find_ssi2];

SIFList=[noro_pd.find_ssi0, noro_pd.find_ssi1, noro_pd.find_ssi2];

if ( SI<0 || SI>2 ) error("sycb_dec : si should be 0,1,2");

SIF = SIFList[SI];

Line 273 def syci_dec(B,V)

Line 287 def syci_dec(B,V)

if ( type(Ass=getopt(ass)) == -1 ) Ass = 0;

if ( type(Colon=getopt(colon)) == -1 ) Colon = 0;

if ( type(Para=getopt(para)) == -1 ) Para = 0;

if ( type(Trace=getopt(trace)) == -1 ) Trace = 0;

Ord = 0;

Tiso = Tint = Tpd = Text = Tint2 = 0;

RTiso = RTint = RTpd = RText = RTint2 = 0;

T00 = time();

G = fast_gb(B,V,Mod,Ord|trace=1);

G = fast_gb(B,V,Mod,Ord|trace=Trace);

IntQ = [1]; QL = RL = []; First = 1;

for ( Level = 0; ; Level++ ) {

T0 = time();

if ( First ) {

if ( !Level ) {

PtR = prime_dec(G,V|indep=1,lexdec=Lexdec,mod=Mod,radical=1);

ACCUM_TIME(Tfpd,RTfpd)

Pt = PtR[0]; IntPt = PtR[1]; Rad = IntPt;

if ( gen_gb_comp(G,Rad,Mod) ) {

/* Gt is radical and Gt = cap Pt */

Line 295 T0 = time();

Line 311 T0 = time();

ACCUM_TIME(Tpd,RTpd)

T0 = time();

Rt = iso_comp(G,Pt,V,Ord|mod=Mod,iso=Iso,para=Para,intq=IntQ);

RL = append(RL,[Rt]);

ACCUM_TIME(Tiso,RTiso)

if ( !Level ) {

if ( Iso == 3 ) {

NI = length(Rt);

Q = IntQ;

T0 = time();

IntQ = ideal_list_intersection(map(first,Rt),V,Ord|mod=Mod,para=Para);

if ( Para ) {

QL = append(QL,[IntQ]);

for ( J = 0, Task = []; J < NI; J++ ) {

T = ["noro_pd.extract_qj",Q,V,Rt[J],Rad,Mod,SI,Colon,-1];

Task = cons(T,Task);

}

Task = reverse(Task);

print("comps:",2); print(length(Task),2);

Rt = para_exec(Para,Task);

} else {

for ( J = 0, T = []; J < NI; J++ ) {

TJ = extract_qj(Q,V,Rt[J],Rad,Mod,SI,Colon,-1);

T = cons(TJ,T);

}

Rt = reverse(T);

}

ACCUM_TIME(Text,RText)

}

print("");

T0 = time();

Int = Rad;

for ( T = Rt; T != []; T = cdr(T) )

if ( !gb_comp(car(T)[0],car(T)[1]) )

Int = ideal_intersection_m(Int,car(T)[0],V,Ord|mod=Mod);

IntQ = nd_gr(Int,V,Mod,Ord);

ACCUM_TIME(Tint,RTint)

RL = append(RL,[Rt]);

} else if ( Iso != 3 ) {

T0 = time();

IntQ = ideal_list_intersection(map(first,Rt),V,Ord|mod=Mod,isgb=1);

RL = append(RL,[Rt]);

ACCUM_TIME(Tint,RTint)

} else {

NI = length(Rt);

Q = IntQ;

if ( Para ) {

for ( J = 0, Task = []; J < NI; J++ ) {

T = ["noro_pd.extract_qj",Q,V,Rt[J],Rad,Mod,SI,Colon,-1];

Task = cons(T,Task);

}

Task = reverse(Task);

print("comps:",2); print(length(Task),2);

T0 = time();

R = para_exec(Para,Task);

ACCUM_TIME(Text,RText)

print("");

T0 = time();

IntQ = ideal_list_intersection(cons(IntQ,map(first,R)),V,Ord|mod=Mod);

ACCUM_TIME(Tint,RTint)

RL = append(RL,[R]);

} else {

for ( J = 0, T = []; J < NI; J++ ) {

T0 = time();

TJ = extract_qj(Q,V,Rt[J],Rad,Mod,SI,Colon,-1);

ACCUM_TIME(Text,RText)

T = cons(TJ,T);

T0 = time();

IntQ = ideal_intersection_m(IntQ,TJ[0],V,Ord|mod=Mod);

ACCUM_TIME(Tint,RTint)

}

print("");

T0 = time();

IntQ = nd_gr(IntQ,V,Mod,Ord);

ACCUM_TIME(Tint,RTint)

T = reverse(T); RL = append(RL,[T]);

}

QL = append(QL,[IntQ]);

if ( gen_gb_comp(IntQ,G,Mod) ) break;

First = 0;

}

T0 = time();

if ( !Ass )

if ( Iso != 3 && !Ass )

RL = extract_comp(QL,RL,V,Rad|mod=Mod,para=Para,si=SI,colon=Colon,ass=Ass);

ACCUM_TIME(Text,RText)

if ( Time ) {

T1 = time();

Tall = T1[0]-T00[0]+T1[1]-T00[1]; RTall += T1[3]-T00[3];

Tass = Tall-Text; RTass = RTall-RText;

print(["total",Tall,"ass",Tass,"pd",Tpd,"iso",Tiso,"int",Tint,"ext",Text]);

print(["total",Tall,"ass",Tass,"pd",Tpd,"(fpd)",Tfpd,"iso",Tiso,"int",Tint,"ext",Text]);

print(["elapsed",RTall,"ass",RTass,"pd",RTpd,"iso",RTiso,"int",RTint,"ext",RText]);

print(["elapsed",RTall,"ass",RTass,"pd",RTpd,"(fpd)",RTfpd,"iso",RTiso,"int",RTint,"ext",RText]);

}

return RL;

}

Line 334 def extract_comp(QL,RL,V,Rad) {

Line 416 def extract_comp(QL,RL,V,Rad) {

Task = cons(T,Task);

}

Task = reverse(Task);

print("comps:",2); print(length(Task),2); print("");

R = para_exec(Para,Task);

S = vector(L);

Line 397 def colon_prime_dec(G,IntQ,V) {

Line 480 def colon_prime_dec(G,IntQ,V) {

print("->",2); print(length(M),2);

R = pd_simp_comp(R,V|mod=Mod);

print("->",2); print(length(R));

#if 1

for ( Pt = [], T = R; T != []; T = cdr(T) ) {

Pi = prime_dec(car(T),V|indep=1,lexdec=Lexdec,mod=Mod);

Pt = append(Pt,Pi);

}

#else

J = ideal_list_intersection(R,V,0|mod=Mod);

Pt = prime_dec(J,V|indep=1,lexdec=Lexdec,mod=Mod);

#endif

}

#if 1

Pt = pd_simp_comp(Pt,V|first=1,mod=Mod);

#endif

return Pt;

}

Line 422 def call_prime_dec(G,V,Indep,Lexdec,Mod)

Line 512 def call_prime_dec(G,V,Indep,Lexdec,Mod)

def extract_qj(Q,V,QL,Rad,Mod,SI,Colon,Level)

{

SIFList=[find_ssi0, find_ssi1,find_ssi2];

SIFList=[noro_pd.find_ssi0, noro_pd.find_ssi1, noro_pd.find_ssi2];

SIF = SIFList[SI];

G = QL[0]; P = QL[1]; PV = QL[2];

C = Colon ? ideal_colon(G,Q,V|mod=Mod) : P;

if ( Q != [1] ) {

Ok = (*SIF)(C,G,Q,Rad,V,0|mod=Mod);

C = Colon ? ideal_colon(G,Q,V|mod=Mod) : P;

Ok = (*SIF)(C,G,Q,Rad,V,0|mod=Mod);

} else

Ok = [];

V0 = setminus(V,PV);

HJ = elim_gb(append(Ok,G),V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);

HJ = contraction(HJ,V0|mod=Mod);

Line 438 def syca_dec(B,V)

Line 531 def syca_dec(B,V)

{

T00 = time();

if ( type(SI=getopt(si)) == -1 ) SI = 2;

SIFList=[find_si0, find_si1,find_si2]; SIF = SIFList[SI];

SIFList=[noro_pd.find_si0, noro_pd.find_si1, noro_pd.find_si2];

SIF = SIFList[SI];

if ( !SIF ) error("syca_dec : si should be 0,1,2");

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

Line 524 def syc0_dec(B,V)

Line 618 def syc0_dec(B,V)

{

T00 = time();

if ( type(SI=getopt(si)) == -1 ) SI = 1;

SIFList=[find_si0, find_si1,find_si2,find_ssi0,find_ssi1,find_ssi2]; SIF = SIFList[SI];

SIFList=[noro_pd.find_si0, noro_pd.find_si1, noro_pd.find_si2, noro_pd.find_ssi0, noro_pd.find_ssi1, noro_pd.find_ssi2];

SIF = SIFList[SI];

if ( !SIF ) error("syc0_dec : si should be 0,1,2");

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(Lexdec=getopt(lexdec)) == -1 ) Lexdec = 0;

Line 619 def find_si1(C,G,Q,Rad,V,Ord) {

Line 714 def find_si1(C,G,Q,Rad,V,Ord) {

/* check whether (Q cap (G+S)) = G */

if ( gen_gb_comp(Int,G,Mod) ) { print([0]); return reverse(S); }

C = qsort(C,comp_tdeg);

C = qsort(C,noro_pd.comp_tdeg);

Tmp = ttttt; TV = cons(Tmp,V); Ord1 = [[0,1],[Ord,length(V)]];

Int0 = incremental_gb(append(vtol(ltov(G)*Tmp),vtol(ltov(Q)*(1-Tmp))),

Line 662 def find_si2(C,G,Q,Rad,V,Ord) {

Line 757 def find_si2(C,G,Q,Rad,V,Ord) {

/* check whether (Q cap (G+S)) = G */

if ( gen_gb_comp(Int,G,Mod) ) { print([0]); return reverse(S); }

C = qsort(C,comp_tdeg);

C = qsort(C,noro_pd.comp_tdeg);

Dp = dp_gr_print(); dp_gr_print(0);

Tmp = ttttt; TV = cons(Tmp,V); Ord1 = [[0,1],[Ord,length(V)]];

Line 682 def find_si2(C,G,Q,Rad,V,Ord) {

Line 777 def find_si2(C,G,Q,Rad,V,Ord) {

print([length(T),I],2);

S = cons(Ui,S);

}

S = qsort(S,comp_tdeg);

S = qsort(S,noro_pd.comp_tdeg);

print("");

End = Len = length(S);

Line 773 def find_ssi1(C,G,Q,Rad,V,Ord) {

Line 868 def find_ssi1(C,G,Q,Rad,V,Ord) {

if ( gen_gb_comp(Int,G,Mod) ) { print([0]); return reverse(S); }

dp_ord(Ord); DC = map(dp_ptod,C,V);

DC = qsort(DC,comp_tord); C = map(dp_dtop,DC,V);

DC = qsort(DC,noro_pd.comp_tord); C = map(dp_dtop,DC,V);

print(length(C),2);

if ( Reduce ) {

SC = map(sq,C,Mod);

Line 831 def find_ssi2(C,G,Q,Rad,V,Ord) {

Line 926 def find_ssi2(C,G,Q,Rad,V,Ord) {

#if 0

dp_ord(Ord); DC = map(dp_ptod,C,V);

DC = qsort(DC,comp_tord); C = map(dp_dtop,DC,V);

DC = qsort(DC,noro_pd.comp_tord); C = map(dp_dtop,DC,V);

#else

C = qsort(C,comp_tdeg);

C = qsort(C,noro_pd.comp_tdeg);

#endif

if ( Reduce ) {

for ( T = C, C1 = [], R1 = Rad; T != []; T = cdr(T) ) {

if ( !gen_nf(car(T),Rad,V,Ord,Mod) ) continue;

if ( radical_membership(car(T),R1,V) ) {

if ( radical_membership(car(T),R1,V|mod=Mod) ) {

C1 = cons(car(T),C1);

R1 = cons(sq(car(T),Mod),R1);

}

Line 851 def find_ssi2(C,G,Q,Rad,V,Ord) {

Line 946 def find_ssi2(C,G,Q,Rad,V,Ord) {

Ui = U = car(T);

S = cons([Ui,U],S);

}

S = qsort(S,comp_tdeg_first);

S = qsort(S,noro_pd.comp_tdeg_first);

print("");

Dp = dp_gr_print(); dp_gr_print(0);

Line 950 def pseudo_dec(G,L,V,Ord)

Line 1045 def pseudo_dec(G,L,V,Ord)

for ( I = 0; I < N; I++ ) {

LI = setminus(L0,[L0[I]]);

PI = ideal_list_intersection(LI,V,Ord|mod=Mod);

PI = qsort(PI,comp_tdeg);

PI = qsort(PI,noro_pd.comp_tdeg);

for ( T = PI; T != []; T = cdr(T) )

if ( gen_nf(car(T),L0[I],V,Ord,Mod) ) break;

if ( T == [] ) error("separator : cannot happen");

Line 984 def iso_comp(G,L,V,Ord)

Line 1079 def iso_comp(G,L,V,Ord)

if ( type(Iso=getopt(iso)) == -1 ) Iso = 0;

if ( type(Para=getopt(para)) == -1 ) Para = 0;

if ( type(Q=getopt(intq)) == -1 ) Q = 0;

if ( type(S=getopt(sep)) == -1 ) S = 0;

S = separator(L,V|mod=Mod);

if ( !S ) S = separator(L,V|mod=Mod);

N = length(L);

print("comps : ",2); print(N); print("",2);

if ( Para ) {

Line 1016 def locsat(G,V,L,S,Mod,IsGB,Iso,Q)

Line 1112 def locsat(G,V,L,S,Mod,IsGB,Iso,Q)

if ( Iso==1 ) {

QI = sat(G,S,V|isgb=IsGB,mod=Mod);

GI = elim_gb(QI,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);

GI = nd_gr(contraction(GI,V0|mod=Mod),V,Mod,0);

GI = nd_gr(contraction(GI,V0|mod=Mod,allv=V),V,Mod,0);

} else if ( Iso==0 ) {

HI = elim_gb(G,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);

GI = nd_gr(contraction(HI,V0|mod=Mod),V,Mod,0);

GI = nd_gr(contraction(HI,V0|mod=Mod,allv=V),V,Mod,0);

GI = sat(GI,S,V|isgb=IsGB,mod=Mod);

} else if ( Iso==2 ) {

HI = elim_gb(G,V0,PV,Mod,[[0,length(V0)],[0,length(PV)]]);

Line 1030 def locsat(G,V,L,S,Mod,IsGB,Iso,Q)

Line 1126 def locsat(G,V,L,S,Mod,IsGB,Iso,Q)

GI = nd_gr_trace(append(HI,[TV*S-1]),cons(TV,V0),

1,1,[[0,1],[0,length(V0)]]|gbblock=[[0,length(HI)]]);

GI = elimination(GI,V);

GI = nd_gr(contraction(GI,V0|mod=Mod),V,Mod,0);

GI = nd_gr(contraction(GI,V0|mod=Mod,allv=V),V,Mod,0);

} else if ( Iso==3 ) {

GI = sat(G,S,V|isgb=IsGB,mod=Mod);

}

if ( Q )

GI = ideal_intersection(Q,GI,V,0|mod=Mod);

Line 1079 def prime_dec(B,V)

Line 1177 def prime_dec(B,V)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;

if ( type(NoLexDec=getopt(lexdec)) == -1 ) LexDec = 0;

if ( type(LexDec=getopt(lexdec)) == -1 ) LexDec = 0;

if ( type(Rad=getopt(radical)) == -1 ) Rad = 0;

B = map(sq,B,Mod);

if ( LexDec )

Line 1090 def prime_dec(B,V)

Line 1188 def prime_dec(B,V)

G = ideal_list_intersection(PD,V,0|mod=Mod);

PD = pd_remove_redundant_comp(G,PD,V,0|mod=Mod);

}

R = []; RL = [];

for ( T = PD; T != []; T = cdr(T) ) {

PDT = prime_dec_main(car(T),V|indep=Indep,mod=Mod);

R = append(R,PDT[0]);

GT = nd_gr(PDT[1],V,Mod,0);

RL = append(RL,[GT]);

}

if ( LexDec ) R = pd_simp_comp(R,V|first=Indep,mod=Mod);

if ( Rad ) {

G = ideal_list_intersection(RL,V,0|mod=Mod);

return [R,G];

} else return R;

}

def prime_dec2(B,V)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;

if ( type(LexDec=getopt(lexdec)) == -1 ) LexDec = 0;

if ( type(Rad=getopt(radical)) == -1 ) Rad = 0;

if ( type(Para=getopt(para)) == -1 || type(Para) != 4 ) Para = [];

B = map(sq,B,Mod);

if ( LexDec )

PD = lex_predec1(B,V|mod=Mod);

else

PD = [B];

if ( length(PD) > 1 ) {

G = ideal_list_intersection(PD,V,0|mod=Mod);

PD = pd_remove_redundant_comp(G,PD,V,0|mod=Mod);

}

R = [];

for ( T = PD; T != []; T = cdr(T) )

R = append(prime_dec_main(car(T),V|indep=Indep,mod=Mod),R);

R = append(prime_dec_main2(car(T),V|indep=Indep,mod=Mod,para=Para),R);

if ( Indep ) {

G = ideal_list_intersection(map(first,R),V,0|mod=Mod);

if ( LexDec ) R = pd_simp_comp(R,V|first=1,mod=Mod);

R = pd_simp_comp(R,V|first=1,mod=Mod);

} else {

G = ideal_list_intersection(R,V,0|mod=Mod);

if ( LexDec ) R = pd_simp_comp(R,V|first=1,mod=Mod);

R = pd_simp_comp(R,V|mod=Mod);

}

return Rad ? [R,G] : R;

}

/* returns [PD,rad(I)] */

def prime_dec_main(B,V)

{

Tpint = RTpint = 0;

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;

G = fast_gb(B,V,Mod,0);

IntP = [1];

PD = [];

DG = ltov(map(dp_ptod,G,V));

for ( Ind = [], I = length(G)-1; I >= 0; I-- ) Ind = cons(I,Ind);

if ( Mod ) DG = map(dp_mod,DG,Mod,[]);

while ( 1 ) {

print([length(PD)],2);

/* rad(G) subset IntP */

/* check if IntP subset rad(G) */

for ( T = IntP; T != []; T = cdr(T) ) {

/* print([length(PD),length(IntP)],2); */

if ( (GNV = radical_membership(car(T),G,V|mod=Mod,isgb=1)) ) {

for ( T = IntP; T != []; T = cdr(T) )

if ( (G0 = radical_membership_sat(car(T),G,V|mod=Mod,isgb=1,dg=[DG,Ind])) ) {

F = car(T);

break;

}

if ( T == [] ) {

print(["pint",Tpint,"rpint",RTpint]);

return [PD,IntP];

}

if ( T == [] ) return PD;

/* GNV = [GB(<NV*F-1,G>),NV] */

G1 = fast_gb(GNV[0],cons(GNV[1],V),Mod,[[0,1],[0,length(V)]]);

G0 = elimination(G1,V);

PD0 = zprimecomp(G0,V,Indep|mod=Mod);

if ( Indep ) {

Int = ideal_list_intersection(Indep?map(first,PD0):PD0,V,0|mod=Mod);

Int = ideal_list_intersection(PD0[0],V,0|mod=Mod);

PD = append(PD,PD0);

IndepSet = PD0[1];

#if 1

for ( PD1 = [], T = PD0[0]; T != []; T = cdr(T) )

T0=time();

PD1 = cons([car(T),IndepSet],PD1);

IntP = ideal_intersection_m(IntP,Int,V,0|mod=Mod);

PD = append(PD,reverse(PD1));

dp_ord(0); DC = map(dp_ptod,IntP,V);

} else {

DC = qsort(DC,noro_pd.comp_tord); IntP = map(dp_dtop,DC,V);

Int = ideal_list_intersection(PD0,V,0|mod=Mod);

ACCUM_TIME(Tpint,RTpint)

PD = append(PD,PD0);

#else

}

IntP = ideal_intersection(IntP,Int,V,0|mod=Mod,gbblock=[[0,length(IntP)]]);

IntP = ideal_intersection(IntP,Int,V,0|mod=Mod);

#endif

}

localf callsat,callzcomp;

def callsat(F,G,V,Mod,DG)

{

return radical_membership(F,G,V|mod=Mod,isgb=1,dg=DG,sat=1);

}

def callzcomp(F,V,Indep,Mod)

{

PD0 = zprimecomp(F,V,Indep|mod=Mod);

Int = ideal_list_intersection(Indep?map(first,PD0):PD0,V,0|mod=Mod);

return [PD0,Int];

}

def prime_dec_main2(B,V)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(Indep=getopt(indep)) == -1 ) Indep = 0;

if ( type(Para=getopt(para)) == -1 || type(Para) != 4 ) Para = [];

NPara = length(Para);

G = fast_gb(B,V,Mod,0);

IntP = [1];

PD = [];

DG = ltov(map(dp_ptod,G,V));

for ( Ind = [], I = length(G)-1; I >= 0; I-- ) Ind = cons(I,Ind);

if ( Mod ) DG = map(dp_mod,DG,Mod,[]);

if ( NPara )

while ( 1 ) {

IntPM = mingen(IntP,V);

for ( T = IntPM, CallSat = []; T != []; T = cdr(T) )

CallSat = cons(["noro_pd.callsat",car(T),G,V,Mod,[DG,Ind]],CallSat);

CallSat = reverse(CallSat);

/* SatL = [[..],0,[...],...] */

SatL = para_exec(Para,CallSat);

for ( T = SatL, Sat = []; T != []; T = cdr(T) ) if ( car(T) ) Sat = cons(car(T),Sat);

if ( Sat == [] ) return PD;

print(length(Sat),2); print("->",2);

Sat = remove_identical_comp(Sat|mod=Mod);

print(length(Sat));

for ( T = Sat, CallComp = []; T != []; T = cdr(T) )

CallComp = cons(["noro_pd.callzcomp",car(T),V,Indep,Mod],CallComp);

CallComp = reverse(CallComp);

/* PDL = [[PD0,Int],...] */

PDL = para_exec(Para,CallComp);

for ( T = PDL; T != []; T = cdr(T) ) PD = append(PD,car(T)[0]);

Int = ideal_list_intersection(map(second,PDL),V,0|mod=Mod);

IntP = ideal_intersection(IntP,Int,V,0|mod=Mod,gbblock=[[0,length(IntP)]]);

}

else

while ( 1 ) {

/* rad(G) subset IntP */

/* check if IntP subset rad(G) */

/* print([length(PD),length(IntP)],2); */

Sat = [];

IntPM = mingen(IntP,V);

for ( T = IntPM; T != [] && length(Sat) < 16; T = cdr(T) )

if ( G0 = radical_membership(car(T),G,V|mod=Mod,isgb=1,dg=[DG,Ind],sat=1) )

Sat = cons(G0,Sat);

if ( Sat == [] ) return PD;

print(length(Sat),2); print("->",2);

Sat = remove_identical_comp(Sat|mod=Mod);

print(length(Sat));

for ( T = Sat; T != []; T = cdr(T) ) {

PD0 = zprimecomp(car(T),V,Indep|mod=Mod); PD = append(PD,PD0);

Int = ideal_list_intersection(Indep?map(first,PD0):PD0,V,0|mod=Mod);

IntP = ideal_intersection(IntP,Int,V,0|mod=Mod,gbblock=[[0,length(IntP)]]);

}

/* pre-decomposition */

def lex_predec1(B,V)

Line 1200 def complete_qdecomp(GD,V,Mod)

Line 1405 def complete_qdecomp(GD,V,Mod)

NV = ttttt;

M = gen_minipoly(cons(NV-U,GQ),cons(NV,V),PV,0,NV,Mod);

M = ppart(M,NV,Mod);

MF = Mod ? modfctr(M) : fctr(M);

MF = Mod ? modfctr(M,Mod) : fctr(M);

R = [];

for ( T = cdr(MF); T != []; T = cdr(T) ) {

S = car(T);

Line 1297 def complete_decomp(GD,V,Mod)

Line 1502 def complete_decomp(GD,V,Mod)

NV = ttttt;

M = gen_minipoly(cons(NV-U,G),cons(NV,V),PV,0,NV,Mod);

M = ppart(M,NV,Mod);

MF = Mod ? modfctr(M) : fctr(M);

MF = Mod ? modfctr(M,Mod) : fctr(M);

if ( length(MF) == 2 ) return [G];

R = [];

for ( T = cdr(MF); T != []; T = cdr(T) ) {

Line 1413 def zprimecomp(G,V,Indep) {

Line 1618 def zprimecomp(G,V,Indep) {

for ( T = PD; T != []; T = cdr(T) ) {

U = contraction(car(T),V0|mod=Mod);

U = nd_gr(U,V,Mod,0);

R = cons(U,R);

R = cons(Indep?[U,W]:U,R);

}

if ( Indep ) return [R,W];

return R;

else return R;

}

def fast_gb(B,V,Mod,Ord)

Line 1483 def elim_gb(G,V,PV,Mod,Ord)

Line 1687 def elim_gb(G,V,PV,Mod,Ord)

G = competitive_exec(EProcs,Arg0,Arg1);

} else if ( GBRat ) {

G1 = nd_gr(G,append(V,PV),0,O1);

G1 = nd_gr_postproc(G1,V,0,Ord,0);

if ( GBRat == 1 )

G1 = nd_gr_postproc(G1,V,0,Ord,0|nora=1);

return G1;

} else

#if 1

Line 1541 def find_npos(GD,V,PV,Mod)

Line 1746 def find_npos(GD,V,PV,Mod)

{

N = length(V); PN = length(PV);

G = GD[0]; D = GD[1]; LD = D[N];

DH = map(dp_dtop,map(dp_ht,map(dp_ptod,D,V)),V);

Ord0 = dp_ord(); dp_ord(0);

HC = map(dp_hc,map(dp_ptod,G,V));

dp_ord(Ord0);

Line 1554 def find_npos(GD,V,PV,Mod)

Line 1760 def find_npos(GD,V,PV,Mod)

NV = ttttt;

for ( B = 2; ; B++ ) {

for ( J = N-2; J >= 0; J-- ) {

for ( U = 0, K = J; K < N; K++ )

for ( U = 0, K = J; K < N; K++ ) {

if ( DH[K] == V[K] ) continue;

U += rsgn()*((random()%B+1))*V[K];

}

#if 0

M = minipolym(G,V,0,U,NV,Mod);

#else

M = gen_minipoly(cons(NV-U,G),cons(NV,V),PV,0,NV,Mod);

#endif

if ( deg(M,NV) == LD ) return U;

}

Line 1564 def find_npos(GD,V,PV,Mod)

Line 1776 def find_npos(GD,V,PV,Mod)

def gen_minipoly(G,V,PV,Ord,VI,Mod)

{

O0 = dp_ord();

if ( PV == [] ) {

NV = sssss;

if ( Mod )

M = minipolym(G,V,Ord,VI,NV,Mod);

else

M = minipoly(G,V,Ord,VI,NV);

dp_ord(O0);

return subst(M,NV,VI);

}

W = setminus(V,[VI]);

Line 1612 def gen_minipoly(G,V,PV,Ord,VI,Mod)

Line 1826 def gen_minipoly(G,V,PV,Ord,VI,Mod)

G = nd_gr_trace(G,PV1,1,GBCheck,[[0,1],[0,length(PV)]]|nora=1);

for ( M = car(G), T = cdr(G); T != []; T = cdr(T) )

if ( deg(car(T),VI) < deg(M,VI) ) M = car(T);

dp_ord(O0);

return M;

}

Line 1657 def maxindep(B,V,O)

Line 1872 def maxindep(B,V,O)

return R;

}

def maxindep2(B,V,O)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

G = fast_gb(B,V,Mod,O);

Old = dp_ord();

dp_ord(O);

H = map(dp_dtop,map(dp_ht,map(dp_ptod,G,V)),V);

H = map(sq,H,0);

H = nd_gr(H,V,0,0);

H = monodec0(H,V);

N = length(V);

Dep = [];

for ( T = H, Len = N+1; T != []; T = cdr(T) ) {

M = length(car(T));

if ( M < Len ) {

Dep = [car(T)];

Len = M;

} else if ( M == Len )

Dep = cons(car(T),Dep);

}

R = [];

for ( T = Dep; T != []; T = cdr(T) )

R = cons(setminus(V,car(T)),R);

dp_ord(Old);

return reverse(R);

}

/* ideal operations */

def contraction(G,V)

{

if ( type(AllV=getopt(allv)) == -1 ) AllV = 0;

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( RepColon ) return contraction_m(G,V|allv=AllV,mod=Mod);

C = [];

for ( T = G; T != []; T = cdr(T) ) {

C1 = dp_hc(dp_ptod(car(T),V));

Line 1670 def contraction(G,V)

Line 1917 def contraction(G,V)

}

W = vars(G);

PV = setminus(W,V);

W = append(V,PV);

if ( AllV ) W = AllV;

else W = append(V,PV);

NV = ttttt;

for ( T = C, S = 1; T != []; T = cdr(T) )

if ( SuccSat ) {

S *= car(T);

W1 = cons(NV,W);

G = saturation([G,NV],S,W|mod=Mod);

O1 = [[0,1],[0,length(W)]];

Block = [];

for ( T = C; T != []; T = cdr(T) ) {

G1 = nd_gr(append(G,[NV*car(T)-1]),W1,Mod,O1|gbblock=Block);

G = elimination(G1,W);

Block = [[0,length(G)]];

}

} else {

for ( T = C, S = 1; T != []; T = cdr(T) )

S *= car(T);

G = saturation([G,NV],S,W|mod=Mod);

}

return G;

}

def contraction_m(G,V)

{

if ( type(AllV=getopt(allv)) == -1 ) AllV = 0;

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

C = [];

for ( T = G; T != []; T = cdr(T) ) {

C1 = dp_hc(dp_ptod(car(T),V));

S = gen_fctr(C1,Mod);

for ( S = cdr(S); S != []; S = cdr(S) )

if ( !member(S[0][0],C) ) C = cons(S[0][0],C);

}

W = vars(G);

PV = setminus(W,V);

if ( AllV ) W = AllV;

else W = append(V,PV);

H = H0 = G;

while ( 1 ) {

for ( T = C; T != []; T = cdr(T) )

H = map(sdiv,ideal_intersection_m([car(T)],H,W,0),car(T));

H = nd_gr(H,W,0,0);

if ( gb_comp(H0,H) ) break;

else H0 = H;

}

return H;

}

def ideal_list_intersection(L,V,Ord)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(Para=getopt(para)) == -1 || type(Para) != 4 ) Para = [];

if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;

N = length(L);

if ( N == 0 ) return [1];

if ( N == 1 ) return fast_gb(L[0],V,Mod,Ord);

if ( N == 1 )

if ( N > 2 && (Len = length(Para)) >= 2 ) {

return IsGB ? L[0] : fast_gb(L[0],V,Mod,Ord);

Div = N >= 2*Len ? Len : 2;

else {

QR = iqr(N,Div); Q = QR[0]; R = QR[1];

for ( I = 0, T = [1]; I < N; I++ )

T = []; K = 0;

T = ideal_intersection_m(T,L[I],V,Ord|mod=Mod);

for ( I = 0; I < Div; I++ ) {

T = nd_gr(T,V,Mod,Ord);

LenI = I<R? Q+1 : Q;

return T;

if ( LenI ) {

for ( LI = [], J = 0; J < LenI; J++ ) LI = cons(L[K++],LI);

TI = ["noro_pd.call_ideal_list_intersection",LI,V,Mod,Ord];

T = cons(TI,T);

}

Tint = para_exec(Para,T);

return ideal_list_intersection(Tint,V,Ord|mod=Mod,para=Para);

} else {

N2 = idiv(N,2);

for ( L1 = [], I = 0; I < N2; I++ ) L1 = cons(L[I],L1);

for ( L2 = []; I < N; I++ ) L2 = cons(L[I],L2);

I1 = ideal_list_intersection(L1,V,Ord|mod=Mod);

I2 = ideal_list_intersection(L2,V,Ord|mod=Mod);

return ideal_intersection(I1,I2,V,Ord|mod=Mod,

gbblock=[[0,length(I1)],[length(I1),length(I2)]]);

}

def call_ideal_list_intersection(L,V,Mod,Ord)

def call_ideal_list_intersection(L,V,Mod,Ord,IsGB)

{

return ideal_list_intersection(L,V,Ord|mod=Mod);

return ideal_list_intersection(L,V,Ord|mod=Mod,isgb=IsGB);

}

def ideal_intersection(A,B,V,Ord)

Line 1750 def ideal_intersection(A,B,V,Ord)

Line 2019 def ideal_intersection(A,B,V,Ord)

return G0;

}

def aa(A) { return [A,A]; }

def ideal_intersection_m(A,B,V,Ord)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

dp_ord(Ord);

DA = map(dp_ptod,A,V); DB = ltov(map(dp_ptod,B,V));

if ( Mod ) {

DA = map(dp_mod,DA,Mod,[]); DB = map(dp_mod,DB,Mod,[]);

setmod(Mod);

}

N = length(B);

for ( Ind = [], I = N-1; I >= 0; I-- ) Ind = cons(I,Ind);

for ( T = DA, C = []; T != []; T = cdr(T) ) {

L = Mod?dp_true_nf_mod(Ind,car(T),DB,1,Mod):dp_true_nf(Ind,car(T),DB,1);

R = dp_dtop(L[0],V); Q = dp_dtop(car(T)*L[1]-L[0],V);

C = cons([R,-Q],C);

}

G = nd_gr(append(C,map(aa,B)),V,Mod,[1,Ord]|intersect=1);

G = map(second,G);

return G;

}

/* returns GB if F notin rad(G) */

def radical_membership(F,G,V) {

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;

F = gen_nf(F,G,V,0,Mod);

if ( type(L=getopt(dg)) == -1 ) L = 0;

if ( !F ) return 0;

if ( type(Sat=getopt(sat)) == -1 ) Sat = 0;

F2 = gen_nf(F*F,G,V,0,Mod);

dp_ord(0);

if ( !F2 ) return 0;

if ( L ) { DG = L[0]; Ind = L[1]; }

F3 = gen_nf(F2*F,G,V,0,Mod);

else {

if ( !F3 ) return 0;

DG = ltov(map(dp_ptod,G,V));

if ( Mod ) DG = map(dp_mod,DG,Mod,[]);

for ( Ind = [], I = length(G)-1; I >= 0; I-- ) Ind = cons(I,Ind);

}

DF = dp_ptod(F,V); DFI = dp_ptod(1,V);

if ( Mod ) {

DF = dp_mod(DF,Mod,[]); DFI = dp_mod(DFI,Mod,[]);

setmod(Mod);

}

for ( I = 0; I < 3; I++ ) {

DFI = Mod?dp_nf_mod(Ind,DF*DFI,DG,0,Mod):dp_nf(Ind,DF*DFI,DG,0);

if ( !DFI ) return 0;

}

NV = ttttt;

if ( IsGB )

T = nd_gr(append(G,[NV*F-1]),cons(NV,V),Mod,0

|gbblock=[[0,length(G)]]);

else

T = nd_gr(append(G,[NV*F-1]),cons(NV,V),Mod,0);

if ( type(car(T)) != 1 ) return [T,NV];

if ( type(car(T)) == 1 ) return 0;

else return 0;

else if ( Sat ) {

G1 = fast_gb(T,cons(NV,V),Mod,[[0,1],[0,length(V)]]);

G0 = elimination(G1,V);

return G0;

} else return [T,NV];

}

def radical_membership_sat(F,G,V) {

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;

if ( type(L=getopt(dg)) == -1 ) L = 0;

dp_ord(0);

if ( L ) { DG = L[0]; Ind = L[1]; }

else {

DG = ltov(map(dp_ptod,G,V));

if ( Mod ) DG = map(dp_mod,DG,Mod,[]);

for ( Ind = [], I = length(G)-1; I >= 0; I-- ) Ind = cons(I,Ind);

}

DF = dp_ptod(F,V); DFI = dp_ptod(1,V);

if ( Mod ) {

DF = dp_mod(DF,Mod,[]); DFI = dp_mod(DFI,Mod,[]);

setmod(Mod);

}

for ( I = 0; I < 3; I++ ) {

DFI = Mod?dp_nf_mod(Ind,DF*DFI,DG,0,Mod):dp_nf(Ind,DF*DFI,DG,0);

if ( !DFI ) return 0;

}

NV = ttttt;

if ( IsGB )

T = nd_gr(append(G,[NV*F-1]),cons(NV,V),Mod,[[0,1],[0,length(V)]]

|gbblock=[[0,length(G)]]);

else

T = nd_gr(append(G,[NV*F-1]),cons(NV,V),Mod,[[0,1],[0,length(V)]]);

if ( type(car(T)) == 1 ) return 0;

G0 = elimination(T,V);

return G0;

}

def modular_radical_membership(F,G,V) {

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( Mod )

Line 1825 def ideal_product(A,B,V)

Line 2166 def ideal_product(A,B,V)

for ( T = PA; T != []; T = cdr(T) )

for ( S = PB; S != []; S = cdr(S) )

R = cons([car(T)[0]*car(S)[0],car(T)[1]+car(S)[1]],R);

T = qsort(R,comp_by_second);

T = qsort(R,noro_pd.comp_by_second);

T = map(first,T);

Len = length(A)>length(B)?length(A):length(B);

Len *= 2;

Line 1882 def sat(G,F,V)

Line 2223 def sat(G,F,V)

return elimination(G1,V);

}

def isat(B,S,V)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( type(IsGB=getopt(isgb)) == -1 ) IsGB = 0;

F = cdr(fctr(S));

R = B;

for ( T = F; T != []; T = cdr(T) )

R = sat(R,car(T)[0],V|mod=Mod,isgb=IsGB);

return R;

}

def satind(G,F,V)

{

if ( type(Block=getopt(gbblock)) == -1 ) Block = 0;

Line 1945 def colon(G,F,V)

Line 2297 def colon(G,F,V)

T = ideal_intersection(G,[F],V,Ord|gbblock=[[0,length(G)]],mod=Mod);

else

T = ideal_intersection(G,[F],V,Ord|mod=Mod);

return Mod?map(sdivm,T,F,Mod):map(ptozp,map(sdiv,T,F));

Gen = Mod?map(sdivm,T,F,Mod):map(ptozp,map(sdiv,T,F));

return nd_gr(Gen,V,Mod,Ord);

}

#if 1

Line 1955 def ideal_colon(G,F,V)

Line 2308 def ideal_colon(G,F,V)

G = nd_gr(G,V,Mod,0);

C = [1];

TV = ttttt;

F = qsort(F,comp_tdeg);

F = qsort(F,noro_pd.comp_tdeg);

for ( T = F; T != []; T = cdr(T) ) {

S = colon(G,car(T),V|isgb=1,mod=Mod);

if ( type(S[0])!= 1 ) {

Line 1981 def ideal_colon(G,F,V)

Line 2334 def ideal_colon(G,F,V)

#endif

def ideal_colon1(G,F,V)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

F = qsort(F,comp_tdeg);

T = mingen(F,V|mod=Mod);

return ideal_colon(G,T,V|mod=Mod);

}

def member(A,L)

{

for ( ; L != []; L = cdr(L) )

Line 1999 def member(A,L)

Line 2344 def member(A,L)

def mingen(B,V) {

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

Data = nd_gr(B,V,Mod,O|gentrace=1,gensyz=1);

G = Data[0];

G = Data[0]; STrace = Data[6];

S = compute_gbsyz(V,Data);

S = dtop(S,V);

R = topnum(S);

N = length(G);

U = [];

S = compute_gbsyz(N,V,STrace,Mod);

for ( I = 0; I < N; I++ )

for ( T = S, R = []; T != []; T = cdr(T) ) {

if ( !member(I,R) ) U = cons(G[I],U);

for ( A = car(T); A1 = dp_rest(A); A = A1);

if ( type(dp_hc(A)) ==1 ) R = cons(dp_etov(A)[0],R);

}

for ( I = 0, U = []; I < N; I++ ) if ( !member(I,R) ) U = cons(G[I],U);

return U;

}

def compute_gbsyz(V,Data)

def compute_gbsyz(N,V,Trace,Mod)

{

G = Data[0];

Homo = Data[1];

Trace = Data[2];

IntRed = Data[3];

Ind = Data[4];

InputRed = Data[5];

SpairTrace = Data[6];

DB = map(dp_ptod,G,V);

N = length(G);

P = vector(N);

for ( I = 0; I < N; I++ ) {

for ( I = 0; I < N; I++ ) P[I] = dp_ptod(x^I,[x]);

C = vector(N); C[I] = 1; P[I] = C;

for ( U = [], T = Trace; T != []; T = cdr(T) ) {

}

U = [];

for ( T = SpairTrace; T != []; T = cdr(T) ) {

Ti = car(T);

if ( Ti[0] != -1 ) error("Input is not a GB");

R = recompute_trace3(Ti[1],P,0);

R = recompute_trace(Ti[1],P,V,Mod);

U = cons(redcoef(R)[0],U);

U = cons(R,U);

}

return reverse(U);

}

def redcoef(L) {

def recompute_trace(Ti,P,V,Mod)

N =L[0]$ D = L[1]$ Len = length(N)$

for ( I = 0; I < Len; I++ ) if ( N[I] ) break;

if ( I == Len ) return [N,0];

for ( I = 0, G = D; I < Len; I++ )

if ( N[I] ) G = igcd(G,dp_hc(N[I])/dp_hc(dp_ptozp(N[I])));

return [N/G,D/G];

}

def recompute_trace3(Ti,P,C)

{

for ( Num = 0, Den = 1; Ti != []; Ti = cdr(Ti) ) {

Sj = car(Ti); Dj = Sj[0]; Ij =Sj[1]; Mj = Sj[2]; Cj = Sj[3];

Sj = car(Ti); Dj = Sj[0]; Ij =Sj[1]; Mj = dp_dtop(Sj[2],V); Cj = Sj[3];

/* Num/Den <- (Dj*(Num/Den)+Mj*P[Ij])/Cj */

/* Num/Den <- (Dj*Num+Den*Mj*P[Ij])/(Den*Cj) */

if ( Dj )

if ( Dj ) Num = (Dj*Num+Den*Mj*P[Ij]);

Num = (Dj*Num+Den*Mj*P[Ij]);

Den *= Cj;

if ( C ) C *= Dj;

}

return [Num,C];

return Num;

}

def dtop(A,V)

{

T = type(A);

if ( T == 4 || T == 5 || T == 6 )

return map(dtop,A,V);

else if ( T == 9 ) return dp_dtop(A,V);

else return A;

}

def topnum(L)

{

for ( R = [], T = L; T != []; T = cdr(T) ) {

V = car(T);

N = length(V);

for ( I = 0; I < N && !V[I]; I++ );

if ( type(V[I])==1 ) R = cons(I,R);

}

return reverse(R);

}

def ideal_sat(G,F,V)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

Line 2189 def pd_remove_redundant_comp(G,P,V,Ord)

Line 2490 def pd_remove_redundant_comp(G,P,V,Ord)

return reverse(T);

}

def remove_identical_comp(L)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

if ( length(L) == 1 ) return L;

A = ltov(L); N = length(A);

for ( I = 0; I < N; I++ ) {

if ( !A[I] ) continue;

for ( J = I+1; J < N; J++ )

if ( A[J] &&

gen_gb_comp(A[I],A[J],Mod) ) A[J] = 0;

}

for ( I = 0, T = []; I < N; I++ ) if ( A[I] ) T = cons(A[I],T);

return reverse(T);

}

/* polynomial operations */

def ppart(F,V,Mod)

Line 2502 def monodec(B,V)

Line 2819 def monodec(B,V)

T0 = map(dp_ptod,D0,W);

D1 = monodec(map(subst,B,X,1),W);

T1 = map(dp_ptod,D1,W);

#if 0

for ( T = T1; T != []; T = cdr(T) ) {

for ( M = car(T), S1 = [], S = T0; S != []; S = cdr(S) )

if ( !dp_redble(car(S),M) ) S1= cons(car(S),S1);

T0 = S1;

}

#else

T0 = dp_mono_reduce(T0,T1);

#endif

D0 = map(dp_dtop,T0,W);

D0 = vtol(X*ltov(D0));

return append(D0,D1);

Line 2516 def separator(P,V)

Line 2837 def separator(P,V)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

N = length(P);

M = matrix(N,N);

dp_ord(0);

DP = vector(N);

for ( I = 0; I < N; I++ ) DP[I] = qsort(ltov(map(dp_ptod,P[I][0],V)),noro_pd.comp_tord);

if ( Mod )

for ( I = 0; I < N; I++ ) DP[I] = map(dp_mod,DP[I],Mod,[]);

Ind = vector(N);

for ( I = 0; I < N; I++ ) {

/* M[I][J] is an element of P[I]-P[J] */

for ( K = [], J = length(DP[I])-1; J >= 0; J-- ) K = cons(J,K);

PI = qsort(P[I][0],comp_tdeg);

Ind[I] = K;

}

S = vector(N);

for ( I = 0; I < N; I++ ) S[I] = 1;

for ( I = 0; I < N; I++ ) {

print(".",2);

for ( J = 0; J < N; J++ ) {

if ( J == I ) continue;

for ( T = PI; T != []; T = cdr(T) )

T = DP[I]; L = length(T);

if ( gen_nf(car(T),P[J][0],V,0,Mod) ) break;

if ( Mod ) {

M[I][J] = sq(car(T),Mod);

for ( K = 0; K < L; K++ )

if ( dp_nf_mod(Ind[J],T[K],DP[J],0,Mod) ) break;

} else {

for ( K = 0; K < L; K++ )

if ( dp_nf(Ind[J],T[K],DP[J],0) ) break;

}

S[J] = lcm(S[J],dp_dtop(T[K],V));

}

S = vector(N);

print("");

for ( J = 0; J < N; J++ ) {

for ( I = 0, T = 1; I < N; I++ ) {

if ( I == J ) continue;

T = sq(T*M[I][J],Mod);

}

S[J] = T;

}

return S;

}

def prepost(PL,V)

{

if ( type(Mod=getopt(mod)) == -1 ) Mod = 0;

A = ltov(PL); N = length(A);

Pre = vector(N);

Post = vector(N);

Line 2547 def prepost(PL,V)

Line 2878 def prepost(PL,V)

Pre[0] = [1];

print("pre ",2);

for ( I = 1; I < N; I++, print(".",2) )

Pre[I] = ideal_intersection(Pre[I-1],A[I-1][0],V,0

Pre[I] = ideal_intersection_m(Pre[I-1],A[I-1],V,0|mod=Mod);

|gbblock=[[0,length(Pre[I-1])]],mod=Mod);

print("done");

print("post ",2);

Post[N-1] = [1];

for ( I = N-2; I >= 0; I--, print(".",2) )

Post[I] = ideal_intersection(Post[I+1],A[I+1][0],V,0

Post[I] = ideal_intersection_m(Post[I+1],A[I+1],V,0|mod=Mod);

|gbblock=[[0,length(Post[I+1])]],mod=Mod);

print("done");

print("int ",2);

for ( I = 0; I < N; I++, print(".",2) )

R[I] = ideal_intersection(Pre[I],Post[I],V,0

R[I] = ideal_intersection_m(Pre[I],Post[I],V,0|mod=Mod);

|gbblock=[[0,length(Pre[I])],[length(Pre[I]),length(Post[I])]],

mod=Mod);

print("done");

return R;

}

Line 2573 def call_func(Arg)

Line 2900 def call_func(Arg)

return call(strtov(F),cdr(Arg));

}

def call_func_serial(Arg,Serial)

{

F = car(Arg);

return [call(strtov(F),cdr(Arg)),Serial];

}

def competitive_exec(P,Arg0,Arg1)

{

P0 = P[0]; P1 = P[1];

Line 2603 def para_exec(Proc,Task) {

Line 2936 def para_exec(Proc,Task) {

Free = Proc;

N = length(Task);

R = [];

print([N],2); print("->",2);

Serial = 0;

while ( N ) {

while ( Task != [] && Free != [] ) {

T = car(Task); Task = cdr(Task);

ox_cmo_rpc(car(Free),"noro_pd.call_func",T);

ox_rpc(car(Free),"noro_pd.call_func_serial",T,Serial++);

ox_push_cmd(car(Free),258); Free = cdr(Free);

}

Finish0 = Finish = ox_select(Proc);

Line 2616 def para_exec(Proc,Task) {

Line 2951 def para_exec(Proc,Task) {

R = cons(L,R);

N--;

}

print([N],2);

Free = append(Free,Finish0);

}

print("");

return reverse(R);

R = qsort(R,noro_pd.comp_by_second);

R = map(first,R);

return R;

}

def redbase(B,V,Mod,Ord)

{

M = nd_gr_postproc(B,V,Mod,Ord,0);

dp_ord(Ord);

DM = ltov(map(dp_ptod,M,V));

if ( Mod ) DM = map(dp_mod,DM,Mod,[]);

N = length(DM);

for ( Ind = [], I = N-1; I >= 0; I-- ) Ind = cons(I,Ind);

for ( T = B, R = vtol(DM); T != []; T = cdr(T) ) {

D = dp_ptod(car(T),V);

if ( Mod ) D = dp_mod(D,Mod,[]);

D = Mod?dp_nf_mod(Ind,D,DM,1,Mod):dp_nf(Ind,D,DM,1);

if ( D ) R = cons(D,R);

}

D = qsort(R,noro_pd.comp_tord);

return map(dp_dtop,D,V);

}

def witness(A,B,V)

{

G = nd_gr(B,V,0,Mod);

L = length(A);

QL = []; PL = [];

for ( I = L-1; I >= 0; I-- ) {

QL = append(map(first,A[I]),QL);

PL = append(map(second,A[I]),PL);

}

N = length(QL);

Qhat = prepost(QL,V);

for ( I = 0, W = []; I < N; I++ ) {

for ( T = Qhat[I]; T != []; T = cdr(T) )

if ( gen_nf(car(T),QL[I],V,0,Mod) ) break;

Ai = car(T);

Ji = colon(G,Ai,V|isgb=1,mod=Mod);

Ji = nd_gr(Ji,V,Mod,0);

if ( gen_gb_comp(Ji,PL[I],Mod) ) Bi = 1;

else {

Ki = ideal_colon(Ji,PL[I],V|mod=Mod);

for ( T = Ki; T != []; T = cdr(T) )

if ( gen_nf(car(T),Ji,V,0,Mod) ) break;

Bi = car(T);

}

W = cons(Ai*Bi,W);

Li = colon(G,W[0],V|isgb=1,mod=Mod);

Li = nd_gr(Li,V,Mod,0);

if ( !gen_gb_comp(Li,PL[I],Mod) )

error("afo");

}

return reverse(W);

}

endmodule$

end$

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