passagemath-singular 10.6.31rc3__cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl

sage_wheels/share/singular/LIB/divisors.lib

@@ -0,0 +1,750 @@
+///////////////////////////////////////////////////////////////////////////////
+version="version divisors.lib 4.2.0.1 Jan_2021 "; // $Id: 654f5ddbed8add1d9fbdc300fee234bd650a9e6e $
+category = "Commutative Algebra";
+info="
+LIBRARY:  divisors.lib      Divisors and P-Divisors
+
+AUTHORS:  Janko Boehm       boehm@mathematik.uni-kl.de
+@*        Lars Kastner      kastner@math.fu-berlin.de
+@*        Benjamin Lorenz   blorenz@math.uni-frankfurt.de
+@*        Hans Schoenemann  hannes@mathematik.uni-kl.de
+@*        Yue Ren           ren@mathematik.uni-kl.de
+
+OVERVIEW:
+
+We implement a class divisor on an algebraic variety and methods
+for computing with them. Divisors are represented by tuples of ideals
+defining the positive and the negative part. In particular, we implement the group
+structure on divisors, computing global sections and testing linear
+equivalence.
+
+In addition to this we provide a class formaldivisor which implements
+integer formal sums of divisors (not necessarily prime). A formal divisor
+can be evaluated to a divisor, and a divisor can be decomposed into
+a formal sum.
+
+Finally we provide a class pdivisor which implements polyhedral formal sums of
+divisors (P-divisors) where the coefficients are assumed to be polyhedra with fixed tail cone.
+There is a function to evaluate a P-divisor on a vector in the dual of the tail cone. The
+result will be a formal divisor.
+
+
+REFERENCES:
+
+For the class divisor we closely follow Macaulay2's tutorial on divisors.
+
+
+PROCEDURES:
+
+makeDivisor(ideal,ideal)                        create a divisor
+divisorplus(divisor,divisor)                    add two divisors
+multdivisor(int,divisor)                        multiply a divisor by an integer
+negativedivisor(divisor)                        compute the negative of the divisor
+normalFormDivisor(divisor)                      normal form of a divisor
+isEqualDivisor(divisor,divisor)                 test whether two divisors are equal
+globalSections(divisor)                         compute the global sections of a divisor
+degreeDivisor(divisor)                          degree of a divisor
+linearlyEquivalent(divisor,divisor)             test whether two divisors a linearly equivalent
+effective(divisor)                              compute an effective divisor
+                                                linearly equivalent to a divisor
+
+makeFormalDivisor(list)                         make a formal integer sum of divisors
+evaluateFormalDivisor(formaldivisor)            evaluate a formal sum of divisors to a divisor
+formaldivisorplus(formaldivisor,formaldivisor)  add two formal divisors
+negativeformaldivisor(formaldivisor)            compute the negative of the formal divisor
+multformaldivisor(int,formaldivisor)            multiply a formal divisor by an integer
+degreeFormalDivisor(formaldivisor)              degree of a formal divisor
+
+makePDivisor(List)                              make a formal polyhedral sum of divisors
+
+
+";
+
+
+////////////////////////////////////////////////////////////////////////////////
+
+LIB "primdec.lib";
+
+static proc mod_init()
+{
+LIB"customstd.lib";
+LIB"gfan.lib";
+newstruct("divisor","ideal den,ideal num");
+newstruct("formaldivisor","list summands");
+newstruct("pdivisor","list summands, cone tail");
+
+system("install","divisor","print",divisor_print,1);
+system("install","divisor","+",divisorplus,2);
+system("install","divisor","*",proxymultdivisor,2);
+system("install","formaldivisor","print",formaldivisor_print,1);
+system("install","formaldivisor","+",formaldivisorplus,2);
+system("install","formaldivisor","*",proxymultformaldivisor,2);
+}
+
+
+
+proc divisor_print(divisor D)
+"USAGE:  divisor_print(D); D; D = divisor. @*
+ASSUME:  D is a divisor.
+RETURN:  Will print D.
+KEYWORDS: divisors
+EXAMPLE: example divisor_print; shows an example
+"
+{
+"("+string(D.num)+") - ("+string(D.den)+")";
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor P = makeDivisor(ideal(x,z),ideal(1));
+P;
+}
+
+
+proc formaldivisor_print(formaldivisor fD)
+"USAGE:  formaldivisor_print(D); D; D = formaldivisor. @*
+ASSUME:  fD is a formaldivisor.
+RETURN:  Will print fD.
+KEYWORDS: divisors
+EXAMPLE: example formaldivisor_print; shows an example
+"
+{
+  int i; string s; list L=fD.summands;
+  list cd; int c; divisor d;
+  string linebreak =
+"
+";
+  for (i=1; i<=size(L); i++)
+  {
+    cd=L[i]; c=cd[1]; d=cd[2];
+    if (i>1 && c>=0) { s = s + "+"; }
+    s = s + string(c)+"*( ("+string(d.num)+") - ("+string(d.den)+") )";
+    if (i!=size(L)) { s = s + linebreak; }
+  }
+  s;
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor P = makeDivisor(ideal(x,z),ideal(1));
+P;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// divisors as numerator and denomiator ideals
+
+proc makeDivisor(ideal I, ideal J)
+"USAGE:  makeDivisor(I ,J); I = ideal, J = ideal. @*
+ASSUME:  I and J are ideals in a qring Q of a smooth irreducible variety X
+         such that any ideal in Q satisfies the S2 condition.
+RETURN:  a divisor on X
+THEORY:  The procedure will eliminate all components which are not of codimension 1.
+         The S2 condition requires that every proper nonzero principal ideal
+         has pure codimension 1.
+KEYWORDS: divisors
+EXAMPLE: example makeDivisor; shows an example
+"
+{
+divisor C;
+C.num = purify1(I);
+C.den = purify1(J);
+return(C);
+}
+
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor P = makeDivisor(ideal(x,z),ideal(1));
+}
+
+
+proc divisorplus(divisor A, divisor B)
+"USAGE:  divisorplus(A ,B); A + B; A = divisor, B = divisor. @*
+ASSUME:  A and B are divisors on X.
+RETURN:  a divisor on X
+THEORY:  The procedure will compute the product of the numerator
+         and denominator ideals, respectively.
+KEYWORDS: divisors
+EXAMPLE: example divisorplus; shows an example
+"
+{
+return(makeDivisor(interred(A.num*B.num),interred(A.den*B.den)));
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+A+B;
+}
+
+
+proc multdivisor(int n, divisor A)
+"USAGE:  multdivisor(n ,A); A*n; n = integer, A = divisor.@*
+ASSUME:  n is an integer and A is a divisor on X.
+RETURN:  a divisor on X
+THEORY:  The procedure will compute the n-th power of the numerator
+         and denominator ideals, respectively.
+KEYWORDS: divisors
+EXAMPLE: example multdivisor; shows an example
+"
+{
+if (n<0) {return(multdivisor(-n,negativedivisor(A)));}
+return(makeDivisor(interred((A.num)^n),interred((A.den)^n)));
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+A;
+divisor D = multdivisor(4,A);
+D;
+A*4;
+}
+
+
+/***
+ * For operator overloading, which needs a procedure which takes a divisor first
+ * and integer second.
+ **/
+proc proxymultdivisor(divisor A, int n)
+{
+if (n<0) {return(multdivisor(-n,negativedivisor(A)));}
+return(makeDivisor(interred((A.num)^n),interred((A.den)^n)));
+}
+
+
+proc negativedivisor(divisor A)
+"USAGE:  negativedivisor(A); A*(-1); A = divisor.@*
+ASSUME:  A is a divisor on X.
+RETURN:  a divisor on X
+THEORY:  The procedure will interchange the numerator and denominator ideals.
+KEYWORDS: divisors
+EXAMPLE: example negativedivisor; shows an example
+"
+{
+divisor B;
+B.num=A.den;
+B.den=A.num;
+return(B);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+A;
+divisor D = negativedivisor(A);
+D;
+}
+
+
+proc normalFormDivisor(divisor A)
+"USAGE:  normalFormDivisor(A); A = divisor.@*
+ASSUME:  A is a divisor on X.
+RETURN:  different representative of the same divisor on X
+THEORY:  The procedure will cancel common components of numerator and denominator.
+KEYWORDS: divisors
+EXAMPLE: example normalFormDivisor; shows an example
+"
+{
+divisor B;
+B.num=quotient(A.num,A.den);
+B.den=quotient(A.den,A.num);
+return(B);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+divisor D = (A+B)+multdivisor(-1,B);
+D;
+normalFormDivisor(D);
+}
+
+
+
+
+static proc isEqualIdeal(ideal A,ideal B){
+return((size(NF(A,std(B)))==0) && (size(NF(B,std(A)))==0));
+}
+
+
+proc isEqualDivisor(divisor A,divisor B)
+"USAGE:  isEqualDivisor(A,B); A = divisor, B = divisor.@*
+ASSUME:  A and B are divisors on X.
+RETURN:  int 0 or 1, checks equality of A and B.
+THEORY:  The procedure will compute the normal forms of A and B and compare.
+KEYWORDS: divisors
+EXAMPLE: example isEqualDivisor; shows an example
+"
+{
+A=normalFormDivisor(A);
+B=normalFormDivisor(B);
+return((isEqualIdeal(A.num,B.num)) && (isEqualIdeal(A.den,B.den)));
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+divisor D = (A+B)+multdivisor(-1,B);
+isEqualDivisor(A,D);
+}
+
+
+static proc purify1(ideal I)
+{
+I = simplify(I,2);
+if (I[1]==0){ERROR("expected a non-zero ideal");}
+ideal f = I[1];
+return(minbase(quotient(f,quotient(f,I))));
+}
+
+
+static proc basis(ideal I,int d)
+{
+I=simplify(jet(intersect(I,maxideal(d)),d),2);
+return(I)}
+
+//basis(ideal(x,y^3),2);
+
+
+proc globalSections(divisor D)
+"USAGE:  globalSections(A); A = divisor.@*
+ASSUME:  A is a divisor on X.
+RETURN:  a list with a basis of the space of global sections of D.
+THEORY:  We assume that the qring of X satisfies the S2-condition and that X is smooth. We compute sat((f*J) : I) /f
+         where D = (I)-(J).
+KEYWORDS: divisors
+EXAMPLE: example globalSections; shows an example
+"
+{
+poly f =(simplify(D.num,2))[1];
+ideal LD = basis(purify1(quotient(f*D.den,D.num)),deg(f));
+list L = simplify(LD,2),f;
+return(L);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor P = makeDivisor(ideal(x,z),ideal(1));
+divisor D = multdivisor(4,P);
+globalSections(D);
+}
+
+
+static proc sectionIdeal(poly f, poly g, divisor D){
+return(purify1(quotient(quotient(f*D.num,g), D.den)));
+}
+
+proc degreeDivisor(divisor A)
+"USAGE:  degreeDivisor(A); A = divisor.@*
+ASSUME:  A is a divisor on X.
+RETURN:  The degree of A.
+THEORY:  We compute difference of the degrees of the numerator and denominator ideals.
+KEYWORDS: divisors
+EXAMPLE: example degreeDivisor; shows an example
+"
+{
+  return( mult(std(A.num))-mult(std(A.den)));
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor P = makeDivisor(ideal(x,z),ideal(1));
+degreeDivisor(P);
+}
+
+proc linearlyEquivalent(divisor A, divisor B)
+"USAGE:  linearlyEquivalent(A,B); A = divisor, B = divisor.@*
+ASSUME:  A and B are divisors on X.
+RETURN:  list if A and B a linearly equivalent and int 0 otherwise.
+THEORY:  Checks whether A-B is principle. If yes, returns a list L=(f,g) where
+         A - B = (f/g).
+KEYWORDS: divisors
+EXAMPLE: example linearlyEquivalent; shows an example
+"
+{
+divisor F = normalFormDivisor(divisorplus(A,negativedivisor(B)));
+list LB = globalSections(F);
+if (size(LB[1])!=1) {return(0);}
+ideal V = sectionIdeal(LB[1][1,1],LB[2],F);
+if (isEqualIdeal(V,ideal(1))==1) {return(list(LB[1][1,1],LB[2]));}
+return(0);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+linearlyEquivalent(A,B);
+linearlyEquivalent(multdivisor(2,A),multdivisor(2,B));
+}
+
+
+proc effective(divisor A)
+"USAGE:  effective(A); A = divisor.@*
+ASSUME:  A is a divisor on X which is linearly equivalent to an effective divisor.
+RETURN:  divisor on X.
+THEORY:  We compute an effective divisor linearly equivalent to A.
+KEYWORDS: divisors
+EXAMPLE: example effective; shows an example
+"
+{
+list LB = globalSections(A);
+if (size(LB[1])==0) {ERROR("the divisor is not linearly equivalent to an effective divisor");}
+ideal V = sectionIdeal(LB[1][1,1],LB[2],A);
+return(makeDivisor(V,ideal(1)));
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+divisor D = divisorplus(multdivisor(2,B),negativedivisor(A));
+effective(D);
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// formal sums of divisors
+
+proc makeFormalDivisor(list L)
+"USAGE:  makeFormalDivisor(L); L = list.@*
+ASSUME:  L is a list of tuples of an integer and a divisor.
+RETURN:  a formal divisor on X
+THEORY:  Represents an integer formal sum of divisors.
+KEYWORDS: divisors
+EXAMPLE: example makeFormalDivisor; shows an example
+"
+{
+formaldivisor C;
+C.summands = L;
+return(C);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+makeFormalDivisor(list(list(-5,A),list(2,B)));
+}
+
+
+proc evaluateFormalDivisor(formaldivisor D)
+"USAGE:  evaluateFormalDivisor(D); D = formal divisor.@*
+ASSUME:  D is a formal divisor on X.
+RETURN:  a divisor on X
+THEORY:  Will evaluate the formal sum.
+KEYWORDS: divisors
+EXAMPLE: example evaluateFormalDivisor; shows an example
+"
+{
+list L = D.summands;
+if (size(L)==0) {return(makeDivisor(ideal(1),ideal(1)));}
+int i;
+divisor E = multdivisor(L[1][1],L[1][2]);
+  for ( i=2; i <= size(L); i++ )
+  {
+    E = divisorplus(E, multdivisor(L[i][1],L[i][2]));
+  }
+return(E);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+formaldivisor fE= makeFormalDivisor(list(list(-5,A),list(2,B)));
+evaluateFormalDivisor(fE);
+}
+
+
+
+static proc position(divisor I,list L){
+int i;
+for (i=1; i <=size(L); i++){
+   if (isEqualDivisor(I,L[i][2])==1) {return(i);}
+}
+return(0);}
+
+
+proc formaldivisorplus(formaldivisor A, formaldivisor B)
+"USAGE:  formaldivisorplus(A ,B); A + B; A = formaldivisor, B = formaldivisor. @*
+ASSUME:  A and B are formal divisors on X.
+RETURN:  a formal divisor on X
+THEORY:  The procedure will add the formal sums.
+KEYWORDS: divisors
+EXAMPLE: example formaldivisorplus; shows an example
+"
+{
+formaldivisor C;
+int i,p;
+int j=1;
+list L;
+list LA=A.summands;
+list LB=B.summands;
+for (i=1; i<=size(LA);i++){
+   p=position(LA[i][2],L);
+   if (p==0) {
+        L[j]=list();
+        L[j][2]=LA[i][2];
+        L[j][1]=LA[i][1];
+        j=j+1;
+   } else {
+        L[p][1]=L[p][1]+LA[i][1];
+   };
+}
+for (i=1; i<=size(LB);i++){
+   p=position(LB[i][2],L);
+   if (p==0) {
+        L[j]=list();
+        L[j][2]=LB[i][2];
+        L[j][1]=LB[i][1];
+        j=j+1;
+   } else {
+        L[p][1]=L[p][1]+LB[i][1];
+   };
+}
+//C.summands = (A.summands)+(B.summands);
+return(L);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+divisor C = makeDivisor(ideal(x-z,y),ideal(1));
+formaldivisor fE= makeFormalDivisor(list(list(-5,A),list(2,B)));
+formaldivisor fE2= makeFormalDivisor(list(list(-5,A),list(2,C)));
+formaldivisorplus(fE,fE2);
+}
+
+
+proc degreeFormalDivisor(formaldivisor A)
+"USAGE:  degreeFormalDivisor(A); A = formaldivisor.@*
+ASSUME:  A is a formaldivisor on X.
+RETURN:  The degree of A.
+THEORY:  We compute degrees of the summands and return the weighted sum.
+KEYWORDS: divisors
+EXAMPLE: example degreeFormalDivisor; shows an example
+"
+{
+int i,s;
+list L = A.summands;
+for (i=1;i<=size(L);i++){
+    s=s+L[i][1]*degreeDivisor(L[i][2]);
+}
+return(s);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+formaldivisor fE= makeFormalDivisor(list(list(-5,A),list(2,B)));
+degreeFormalDivisor(fE);
+}
+
+
+proc multformaldivisor(int n,formaldivisor A)
+"USAGE:  multformaldivisor(n ,A); A*n; n = integer, A = formaldivisor.@*
+ASSUME:  n is an integer and A is a formal divisor on X.
+RETURN:  a formal divisor on X
+THEORY:  The procedure will multiply the formal sum with n.
+KEYWORDS: divisors
+EXAMPLE: example multformaldivisor; shows an example
+"
+{
+formaldivisor B;
+list L=A.summands;
+int i;
+for (i=1;i<=size(L);i++){
+  L[i][1]=n*L[i][1];
+}
+B.summands=L;
+return(B);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+formaldivisor fE= makeFormalDivisor(list(list(-5,A),list(2,B)));
+fE*2;
+}
+
+
+/***
+ * For operator overloading, which needs a procedure which takes a divisor first
+ * and integer second.
+ **/
+proc proxymultformaldivisor(formaldivisor A, int n)
+{
+formaldivisor B;
+list L=A.summands;
+int i;
+for (i=1;i<=size(L);i++){
+  L[i][1]=n*L[i][1];
+}
+B.summands=L;
+return(B);
+}
+
+
+
+proc negativeformaldivisor(formaldivisor A)
+"USAGE:  negativeformaldivisor(A); A = formaldivisor.@*
+ASSUME:  A is a formaldivisor on X.
+RETURN:  a formal divisor on X
+THEORY:  The procedure will change the signs of the coefficients.
+KEYWORDS: divisors
+EXAMPLE: example negativeformaldivisor; shows an example
+"
+{
+formaldivisor B;
+list L=A.summands;
+int i;
+for (i=1;i<=size(L);i++){
+  L[i][1]=-L[i][1];
+}
+B.summands=L;
+return(B);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+formaldivisor fE= makeFormalDivisor(list(list(-5,A),list(2,B)));
+negativeformaldivisor(fE);
+}
+
+
+static proc primDecDivisor(divisor D)
+"decompose a divisor into a formal divisor of primary divisors"
+{
+formaldivisor E;
+ideal I = D.num;
+ideal J = D.den;
+list L;
+int i;
+int j = 1;
+list LI = primdecGTZ(I);
+for (i=1;i<=size(LI);i++){
+   LI[i][2];
+   L[j]=list(1,makeDivisor(LI[i][1],ideal(1)));
+   j=j+1;
+};
+list LJ = primdecGTZ(J);
+for (i=1;i<=size(LJ);i++){
+   LJ[i][2];
+   L[j]=list(-1,makeDivisor(LJ[i][1],ideal(1)));
+   j=j+1;
+};
+E.summands=L;
+return(E);}
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// P-divisors
+
+proc makePDivisor(list L)
+"USAGE:  makePDivisor(L); L = list.@*
+ASSUME:  L is a list of tuples of a integral polyhedron and a divisor such that
+         all polyhedra have the same tail cone.
+RETURN:  a pdivisor on X
+THEORY:  Represents an polyhedral formal sum of divisors.
+KEYWORDS: divisors, polyhedra
+EXAMPLE: example makePDivisor; shows an example
+"
+{
+pdivisor P;
+list CP = decomposePolyhedron(L[1][1]);
+P.tail = CP[1];
+list LP;
+LP[1]=list(CP[2],L[1][2]);
+int i;
+for (i=2; i<=size(L);i++){
+   CP = decomposePolyhedron(L[i][1]);
+   if (!(CP[1]==P.tail)) {ERROR("All P-coefficients should have the same tail cone");}
+   LP[i]=list(CP[2],L[i][2]);
+}
+P.summands = LP;
+return(P);
+}
+example
+{ "EXAMPLE:";
+ring r=31991,(x,y,z),dp;
+ideal I = y^2*z - x*(x-z)*(x+3*z);
+qring Q = std(I);
+divisor A = makeDivisor(ideal(x,z),ideal(1));
+divisor B = makeDivisor(ideal(x,y),ideal(1));
+intmat M[4][4]= 1,4,0,0,
+                1,0,3,0,
+                0,0,0,2,
+                1,1,1,1;
+polytope PP = polytopeViaPoints(M);
+makePDivisor(list(list(PP,A),list(PP,B)));
+}
+
+static proc decomposePolyhedron(polytope P){
+bigintmat rays = vertices(P);
+bigintmat rays2 = rays;
+int i,j;
+for (i=1; i<=nrows(rays);i++){
+   if (rays[i,1]==1) {
+      for (j=1; j<=ncols(rays);j++){
+         rays[i,j]=0;
+      }
+   } else {
+      for (j=1; j<=ncols(rays);j++){
+         rays2[i,j]=0;
+      }
+   }
+}
+cone C = coneViaPoints(rays);
+polytope C2 = polytopeViaPoints(rays2);
+return(list(C,C2));
+}