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

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 galoisfixedfield galoisinit galoispermtopol galoissubcyclo 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 rnfkummer rnflllgram rnfnormgroup rnfpolred rnfpolredabs rnfpseudobasis rnfsteinitz subgrouplist zetak zetakinit | |

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 10 components (it is
v[1] is equal to the polynomial P. Note that for optimum performance,
P should have gone through 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 a measure of the correctness of the result. If it is close to 1,
the results are correct (under GRH). If it is close to a larger integer,
this shows that the product of the class number by the regulator is off by a
factor equal to this integer, and you must start again with a larger value
for c or a different random seed, i.e.use the function v[8] ( v[9] ( v[10] gives a measure of the correctness of the computations of the
fundamental units (not of the regulator), expressed as a number of bits. If
this number is greater than 20, say, everything is OK. If v[10] 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 = []}) | |

essentially identical
to
Finally,
nf as would be given by
nfinit.
, the general "check" number which should be
close to 1, the number of roots of unity and a generator bnf.reg
,
the fundamental units bnf.tu
, and finally the check on their
computation. If the precision becomes insufficient, GP outputs a warning
(bnf.fu
fundamental units too large, not given) and does not strive to
compute the units by default (flag = 0). When When When Note that all the components are exact (integral or rational), except for
the roots in v[5]. In practice, this is the only component which a user
is allowed to modify, by recomputing the roots to a higher accuracy if
desired. Note also that the 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 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 If you are willing to assume GRH, the answer is guaranteed
(i.e.x is a norm iff b = 1), if S contains all primes less than
12log( 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
). The c_i are chosen so that 0 bnf[8][1][3]
<= c_i < n_i
where n_i is the order of g_i (the vector of n_i being
, that is bnf.clgp.cyc
).bnf[8][1][2] 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, and if this the case x = alpha Finally the third component 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
bnrclass.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) | |

The library syntax is | |

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

L(s, chi) = c_chi.s^{r_chi} + O(s^{r_chi + 1}) near 0. Example:
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}) | |

If If The library syntax is | |

bnrclassno(bnf,I) | |

The library syntax is | |

bnrclassnolist(bnf,list) | |

The library syntax is | |

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

conductor of the
subfield of a ray class field as defined by [a_1,a_2,a_3] (see 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 groud field K (see If If If The library syntax is | |

bnrdisclist(bnf,bound,{arch},{flag = 0}) | |

The alternative syntax The output format is as follows. The output v is a row vector of row vectors, allowing the bound to be greater than 2^{16} for 32-bit machines, and v[i][j] is understood to be in fact V[2^{15}(i-1)+j] of a unique big vector V (note that 2^{15} is hardwired and can be increased in the source code only on 64-bit machines and higher). Such a component V[k] is itself a vector W (maybe of length 0) whose
components correspond to each possible ideal of norm k. Each component
W[i] corresponds to an Abelian extension L of
m can be decoded using The library syntax is | |

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

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,{flag = 0})} | |

returns the ray class field of
In this case, the corresponding congruence group is a product of cyclic groups and, for the time being, the class field has to be obtained by splitting this group into its cyclic components. 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 library syntax is | |

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

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

galoisinit(pol,{den}) | |

computes the Galois group
and all neccessary information for computing the fixed fields of the
Galois extension K/
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 If present den must be a suitable value for The library syntax is | |

galoispermtopol(gal,perm) | |

Note that
is equivalent to The library syntax is | |

galoissubcyclo(n,H,{Z},{v}) | |

compute a polynomial
defining the subfield of The following function can be used to compute all subfields of
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_ 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 | |

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,x,y) | |

intersection of the two ideals
x and y in the number field 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 If 1: give also the generators in the 2: output [L,U], where L is as before and U is a vector of
4: give only the ideals and not the The library syntax is | |

ideallistarch(nf,list,{arch = []},{flag = 0}) | |

vector of vectors of all 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 | |

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 | |

idealprimedec(nf,p) | |

computes the prime ideal
decomposition of the prime number p in the number field The result is a vector of 5-component vectors, each representing one of the
prime ideals above p in the number field Z_K such
that vp^{-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 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}) | |

If If If To solve discrete logarithms (using 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},{p}) | |

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. 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 p is present, we assume (without checking!) that it is the two-column
matrix of the factorization of the discriminant of the polynomial x. Note
that it does The library syntax is | |

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},{p}) | |

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 | |

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 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 "weakly" super solvable. In
practice, almost all groups of small order are "weakly" super solvable, the
exceptions having order 36(1 exception), 48(2), 56(1), 60(1), 72(5), 75(1),
80(1), 96(10) and Hence The library syntax is | |

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}) | |

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, The special input format [x,B] is also accepted where x is a polynomial
as above and B is the integer basis, as computed by 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(nf,{d = 0}) | |

finds all subfields of degree d
of the number field 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(x,y,{flag = 0}) | |

x and y being polynomials
in If The compositum will quite often be 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 3-component vector [n,s,k] 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 k is the number of the group corresponding to a given pair (n,s) (k = 1 except in 2 cases). Specifically, the groups are coded as follows, using standard notations (see GTM 138, quoted at the beginning of this section; see also "The transitive groups of degree up to eleven", by G.Butler and J.McKay in Communications in Algebra, vol.11, 1983, pp.863--911): 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]. The method used is that of resolvent polynomials and is sensitive to the current precision. The precision is updated internally but, in very rare cases, a wrong result may be returned if the initial precision was not sufficient. The library syntax is | |

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

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: does a partial reduction only. This means that only a suborder of the maximal order may be used. 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 p 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 | |

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 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) | |

The library syntax is | |

rnfbasis(bnf,x) | |

given a big number field The library syntax is | |

rnfbasistoalg(rnf,x) | |

The library syntax is | |

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

characteristic polynomial of
a over The library syntax is | |

rnfconductor(bnf,pol) | |

The library syntax is | |

rnfdedekind(nf,pol,pr) | |

given a number field
The library syntax is | |

rnfdet(nf,M) | |

given a pseudomatrix M over the maximal
order of The library syntax is | |

rnfdisc(nf,pol) | |

given a number field Note: As usual, The library syntax is | |

rnfeltabstorel(rnf,x) | |

The library syntax is | |

rnfeltdown(rnf,x) | |

The library syntax is | |

rnfeltreltoabs(rnf,x) | |

The library syntax is | |

rnfeltup(rnf,x) | |

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 a big number field The library syntax is | |

rnfidealabstorel(rnf,x) | |

The library syntax is | |

rnfidealdown(rnf,x) | |

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 an 11-component row vector as follows (most of the components
are technical), the numbering being very close to that of
Finally, The library syntax is | |

rnfisfree(bnf,x) | |

given a big number field The library syntax is | |

rnfisnorm(bnf,ext,el,{flag = 1}) | |

similar to
This returns a vector [a,b], where
checks whether 17 is a norm in the Galois extension The library syntax is | |

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

(THIS PROGRAM IS STILL IN DEVELOPMENT STAGE) 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
rnfequation( but faster).
The library syntax is | |

rnfpseudobasis(nf,pol) | |

given a number field
Note: As usual, The library syntax is | |

rnfsteinitz(nf,x) | |

given a number field Note: The library syntax is | |

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

The library syntax is | |

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

The accuracy of the result depends in an essential way on the accuracy of
both the 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
(e.g The library syntax is | |