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

sage_wheels/share/singular/LIB/ellipticcovers.lib

@@ -0,0 +1,548 @@
+///////////////////////////////////////////////////////////////////////////////
+version="version ellipticcovers.lib 4.1.2.0 Feb_2019 ";
+category="Commutative algebra";
+info="
+LIBRARY:  ellipticCovers.lib    Gromov-Witten numbers of elliptic curves
+
+AUTHORS:  J. Boehm, boehm @ mathematik.uni-kl.de
+          A. Buchholz, buchholz @ math.uni-sb.de
+          H. Markwig   hannah @ math.uni-sb.de
+
+OVERVIEW:
+
+We implement a formula for computing the number of covers of elliptic curves.
+It has been obtained by proving mirror symmetry
+for arbitrary genus by tropical methods in [BBM]. A Feynman graph of genus
+g is a trivalent, connected graph of genus g (with 2g-2 vertices
+and 3g-3 edges). The branch type b=(b_1,...,b_(3g-3)) of a stable map is the
+multiplicity of the the edge i over a fixed base point.
+
+Given a Feynman graph G and a branch type b, we obtain the number
+N_(G,b) of stable maps of branch type b from a genus g curve of topological type G
+to the elliptic curve by computing a path integral
+over a rational function. The path integral is computed as a residue.
+
+The sum of N_(G,b) over all branch types b of sum d gives N_(G,d)*|Aut(G)|, with the
+Gromov-Witten invariant N_(G,d) of degree d stable maps from a genus g curve
+of topological type G to the elliptic curve.
+
+The sum of N_(G,d) over all such graphs gives the usual Gromov-Witten invariant N_(g,d)
+of degree d stable maps from a genus g curve to the elliptic curve.
+
+The key function computing the numbers N_(G,b) and N_(G,d) is gromovWitten.
+
+REFERENCES:
+
+[BBM] J. Boehm, A. Buchholz, H. Markwig: Tropical mirror symmetry for elliptic curves, arXiv:1309.5893 (2013).
+
+KEYWORDS:
+tropical geometry; mirror symmetry; tropical mirror symmetry; Gromov-Witten invariants; elliptic curves; propagator; Feynman graph; path integral
+
+TYPES:
+
+graph
+
+PROCEDURES:
+
+makeGraph(list, list)                     generate a graph from a list of vertices and a list of edges
+printGraph(graph)                         print procedure for graphs
+propagator(list,int)                      propagator factor of degree d in the quotient of two variables, or
+                                          propagator for fixed graph and branch type
+computeConstant(number, number)           constant coefficient in the Laurent series expansion of a rational function in a given variable
+evaluateIntegral(number, list)            path integral for a given propagator and ordered sequence of variables
+gromovWitten(number)                      sum of path integrals for a given propagator over all orderings of the variables, or
+                                          Gromov Witten invariant for a given graph and a fixed branch type, or
+                                          list of Gromov Witten invariants for a given graph and all branch types
+computeGromovWitten(graph, int, int)      compute the Gromov Witten invariants for a given graph and some branch types
+generatingFunction (graph, int)           multivariate generating function for the Gromov Witten invariants of a graph up to fixed degree
+
+partitions(int, int)                      partitions of an integer into a fixed number of summands
+permute(list)                             all permutations of a list
+lsum(list)                                sum of the elements of a list
+
+";
+
+
+LIB "parallel.lib";
+
+
+static proc mod_init()
+{
+  newstruct("graph","list vertices, list edges");
+  newstruct("Net","list rows");
+
+  system("install","graph","print",printGraph,1);
+  system("install","Net","print",printNet,1);
+  system("install","Net","+",catNet,2);
+}
+
+static proc catNet(Net N, Net M)
+{
+  list L;
+  list LN=N.rows;
+  list LM=M.rows;
+  int widthN=size(LN[1]);
+  int widthM=size(LM[1]);
+  int nm=max(size(LN),size(LM));
+  for (int j=1; j<=nm; j++)
+  {
+    if (j>size(LN)){LN[j]=emptyString(widthN);}
+    if (j>size(LM)){LM[j]=emptyString(widthM);}
+    L[j]=LN[j]+LM[j];
+  }
+  Net NM;
+  NM.rows=L;
+  return(NM);
+}
+
+
+static proc netList(list L1)
+{
+  Net N=net("[");
+  for (int j=1; j<=size(L1)-1; j++)
+  {
+     N=N+net(L1[j])+net(", ");
+  }
+  N=N+net(L1[size(L1)])+net("]");
+  return(N);
+}
+
+static proc printNet(Net N)
+{
+  list L = N.rows;
+  for (int j=1; j<=size(L); j++)
+  {
+    print(L[j]);
+  }
+}
+
+static proc net(def M)
+{
+  if (typeof(M)=="list")
+  {
+    return(netList(M));
+  }
+  Net N;
+  list L;
+  L[1]=string(M);
+  N.rows=L;
+  return(N);
+}
+
+
+
+proc printGraph(graph G)
+"USAGE:  printGraph(G); G graph@*
+ASSUME:  G is a graph.
+THEORY:  This is the print function used by Singular to print a graph.
+KEYWORDS: graph
+EXAMPLE:  example printGraph; shows an example
+"
+{
+  print(netList(G.edges));
+  print("Graph with "+string(size(G.vertices))+" vertices and "+string(size(G.edges))+" edges")
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
+  graph G = makeGraph(list(1,2,3,4),list(list(1,3),list(1,2),list(1,2),list(2,4),list(3,4),list(3,4)));
+  G;
+}
+
+proc makeGraph(list v, list e)
+"USAGE:  makeGraph(v,e); v list, e list@*
+ASSUME:  v is a list of integers, e is a list of two element lists of v.
+RETURN:  graph with vertices v and edges e
+THEORY:  Creates a graph from a list of vertices and edges. The vertices can be any type.
+KEYWORDS: graph
+EXAMPLE:  example printGraph; shows an example
+"
+{
+  graph G;
+  G.vertices = v;
+  G.edges = e;
+  return(G);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
+  graph G = makeGraph(list(1,2,3,4),list(list(1,3),list(1,2),list(1,2),list(2,4),list(3,4),list(3,4)));
+  G;
+}
+
+proc propagator(def xy, def d)
+"USAGE:  propagator(xy,d); xy list, d int@*
+         propagator(G,b); G graph, b list@*
+ASSUME:  xy is a list of two numbers x and y in a rational function field, d non-negative integer.@*
+         G is a Feynman graph, a is a list of integers of length equal to the number of edges of G.@*
+         We assume that the coefficient ring has one rational variable for each vertex of G.
+RETURN:  number, the propagator associated to the input data.
+THEORY:  If xy and d are specified, then the function returns x^2*y^2/(x^2-y^2)^2) for d=0, which
+         is a associated to an edge with vertices x and y not passing above the base point.
+         For d>0 it returns the sum of (j*x^(4*j)+j*y^(4*j))/(x*y)^(2*j) over all divisors j of d,
+         which is associated to an edge with vertices x and y passing with multiplicity d above the base point.
+
+         Essentially the variables x and y stand for the position of the base points.
+
+         In the second way of using this function, G is a Feynman graph and b is a branch type
+         over a fixed base point of a cover with source G and target an elliptic curve. It returns the
+         product of propagator(list(v[i],w[i]),b[i]) over all edges i with multiplicity b[i] over the base point
+         and vertices v[i] and w[i].
+
+KEYWORDS: elliptic curve
+EXAMPLE:  example propagator; shows an example
+"
+{
+  if ((typeof(xy)=="list")||(typeof(d)=="int"))
+  {
+    number x = xy[1];
+    number y = xy[2];
+    if (d<0) {ERROR("expected non-negative degree");}
+    if (d==0) {return(x^2*y^2/(x^2-y^2)^2);}
+    number p=0;
+    for (int j=1; j<=d; j++)
+    {
+       if (d%j==0){p=p+(j*x^(4*j)+j*y^(4*j))/(x*y)^(2*j);}
+    }
+    return(p);
+  }
+  if ((typeof(xy)=="graph")||(typeof(d)=="list"))
+  {
+    list xl = ringlist(basering)[1][2];
+    list ed = xy.edges;
+    number f=1;
+    for (int j=1; j<=size(ed); j++)
+    {
+       execute("number xx1 = "+xl[ed[j][1]]);
+       execute("number xx2 = "+xl[ed[j][2]]);
+       f=f*propagator(list(xx1,xx2),d[j]);
+       kill xx1;
+       kill xx2;
+    }
+    return(f);
+  }
+  if ((typeof(xy)=="graph")||(typeof(d)=="int"))
+  {
+  }
+  ERROR("wrong input type");
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
+  graph G = makeGraph(list(1,2,3,4),list(list(1,3),list(1,2),list(1,2),list(2,4),list(3,4),list(3,4)));
+  propagator(list(x1,x2),0);
+  propagator(list(x1,x2),2);
+  propagator(G,list(1,1,1,0,0,0));
+}
+
+proc computeConstant(number f,number xx)
+"USAGE:  computeConstant(f,x); f number, x number@*
+ASSUME:  f is a number in a rational function field, x is a variable of the field.@*
+RETURN:  number, the constant coefficient of the Laurent series of f in the variable x.
+THEORY:  Computes the constant coefficient of the Laurent series by iterative differentiation.
+KEYWORDS: Laurent series
+EXAMPLE:  example computeConstant; shows an example
+"
+{
+  int tst=0;
+  number ff=f;
+  int k;
+  int j;
+  poly de;
+  while (tst==0)
+  {
+    ff=f*xx^k;
+    for (j=1; j<=k; j++)
+    {
+      ff=diff(ff,xx)/j;
+    }
+    de = subst(denominator(ff),xx,0);
+    if (de!=0)
+    {
+      poly nu = subst(numerator(ff),xx,0);
+      return(number(nu/de));
+    }
+    k++;
+  }
+  ERROR("error in computeConstant");
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
+  graph G = makeGraph(list(1,2,3,4),list(list(1,3),list(1,2),list(1,2),list(2,4),list(3,4),list(3,4)));
+  number P = propagator(G,list(1,1,1,0,0,0));
+  computeConstant(P,x2);
+}
+
+proc evaluateIntegral(number P, list xL)
+"USAGE:  evaluateIntegral(P,xx); P number, xx list@*
+ASSUME:  P is a number in a rational function field, xx is a list of variables of the field@*
+RETURN:  number, the constant coefficient of the Laurent series of f in the variables in the list xx.
+THEORY:  Computes the constant coefficient of the Laurent series iteratively for the elements of xx.
+
+         In the setting of covers of elliptic curves this is the path integral over the
+         propagator divided by the product of all variables (corresponding to the vertices)
+         computed as a residue.
+
+KEYWORDS: residue; Laurent series
+EXAMPLE:  example evaluateIntegral; shows an example
+"
+{
+  number p = P;
+  for(int j=1; j<=size(xL); j++)
+  {
+     p=computeConstant(p,xL[j]);
+  }
+  return(p);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
+  graph G = makeGraph(list(1,2,3,4),list(list(1,3),list(1,2),list(1,2),list(2,4),list(3,4),list(3,4)));
+  number p = propagator(G,list(0,2,1,0,0,1));
+  evaluateIntegral(p,list(x1,x3,x4,x2));
+}
+
+proc permute (list N)
+"USAGE:  permute(N); N list@*
+ASSUME:  N is a list@*
+RETURN:  list with all permutations of N.
+THEORY:  Computes all permutations of N.
+
+         This will eventually be deleted and become a more efficient kernel function.
+
+KEYWORDS: permutations
+EXAMPLE:  example permute; shows an example
+"
+{
+  int i,j,k;
+  list L,L1;
+  if (size(N)==1)
+  {
+    return(list(N));
+  }
+  else
+  {
+    k=1;
+    for (i=1; i<=size(N); i++)
+    {
+      L=permute(delete(N,i));
+      for (j=1; j<=size(L); j++)
+      {
+        L1[k]=L[j]+list(N[i]);
+        k=k+1;
+      }
+    }
+  }
+  return(L1);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2,x3,x4),(q),dp;
+  permute(list(x1,x2,x3,x4));
+}
+
+
+
+proc partitions(int n, int a)
+"USAGE:  partitions(n,a); n int, a int@*
+ASSUME:  n and a  are positive integers@*
+RETURN:  list of all partitions of a into n summands.
+THEORY:  Computes all partitions of a into n summands.
+
+         This may eventually be deleted and become a more efficient kernel function.
+
+KEYWORDS: partitions
+EXAMPLE:  example partitions; shows an example
+"
+{
+  ring R = 2,(x(1..n)),dp;
+  ideal I = maxideal(a);
+  list L;
+  for (int j=1;j<=size(I);j++)
+  {
+    L[j]=leadexp(I[j]);
+  }
+  return(L);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  partitions(3,7);
+}
+
+proc gromovWitten(def P,list #)
+"USAGE:  gromovWitten(P); P number@*
+         gromovWitten(G,d); G graph, d int@*
+         gromovWitten(G,b); G graph, b list@*
+ASSUME:  P is a propagator, or @*
+         G is a Feynman graph and d a non-negative integer, or@*
+         G is a Feynman graph and b is a list of integers of length equal to the number of edges of G@*
+         We assume that the coefficient ring has one rational variable for each vertex of G.@*
+RETURN:  Gromov-Witten invariant.
+THEORY:  Computes @*
+
+         - the Gromov-Witten invariant of a given propagator P, or @*
+
+         - the invariant N_(G,d)*|Aut(G)| where d is the degree of the covering, or @*
+
+         - the number N_(G,b) of coverings with source G and target an elliptic curves with branch type a over a
+         fixed base point (that is, the i-th edge passes over the base point with multiplicity b[i]).@*
+
+KEYWORDS: Gromov-Witten invariants; elliptic curves; coverings; Hurwitz numbers
+EXAMPLE:  example gromovWitten; shows an example
+"
+{
+  if (typeof(P)=="number")
+  {
+    list xl = ringlist(basering)[1][2];
+    int j;
+    for(j=1; j<=size(xl); j++)
+    {
+      execute("number n= "+xl[j]);
+      xl[j]=n;
+      kill n;
+    }
+    list pxl = permute(xl);
+    number p = 0;
+    for(j=1; j<=size(pxl); j++)
+    {
+      p=p+evaluateIntegral(P,pxl[j]);
+    }
+    return(p);
+  }
+  if (typeof(P)=="graph")
+  {
+    if (size(#)>1)
+    {
+      return(gromovWitten(propagator(P,#)));
+    }
+    else
+    {
+      int d =#[1];
+      list pa = partitions(size(P.edges),d);
+      list re;
+      int ti;
+      for (int j=1; j<=size(pa); j++)
+      {
+        ti=timer;
+        re[j]=gromovWitten(propagator(P,pa[j]));
+        ti=timer-ti;
+        //print(string(j)+" / "+string(size(pa))+"    "+string(pa[j])+"     "+string(re[j])+"      "+string(sum(re))+"     "+string(ti));
+      }
+      return(lsum(re));
+    }
+  }
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
+  graph G = makeGraph(list(1,2,3,4),list(list(1,3),list(1,2),list(1,2),list(2,4),list(3,4),list(3,4)));
+  number P = propagator(G,list(0,2,1,0,0,1));
+  gromovWitten(P);
+  gromovWitten(G,list(0,2,1,0,0,1));
+  gromovWitten(G,2);
+}
+
+proc computeGromovWitten(graph P,int d, int st, int en, list #)
+"USAGE:  computeGromovWitten(G, d, st, en [, vb] ); G graph, d int, st int, en  int, optional: vb int@*
+ASSUME:  G is a Feynman graph, d a non-negative integer, st specified the start- and en the end partition
+         in the list pa = partition(d). Specifying a positive optional integer vb leads to intermediate printout.@*
+         We assume that the coefficient ring has one rational variable for each vertex of G.@*
+RETURN:  list L, where L[i] is gromovWitten(G,pa[i]) and all others are zero.
+THEORY:  This function does essentially the same as the function gromovWitten, but is designed for handling complicated examples.
+         Eventually it will also run in parallel.@*
+
+KEYWORDS: Gromov-Witten invariants; elliptic curves; coverings; Hurwitz numbers
+EXAMPLE:  example computeGromovWitten; shows an example
+"
+{
+  number s =0;
+  list pararg;
+  list re;
+  list pa = partitions(size(P.edges),d);
+  int vb=0;
+  if (size(#)>0){vb=#[1];}
+  int ti;
+  if (vb>0){print(size(pa));}
+  for (int j=1; j<=size(pa); j++)
+  {
+    if ((j>=st)&(j<=en))
+    {
+      ti=timer;
+      //pararg[j]=list(propagator(G,pa[j]));
+      re[j]=gromovWitten(propagator(P,pa[j]));
+      ti=timer-ti;
+      if (vb>0){print(string(j)+" / "+string(size(pa))+"    "+string(pa[j])+"     "+string(re[j])+"      "+string(lsum(re))+"     "+string(ti));}
+    }
+    else
+    {re[j]=s;}
+  }
+  //list re = parallelWaitAll("gromovWitten", pararg, list(list(list(2))));
+  return(re);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2,x3,x4),(q1,q2,q3,q4,q5,q6),dp;
+  graph G = makeGraph(list(1,2,3,4),list(list(1,3),list(1,2),list(1,2),list(2,4),list(3,4),list(3,4)));
+  partitions(6,2);
+  computeGromovWitten(G,2,3,7);
+  computeGromovWitten(G,2,3,7,1);
+}
+
+proc lsum(list L)
+"USAGE:  lsum(L); L list@*
+ASSUME:  L is a list of things with the binary operator + defined.@*
+RETURN:  The sum of the elements of L.
+THEORY:  Sums the elements of a list.
+
+         Eventually this will be deleted and become a more efficient kernel function.@*
+
+EXAMPLE:  example lsum; shows an example
+"
+{
+  execute(typeof(L[1])+" s");
+  for(int j=1; j<=size(L); j++)
+  {
+    s=s+L[j];
+  }
+  return(s);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  list L = 1,2,3,4,5;
+  lsum(L);
+}
+
+proc generatingFunction(graph G, int d)
+"USAGE:  generatingFunction(G, d); G graph, d int@*
+ASSUME:  G is a Feynman graph, d a non-negative integer. The basering has one polynomial variable for each
+         edge, and the coefficient ring has one rational variable for each vertex.@*
+RETURN:  poly.
+THEORY:  This function compute the multivariate generating function of all Gromov-Witten invariants up to
+         degree d, that is, the sum of all gromovWitten(G,b)*q^b.@*
+
+KEYWORDS: generating function; Gromov-Witten invariants; elliptic curves; coverings; Hurwitz numbers
+EXAMPLE:  example generatingFunction; shows an example
+"
+{
+  poly  s =0;
+  int j,jj;
+  list pa,L;
+  for (j=1; j<=d; j++)
+  {
+    pa = partitions(size(G.edges),j);
+    L = computeGromovWitten(G,j,1,size(pa));
+    for (jj=1; jj<=size(pa); jj++)
+    {
+      s=s+L[jj]*monomial(pa[jj]);
+    }
+  }
+  return(s);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  ring R=(0,x1,x2),(q1,q2,q3),dp;
+  graph G = makeGraph(list(1,2),list(list(1,2),list(1,2),list(1,2)));
+  generatingFunction(G,3);
+}
+

sage_wheels/share/singular/LIB/enumpoints.lib

@@ -0,0 +1,146 @@
+///////////////////////////////////////////////////////////////////////////////
+version="version enumpoints.lib 4.3.0.0 Jan_2022 "; // $Id: 97d1ede4878f36c0f90ebc61a7ecc2aba1038c68 $
+
+category="General purpose";
+info="
+LIBRARY: enumpoints.lib   enumerating rational points
+AUTHOR: Jieao Song (8d1h)
+KEYWORDS: multivariate equations; finite field
+
+PROCEDURES:
+ points(ideal I)         points in the zero set of I
+ projPoints(ideal I)     projective points in the zero set of the homogeneous I
+";
+///////////////////////////////////////////////////////////////////////////////
+// utility function that lists all elements in the ground field
+static proc listFieldElements()
+{
+  int k;
+  int ch = char(basering);
+  list els = list();
+  if (npars(basering)==0) { // Fp for p prime
+      for (k=ch-1;k>=0;k--) { els[k+1]=k; }
+  }
+  else
+  { // Fq defined by a minpoly
+    ideal fct = factorize(var(1)^(ch^pardeg(minpoly))-var(1),1);
+    for (k=size(fct);k>0;k--)
+    {
+      els[k]= -coeffs(fct[k],var(1))[1][1];
+    }
+  }
+  return(els);
+}
+///////////////////////////////////////////////////////////////////////////////
+// enumerate points coordinate by coordinate using elimination
+// i: the current coordinate to enumerate
+// part: partially determined coordinates
+// els: elements of the field
+static proc enumPoints(ideal I,int i,list part,list els)
+{
+  int k; ideal I1; list part1;
+  list ans = list();
+  int n = nvars(basering);
+  poly rest = 1;
+  for (k=i+1;k<=n;k++) { rest = rest*var(k); }
+  poly g = eliminate(I,rest)[1];
+  if (g!=0)
+  { // when the eliminant is non-trivial, only enumerate its zeros
+    vector cc; poly v;
+    ideal fct = factorize(g,1);
+    for (k=1;k<=ncols(fct);k++)
+    {
+      if (deg(fct[k])==1)
+      {
+        cc = coeffs(fct[k],var(i))[1];
+        part1 = part + list(-cc[1]/cc[2]);
+        if (i==n) { ans[size(ans)+1]=part1; }
+        else
+        {
+          I1 = std(reduce(I,fct[k]));
+          ans = ans + enumPoints(I1,i+1,part1,els);
+        }
+      }
+      // this can help find the splitting field
+      // else { printf("  // %p", fct[k]); }
+    }
+  }
+  else
+  { // otherwise enumerate over the entire field
+    for (k=1;k<=size(els);k++)
+    {
+      I1 = std(subst(I,var(i),els[k]));
+      if (dim(I1)>-1)
+      {
+        part1 = part + list(els[k]);
+        if (i==n) { ans[size(ans)+1]=part1; }
+        else { ans = ans + enumPoints(I1,i+1,part1,els); }
+      }
+    }
+  }
+  return(ans);
+}
+///////////////////////////////////////////////////////////////////////////////
+// enumerate points on a homogeneous ideal
+static proc enumProjPoints(ideal I,int i,list part,list els)
+{
+  int j; int k; ideal I1; list part1;
+  list ans = list();
+  int n = nvars(basering);
+  for (k=i;k<=n;k++)
+  { // find points of the form (1,..), (0,1,..), etc.
+    I1 = I;
+    part1 = part;
+    for (j=i;j<k;j++)
+    {
+      part1 = part1 + list(0);
+      I1 = subst(I1,var(j),0);
+    }
+    part1 = part1 + list(1);
+    I1 = std(subst(I1,var(k),1));
+    if (dim(I1)>-1)
+    {
+      if (k==n) { ans = ans + list(part1); }
+      else { ans = ans + enumPoints(I1,k+1,part1,els); }
+    }
+  }
+  return(ans);
+}
+///////////////////////////////////////////////////////////////////////////////
+// main interface
+proc points(ideal I)
+"USAGE: points(I);    I homogeneous ideal
+RETURN: list of coordinates of points on the zero set of I
+ASSUMES: dim(I)==0
+"
+{
+    if (char(basering)==0 and dim(I) > 0) { ERROR("over number fields the ideal must be 0-dimensional")};
+    return(enumPoints(I,1,list(),listFieldElements()));
+}
+///////////////////////////////////////////////////////////////////////////////
+proc projPoints(ideal I)
+// enumerate points on a homogeneous ideal
+"USAGE: projPoints(I);    I homogeneous ideal
+RETURN: list of coordinates of points on the zero set of I
+ASSUMES: dim(I)==0
+"
+{
+    if (!homog(I)) { ERROR("the ideal is not homogeneous"); }
+    if (char(basering)==0 and dim(I) > 1) { ERROR("over number fields the ideal must be 0-dimensional")};
+    return(enumProjPoints(I,1,list(),listFieldElements()));
+}
+example
+{
+  // The set of nodes is a 0-dimensional variety over a number field.
+  ring R2 = (0,q),(x,y,z,w),dp;
+  minpoly = q16-q12+q8-q4+1;
+  poly s = 2q13-q9-q7+q5-q3-q;
+  ideal Togliatti = 64*(x-w)*(x^4 -4*x^3*w -10*x^2*y^2 -4*x^2*w^2 +16*x*w^3 -20*x*y^2*w+5*y^4 +16*w^4 -20*y^2*w^2) -5*s*(2*z -s*w)*(4*(x^2+y^2-z^2) +(1+3*(5-s^2))*w^2)^2;
+  matrix Jac = jacob(Togliatti);
+  ideal I2 = Togliatti+Jac;
+  list L=projPoints(std(I2));
+  L[1];
+  size(L);
+}
+///////////////////////////////////////////////////////////////////////////////
+