#### D.6.15.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;
    ==> // coefficients: QQ[a]/(a2+1) considered as a field
    ==> // 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

See also: develop; displayHNE; extdevelop; param.

User manual for Singular version 4.4.1, 2025, generated by texi2html.