OpenXM_contrib2/asir2000/lib/primdec_mod - diff

Return to primdec_mod CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / lib

Diff for /OpenXM_contrib2/asir2000/lib/primdec_mod between version 1.1 and 1.15

version 1.1, 2003/04/20 02:42:08

version 1.15, 2006/02/24 01:15:56

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/lib/primdec_mod,v 1.14 2004/07/30 02:24:11 noro Exp $ */

extern Hom,GBTime$

extern DIVLIST,INTIDEAL,ORIGINAL,ORIGINALDIMENSION,STOP,Trials,REM$

extern T_GRF,T_INT,T_PD,T_MP$

Line 5 extern BuchbergerMinipoly,PartialDecompByLex,ParallelM

Line 7 extern BuchbergerMinipoly,PartialDecompByLex,ParallelM

extern B_Win,D_Win$

extern COMMONCHECK_SF,CID_SF$

if (!module_definedp("fff")) load("fff"); else $

if (!module_definedp("gr")) load("gr"); else $

module primdec_mod $

/* Empty for now. It will be used in a future. */

endmodule $

/*==============================================*/

/* prime decomposition of ideals over */

/* finite fields */

Line 129 def frobeniuskernel_main(P,VSet,WSet)

Line 137 def frobeniuskernel_main(P,VSet,WSet)

XSet=append(VSet,WSet);

NewOrder=[[0,length(VSet)],[0,length(WSet)]];

Char=setmod_ff()[0];

Char=characteristic_ff();

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

