Pari/GP Reference Documentation |
Contents - Index - Meta commands |

Algebraic numbers and ideals Class field theory Class group, units, and the GRH Finite abelian groups General use Number field structures Relative extensions bnfcertify bnfclassunit bnfclgp bnfdecodemodule bnfinit bnfisintnorm bnfisnorm bnfisprincipal bnfissunit bnfisunit bnfmake bnfnarrow bnfreg bnfsignunit bnfsunit bnfunit bnrL1 bnrclass bnrclassno bnrclassnolist bnrconductor bnrconductorofchar bnrdisc bnrdisclist bnrinit bnrisconductor bnrisprincipal bnrrootnumber bnrstark dirzetak factornf galoisexport galoisfixedfield galoisidentify galoisinit galoisisabelian galoispermtopol galoissubcyclo galoissubfields galoissubgroups idealadd idealaddtoone idealappr idealchinese idealcoprime idealdiv idealfactor idealhnf idealintersect idealinv ideallist ideallistarch ideallog idealmin idealmul idealnorm idealpow idealprimedec idealprincipal idealred idealstar idealtwoelt idealval ideleprincipal matalgtobasis matbasistoalg modreverse newtonpoly nfalgtobasis nfbasis nfbasistoalg nfdetint nfdisc nfeltdiv nfeltdiveuc nfeltdivmodpr nfeltdivrem nfeltmod nfeltmul nfeltmulmodpr nfeltpow nfeltpowmodpr nfeltreduce nfeltreducemodpr nfeltval nffactor nffactormod nfgaloisapply nfgaloisconj nfhilbert nfhnf nfhnfmod nfinit nfisideal nfisincl nfisisom nfkermodpr nfmodprinit nfnewprec nfroots nfrootsof1 nfsnf nfsolvemodpr nfsubfields polcompositum polgalois polred polredabs polredord poltschirnhaus rnfalgtobasis rnfbasis rnfbasistoalg rnfcharpoly rnfconductor rnfdedekind rnfdet rnfdisc rnfeltabstorel rnfeltdown rnfeltreltoabs rnfeltup rnfequation rnfhnfbasis rnfidealabstorel rnfidealdown rnfidealhnf rnfidealmul rnfidealnormabs rnfidealnormrel rnfidealreltoabs rnfidealtwoelt rnfidealup rnfinit rnfisfree rnfisnorm rnfisnorminit rnfkummer rnflllgram rnfnormgroup rnfpolred rnfpolredabs rnfpseudobasis rnfsteinitz subgrouplist zetak zetakinit | |

Number field structures | |

Let K =
| |

Algebraic numbers and ideals | |

An
An
One may use
| |

Finite abelian groups | |

