Singular Manual: hnexpansion

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)
==> // 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.0, 2024, generated by texi2html.