{

Line 163 def frobeniuskernel_main2(P,VSet,WSet)

Line 171 def frobeniuskernel_main2(P,VSet,WSet)

XSet=append(VSet,WSet);

NewOrder=[[0,NV],[0,NV]];

Char=setmod_ff()[0];

Char=characteristic_ff();

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

{

Line 211 def frobeniuskernel_main4(P,VSet,WSet)

Line 219 def frobeniuskernel_main4(P,VSet,WSet)

XSet=append(VSet,WSet);

NewOrder=[[0,NV],[0,NV]];

Char=setmod_ff()[0];

Char=characteristic_ff();

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

{

Line 274 def frobeniuskernel_main3(P,VSet,WSet)

Line 282 def frobeniuskernel_main3(P,VSet,WSet)

NewP=coefficientfrobeniuskernel(P);

Char=setmod_ff()[0];

Char=characteristic_ff();

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

{

Line 337 def coefficientfrobeniuskernel_main(Poly)

Line 345 def coefficientfrobeniuskernel_main(Poly)

Vars=vars(Poly);

QP=dp_ptod(Poly,Vars);

ANS=0;

FOrd=deg(setmod_ff()[1],x);

FOrd=extdeg_ff();

Char=setmod_ff()[0];

Char=characteristic_ff();

Pow=Char^(FOrd-1);

while(QP !=0 )

Line 921 def primedec_sf(P,VSet,Ord,Strategy)

Line 929 def primedec_sf(P,VSet,Ord,Strategy)

REM[I]=[];

}

print("The dimension of the ideal is ",2);print(ORIGINALDIMENSION,2);

if ( dp_gr_print() ) {

print(". ");

print("The dimension of the ideal is ",2);print(ORIGINALDIMENSION,2);

print(". ");

}

if ( ORIGINALDIMENSION == 0 )

{

Line 932 def primedec_sf(P,VSet,Ord,Strategy)

Line 942 def primedec_sf(P,VSet,Ord,Strategy)

ANS=gr_fctr_sf([ORIGINAL],VSet,Ord);

NANS=length(ANS);

print("There are ",2);print(NANS,2);print(" partial components. ");

if ( dp_gr_print() ) {

print("There are ",2);print(NANS,2);print(" partial components. ");

}

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

{

TempI=ANS[I];

Line 958 def primedec_sf(P,VSet,Ord,Strategy)

Line 969 def primedec_sf(P,VSet,Ord,Strategy)

{

DIVLIST = prime_irred_sf_by_first(DIVLIST,VSet,0);

DIVLIST = monic_sf_first(DIVLIST,VSet);

print("We finish the computation. ");

if ( dp_gr_print() ) {

T_TOTAL = time()[3]-T0[3];

print("We finish the computation. ");

print(["T_TOTAL",T_TOTAL,"T_GRF",T_GRF,"T_PD",T_PD,"T_MP",T_MP,"T_INT",T_INT,"B_Win",B_Win,"D_Win",D_Win]);

T_TOTAL = time()[3]-T0[3];

print(["T_TOTAL",T_TOTAL,"T_GRF",T_GRF,"T_PD",T_PD,"T_MP",T_MP,"T_INT",T_INT,"B_Win",B_Win,"D_Win",D_Win]);

}

return 0;

}

Line 970 def primedec_sf(P,VSet,Ord,Strategy)

Line 983 def primedec_sf(P,VSet,Ord,Strategy)

DIVLIST = prime_irred_sf_by_first(DIVLIST,VSet,0);

DIVLIST = monic_sf_first(DIVLIST,VSet);

T_TOTAL = time()[3]-T0[3];

print(["T_TOTAL",T_TOTAL,"T_GRF",T_GRF,"T_PD",T_PD,"T_MP",T_MP,"T_INT",T_INT,"B_Win",B_Win,"D_Win",D_Win]);

if ( dp_gr_print() ) {

print(["T_TOTAL",T_TOTAL,"T_GRF",T_GRF,"T_PD",T_PD,"T_MP",T_MP,"T_INT",T_INT,"B_Win",B_Win,"D_Win",D_Win]);

}

return 0;

}

Line 1108 def primedecomposition(P,VSet,Ord,COUNTER,Strategy)

Line 1123 def primedecomposition(P,VSet,Ord,COUNTER,Strategy)

Dimension=Dimeset[0];

MSI=Dimeset[1];

print("The dimension of the ideal is ",2); print(Dimension,2);

if ( dp_gr_print() ) {

print(".");

print("The dimension of the ideal is ",2); print(Dimension,2);

print(".");

}

TargetVSet=setminus(VSet,MSI);

NewGP=dp_gr_f_main(GP,TargetVSet,Hom,Ord);

Line 1121 def primedecomposition(P,VSet,Ord,COUNTER,Strategy)

Line 1137 def primedecomposition(P,VSet,Ord,COUNTER,Strategy)

/* Then the ideal is 0-dimension in K[TargetVSet]. */

print("We enter Zero-dimension Prime Decomposition. ",2);

if ( dp_gr_print() ) {

print("We enter Zero-dimension Prime Decomposition. ",2);

}

QP=zeroprimedecomposition(NewGP,TargetVSet,VSet);

ANS=[];

NQP=length(QP);

print("The number of the newly found component is ",2);

if ( dp_gr_print() ) {

print(NQP,2);print(". ",2);

print("The number of the newly found component is ",2);

print(NQP,2);print(". ",2);

}

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

{

ZPrimeideal=QP[I];

Line 1168 def primedecomposition(P,VSet,Ord,COUNTER,Strategy)

Line 1187 def primedecomposition(P,VSet,Ord,COUNTER,Strategy)

if (CHECK==1)

{

print("We already obtain all divisor. ");

if ( dp_gr_print() ) {

print("We already obtain all divisor. ");

}

STOP = 1;

return 0;

}

Line 1200 def primedecomposition(P,VSet,Ord,COUNTER,Strategy)

Line 1221 def primedecomposition(P,VSet,Ord,COUNTER,Strategy)

if ( CHECKADD != 0 )

{

print("Avoid unnecessary computation. ",2);

if ( dp_gr_print() ) {

print("Avoid unnecessary computation. ",2);

}

continue;

}

Line 1291 def zeroprimedecomposition(P,TargetVSet,VSet)

Line 1314 def zeroprimedecomposition(P,TargetVSet,VSet)

ZDecomp=[PDiv];

print("An intermediate ideal is of generic type. ");

if ( dp_gr_print() ) {

print("An intermediate ideal is of generic type. ");

}

else

{

print("An intermediate ideal is not of generic type. ",2);

if ( dp_gr_print() ) {

print("An intermediate ideal is not of generic type. ",2);

}

/* We compute the separable closure of <P> by using minimal polynomails.*/

/* separableclosure outputs */

Line 1311 def zeroprimedecomposition(P,TargetVSet,VSet)

Line 1338 def zeroprimedecomposition(P,TargetVSet,VSet)

if ( Sep[1] != 0 )

{

print("The ideal is inseparable. ",2);

if ( dp_gr_print() ) {

print("The ideal is inseparable. ",2);

}

CHECK2=checkgeneric2(Sep[2]);

}

else

{

print("The ideal is already separable. ",2);

if ( dp_gr_print() ) {

print("The ideal is already separable. ",2);

}

if ( Sep[1] !=0 && CHECK2 == 1 )

{

print("The separable closure is of generic type. ",2);

if ( dp_gr_print() ) {

print("So, the intermediate ideal is prime or primary. ",2);

print("The separable closure is of generic type. ",2);

print("So, the intermediate ideal is prime or primary. ",2);

}

PDiv=convertdivisor(Sep[0],TargetVSet,VSet,Sep[1]);

if ( TargetVSet != VSet )

{

Line 1414 def zeroseparableprimedecomposition(P,TargetVSet,VSet)

Line 1446 def zeroseparableprimedecomposition(P,TargetVSet,VSet)

/* Generic=[f, minimal polynomial of f in newt, newt], */

/* where newt (X) is a newly introduced variable. */

print("We search for a linear sum of variables in generic position. ",2);

if ( dp_gr_print() ) {

print("We search for a linear sum of variables in generic position. ",2);

}

Generic=findgeneric(NewGP,TargetVSet,VSet);

X=Generic[2]; /* newly introduced variable */

Line 1596 def separableclosure(CP,TargetVSet,VSet)

Line 1629 def separableclosure(CP,TargetVSet,VSet)

if ( CHECK == 1 )

{

print("This is already a separable ideal.", 2);

if ( dp_gr_print() ) {

print("This is already a separable ideal.", 2);

}

return [CP[0],0];

}

print("This is not a separable ideal, so we make its separable closure.", 2);

if ( dp_gr_print() ) {

print("This is not a separable ideal, so we make its separable closure.", 2);

}

WSet=makecounterpart(TargetVSet);

Char=setmod_ff()[0];

Char=characteristic_ff();

NewP=CP[0];

EXPVECTOR=newvect(NVSet);

Line 1659 def convertdivisor(P,TargetVSet,VSet,ExVector)

Line 1695 def convertdivisor(P,TargetVSet,VSet,ExVector)

NVSet=length(TargetVSet);

WSet=makecounterpart(TargetVSet);

Char=setmod_ff()[0];

Char=characteristic_ff();

Ord=0;

NewP=P;

Line 1762 def findgeneric(P,TargetVSet,VSet)

Line 1798 def findgeneric(P,TargetVSet,VSet)

}

#endif

print("Extend the ground field. ",2);

if ( dp_gr_print() ) {

print("Extend the ground field. ",2);

}

error();

}

Line 1936 def contraction(P,V,W)

Line 1974 def contraction(P,V,W)

/* This procedure is called by zeroprimedecomposition. */

/* So, P is supposed to be a GB w.r.t. DRL. */

Ord0 = dp_ord();

Ord=0;

YSet=setminus(W,V);

Ord1 = [[Ord,length(V)],[0,length(YSet)]];

GP1 = dp_gr_f_main(P,W,Hom,Ord1);

W1 = append(V,YSet);

GP1 = dp_gr_f_main(P,W1,Hom,Ord1);

Factor = extcont_factor(GP1,V,Ord);

for ( F = 1, T = Factor; T != []; T = cdr(T) )

Line 1952 def contraction(P,V,W)

Line 1992 def contraction(P,V,W)

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

if ( !member(Vt,vars(car(T))) )

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

dp_ord(Ord0);

return [R,F];

}

Line 1999 def checkseparablepoly(P,V)

Line 2040 def checkseparablepoly(P,V)

def pdivide(F,V)

{

Char=setmod_ff()[0];

Char=characteristic_ff();

TestP=P;

Deg=ideg(TestP,V);

Line 2047 def convertsmallfield(PP,VSet,Ord)

Line 2088 def convertsmallfield(PP,VSet,Ord)

{

dp_ord(Ord);

NVSet=length(VSet);

Char=setmod_ff()[0];

Char=characteristic_ff();

ExtDeg=deg(setmod_ff()[1],x);

ExtDeg=extdeg_ff();

NewV=pg;

NewV=pgpgpgpgpgpgpg;

MPP=map(monic_hc,PP,VSet);

MPP=map(sfptopsfp,MPP,NewV);

MinPoly=subst(setmod_ff()[1],x,NewV);

DefPoly=setmod_ff()[1];

/* GF(p) case */

if ( !DefPoly )

return MPP;

MinPoly=subst(DefPoly,var(DefPoly),NewV);

XSet=cons(NewV,VSet);

Ord1=[[0,1],[Ord,NVSet]];

Line 2074 def checkgaloisorbit(PP,VSet,Ord,Flag)

Line 2120 def checkgaloisorbit(PP,VSet,Ord,Flag)

{

NPP=length(PP);

TmpPP=PP;

ExtDeg=deg(setmod_ff()[1],x);

ExtDeg=extdeg_ff();

ANS=[];

BNS=[];

Line 2162 def partial_decomp(B,V)

Line 2208 def partial_decomp(B,V)

map(ox_cmo_rpc,ParallelMinipoly,"setmod_ff",characteristic_ff(),extdeg_ff());

map(ox_pop_cmo,ParallelMinipoly);

}

B = map(ptosfp,B);

B = map(simp_ff,B);

B = dp_gr_f_main(B,V,0,0);

R = partial_decomp0(B,V,length(V)-1);

if ( PartialDecompByLex ) {

Line 2335 def minipoly_sf_by_buchberger(G,V,O,F,V0,Server)

Line 2381 def minipoly_sf_by_buchberger(G,V,O,F,V0,Server)

if ( Server )

ox_sync(0);

Vc = cons(V0,setminus(vars(G),V));

Gf = cons(ptosfp(V0-F),G);

Gf = cons(simp_ff(V0-F),G);

Vf = append(V,Vc);

Gelim = dp_gr_f_main(Gf,Vf,1,[[0,length(V)],[0,length(Vc)]]);

for ( Gc = [], T = Gelim; T != []; T = cdr(T) ) {

Line 2370 def minipoly_sf_0dim(G,V,O,F,V0,Server)

Line 2416 def minipoly_sf_0dim(G,V,O,F,V0,Server)

for ( I = Len - 1, GI = []; I >= 0; I-- )

GI = cons(I,GI);

MB = dp_mbase(HL); DIM = length(MB); UT = newvect(DIM);

U = dp_ptod(ptosfp(F),V);

U = dp_ptod(simp_ff(F),V);

U = dp_nf_f(GI,U,PS,1);

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

UT[I] = [MB[I],dp_nf_f(GI,U*MB[I],PS,1)];

T = dp_ptod(ptosfp(1),[V0]);

T = dp_ptod(simp_ff(1),[V0]);

TT = dp_ptod(ptosfp(1),V);

TT = dp_ptod(simp_ff(1),V);

G = H = [[TT,T]];

for ( I = 1; ; I++ ) {

if ( dp_gr_print() )

print(".",2);

T = dp_ptod(ptosfp(V0^I),[V0]);

T = dp_ptod(simp_ff(V0^I),[V0]);

TT = dp_nf_tab_f(H[0][0],UT);

H = cons([TT,T],H);

L = dp_lnf_f([TT,T],G);

Line 2401 def minipoly_sf_rat(G,V,F,V0)

Line 2447 def minipoly_sf_rat(G,V,F,V0)

Vc = setminus(vars(G),V);

Gf = cons(V0-F,G);

Vf = append(V,[V0]);

G3 = dp_gr_f_main(map(ptosfp,Gf),Vf,0,3);

G3 = dp_gr_f_main(map(simp_ff,Gf),Vf,0,3);

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

Vt = setminus(vars(car(T)),Vc);

if ( Vt == [V0] )

Line 2784 def henleq_gsl_sfrat(L,B,Vc,Eval)

Line 2830 def henleq_gsl_sfrat(L,B,Vc,Eval)

X = map(subst,X,V0,V0-E0);

if ( zerovector(RESTA*X+RESTB) ) {

if ( dp_gr_print() ) print("end",0);

return [X,ptosfp(1)];

return [X,simp_ff(1)];

} else

return 0;

} else if ( COUNT == CCC ) {

Line 2847 def henleq_gsl_sfrat_higher(L,B,Vc,Eval)

Line 2893 def henleq_gsl_sfrat_higher(L,B,Vc,Eval)

X = map(mshift,X,Vc,E,-1);

if ( zerovector(RESTA*X+RESTB) ) {

if ( dp_gr_print() ) print("end",0);

return [X,ptosfp(1)];

return [X,simp_ff(1)];

} else

return 0;

} else if ( COUNT == CCC ) {

Line 2957 def polyvtoratv_higher(Vect,Vc,K)

Line 3003 def polyvtoratv_higher(Vect,Vc,K)

def polytorat_gcd(F,V,K)

{

if ( deg(F,V) < K )

return [F,ptosfp(1)];

return [F,simp_ff(1)];

F1 = Mod^(K*2); F2 = F;

B1 = 0; B2 = 1;

while ( 1 ) {

Line 2989 def polytorat_gcd(F,V,K)

Line 3035 def polytorat_gcd(F,V,K)

def polytorat(F,V,Mat,K)

{

if ( deg(F,V) < K )

return [F,ptosfp(1)];

return [F,simp_ff(1)];

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

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

Mat[I][J] = coef(F,I+K-J);

Line 3011 def polytorat_higher(F,V,K)

Line 3057 def polytorat_higher(F,V,K)

{

if ( K < 2 ) return 0;

if ( homogeneous_deg(F) < K )

return [F,ptosfp(1)];

return [F,simp_ff(1)];

D = create_icpoly(V,K);

C = extract_coef(D*F,V,K,2*K);

Vc = vars(C);

Line 3116 def ideal_uniq(L) /* sub procedure of welldec and norm

Line 3162 def ideal_uniq(L) /* sub procedure of welldec and norm

R = append(R,[L[I]]);

else {

for (J = 0; J < length(R); J++)

if ( gb_comp(L[I],R[J]) )

if ( gb_comp_old(L[I],R[J]) )

break;

if ( J == length(R) )

R = append(R,[L[I]]);

Line 3132 def ideal_uniq_by_first(L) /* sub procedure of welldec

Line 3178 def ideal_uniq_by_first(L) /* sub procedure of welldec

R = append(R,[L[I]]);

else {

for (J = 0; J < length(R); J++)

if ( gb_comp(L[I][0],R[J][0]) )

if ( gb_comp_old(L[I][0],R[J][0]) )

break;

if ( J == length(R) )

R = append(R,[L[I]]);

Line 3193 def gr_fctr_sf(FL,VL,Ord)

Line 3239 def gr_fctr_sf(FL,VL,Ord)

for (TP = [],I = 0; I<length(FL); I++ ) {

F = FL[I];

SF = idealsqfr_sf(F);

if ( !gb_comp(F,SF) )

if ( !gb_comp_old(F,SF) )

F = dp_gr_f_main(SF,VL,0,Ord);

CID_SF=[1];

SP = gr_fctr_sub_sf(F,VL,Ord);

Line 3217 def gr_fctr_sub_sf(G,VL,Ord)

Line 3263 def gr_fctr_sub_sf(G,VL,Ord)

W = cons(FL[J][0],G);

NG = dp_gr_f_main(W,VL,0,Ord);

TNG = idealsqfr_sf(NG);

if ( !gb_comp(NG,TNG) )

if ( !gb_comp_old(NG,TNG) )

NG = dp_gr_f_main(TNG,VL,0,Ord);

if ( !inclusion_test(CID_SF,NG,VL,Ord) ) {

DG = gr_fctr_sub_sf(NG,VL,Ord);

Line 3235 def gr_fctr_sub_sf(G,VL,Ord)

Line 3281 def gr_fctr_sub_sf(G,VL,Ord)

if (I == length(G))

RL = append([G],RL);

return RL;

}

def gb_comp_old(A,B)

{

LA = length(A);

LB = length(B);

if ( LA != LB )

return 0;

A = newvect(LA,A);

B = newvect(LB,B);

A1 = qsort(A);

B1 = qsort(B);

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

if ( A1[I] != B1[I] && A1[I] != -B1[I] )

break;

return I == LA ? 1 : 0;

}

end$

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