A finite abelian group G in user-readable format is given by its Smith
Normal Form as a pair [h,d] or triple [h,d,g].
Here h is the cardinality of G, (d_i) is the vector of elementary
divisors, and (g_i) is a vector of generators. In short,
G = oplus_{i
| |

Relative extensions | |

When defining a relative extension, the base field
| |

Class field theory | |

A A Finally we explain how to input ray number fields (or
The corresponding | |

General use | |

All the functions which are specific to relative extensions, number fields,
Buchmann's number fields, Buchmann's number rays, share the prefix However, and even though it may not be specified in the descriptions of the
functions below, it is permissible, if the function expects a The data types corresponding to the structures described above are rather complicated. Thus, as we already have seen it with elliptic curves, GP provides "member functions" to retrieve data from these structures (once they have been initialized of course). The relevant types of number fields are indicated between parentheses:
For instance, assume that
the class number. If we had set bnf.clgp.nobnf =
nfinit(pol), both would have output an error message. All these
functions are completely recursive, thus for instance
will yield the maximal order of bnr.bnf.nf.zkbnr, which
you could get directly with a simple
.bnr.zk | |

Class group, units, and the GRH | |

Some of the functions starting with P is the defining polynomial for the number field, which must be in
The numbers c
Apart from the polynomial P, you do not need to supply the technical
parameters (under the library you still need to send at least an empty
vector, coded as Note also that you can use an | |

bnfcertify(bnf) | |

The library syntax is | |

bnfclassunit(P,{flag = 0},{tech = []}) | |

Buchmann's sub-exponential algorithm for computing the class group, the regulator and a system of fundamental units of the general algebraic number field K defined by the irreducible polynomial P with integer coefficients. The result of this function is a vector v with many components, which for
ease of presentation is in fact output as a one column matrix. It is
v[1] is equal to the polynomial P. v[2] is the 2-component vector [r1,r2], where r1 and r2 are as usual the number of real and half the number of complex embeddings of the number field K. v[3] is the 2-component vector containing the field discriminant and the index. v[4] is an integral basis in Hermite normal form. v[5] ( v[6] ( v[7] is deprecated, maintained for backward compatibility and always equal to 1. v[8] ( v[9] ( If If The library syntax is | |

bnfclgp(P,{tech = []}) | |

as The library syntax is | |

bnfdecodemodule(nf,m) | |

if m is a module as output in the
first component of an extension given by The library syntax is | |

bnfinit(P,{flag = 0},{tech = []}) | |

initializes a
This implements Buchmann's sub-exponential algorithm for computing the class group, the regulator and a system of fundamental units of the general algebraic number field K defined by the irreducible polynomial P with integer coefficients. If the precision becomes insufficient, When When When
The components of a
nf as would be given by
nfinit.
, a 1 (used to
contain an obsolete "check number"), the number of roots of unity and a
generator bnf.reg
, the fundamental units bnf.tu
.bnf.fu
An Note that all the components are exact (integral or rational), except for
the roots in v[5]. Note also that member functions will The library syntax is | |

bnfisintnorm(bnf,x) | |

computes a complete system of
solutions (modulo units of positive norm) of the absolute norm equation
\Norm(a) = x,
where a is an integer in See also The library syntax is | |

bnfisnorm(bnf,x,{flag = 1}) | |

tries to tell whether the
rational number x is the norm of some element y in Assuming GRH, the answer is guaranteed (i.e.x is a norm iff b = 1),
if S contains all primes less than 12log(\disc( See also The library syntax is | |

bnfissunit(bnf,sfu,x) | |

The library syntax is | |

bnfisprincipal(bnf,x,{flag = 1}) | |

v_1 is the vector of components c_i of the class of the ideal x in the
class group, expressed on the generators g_i given by
<= c_i < n_i
where n_i is the order of g_i (the vector of n_i being
).bnf.cyc v_2 gives on the integral basis the components of alpha such that
x = alphaprod_ig_i^{c_i}. In particular, x is principal if and only if
v_1 is equal to the zero vector. In the latter case, x = alpha If If If The user is warned that these two last setting may induce The library syntax is | |

bnfisunit(bnf,x) | |

The library syntax is | |

bnfmake(sbnf) | |

Note that the member functions are The library syntax is | |

bnfnarrow(bnf) | |

): the first component
is the narrow class number bnf[8][1]
v.no, the second component is a vector
containing the SNF cyclic components
v.cyc of
the narrow class group, and the third is a vector giving the generators of
the corresponding
v.gen cyclic groups. Note that this function is a
special case of
bnrinit.The library syntax is | |

bnfsignunit(bnf) | |

The library syntax is | |

bnfreg(bnf) | |

The library syntax is | |

bnfsunit(bnf,S) | |

computes the fundamental S-units of the
number field v[1] gives a minimal system of (integral) generators of the S-unit group modulo the unit group. v[2] contains technical data needed by v[3] is an empty vector (used to give the logarithmic embeddings of the generators in v[1] in version 2.0.16). v[4] is the S-regulator (this is the product of the regulator, the determinant of v[2] and the natural logarithms of the norms of the ideals in S). v[5] gives the S-class group structure, in the usual format (a row vector whose three components give in order the S-class number, the cyclic components and the generators). v[6] is a copy of S. The library syntax is | |

bnfunit(bnf) | |

This function is mostly useless, since it will only succeed if
The library syntax is | |

bnrL1(bnr,{subgroup},{flag = 0}) | |

L(s, chi) = c_chi.s^{r_chi} + O(s^{r_chi + 1}) near 0.
returns the order and the first non-zero term of the abelian
L-functions L(s, chi) at s = 0 where chi runs through the
characters of the class group of
returns the order and the first non-zero terms of the abelian
L-functions L_S(s, chi) at s = 0 where chi runs through the
characters of the class group of The library syntax is | |

bnrclass(bnf,ideal,{flag = 0}) | |

The library syntax is | |

bnrclassno(bnf,I) | |

The library syntax is | |

bnrclassnolist(bnf,list) | |

The weird
The library syntax is | |

bnrconductor(a_1,{a_2},{a_3}, {flag = 0}) | |

conductor f of
the subfield of a ray class field as defined by [a_1,a_2,a_3] (see
If If If The library syntax is | |

bnrconductorofchar(bnr,chi) | |

The library syntax is | |

bnrdisc(a1,{a2},{a3},{flag = 0}) | |

a1, a2, a3
defining a big ray number field L over a ground field K (see If If If The library syntax is | |

bnrdisclist(bnf,bound,{arch}) | |

The alternative syntax The output v is a vector of vectors, where v[i][j] is understood to be in fact V[2^{15}(i-1)+j] of a unique big vector V. (This akward scheme allows for larger vectors than could be otherwise represented.) V[k] is itself a vector W, whose length is the number of ideals of norm
k. We consider first the case where If Finally, each prime ideal pr = [p,alpha,e,f,beta] in the prime factorization m is coded as the integer p.n^2+(f-1).n+(j-1), where n is the degree of the base field and j is such that
m can be decoded using
Note that to compute such data for a single field, either The library syntax is | |

bnrinit(bnf,f,{flag = 0}) | |

The last group of functions are different from the members of the underlying
to get the cyclic decomposition
of the class group.bnr.bnf.cycThey are also different from the members of the underlying
to get phi(f).bnr.bid.noIf If The library syntax is | |

bnrisconductor(a1,{a2},{a3}) | |

a1, a2, a3 represent
an extension of the base field, given by class field theory for some modulus
encoded in the parameters. Outputs 1 if this modulus is the conductor, and 0
otherwise. This is slightly faster than The library syntax is | |

bnrisprincipal(bnr,x,{flag = 1}) | |

If The library syntax is | |

bnrrootnumber(bnr,chi,{flag = 0}) | |

if chi = Lambda(1-s,chi) = W(chi) Lambda(s,\overline{chi}) where Lambda(s,chi) = A(chi)^{s/2}gamma_chi(s) L(s,chi) is the enlarged L-function associated to L. The generators of the ray class group are needed, and you can set
returns the root number of the character chi of Cl_7( The library syntax is | |

bnrstark{(bnr,{subgroup})} | |

The routine uses Stark units and needs to find a suitable auxilliary
conductor, which may not exist when the class field is not cyclic over the
base. In this case The main variable of
returns the ray class field of
The library syntax is | |

dirzetak(nf,b) | |

gives as a vector the first b
coefficients of the Dedekind zeta function of the number field The library syntax is | |

factornf(x,t) | |

factorization of the univariate polynomial x
over the number field defined by the (univariate) polynomial t. x may
have coefficients in The main variable of t must be of
The library syntax is | |

galoisexport(gal,{flag = 0}) | |

This command also accepts subgroups returned by The library syntax is | |

galoisfixedfield(gal,perm,{flag = 0},{v = y})) | |

If no flags or If If
computes the factorization x^4+1 = (x^2-sqrt{-2}x-1)(x^2+sqrt{-2}x-1) The library syntax is | |

galoisidentify(gal) | |

This command also accepts subgroups returned by The current implementation is limited to degree less or equal to 127. Some larger "easy" orders are also supported. The output is similar to the output of the function The library syntax is | |

galoisinit(pol,{den}) | |

computes the Galois group
and all necessary information for computing the fixed fields of the
Galois extension K/ This is a prerequisite for most of the
The output is an 8-component vector pol totally split
modulo p , e is an integer and q = p^e (
) is the
modulus of the roots in gal.mod
.gal.roots
).gal.roots Let H be the maximal normal supersolvable subgroup of G, we have the following properties:
-- for 1 -- x = g_1^{e_1}g_2^{e_2}...g_n^{e_n} If present den must be a suitable value for The library syntax is | |

galoisisabelian(gal,{fl = 0}) | |

This command also accepts subgroups returned by The library syntax is | |

galoispermtopol(gal,perm) | |

Note that
is equivalent to The library syntax is | |

galoissubcyclo(N,H,{fl = 0},{v}) | |

computes the subextension
of The pair (n, H) is deduced from the parameters (N, H) as follows
In this last case, beware that H is understood relatively to N; in
particular, if the infinite place does not divide the module, e.g if m is
an integer, then it is not a subgroup of ( If fl = 0, compute a polynomial (in the variable If fl = 1, compute only the conductor of the abelian extension, as a module. If fl = 2, output [pol, N], where pol is the polynomial as output when fl = 0 and N the conductor as output when fl = 1. The following function can be used to compute all subfields of
Setting The library syntax is | |

galoissubfields(G,{fl = 0},{v}) | |

Output all the subfields of
the Galois group The library syntax is | |

galoissubgroups(gal) | |

Output all the subgroups of the Galois
group To get the subfield fixed by a subgroup
The library syntax is | |

idealadd(nf,x,y) | |

sum of the two ideals x and y in the
number field The library syntax is | |

idealaddtoone(nf,x,{y}) | |

x and y being two co-prime integral ideals (given in any form), this gives a two-component row vector [a,b] such that a belongs to x, b belongs to y and a+b = 1. The alternative syntax The library syntax is | |

idealappr(nf,x,{flag = 0}) | |

if x is a fractional ideal
(given in any form), gives an element alpha in If
idealappr(.nf,x,1)The library syntax is | |

idealchinese(nf,x,y) | |

x being a prime ideal factorization
(i.e.a 2 by 2 matrix whose first column contain prime ideals, and the second
column integral exponents), y a vector of elements in v_wp(b - y_wp) The library syntax is | |

idealcoprime(nf,x,y) | |

given two integral ideals x and y
in the number field The library syntax is | |

idealdiv(nf,x,y,{flag = 0}) | |

quotient x.y^{-1} of the
two ideals x and y in the number field If The library syntax is flag = 0) and
(idealdivexact(nf,x,y)flag = 1). | |

idealfactor(nf,x) | |

factors into prime ideal powers the
ideal x in the number field The library syntax is | |

idealhnf(nf,a,{b}) | |

gives the Hermite normal form
matrix of the ideal a. The ideal can be given in any form whatsoever
(typically by an algebraic number if it is principal, by a If b is not omitted, assume the ideal given was a The library syntax is | |

idealintersect(nf,A,B) | |

intersection of the two ideals
A and B in the number field
This function does not apply to general
The library syntax is | |

idealinv(nf,x) | |

inverse of the ideal x in the
number field The library syntax is | |

ideallist(nf,bound,{flag = 4}) | |

computes the list
of all ideals of norm less or equal to The possible values of 0: give the 1: as 0, but include the generators in the 2: in this case, 3: as 2, but include the generators in the 4: give only the HNF of the ideal.
If one wants more information, one could do instead: where we ask for the structures of the ( Z[i]/I)^* for all
three ideals of norm 25. In fact, for all moduli with finite part of norm
25 and trivial archimedean part, as the last 3 commands show. See
ideallistarch to treat general moduli.
The library syntax is flag = 4. | |

ideallistarch(nf,list,arch) | |

Of course, the results above are obvious: adding t places at infinity will
add t copies of
The library syntax is | |

ideallog(nf,x,bid) | |

The library syntax is | |

idealmin(nf,x,{vdir}) | |

computes a minimum of
the ideal x in the direction The library syntax is | |

idealmul(nf,x,y,{flag = 0}) | |

ideal multiplication of the
ideals x and y in the number field If The library syntax is flag != 0), where as usual,
prec is a C long integer representing the precision. | |

idealnorm(nf,x) | |

computes the norm of the idealx
in the number field The library syntax is | |

idealpow(nf,x,k,{flag = 0}) | |

computes the k-th power of
the ideal x in the number field If The library syntax corresponding to
long, you can use
. Corresponding to idealpows(nf,x,k)flag = 1 is
, where idealpowred(nf,vp,k,prec)prec is a
long. | |

idealprimedec(nf,p) | |

computes the prime ideal
decomposition of the prime number p in the number field The result is a vector of Z_K such that P^{-1} = Z_K+beta/pZ_K which
will be useful for computing valuations, but which the user can ignore. The
number alpha is guaranteed to have a valuation equal to 1 at the prime
ideal (this is automatic if e > 1).The components of The library syntax is | |

idealprincipal(nf,x) | |

creates the principal ideal
generated by the algebraic number x (which must be of type integer,
rational or polmod) in the number field The library syntax is | |

idealred(nf,I,{vdir = 0}) | |

LLL reduction of
the ideal I in the number field This function finds a "small" a in I (it is an LLL pseudo-minimum
along direction More often than not, a principal ideal will yield the identity
matrix. This is a quick and dirty way to check if ideals are principal
without computing a full Note that this is The library syntax is | |

idealstar(nf,I,{flag = 1}) | |

outputs a This
(G as a finite abelian group),
bid.clgp
(the cardinality of G),
bid.no
(elementary divisors) and
bid.cyc
(generators).bid.genIf If If The library syntax is | |

idealtwoelt(nf,x,{a}) | |

computes a two-element
representation of the ideal x in the number field Note that when an explicit a is given, we use an asymptotically faster method, however in practice it is usually slower. The library syntax is | |

idealval(nf,x,vp) | |

gives the valuation of the
ideal x at the prime ideal The library syntax is | |

ideleprincipal(nf,x) | |

creates the principal idele
generated by the algebraic number x (which must be of type integer,
rational or polmod) in the number field The library syntax is | |

matalgtobasis(nf,x) | |

The library syntax is | |

matbasistoalg(nf,x) | |

The library syntax is | |

modreverse(a) | |

a being a polmod A(X) modulo T(X), finds the "reverse polmod" B(X) modulo Q(X), where Q is the minimal polynomial of a, which must be equal to the degree of T, and such that if theta is a root of T then theta = B(alpha) for a certain root alpha of Q. This is very useful when one changes the generating element in algebraic extensions. The library syntax is | |

newtonpoly(x,p) | |

gives the vector of the slopes of the Newton
polygon of the polynomial x with respect to the prime number p. The n
components of the vector are in decreasing order, where n is equal to the
degree of x. Vertical slopes occur iff the constant coefficient of x is
zero and are denoted by The library syntax is | |

nfalgtobasis(nf,x) | |

this is the inverse function of
The library syntax is | |

nfbasis(x,{flag = 0},{fa}) | |

integral basis of the number
field defined by the irreducible, preferably monic, polynomial x, using a
modified version of the round 4 algorithm by default, due to David
Ford, Sebastian Pauli and Xavier Roblot. The binary digits
of 1: assume that no square of a prime greater than the default 2: use round 2 algorithm. For small degrees and coefficient size, this is sometimes a little faster. (This program is the translation into C of a program written by David Ford in Algeb.) Thus for instance, if If The library syntax is not of the polynomial x), and an omitted fa is input
as
NULL. Also available are
(base(x,&d)flag = 0),
(base2(x,&d)flag = 2) and
.factoredbase(x,fa,&d) | |

nfbasistoalg(nf,x) | |

this is the inverse function of
The library syntax is | |

nfdetint(nf,x) | |

given a pseudo-matrix x, computes a
non-zero ideal contained in (i.e.multiple of) the determinant of x. This
is particularly useful in conjunction with The library syntax is | |

nfdisc(x,{flag = 0},{fa}) | |

field discriminant of the
number field defined by the integral, preferably monic, irreducible
polynomial x. 1: assume that no square of a prime greater than 2: use the round 2 algorithm, instead of the default round 4. This should be slower except maybe for polynomials of small degree and coefficients. The library syntax is flag = 0). | |

nfeltdiv(nf,x,y) | |

given two elements x and y in
The library syntax is | |

nfeltdiveuc(nf,x,y) | |

given two elements x and y in
The library syntax is | |

nfeltdivmodpr(nf,x,y,pr) | |

given two elements x
and y in The library syntax is | |

nfeltdivrem(nf,x,y) | |

given two elements x and y in
The library syntax is | |

nfeltmod(nf,x,y) | |

given two elements x and y in
The library syntax is | |

nfeltmul(nf,x,y) | |

given two elements x and y in
The library syntax is | |

nfeltmulmodpr(nf,x,y,pr) | |

given two elements x and
y in The library syntax is | |

nfeltpow(nf,x,k) | |

given an element x in The library syntax is | |

nfeltpowmodpr(nf,x,k,pr) | |

given an element x in
The library syntax is | |

nfeltreduce(nf,x,ideal) | |

given an ideal in
Hermite normal form and an element x of the number field The library syntax is | |

nfeltreducemodpr(nf,x,pr) | |

given
an element x of the number field The library syntax is | |

nfeltval(nf,x,pr) | |

given an element x in
The library syntax is | |

nffactor(nf,x) | |

factorization of the univariate
polynomial x over the number field
The library syntax is | |

nffactormod(nf,x,pr) | |

factorization of the
univariate polynomial x modulo the prime ideal The library syntax is | |

nfgaloisapply(nf,aut,x) | |

The library syntax is | |

nfgaloisconj(nf,{flag = 0},{d}) | |

If no flags or If If If A group G is "weakly" super solvable (WKSS) if it contains a super solvable
normal subgroup H such that G = H , or G/H ~ A_4 , or G/H ~
S_4. Abelian and nilpotent groups are WKSS. In practice, almost all groups
of small order are WKSS, the exceptions having order 36(1 exception), 48(2),
56(1), 60(1), 72(5), 75(1), 80(1), 96(10) and Hence This routine can only compute
The library syntax is flag = 0,
for galoisconj2(nf,n,prec)flag = 2 where n is a bound
on the number of conjugates, and
corresponding to galoisconj4(nf,d)flag = 4. | |

nfhilbert(nf,a,b,{pr}) | |

if The library syntax is | |

nfhnf(nf,x) | |

given a pseudo-matrix (A,I), finds a pseudo-basis in Hermite normal form of the module it generates. The library syntax is | |

nfhnfmod(nf,x,detx) | |

given a pseudo-matrix (A,I)
and an ideal The library syntax is | |

nfinit(pol,{flag = 0}) | |

,
nf.r1
), the number of real and complex places of K.nf.r2
Z_K : Z[theta]], where theta is any root of nf[1].
Z-basis
of the different of K on the integral basis.
idealinv.
nf[1] corresponding to the r1+r2
embeddings of the number field into C (the first r1 components are real,
the next r2 have positive imaginary part).
If a non monic polynomial is input,
In case
If If If If The library syntax is | |

nfisideal(nf,x) | |

returns 1 if x is an ideal in
the number field The library syntax is | |

nfisincl(x,y) | |

tests whether the number field K defined
by the polynomial x is conjugate to a subfield of the field L defined
by y (where x and y must be in If y is a number field ( The library syntax is | |

nfisisom(x,y) | |

as The library syntax is | |

nfnewprec(nf) | |

transforms the number field The library syntax is | |

nfkermodpr(nf,a,pr) | |

kernel of the matrix a in
The library syntax is | |

nfmodprinit(nf,pr) | |

transforms the prime ideal
The library syntax is | |

nfsubfields(pol,{d = 0}) | |

finds all subfields of degree
d of the number field defined by the (monic, integral) polynomial
The library syntax is | |

nfroots({nf},x) | |

roots of the polynomial x in the
number field The library syntax is | |

nfrootsof1(nf) | |

computes the number of roots of unity
w and a primitive w-th root of unity (expressed on the integral basis)
belonging to the number field The library syntax is | |

nfsnf(nf,x) | |

given a torsion module x as a 3-component
row
vector [A,I,J] where A is a square invertible n x n matrix, I and
J are two ideal lists, outputs an ideal list d_1,...,d_n which is the
Smith normal form of x. In other words, x is isomorphic to
The library syntax is | |

nfsolvemodpr(nf,a,b,pr) | |

solution of a.x = b
in The library syntax is | |

polcompositum(P,Q,{flag = 0}) | |

P and Q
being squarefree polynomials in Note that it is more efficient to reduce to the case where P and Q are
irreducible first. The routine will not perform this for you, since it may be
expensive, and the inputs are irreducible in most applications anyway.
Assuming P is irreducible (of smaller degree than Q for efficiency), it
is in general
to obtain the same result. If you are only interested in the degrees of the
simple factors, the If A compositum is quite often defined by a complicated polynomial, which it is
advisable to reduce before further work. Here is a simple example involving
the field
The library syntax is | |

polgalois(x) | |

Galois group of the non-constant
polynomial x belongs to The output is a 4-component vector [n,s,k,name] with the following meaning: n is the cardinality of the group, s is its signature (s = 1 if the group is a subgroup of the alternating group A_n, s = -1 otherwise) and name is a character string containing name of the transitive group according to the GAP 4 transitive groups library by Alexander Hulpke. k is more arbitrary and the choice made up to version2.2.3 of PARI is rather
unfortunate: for n > 7, k is the numbering of the group among all
transitive subgroups of S_n, as given in "The transitive groups of degree up
to eleven", G.Butler and J.McKay, In degree 1: S_1 = [1,1,1]. In degree 2: S_2 = [2,-1,1]. In degree 3: A_3 = C_3 = [3,1,1], S_3 = [6,-1,1]. In degree 4: C_4 = [4,-1,1], V_4 = [4,1,1], D_4 = [8,-1,1], A_4 = [12,1,1], S_4 = [24,-1,1]. In degree 5: C_5 = [5,1,1], D_5 = [10,1,1], M_{20} = [20,-1,1], A_5 = [60,1,1], S_5 = [120,-1,1]. In degree 6: C_6 = [6,-1,1], S_3 = [6,-1,2], D_6 = [12,-1,1], A_4 = [12,1,1], G_{18} = [18,-1,1], S_4^ -= [24,-1,1], A_4 x C_2 = [24,-1,2], S_4^ += [24,1,1], G_{36}^ -= [36,-1,1], G_{36}^ += [36,1,1], S_4 x C_2 = [48,-1,1], A_5 = PSL_2(5) = [60,1,1], G_{72} = [72,-1,1], S_5 = PGL_2(5) = [120,-1,1], A_6 = [360,1,1], S_6 = [720,-1,1]. In degree 7: C_7 = [7,1,1], D_7 = [14,-1,1], M_{21} = [21,1,1], M_{42} = [42,-1,1], PSL_2(7) = PSL_3(2) = [168,1,1], A_7 = [2520,1,1], S_7 = [5040,-1,1]. This is deprecated and obsolete, but for reasons of backward compatibility,
we cannot change this behaviour yet. So you can use the default
In degree 1: S_1 = [1,1,1]. In degree 2: S_2 = [2,-1,1]. In degree 3: A_3 = C_3 = [3,1,1], S_3 = [6,-1,2]. In degree 4: C_4 = [4,-1,1], V_4 = [4,1,2], D_4 = [8,-1,3], A_4 = [12,1,4], S_4 = [24,-1,5]. In degree 5: C_5 = [5,1,1], D_5 = [10,1,2], M_{20} = [20,-1,3], A_5 = [60,1,4], S_5 = [120,-1,5]. In degree 6: C_6 = [6,-1,1], S_3 = [6,-1,2], D_6 = [12,-1,3], A_4 = [12,1,4], G_{18} = [18,-1,5], A_4 x C_2 = [24,-1,6], S_4^ += [24,1,7], S_4^ -= [24,-1,8], G_{36}^ -= [36,-1,9], G_{36}^ += [36,1,10], S_4 x C_2 = [48,-1,11], A_5 = PSL_2(5) = [60,1,12], G_{72} = [72,-1,13], S_5 = PGL_2(5) = [120,-1,14], A_6 = [360,1,15], S_6 = [720,-1,16]. In degree 7: C_7 = [7,1,1], D_7 = [14,-1,2], M_{21} = [21,1,3], M_{42} = [42,-1,4], PSL_2(7) = PSL_3(2) = [168,1,5], A_7 = [2520,1,6], S_7 = [5040,-1,7].
The library syntax is | |

polred(x,{flag = 0},{fa}) | |

finds polynomials with reasonably
small coefficients defining subfields of the number field defined by x.
One of the polynomials always defines The following binary digits of 1: possibly use a suborder of the maximal order. The primes dividing the
index of the order chosen are larger than 2: gives also elements. The result is a two-column matrix, the first column giving the elements defining these subfields, the second giving the corresponding minimal polynomials. If fa is given, it is assumed that it is the two-column matrix of the factorization of the discriminant of the polynomial x. The library syntax is
, both
corresponding to factoredpolred(x,fa)flag = 0. | |

polredabs(x,{flag = 0}) | |

finds one of the polynomial defining
the same number field as the one defined by x, and such that the sum of the
squares of the modulus of the roots (i.e.the T_2-norm) is minimal.
All x accepted by
The binary digits of 1: outputs a two-component row vector [P,a], where P is the default output and a is an element expressed on a root of the polynomial P, whose minimal polynomial is equal to x. 4: gives 16: possibly use a suborder of the maximal order. The primes dividing the
index of the order chosen are larger than The library syntax is | |

polredord(x) | |

finds polynomials with reasonably small
coefficients and of the same degree as that of x defining suborders of the
order defined by x. One of the polynomials always defines The library syntax is | |

poltschirnhaus(x) | |

applies a random Tschirnhausen
transformation to the polynomial x, which is assumed to be non-constant
and separable, so as to obtain a new equation for the étale algebra
defined by x. This is for instance useful when computing resolvents,
hence is used by the The library syntax is | |

rnfalgtobasis(rnf,x) | |

expresses x on the relative
integral basis. Here, The library syntax is | |

rnfbasis(bnf, M) | |

let K the field represented by
It is allowed to use a polynomial P with coefficients in K instead of M,
in which case, M is defined as the ring of integers of K[X]/(P)
(P is assumed irreducible over K), viewed as a The library syntax is | |

rnfbasistoalg(rnf,x) | |

computes the representation of x
as a polmod with polmods coefficients. Here, The library syntax is | |

rnfcharpoly(nf,T,a,{v = x}) | |

characteristic polynomial of
a over The library syntax is | |

rnfconductor(bnf,pol,{flag = 0}) | |

given The library syntax is | |

rnfdedekind(nf,pol,pr) | |

given a number field
The library syntax is | |

rnfdet(nf,M) | |

given a pseudo-matrix M over the maximal
order of The library syntax is | |

rnfdisc(nf,pol) | |

given a number field The library syntax is | |

rnfeltabstorel(rnf,x) | |

The library syntax is | |

rnfeltdown(rnf,x) | |

The library syntax is | |

rnfeltreltoabs(rnf,x) | |

rnfbasistoalg first,
otherwise PARI will believe you are dealing with a vector.The library syntax is | |

rnfeltup(rnf,x) | |

nfbasistoalg first, otherwise PARI will believe you are dealing with a
vector.The library syntax is | |

rnfequation(nf,pol,{flag = 0}) | |

given a number field
If The main variable of The library syntax is | |

rnfhnfbasis(bnf,x) | |

given The library syntax is | |

rnfidealabstorel(rnf,x) | |

let If x is an ideal in HNF form, associated to an The library syntax is | |

rnfidealdown(rnf,x) | |

let The library syntax is | |

rnfidealhnf(rnf,x) | |

The library syntax is | |

rnfidealmul(rnf,x,y) | |

The library syntax is | |

rnfidealnormabs(rnf,x) | |

The library syntax is | |

rnfidealnormrel(rnf,x) | |

The library syntax is | |

rnfidealreltoabs(rnf,x) | |

The library syntax is | |

rnfidealtwoelt(rnf,x) | |

The library syntax is | |

rnfidealup(rnf,x) | |

The library syntax is | |

rnfinit(nf,pol) | |

The result is a row vector, whose components are technical. In the following
description, we let K be the base field defined by
The library syntax is | |

rnfisfree(bnf,x) | |

given The library syntax is | |

rnfisnorm(T,a,{flag = 0}) | |

similar to
The output is a vector [x,q], where a = \Norm(x)*q. The
algorithm looks for a solution x which is an S-integer, with S a list
of places of K containing at least the ramified primes, the generators of
the class group of L, as well as those primes dividing a. If L/K is
Galois, then this is enough; otherwise, The answer is guaranteed (i.e.a is a norm iff q = 1) if the field is Galois, or, under GRH, if S contains all primes less than 12log^2|\disc(M)|, where M is the normal closure of L/K. If
checks whether 17 is a norm in the Galois extension The library syntax is | |

rnfisnorminit(pol,polrel,{flag = 2}) | |

let K be defined by a root of If If If The library syntax is | |

rnfkummer(bnr,{subgroup},{deg = 0}) | |

The library syntax is | |

rnflllgram(nf,pol,order) | |

given a polynomial
The library syntax is | |

rnfnormgroup(bnr,pol) | |

The library syntax is | |

rnfpolred(nf,pol) | |

relative version of The library syntax is | |

rnfpolredabs(nf,pol,{flag = 0}) | |

relative version of
1: returns [P,a] where P is the default output and a is an
element expressed on a root of P whose characteristic polynomial is
2: returns an absolute polynomial (same as
rnfequation( 16: possibly use a suborder of the maximal order. This is slower than the
default when the relative discriminant is smooth, and much faster otherwise.
See Section [
The library syntax is | |

rnfpseudobasis(nf,pol) | |

given a number field
The library syntax is | |

rnfsteinitz(nf,x) | |

given a number field The library syntax is | |

subgrouplist(bnr,{bound},{flag = 0}) | |

If If
In the last example, L corresponds to the 24 subfields of
will produce their equations. (For a general base field, you would
have to rely on The library syntax is | |

zetak(znf,x,{flag = 0}) | |

The library syntax is | |

zetakinit(x) | |

computes a number of initialization data
concerning the number field defined by the polynomial x so as to be able
to compute the Dedekind zeta and lambda functions (respectively
This function is very inefficient and should be rewritten. It needs to
computes millions of coefficients of the corresponding Dirichlet series if
the precision is big. Unless the discriminant is small it will not be able
to handle more than 9 digits of relative precision. For instance,
The library syntax is | |