|  |  D.6.11.1 hnexpansion Procedure from libraryhnoether.lib(see  hnoether_lib).
 
Example:Usage:
hnexpansion(f[,"ess"]); f poly
Assume:
f is a bivariate polynomial (in the first 2 ring variables)
Return:
list L, containing Hamburger-Noether data off:
If the computation of the HNE required no field extension,Lis a list of listsL[i](corresponding to the output ofdevelop, applied to a branch off, but the last entry
being omitted):
 
L[i][1]; matrix:         Each row contains the coefficients of the corresponding line of the
         Hamburger-Noether expansion (HNE) for the i-th branch. The end of
         the line is marked in the matrix by the first ring variable
         (usually x).
L[i][2]; intvec:         indicating the length of lines of the HNE
L[i][3]; int:         0  if the 1st ring variable was transversal (with respect to the
            i-th branch), 1  if the variables were changed at the beginning of the
            computation,
 -1  if an error has occurred.
L[i][4]; poly:         the transformed equation of the i-th branch to make it possible
         to extend the Hamburger-Noether data a posteriori without having
         to do all the previous calculation once again (0 if not needed).
 
If the computation of the HNE required a field extension, the first
entry L[1]of the list is a ring, in which a listhneof lists (the HN data, as above) and a polynomialf(image offover the new field) are stored.If called with an additional input parameter,
 hnexpansioncomputes only one representative for each class of conjugate
branches (over the ground field active when calling the procedure).
In this case, the returned listLalways has only two
entries:L[1]is either a list of lists (the HN data) or a
ring (as above), andL[2]is an integer vector (the number
of branches in the respective conjugacy classes). 
Note:
If f is known to be irreducible as a power series, develop(f)could be chosen instead to avoid a change of basering during the
computations.Increasing
 printlevelleads to more and more comments.Having defined a variable
 HNDebugOnleads to a maximum
number of comments.
 See also:
 develop;
 displayHNE;
 extdevelop;
 param.|  | LIB "hnoether.lib";
ring r=0,(x,y),dp;
// First, an example which requires no field extension:
list Hne=hnexpansion(x4-y6);
==> // No change of ring necessary, return value is HN expansion.
size(Hne);           // number of branches
==> 2
displayHNE(Hne);     // HN expansion of branches
==> // Hamburger-Noether development of branch nr.1:
==>   x = z(1)*y
==>   y = z(1)^2
==> 
==> // Hamburger-Noether development of branch nr.2:
==>   x = z(1)*y
==>   y = -z(1)^2
==> 
param(Hne[1]);       // parametrization of 1st branch
==> _[1]=x3
==> _[2]=x2
param(Hne[2]);       // parametrization of 2nd branch
==> _[1]=-x3
==> _[2]=-x2
// An example which requires a field extension:
list L=hnexpansion((x4-y6)*(y2+x4));
==> 
==> // 'hnexpansion' created a list of one ring.
==> // To see the ring and the data stored in the ring, type (if you assigned
==> // the name L to the list):
==>      show(L);
==> // To display the computed HN expansion, type
==>      def HNring = L[1]; setring HNring;  displayHNE(hne); 
def R=L[1]; setring R; displayHNE(hne);
==> // Hamburger-Noether development of branch nr.1:
==>   y = (a)*x^2
==> 
==> // Hamburger-Noether development of branch nr.2:
==>   y = (-a)*x^2
==> 
==> // Hamburger-Noether development of branch nr.3:
==>   x = z(1)*y
==>   y = z(1)^2
==> 
==> // Hamburger-Noether development of branch nr.4:
==>   x = z(1)*y
==>   y = -z(1)^2
==> 
basering;
==> // coefficients: QQ[a]/(a2+1)
==> // number of vars : 2
==> //        block   1 : ordering ls
==> //                  : names    x y
==> //        block   2 : ordering C
setring r; kill R;
// Computing only one representative per conjugacy class:
L=hnexpansion((x4-y6)*(y2+x4),"ess");
==> 
==> // 'hnexpansion' created a list of one ring.
==> // To see the ring and the data stored in the ring, type (if you assigned
==> // the name L to the list):
==>      show(L);
==> // To display the computed HN expansion, type
==>      def HNring = L[1]; setring HNring;  displayHNE(hne); 
==> // As second entry of the returned list L, you obtain an integer vector,
==> // indicating the number of conjugates for each of the computed branches.
def R=L[1]; setring R; displayHNE(hne);
==> // Hamburger-Noether development of branch nr.1:
==>   y = (a)*x^2
==> 
==> // Hamburger-Noether development of branch nr.2:
==>   x = z(1)*y
==>   y = z(1)^2
==> 
==> // Hamburger-Noether development of branch nr.3:
==>   x = z(1)*y
==>   y = -z(1)^2
==> 
L[2];     // number of branches in respective conjugacy classes
==> 2,1,1
 | 
 
 |