Singular

D.6.11.1 hnexpansion

Procedure from library `hnoether.lib` (see hnoether_lib).

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 of `f`: If the computation of the HNE required no field extension, `L` is a list of lists `L[i]` (corresponding to the output of `develop`, applied to a branch of `f`, 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 list `hne` of lists (the HN data, as above) and a polynomial `f` (image of `f` over the new field) are stored.
If called with an additional input parameter, `hnexpansion` computes only one representative for each class of conjugate branches (over the ground field active when calling the procedure). In this case, the returned list `L` always has only two entries: `L[1]` is either a list of lists (the HN data) or a ring (as above), and `L[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 `printlevel` leads to more and more comments.
Having defined a variable `HNDebugOn` leads to a maximum number of comments.

Example:
 ```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; ==> // characteristic : 0 ==> // 1 parameter : a ==> // minpoly : (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 ```