$ __text__TEXTC4t__data__DATACAG$$__literal4__TEXT ,__bss__DATAH__cstring__TEXTǃ~$Fǃr$Wu u$ǃb[É$-Vt$ VNB9tD$$F^Í NL$$NАWVt$ |$$t8FNGO$1;N};N|^_É<$AVt$ FF$^ÐD$ $ÐVt$ $ t$t$$t$$t$$ t$$ ^Ð t Ð ` ÐUWVSK,L$FT$D$<$T$9D$D$P9T$}]t$t$t$l$4t7l$D$,$TN N4F uԋD$PD$9T$|1;,[^_]ÐUWVS,D$H$D$HǃCD$HD$@t$@ǃsǃo)ƉG4$oFoǃwskD$D${=8\$p$^$L$:$(11"ʋ?΍Iv$"$1~$1~$n1~t2l$,$D$N N4F uҋt2l$,$D$N N4F uҍ+7<$}t$<$:,$,$|$ +}Gt4|$<$D$0NLNtF uЋ}ǃ$Gu_1ҋG4~덻ǃD$$\<$ǃO1ǃ,[^_]Í$ l$뉍$T$1Ct/t$|$$ 4$mo.$0Ë~$$.8$$D$$D$D$D$ $uÐUWVSl$0u1otp$Xustp$:u~$ $$|#$h#$Z$L'$>$0 $o$w$s$$$$$$$$~uat6OGLuCoT,$"E$VGP@uGdu[^_]É$5$+݉$!볉$땉$!u$$Ð<\$,t$0(wt$|$4t$$l$8D$D$BD$|$ VL$T$+9|D$F"|$GD$u%t$FD$\$,t$0|$4l$8<ËD$~Fw+vGF@D$F$Ӌl$ݍw+vGFn$م~Iu+9wEF@~$fԉݍw+9wGFn$$s,\$t$ @|$$l$(l$0|$4t4$|$Ջvu\$t$ |$$l$(,ÐL\$D$Jl $D$<$3L$PL$D $D$t|Wt"T$HB2D$D$Dt$$iFD$D$DL$$K~F <$D$%uFD$HD$D$D$뎋|$D1D$D_lэT|$D$$.~t$D|$|$4$_|$Pgll$t$<$|$$$ J\$`t$$t$$ gD$D$$$ D$ t$$\$t$Ð$$$$$g$$!Ȩ$4D$D苃t; t$otOt<"t<4$‹8$$$$ĜÀ~"uϋ  T$ l$xD$D$D$$t\D$||$<$ D$|tD$$D$|dD$T$$D$|D$xt$ t$$D$$$D$||$"gu V$)gu .5$0g u $$9gu $Agu $Hg u $Qgu $Xgu o$8_]g$T$!DUWVS,D$@D$сtoց+ )9w;l$@E%9}l$@D9|ȃ,[^_]$l뷋D$@p+,)9w $$㋃;뚋ׁ+ )9w`T$@%EtB|$tt$@FE9|5L$@$D9|݋z$뒐<\$,t$0l$8D$@|$4Dl$D$D$сt{,ց+0 )9wG,l$@E%9}l$@D9|ȋ\$,t$0|$4l$8<$뫋D$@p,+0,)9w, $p㋃뎋, +0)9wd,uE 7|$tt$@FG9|5L$@$9|$$뎐<\$,t$0|$4l$8l$@EƋ|+L$ )9wv|E%|$ tI|$t't Du\$,t$0|$4l$8<ÃtD$\uϋEGE$AG$yUWVS,T$@|$tNNjL$D)4))T$@%9E)}L$@D9|,[^_]ËrD$D)эV~l$@D1D$D뵉NjT$D*4)*t$@%ED$D(tJ|$tL$@AE9^D$DL$@D$$D9|7~뱐UWVS,D$@kD$1tKtP׋L$D)4))T$@%9E)}L$@D9|,[^_]ËD$DD$@p)эV~l$@D1΋D$D믉׋T$D*4)*t$@%ED$D(tJ|$tL$@AE9XD$DL$@D$$D9|1~뱐UWVS/,D$@D$1tItNՋL$D94)9T$@%99}L$@9|,[^_]ËD$@t$Dh>)ׁ>T$@B9GT$@.}L$@L$@9|똉ՋT$D:4):t$@%D$D8tI|$tL$@AG9DD$DL$@D$$9|n벐,\$|$$D$0t$ l$(e빐,\$|$$|$0t$ l$(;r5;s-Դ,ttf́49|\$t$ |$$l$(,Ë<$D$ t 9|ˍQ|$ t$T$$ 1뮋o띐UWVSC $ŰT$(D$$T$$ʰD$ $OMD$$Ű>\$t$|$Ð\$Pt$|$L> $ET$$D$ T$$JLD$$Ly>\$t$|$Ð $ ÐST$$[SD$ wyR]u} [ÍD$$W㍃捃&ލY֍hΐU1WV;l$$}AD$ 1t$Brgr hv#jt$ku܃;l$$|^_]ÅtWB؋D$ 쐐VS蕿$L6He@pBPAѵյ@@p(ѵյB@A@P@ѵAյA͵@(͵H4F͵Fٵݵ@4ѵٵHյٵpݵ ݵHѵݵH[^ÐVt$$D$ $F^Ð,\$|$$D$0t$ l$((E`EE=L`Q   t  r \H`i\e)@,, A0?DT?55new bloc, size %6lu (no %ld): %08lx mallocing NULL object in newblockilling bloc (no %ld): %08lx popping %s (bloc no %ld) mallocing NULL objectpari.pspari.logGP_DATA_DIR/usr/local/share/parixResetting all trapsCannot initialize kernelnot enough memory, new stack %lu *** Error in the PARI system. End of program. changevarvariable out of range in reorderduplicate indeterminates in reorderreorderleaving recover() entering recover(), loc = %ld *** %s: no such error number: %ldcan't trap memory errors *** %s: %s. %s: %s in %s; new prec = %ld *** %suse pari_warn for warnings current stack size: %lu (%.3f Mbytes) [hint] you can increase GP stack with allocatemem() %s, please report %s is not yet implemented.%lu.additionmultiplicationgcd,-->assignment %s %s %s %s.division in %s. ### user error: %s fileuncaught error: %ld For full compatibility with GP 1.39.15, type "default(compatible,3)", or set "compatible = 3" in your GPRC fileerrpiletypeergdiverinvmoderaccurerarchersigintertalkeruserthis trap keywordsignificant pointers lost in gerepile! (please report)bad component %ld in object %Zlbot>ltop in gerepiledoubling stack size; new stack = %lu (%.3f Mbytes)bot=0x%lx top=0x%lx 0x%p: 0x%lx %lu Time : %ld ColDGCol({x=[]}): transforms the object x into a column vector. Empty vector if x is omittedEulerpEuler=Euler(): Euler's constant with current precisionII=I(): square root of -1ListList({x=[]}): transforms the vector or list x into a list. Empty list if x is omittedMatMat({x=[]}): transforms any GEN x into a matrix. Empty matrix if x is omittedModGGD0,L,Mod(x,y): creates 'x modulo y'.OO(a^b): p-adic or power series zero with precision given by bPiPi=Pi(): the constant pi, with current precisionPolGDnPol(x,{v=x}): convert x (usually a vector or a power series) into a polynomial with variable v, starting with the leading coefficientPolrevPolrev(x,{v=x}): convert x (usually a vector or a power series) into a polynomial with variable v, starting with the constant termQfbGGGDGpQfb(a,b,c,{D=0.}): binary quadratic form a*x^2+b*x*y+c*y^2. D is optional (0.0 by default) and initializes Shanks's distance if b^2-4*a*c>0SerSer(x,{v=x}): convert x (usually a vector) into a power series with variable v, starting with the constant coefficientSetSet({x=[]}): convert x into a set, i.e. a row vector with strictly increasing coefficients. Empty set if x is omittedStrs*Str({str}*): concatenates its (string) argument into a single stringStrchrGStrchr(x): converts x to a string, translating each integer into a characterStrexpandStrexpand({str}*): concatenates its (string) argument into a single string, performing tilde expansionStrtexStrtex({str}*): translates its (string) arguments to TeX format and returns the resulting stringVecVec({x=[]}): transforms the object x into a vector. Empty vector if x is omittedVecsmallVecsmall({x=[]}): transforms the object x into a VECSMALL. Empty vector if x is omittedabsGpabs(x): absolute value (or modulus) of xacosacos(x): inverse cosine of xacoshacosh(x): inverse hyperbolic cosine of xaddhelpvSsaddhelp(symbol,"message"): add/change help message for a symboladdprimesaddprimes({x=[]}): add primes in the vector x to the prime table to be used in trial division. x may also be a single integer. Composite "primes" are allowed, and in that case you may later get a message "impossible inverse", which will give you some factors. List the current extra primes if x is omitted. If some primes are added which intersect non trivially the existing table entries, suitable updating is doneagmGGpagm(x,y): arithmetic-geometric mean of x and yalgdepGLD0,L,palgdep(x,n,{flag=0}): algebraic relations up to degree n of x, using lindep([1,x,...,x^(n-1)], flag).aliasvrralias("new","old"): new is now an alias for oldallocatememvD0,L,allocatemem({s=0}): allocates a new stack of s bytes. doubles the stack if s is omittedargarg(x): argument of x,such that -pi0. The answer is guaranteed (i.e x norm iff b=1) under GRH, if S contains all primes less than 12.log(disc(Bnf))^2, where Bnf is the Galois closure of bnfbnfisprincipalGGD1,L,bnfisprincipal(bnf,x,{flag=1}): bnf being output by bnfinit (with flag<=2), gives [v,alpha], where v is the vector of exponents on the class group generators and alpha is the generator of the resulting principal ideal. In particular x is principal if and only if v is the zero vector. flag is optional, whose meaning is: 0: output only v; 1: default; 2: output only v, precision being doubled until the result is obtained; 3: as 2 but output generatorsbnfissunitGGGbnfissunit(bnf,sfu,x): bnf being output by bnfinit (with flag<=2), sfu by bnfsunit, gives the column vector of exponents of x on the fundamental S-units and the roots of unity if x is a unit, the empty vector otherwisebnfisunitbnfisunit(bnf,x): bnf being output by bnfinit (with flag<=2), gives the column vector of exponents of x on the fundamental units and the roots of unity if x is a unit, the empty vector otherwisebnfmakebnfmake(sbnf): transforms small sbnf as output by bnfinit with flag=3 into a true big bnfbnfnarrowbnfnarrow(bnf): given a big number field as output by bnfinit, gives as a 3-component vector the structure of the narrow class groupbnfregbnfreg(P,{tech=[]}): compute the regulator of the number field defined by the polynomial P. If P is a non-zero integer, it is interpreted as a quadratic discriminant. See manual for details about techbnfsignunitbnfsignunit(bnf): matrix of signs of the real embeddings of the system of fundamental units found by bnfinitbnfsunitbnfsunit(bnf,S): compute the fundamental S-units of the number field bnf output by bnfinit, S being a list of prime ideals. res[1] contains the S-units, res[5] the S-classgroup. See manual for detailsbnfunitbnfunit(bnf): compute the fundamental units of the number field bnf output by bnfinit when they have not yet been computed (i.e. with flag=2)bnrL1GDGD0,L,pbnrL1(bnr, {subgroup}, {flag=0}): bnr being output by bnrinit(,,1) and subgroup being a square matrix defining a congruence subgroup of bnr (the trivial subgroup if omitted), for each character of bnr trivial on this subgroup, compute L(1, chi) (or equivalently the first non-zero term c(chi) of the expansion at s = 0). The binary digits of flag mean 1: if 0 then compute the term c(chi) and return [r(chi), c(chi)] where r(chi) is the order of L(s, chi) at s = 0, or if 1 then compute the value at s = 1 (and in this case, only for non-trivial characters), 2: if 0 then compute the value of the primitive L-function associated to chi, if 1 then compute the value of the L-function L_S(s, chi) where S is the set of places dividing the modulus of bnr (and the infinite places), 3: return also the charactersbnrclassbnrclass(bnf,ideal,{flag=0}): given a big number field as output by bnfinit (only) and an ideal or a 2-component row vector formed by an ideal and a list of R1 zeros or ones representing a module, finds the ray class group structure corresponding to this module. flag is optional, and can be 0: default, 1: compute data necessary for working in the ray class group, for example with functions such as bnrisprincipal or bnrdisc, without computing the generators of the ray class group, or 2: with the generators. When flag=1 or 2, the fifth component is the ray class group structure obtained when flag=0bnrclassnobnrclassno(bnf,x): ray class number of the module x for the big number field bnf. Faster than bnrclass if only the ray class number is wantedbnrclassnolistbnrclassnolist(bnf,list): if list is as output by ideallist or similar, gives list of corresponding ray class numbersbnrconductorGDGDGDGbnrconductor(a1,{a2},{a3},{flag=0}): conductor f of the subfield of the ray class field given by a1,a2,a3 (see bnrdisc). flag is optional and can be 0: default, 1: returns [f, Cl_f, H], H subgroup of the ray class group modulo f defining the extension, 2: returns [f, bnr(f), H]bnrconductorofcharbnrconductorofchar(bnr,chi): conductor of the character chi on the ray class group bnrbnrdiscGDGDGD0,L,bnrdisc(a1,{a2},{a3},{flag=0}): absolute or relative [N,R1,discf] of the field defined by a1,a2,a3. [a1,{a2},{a3}] is of type [bnr], [bnr,subgroup], [bnf, module] or [bnf,module,subgroup], where bnf is as output by bnfclassunit (with flag<=2), bnr by bnrclass (with flag>0), and subgroup is the HNF matrix of a subgroup of the corresponding ray class group (if omitted, the trivial subgroup). flag is optional whose binary digits mean 1: give relative data; 2: return 0 if module is not the conductorbnrdisclistbnrdisclist(bnf,bound,{arch}): gives list of discriminants of ray class fields of all conductors up to norm bound, in a long vector The ramified Archimedean places are given by arch; all possible values are taken if arch is omitted. Supports the alternative syntax bnrdisclist(bnf,list), where list is as output by ideallist or ideallistarch (with units)bnrinitbnrinit(bnf,ideal,{flag=0}): given a big number field as output by bnfinit (only) and an ideal or a 2-component row vector formed by an ideal and a list of R1 zeros or ones representing a module, initializes data linked to the ray class group structure corresponding to this module. flag is optional, and can be 0: default (same as bnrclass with flag = 1), 1: compute also the generators (same as bnrclass with flag = 2). The fifth component is the ray class group structurebnrisconductorlGDGDGbnrisconductor(a1,{a2},{a3}): returns 1 if the modulus is the conductor of the subfield of the ray class field given by a1,a2,a3 (see bnrdisc), and 0 otherwise. Slightly faster than bnrconductor if this is the only desired resultbnrisprincipalbnrisprincipal(bnr,x,{flag=1}): bnr being output by bnrinit, gives [v,alpha], where v is the vector of exponents on the class group generators and alpha is the generator of the resulting principal ideal. In particular x is principal if and only if v is the zero vector. If (optional) flag is set to 0, output only vbnrrootnumberbnrrootnumber(bnr,chi,{flag=0}); returns the so-called Artin Root Number, i.e. the constant W appearing in the functional equation of the Hecke L-function associated to chi. Set flag = 1 if the character is known to be primitivebnrstarkbnrstark(bnr,{subgroup}): bnr being as output by bnrinit(,,1), finds a relative equation for the class field corresponding to the module in bnr and the given congruence subgroup (the trivial subgroup if omitted) using Stark's units. The ground field and the class field must be totally real.breakD1,L,break({n=1}): interrupt execution of current instruction sequence, and exit from the n innermost enclosing loopsceilceil(x): ceiling of x=smallest integer>=xcenterliftcenterlift(x,{v}): centered lift of x. Same as lift except for integermodschangevar(x,y): change variables of x according to the vector ycharpolyGDnD0,L,charpoly(A,{v=x},{flag=0}): det(v*Id-A)=characteristic polynomial of the matrix or polmod A. flag is optional and may be set to 1 (use Lagrange interpolation) or 2 (use Hessenberg form), 0 being the defaultchineseGDGchinese(x,{y}): x,y being both intmods (or polmods) computes z in the same residue classes as x and ycomponentcomponent(x,s): the s'th component of the internal representation of x. For vectors or matrices, it is simpler to use x[]. For list objects such as nf, bnf, bnr or ell, it is much easier to use member functions starting with "."concatconcat(x,{y}): concatenation of x and y, which can be scalars, vectors or matrices, or lists (in this last case, both x and y have to be lists). If y is omitted, x has to be a list or row vector and its elements are concatenatedconjconj(x): the algebraic conjugate of xconjvecconjvec(x): conjugate vector of the algebraic number xcontentcontent(x): gcd of all the components of x, when this makes sensecontfracGDGD0,L,contfrac(x,{b},{lmax}): continued fraction expansion of x (x rational,real or rational function). b and lmax are both optional, where b is the vector of numerators of the continued fraction, and lmax is a bound for the number of terms in the continued fraction expansioncontfracpnqncontfracpnqn(x): [p_n,p_{n-1}; q_n,q_{n-1}] corresponding to the continued fraction xcoreGD0,L,core(n,{flag=0}): unique (positive of negative) squarefree integer d dividing n such that n/d is a square. If (optional) flag is non-null, output the two-component row vector [d,f], where d is the unique squarefree integer dividing n such that n/d=f^2 is a squarecoredisccoredisc(n,{flag=0}): discriminant of the quadratic field Q(sqrt(n)). If (optional) flag is non-null, output a two-component row vector [d,f], where d is the discriminant of the quadratic field Q(sqrt(n)) and n=df^2. f may be a half integercoscos(x): cosine of xcoshcosh(x): hyperbolic cosine of xcotancotan(x): cotangent of xdefaultD"",r,D"",s,D0,L,default({opt},{v}): returns the current value of the current default opt. If v is present, set opt to v first. If no argument is given, print a list of all defaults as well as their values.denominatordenominator(x): denominator of x (or lowest common denominator in case of an array)derivderiv(x,{y}): derivative of x with respect to the main variable of y, or to the main variable of x if y is omitteddilogdilog(x): dilogarithm of xdirdivdirdiv(x,y): division of the Dirichlet series x by the Dirichlet series ydireulerV=GGEDGdireuler(p=a,b,expr,{c}): Dirichlet Euler product of expression expr from p=a to p=b, limited to b terms. Expr should be a polynomial or rational function in p and X, and X is understood to mean p^(-s). If c is present, output only the first c termsdirmuldirmul(x,y): multiplication of the Dirichlet series x by the Dirichlet series ydirzetakdirzetak(nf,b): Dirichlet series of the Dedekind zeta function of the number field nf up to the bound b-1divisorsdivisors(x): gives a vector formed by the divisors of x in increasing orderdivremGGDndivrem(x,y,{v}): euclidean division of x by y giving as a 2-dimensional column vector the quotient and the remainder, with respect to v (to main variable if v is omitted)eint1eint1(x,{n}): exponential integral E1(x). If n is present, computes the vector of the first n values of the exponential integral E1(n.x) (x > 0)elladdelladd(e,z1,z2): sum of the points z1 and z2 on elliptic curve eellakellak(e,n): computes the n-th Fourier coefficient of the L-function of the elliptic curve eellanellan(e,n): computes the first n Fourier coefficients of the L-function of the elliptic curve e (n<2^24 on a 32-bit machine)ellapellap(e,p,{flag=0}): computes a_p for the elliptic curve e using Shanks-Mestre's method. flag is optional and can be set to 0 (default) or 1 (use Jacobi symbols)ellbilGGGpellbil(e,z1,z2): canonical bilinear form for the points z1,z2 on the elliptic curve e. Either z1 or z2 can also be a vector/matrix of pointsellchangecurveellchangecurve(x,y): change data on elliptic curve according to y=[u,r,s,t]ellchangepointellchangepoint(x,y): change data on point or vector of points x on an elliptic curve according to y=[u,r,s,t]ellconvertnameellconvertname(name): convert an elliptic curve name (as found in the elldata database) from a string to a triplet [conductor, isogeny class, index]. It will also convert a triplet back to a curve name.elleisnumelleisnum(om,k,{flag=0}): om=[om1,om2] being a 2-component vector giving a basis of a lattice L and k an even positive integer, computes the numerical value of the Eisenstein series of weight k. When flag is non-zero and k=4 or 6, this gives g2 or g3 with the correct normalizationelletaelleta(om): om=[om1,om2], returns the two-component row vector [eta1,eta2] of quasi-periods associated to [om1,om2]ellgeneratorsellgenerators(E): if E is an elliptic curve as output by ellinit(), return the generators of the Mordell-Weil group associated to the curve. This function depends on the curve being referenced in the elldata database.ellglobalredellglobalred(e): e being an elliptic curve, returns [N,[u,r,s,t],c], where N is the conductor of e, [u,r,s,t] leads to the standard model for e, and c is the product of the local Tamagawa numbers c_pellheightGGD2,L,pellheight(e,x,{flag=2}): canonical height of point x on elliptic curve E defined by the vector e. flag is optional and selects the algorithm used to compute the archimedean local height. Its meaning is 0: use theta-functions, 1: use Tate's method, 2: use Mestre's AGMellheightmatrixellheightmatrix(e,x): gives the height matrix for vector of points x on elliptic curve e using theta functionsellidentifyellidentify(E): look up the elliptic curve E in the elldata database and return [[N, M, ...], C] where N is the name of the curve in J. E. Cremona database, M the minimal model and C the coordinates change (see ellchangecurve).ellinitGD0,L,pellinit(x,{flag=0}): x being the vector [a1,a2,a3,a4,a6] defining the curve Y^2 + a1.XY + a3.Y = X^3 + a2.X^2 + a4.X + a6, gives the vector: [a1,a2,a3,a4,a6,b2,b4,b6,b8,c4,c6,disc,j,[e1,e2,e3],w1,w2,eta1,eta2,area]. If the curve is defined over a p-adic field, the last six components are replaced by root,u^2,u,q,w,0. If optional flag is 1, omit them altogether. x can also be a string, in this case the coefficients of the curve with matching name are looked in the elldata database if available.ellisoncurveellisoncurve(e,x): true(1) if x is on elliptic curve e, false(0) if notelljellj(x): elliptic j invariant of xelllocalredelllocalred(e,p): e being an elliptic curve, returns [f,kod,[u,r,s,t],c], where f is the conductor's exponent, kod is the Kodaira type for e at p, [u,r,s,t] is the change of variable needed to make e minimal at p, and c is the local Tamagawa number c_pelllseriesGGDGpelllseries(e,s,{A=1}): L-series at s of the elliptic curve e, where A a cut-off point close to 1ellminimalmodelGD&ellminimalmodel(e,{&v}): return the standard minimal integral model of the rational elliptic curve e. Sets v to the corresponding change of variablesellorderellorder(e,p): order of the point p on the elliptic curve e over Q, 0 if non-torsionellordinateellordinate(e,x): y-coordinates corresponding to x-ordinate x on elliptic curve eellpointtozellpointtoz(e,P): lattice point z corresponding to the point P on the elliptic curve eellpowellpow(e,x,n): n times the point x on elliptic curve e (n in Z)ellrootnolGDGellrootno(e,{p=1}): root number for the L-function of the elliptic curve e. p can be 1 (default), global root number, or a prime p (including 0) for the local root number at pellsearchellsearch(N): if N is an integer, it is taken as a conductor else if N is a string, it can be a curve name ("11a1"), a isogeny class ("11a") or a conductor ("11"). Return all curves in the elldata database that match the property.ellsigmaellsigma(om,z,{flag=0}): om=[om1,om2], value of the Weierstrass sigma function of the lattice generated by om at z if flag = 0 (default). If flag = 1, arbitrary determination of the logarithm of sigma. If flag = 2 or 3, same but using the product expansion instead of theta seriesellsubellsub(e,z1,z2): difference of the points z1 and z2 on elliptic curve eelltaniyamaGPelltaniyama(e): modular parametrization of elliptic curve eelltorselltors(e,{flag=0}): torsion subgroup of elliptic curve e: order, structure, generators. If flag = 0, use Doud's algorithm; if flag = 1, use Lutz-NagellellwpGDGD0,L,pPellwp(e,{z=x},{flag=0}): Complex value of Weierstrass P function at z on the lattice generated over Z by e=[om1,om2] (e as given by ellinit is also accepted). Optional flag means 0 (default), compute only P(z), 1 compute [P(z),P'(z)], 2 consider om as an elliptic curve and compute P(z) for that curve (identical to ellztopoint in that case). If z is omitted or is a simple variable, return formal expansion in zellzetaellzeta(om,z): om=[om1,om2], value of the Weierstrass zeta function of the lattice generated by om at zellztopointellztopoint(e,z): coordinates of point P on the curve e corresponding to the complex number zerfcerfc(x): complementary error functionerrorvs*error("msg"): abort script with error message msgetaeta(x,{flag=0}): if flag=0, eta function without the q^(1/24), otherwise eta of the complex number x in the upper half plane intelligently computed using SL(2,Z) transformationseulerphieulerphi(x): Euler's totient function of xevaleval(x): evaluation of x, replacing variables by their valueexpexp(x): exponential of xfactorfactor(x,{lim}): factorization of x. lim is optional and can be set whenever x is of (possibly recursive) rational type. If lim is set return partial factorization, using primes up to lim (up to primelimit if lim=0)factorbackGDGDGfactorback(f,{e},{nf}): given a factorisation f, gives the factored object back. If this is a prime ideal factorisation you must supply the corresponding number field as last argument. If e is present, f has to be a vector of the same length, and we return the product of the f[i]^e[i]factorcantorfactorcantor(x,p): factorization mod p of the polynomial x using Cantor-Zassenhausfactorfffactorff(x,p,a): factorization of the polynomial x in the finite field F_p[X]/a(X)F_p[X]factorialfactorial(x): factorial of x (x C-integer), the result being given as a real numberfactorintfactorint(x,{flag=0}): factor the integer x. flag is optional, whose binary digits mean 1: avoid MPQS, 2: avoid first-stage ECM (may fall back on it later), 4: avoid Pollard-Brent Rho and Shanks SQUFOF, 8: skip final ECM (huge composites will be declared prime)factormodfactormod(x,p,{flag=0}): factorization mod p of the polynomial x using Berlekamp. flag is optional, and can be 0: default or 1: simple factormod, same except that only the degrees of the irreducible factors are givenfactornffactornf(x,t): factorization of the polynomial x over the number field defined by the polynomial tfactorpadicGGLD0,L,factorpadic(x,p,r,{flag=0}): p-adic factorization of the polynomial x to precision r. flag is optional and may be set to 0 (use round 4) or 1 (use Buchmann-Lenstra)ffinitGLDnffinit(p,n,{v=x}): monic irreducible polynomial of degree n over F_p[v]fibonaccifibonacci(x): fibonacci number of index x (x C-integer)floorfloor(x): floor of x = largest integer<=xforvV=GGIfor(X=a,b,seq): the sequence is evaluated, X going from a up to bfordivvGVIfordiv(n,X,seq): the sequence is evaluated, X running over the divisors of nforellvVLLIforell(E,a,b,seq): execute seq for each elliptic curves E of conductor between a and b in the elldata database.forprimeforprime(X=a,b,seq): the sequence is evaluated, X running over the primes between a and bforstepvV=GGGIforstep(X=a,b,s,seq): the sequence is evaluated, X going from a to b in steps of s (can be a vector of steps)forsubgroupvV=GDGIforsubgroup(H=G,{bound},seq): execute seq for each subgroup H of the abelian group G (in SNF form), whose index is bounded by bound. H is given as a left divisor of G in HNF formforvecvV=GID0,L,forvec(x=v,seq,{flag=0}): v being a vector of two-component vectors of length n, the sequence is evaluated with x[i] going from v[i][1] to v[i][2] for i=n,..,1 if flag is zero or omitted. If flag = 1 (resp. flag = 2), restrict to increasing (resp. strictly increasing) sequencesfracfrac(x): fractional part of x = x-floor(x)galoisexportgaloisexport(gal,{flag}): gal being a galois field as output by galoisinit, output a string representing the underlying permutation group in GAP notation (default) or Magma notation (flag = 1)galoisfixedfieldGGD0,L,Dngaloisfixedfield(gal,perm,{flag},{v=y}): gal being a galois field as output by galoisinit and perm an element of gal.group or a vector of such elements, return [P,x] such that P is a polynomial defining the fixed field of gal[1] by the subgroup generated by perm, and x is a root of P in gal expressed as a polmod in gal.pol. If flag is 1 return only P. If flag is 2 return [P,x,F] where F is the factorization of gal.pol over the field defined by P, where the variable v stands for a root of Pgaloisidentifygaloisidentify(gal): gal being a galois field as output by galoisinit, output the isomorphism class of the underlying abstract group as a two-components vector [o,i], where o is the group order, and i is the group index in the GAP4 small group librarygaloisinitgaloisinit(pol,{den}): pol being a polynomial or a number field as output by nfinit defining a Galois extension of Q, compute the Galois group and all neccessary informations for computing fixed fields. den is optional and has the same meaning as in nfgaloisconj(,4)(see manual)galoisisabeliangaloisisabelian(gal,{flag=0}): gal being as output by galoisinit, return 0 if gal is not abelian, the HNF matrix of gal over gal.gen if flag=0, 1 if flag is 1, and the SNF of gal is flag=2galoispermtopolgaloispermtopol(gal,perm): gal being a galois field as output by galoisinit and perm a element of gal.group, return the polynomial defining the corresponding Galois automorphismgaloissubcycloGDGD0,L,Dngaloissubcyclo(N,H,{fl=0},{v}):Compute a polynomial (in variable v) defining the subfield of Q(zeta_n) fixed by the subgroup H of (Z/nZ)*. N can be an integer n, znstar(n) or bnrinit(bnfinit(y),[n,[1]],1). H can be given by a generator, a set of generator given by a vector or a HNF matrix (see manual). If flag is 1, output only the conductor of the abelian extension. If flag is 2 output [pol,f] where pol is the polynomial and f the conductor.galoissubfieldsGD0,L,Dngaloissubfields(G,{flags=0},{v}):Output all the subfields of G. flags have the same meaning as for galoisfixedfieldgaloissubgroupsgaloissubgroups(G):Output all the subgroups of Ggammagamma(x): gamma function at xgammahgammah(x): gamma of x+1/2 (x integer)gcd(x,{y}): greatest common divisor of x and y.getheapgetheap(): 2-component vector giving the current number of objects in the heap and the space they occupygetrandlgetrand(): current value of random number seedgetstackgetstack(): current value of stack pointer avmagettimegettime(): time (in milliseconds) since last call to gettimeglobalglobal(x): declare x to be a global variablehilbertlGGDGhilbert(x,y,{p}): Hilbert symbol at p of x,y. If x,y are integermods or p-adic, p can be omittedhyperuhyperu(a,b,x): U-confluent hypergeometric functionidealaddidealadd(nf,x,y): sum of two ideals x and y in the number field defined by nfidealaddtooneidealaddtoone(nf,x,{y}): if y is omitted, when the sum of the ideals in the number field K defined by nf and given in the vector x is equal to Z_K, gives a vector of elements of the corresponding ideals who sum to 1. Otherwise, x and y are ideals, and if they sum up to 1, find one element in each of them such that the sum is 1idealappridealappr(nf,x,{flag=0}): x being a fractional ideal, gives an element b such that v_p(b)=v_p(x) for all prime ideals p dividing x, and v_p(b)>=0 for all other p. If (optional) flag is non-null x must be a prime ideal factorization with possibly zero exponentsidealchineseidealchinese(nf,x,y): x being a prime ideal factorization and y a vector of elements, gives an element b such that v_p(b-y_p)>=v_p(x) for all prime ideals p dividing x, and v_p(b)>=0 for all other pidealcoprimeidealcoprime(nf,x,y): gives an element b in nf such that b. x is an integral ideal coprime to the integral ideal yidealdivGGGD0,L,idealdiv(nf,x,y,{flag=0}): quotient x/y of two ideals x and y in HNF in the number field nf. If (optional) flag is non-null, the quotient is supposed to be an integral ideal (slightly faster)idealfactoridealfactor(nf,x): factorization of the ideal x given in HNF into prime ideals in the number field nfidealhnfidealhnf(nf,a,{b}): hermite normal form of the ideal a in the number field nf, whatever form a may have. If called as idealhnf(nf,a,b), the ideal is given as aZ_K+bZ_K in the number field K defined by nfidealintersectidealintersect(nf,x,y): intersection of two ideals x and y in the number field defined by nfidealinvidealinv(nf,x,{flag=0}): inverse of the ideal x in the number field nf. If flag is omitted or set to 0, use the different. If flag is 1 do not use itideallistGLD4,L,ideallist(nf,bound,{flag=4}): vector of vectors L of all idealstar of all ideals of norm<=bound. If (optional) flag is present, its binary digits are toggles meaning 1: give generators; 2: add units; 4: give only the ideals and not the bid.ideallistarchideallistarch(nf,list,arch): list is a vector of vectors of of bid's as output by ideallist. Return a vector of vectors with the same number of components as the original list. The leaves give information about moduli whose finite part is as in original list, in the same order, and archimedean part is now arch. The information contained is of the same kind as was present in the input.ideallogideallog(nf,x,bid): if bid is a big ideal, as given by idealstar(nf,I,1) or idealstar(nf,I,2), gives the vector of exponents on the generators bid[2][3] (even if these generators have not been computed)idealminidealmin(nf,ix,{vdir}): minimum of the ideal ix in the direction vdir in the number field nfidealmulGGGD0,L,pidealmul(nf,x,y,{flag=0}): product of the two ideals x and y in the number field nf. If (optional) flag is non-nul, reduce the resultidealnormidealnorm(nf,x): norm of the ideal x in the number field nfidealpowidealpow(nf,x,n,{flag=0}): n-th power of the ideal x in HNF in the number field nf If (optional) flag is non-null, reduce the resultidealprimedecidealprimedec(nf,p): prime ideal decomposition of the prime number p in the number field nf as a vector of 5 component vectors [p,a,e,f,b] representing the prime ideals pZ_K+a. Z_K, e,f as usual, a as vector of components on the integral basis, b Lenstra's constantidealprincipalidealprincipal(nf,x): returns the principal ideal generated by the algebraic number x in the number field nfidealredidealred(nf,x,{vdir=0}): LLL reduction of the ideal x in the number field nf along direction vdir, in HNFidealstaridealstar(nf,I,{flag=1}): gives the structure of (Z_K/I)^*. flag is optional, and can be 0: simply gives the structure as a 3-component vector v such that v[1] is the order (i.e. eulerphi(I)), v[2] is a vector of cyclic components, and v[3] is a vector giving the corresponding generators. If flag=1 (default), gives idealstarinit, i.e. a 6-component vector [I,v,fa,f2,U,V] where v is as above without the generators, fa is the prime ideal factorisation of I and f2, U and V are technical but essential to work in (Z_K/I)^*. Finally if flag=2, same as with flag=1 except that the generators are also givenidealtwoeltidealtwoelt(nf,x,{a}): two-element representation of an ideal x in the number field nf. If (optional) a is non-zero, first element will be equal to aidealvallGGGidealval(nf,x,p): valuation at p given in idealprimedec format of the ideal x in the number field nfideleprincipalideleprincipal(nf,x): returns the principal idele generated by the algebraic number x in the number field nfifif(a,seq1,seq2): if a is nonzero, seq1 is evaluated, otherwise seq2. seq1 and seq2 are optional, and if seq2 is omitted, the preceding comma can be omitted alsoimagimag(x): imaginary part of xincgamincgam(s,x,{y}): incomplete gamma function. y is optional and is the precomputed value of gamma(s)incgamcincgamc(s,x): complementary incomplete gamma functionintcircV=GGEDGpintcirc(X=a,R,s,{tab}): numerical integration of s on the circle |z-a|=R, divided by 2*I*Pi. tab is as in intnum.intformalintformal(x,{y}): formal integration of x with respect to the main variable of y, or to the main variable of x if y is omittedintfouriercosV=GGGEDGpintfouriercos(X=a,b,x,s,{tab}): numerical integration from a to b of cos(2*Pi*x*X)*s(X) from a to b, where a, b, and tab are as in intnum. This is the cosine-Fourier transform if a=-infty and b=+infty.intfourierexpintfourierexp(X=a,b,x,s,{tab}): numerical integration from a to b of exp(-2*I*Pi*x*X)*s(X) from a to b, where a, b, and tab are as in intnum. This is the ordinary Fourier transform if a=-infty and b=+infty. Note the minus sign.intfouriersinintfouriersin(X=a,b,x,s,{tab}): numerical integration from a to b of sin(2*Pi*x*X)*s(X) from a to b, where a, b, and tab are as in intnum. This is the sine-Fourier transform if a=-infty and b=+infty.intfuncinitV=GGED0,L,D0,L,pintfuncinit(X=a,b,s,{flag=0},{m=0}): initialize tables for integrations from a to b using a weight s(X). Essential for integral transforms such as intmellininv, intlaplaceinv and intfourier, since it avoids recomputing all the time the same quantities. Must then be used with intmellininvshort (for intmellininv) and directly with intnum and not with the corresponding integral transforms for the others. See help for intnum for coding of a and b, and m is as in intnuminit. If flag is nonzero, assumes that s(-X)=conj(s(X)), which is twice faster.intlaplaceinvintlaplaceinv(X=sig,x,s,{tab}): numerical integration on the line real(z) = sig of s(z)exp(xz)dz/(2*I*Pi), i.e. inverse Laplace transform of s at x. tab is as in intnum.intmellininvintmellininv(X=sig,x,s,{tab}): numerical integration on the line real(z) = sig (or sig[1]) of s(z)x^(-z)dz/(2*I*Pi), i.e. inverse Mellin transform of s at x. sig is coded as follows: either it is real, and then by default assume s(z) decreases like exp(-z). Or sig = [sigR, al], sigR is the abcissa of integration, and al = 0 for slowly decreasing functions, or al > 0 if s(z) decreases like exp(-al*z). tab is as in intnum. Use intmellininvshort if several values must be computed.intmellininvshortintmellininvshort(sig,x,tab): numerical integration on the line real(z) = sig (or sig[1]) of s(z)x^(-z)dz/(2*I*Pi), i.e. inverse Mellin transform of s at x. sig is coded as follows: either it is real, and then by default assume s(z) decreases like exp(-z). Or sig = [sigR, al], sigR is the abcissa of integration, and al = 0 for slowly decreasing functions, or al > 0 if s(z) decreases like exp(-al*z). Compulsory table tab has been precomputed using the command intfuncinit(t=[[-1],sig[2]],[[1],sig[2]],s) (with possibly its two optional additional parameters), where sig[2] = 1 if not given. Orders of magnitude faster than intmellininv.intnumintnum(X=a,b,s,{tab}): numerical integration of s from a to b with respect to X. a (and similarly b) is coded as follows. It can be a scalar: f is assumed to be C^infty at a. It can be a two component vector [a[1],a[2]], where a[1] is the scalar, and a[2] is the singularity exponent (in ]-1,0]), logs being neglected. It can be a one component vector [1] or [-1] meaning +infty or -infty, slowly decreasing functions. It can be a two component vector [[1], z] or [[-1], z], where [1] or [-1] indicates +infty or -infty and z is coded as follows. If z is zero, slowly decreasing. If z is real positive, exponentially decreasing, of the type exp(-zX). If z<-1, very slowly decreasing like X^(-z). If z is complex nonreal, real part is ignored and if z = r+I*s then if s>0, cosine oscillation exactly cos(sX), while if s<0, sine oscillation exactly sin(sX). If f is exponentially decreasing times oscillating function, you have a choice, but it is in general better to choose the oscillating part. Finally tab is either 0 (let the program choose the integration step), a positive integer m (choose integration step 1/2^m), or a table tab precomputed with intnuminit (depending on the type of interval: compact, semi-compact or R, very slow, slow, exponential, or cosine or sine-oscillating decrease).intnuminitintnuminit(a,b,{m=0}): initialize tables for integrations from a to b. See help for intnum for coding of a and b. Possible types: compact interval, semi-compact (one extremity at + or - infinity) or R, and very slowly, slowly or exponentially decreasing, or sine or cosine oscillating at infinities,intnuminitgenVGGED0,L,D0,L,pintnuminitgen(t,a,b,ph,{m=0},{flag=0}): initialize tables for integrations from a to b using abcissas ph(t) and weights ph'(t). Note that there is no equal sign after the variable name t since t always goes from -infty to +infty, but it is ph(t) which goes from a to b, and this is not checked. If flag = 1 or 2, multiply the reserved table length by 4^flag, to avoid corresponding error.intnumrombV=GGED0,L,pintnumromb(X=a,b,s,{flag=0}): numerical integration of s (smooth in ]a,b[) from a to b with respect to X. flag is optional and mean 0: default. s can be evaluated exactly on [a,b]; 1: general function; 2: a or b can be plus or minus infinity (chosen suitably), but of same sign; 3: s has only limits at a or bintnumsteplpintnumstep(): gives the default value of m used by all intnum and sumnum routines, such that the integration step is 1/2^m.isfundamentalisfundamental(x): true(1) if x is a fundamental discriminant (including 1), false(0) if notispowerlGDGD&ispower(x,{k},{&n}): true (1) if x is a k-th power, false (0) if not. If n is given and a k-th root was computed in the process, put that in n. If k is omitted, return the maximal k >= 2 such that x = n^k is a perfect power, or 0 if no such k exist.isprimeisprime(x,{flag=0}): true(1) if x is a (proven) prime number, false(0) if not. If flag is 0 or omitted, use a combination of algorithms. If flag is 1, the primality is certified by the Pocklington-Lehmer Test. If flag is 2, the primality is certified using the APRCL test.ispseudoprimeispseudoprime(x,{n}): true(1) if x is a strong pseudoprime, false(0) if not. If n is 0 or omitted, use BPSW test, otherwise use strong Rabin-Miller test for n randomly chosen basesissquareissquare(x,{&n}): true(1) if x is a square, false(0) if not. If n is given puts the exact square root there if it was computedissquarefreeissquarefree(x): true(1) if x is squarefree, false(0) if notkillvSkill(x): kills the present value of the variable or function x. Returns new value or 0kroneckerkronecker(x,y): kronecker symbol (x/y)lcmlcm(x,{y}): least common multiple of x and y, i.e. x*y / gcd(x,y)lengthlength(x): number of non code words in x, number of characters for a stringlexiGGlex(x,y): compare x and y lexicographically (1 if x>y, 0 if x=y, -1 if x=0, transforms the rational or integral mxn (m>=n) matrix x into an integral matrix with gcd of maximal determinants equal to 1 if p is equal to 0, not divisible by p otherwise. If p=-1, finds a basis of the intersection with Z^n of the lattice spanned by the columns of x. If p=-2, finds a basis of the intersection with Z^n of the Q-vector space spanned by the columns of xmatsizematsize(x): number of rows and columns of the vector/matrix x as a 2-vectormatsnfmatsnf(x,{flag=0}): Smith normal form (i.e. elementary divisors) of the matrix x, expressed as a vector d. Binary digits of flag mean 1: returns [u,v,d] where d=u*x*v, otherwise only the diagonal d is returned, 2: allow polynomial entries, otherwise assume x is integral, 4: removes all information corresponding to entries equal to 1 in dmatsolvematsolve(M,B): gaussian solution of MX=B (M matrix, B column vector)matsolvemodmatsolvemod(M,D,B,{flag=0}): one solution of system of congruences MX=B mod D (M matrix, B and D column vectors). If (optional) flag is non-null return all solutionsmatsupplementmatsupplement(x): supplement the columns of the matrix x to an invertible matrixmattransposemattranspose(x): x~=transpose of xmaxmax(x,y): maximum of x and yminmin(x,y): minimum of x and yminpolyminpoly(A,{v=x}): minimal polynomial of the matrix or polmod A.modreversemodreverse(x): reverse polymod of the polymod x, if it existsmoebiusmoebius(x): Moebius function of xnewtonpolynewtonpoly(x,p): Newton polygon of polynomial x with respect to the prime pnextnext({n=1}): interrupt execution of current instruction sequence, and start another iteration from the n-th innermost enclosing loopsnextprimenextprime(x): smallest pseudoprime >= xnfalgtobasisnfalgtobasis(nf,x): transforms the algebraic number x into a column vector on the integral basis nf.zknfbasisGD0,L,DGnfbasis(x,{flag=0},{p}): integral basis of the field Q[a], where a is a root of the polynomial x, using the round 4 algorithm. Second and third args are optional. Binary digits of flag mean 1: assume that no square of a prime>primelimit divides the discriminant of x, 2: use round 2 algorithm instead. If present, p provides the matrix of a partial factorization of the discriminant of x, useful if one wants only an order maximal at certain primes onlynfbasistoalgnfbasistoalg(nf,x): transforms the column vector x on the integral basis into an algebraic numbernfdetintnfdetint(nf,x): multiple of the ideal determinant of the pseudo generating set xnfdiscnfdisc(x,{flag=0},{p}): discriminant of the number field defined by the polynomial x using round 4. Optional args flag and p are as in nfbasisnfeltdivnfeltdiv(nf,a,b): element a/b in nfnfeltdiveucnfeltdiveuc(nf,a,b): gives algebraic integer q such that a-bq is smallnfeltdivmodprGGGGnfeltdivmodpr(nf,a,b,pr): element a/b modulo pr in nf, where pr is in modpr format (see nfmodprinit)nfeltdivremnfeltdivrem(nf,a,b): gives [q,r] such that r=a-bq is smallnfeltmodnfeltmod(nf,a,b): gives r such that r=a-bq is small with q algebraic integernfeltmulnfeltmul(nf,a,b): element a. b in nfnfeltmulmodprnfeltmulmodpr(nf,a,b,pr): element a. b modulo pr in nf, where pr is in modpr format (see nfmodprinit)nfeltpownfeltpow(nf,a,k): element a^k in nfnfeltpowmodprnfeltpowmodpr(nf,a,k,pr): element a^k modulo pr in nf, where pr is in modpr format (see nfmodprinit)nfeltreducenfeltreduce(nf,a,id): gives r such that a-r is in the ideal id and r is smallnfeltreducemodprnfeltreducemodpr(nf,a,pr): element a modulo pr in nf, where pr is in modpr format (see nfmodprinit)nfeltvalnfeltval(nf,a,pr): valuation of element a at the prime pr as output by idealprimedecnffactornffactor(nf,x): factor polynomial x in number field nfnffactormodnffactormod(nf,pol,pr): factorize polynomial pol modulo prime ideal pr in number field nfnfgaloisapplynfgaloisapply(nf,aut,x): Apply the Galois automorphism sigma (polynomial or polymod) to the object x (element or ideal) in the number field nfnfgaloisconjnfgaloisconj(nf,{flag=0},{den}): list of conjugates of a root of the polynomial x=nf.pol in the same number field. flag is optional (set to 0 by default), meaning 0: use combination of flag 4 and 1, always complete; 1: use nfroots; 2 : use complex numbers, LLL on integral basis (not always complete); 4: use Allombert's algorithm, complete if the field is Galois of degree <= 35 (see manual for detail). nf can be simply a polynomial with flag 0,2 and 4, meaning: 0: use combination of flag 4 and 2, not always complete (but a warning is issued when the list is not proven complete); 2 & 4: same meaning and restrictions. Note that only flag 4 can be applied to fields of large degrees (approx. >= 20)nfhilbertlGGGDGnfhilbert(nf,a,b,{p}): if p is omitted, global Hilbert symbol (a,b) in nf, that is 1 if X^2-aY^2-bZ^2 has a non-trivial solution (X,Y,Z) in nf, -1 otherwise. Otherwise compute the local symbol modulo the prime ideal pnfhnfnfhnf(nf,x): if x=[A,I], gives a pseudo-basis of the module sum A_jI_jnfhnfmodnfhnfmod(nf,x,detx): if x=[A,I], and detx is a multiple of the ideal determinant of x, gives a pseudo-basis of the module sum A_jI_jnfinitnfinit(pol,{flag=0}): pol being a nonconstant irreducible polynomial, gives the vector: [pol,[r1,r2],discf,index,[M,MC,T2,T,different] (see manual),r1+r2 first roots, integral basis, matrix of power basis in terms of integral basis, multiplication table of basis]. flag is optional and can be set to 0: default; 1: do not compute different; 2: first use polred to find a simpler polynomial; 3: outputs a two-element vector [nf,Mod(a,P)], where nf is as in 2 and Mod(a,P) is a polymod equal to Mod(x,pol) and P=nf.pol; 4: as 2 but use a partial polred; 5: is to 3 what 4 is to 2nfisideallGGnfisideal(nf,x): true(1) if x is an ideal in the number field nf, false(0) if notnfisinclnfisincl(x,y): tests whether the number field x is isomorphic to a subfield of y (where x and y are either polynomials or number fields as output by nfinit). Return 0 if not, and otherwise all the isomorphisms. If y is a number field, a faster algorithm is usednfisisomnfisisom(x,y): as nfisincl but tests whether x is isomorphic to ynfkermodprnfkermodpr(nf,x,pr): kernel of the matrix x in Z_K/pr, where pr is in modpr format (see nfmodprinit)nfmodprinitnfmodprinit(nf,pr): transform the 5 element row vector pr representing a prime ideal into modpr format necessary for all operations mod pr in the number field nf (see manual for details about the format)nfnewprecnfnewprec(nf): transform the number field data nf into new data using the current (usually larger) precisionnfrootsDGGnfroots({nf},pol): roots of polynomial pol belonging to nf (Q if omitted) without multiplicitynfrootsof1nfrootsof1(nf): number of roots of unity and primitive root of unity in the number field nfnfsnfnfsnf(nf,x): if x=[A,I,J], outputs [c_1,...c_n] Smith normal form of xnfsolvemodprnfsolvemodpr(nf,a,b,pr): solution of a*x=b in Z_K/pr, where a is a matrix and b a column vector, and where pr is in modpr format (see nfmodprinit)nfsubfieldsnfsubfields(nf,{d=0}): find all subfields of degree d of number field nf (all subfields if d is null or omitted). Result is a vector of subfields, each being given by [g,h], where g is an absolute equation and h expresses one of the roots of g in terms of the root x of the polynomial defining nfnormnorm(x): norm of xnorml2norml2(x): square of the L2-norm of the vector xnumbpartnumbpart(x): number of partitions of xnumdivnumdiv(x): number of divisors of xnumeratornumerator(x): numerator of xnumtopermLGnumtoperm(n,k): permutation number k (mod n!) of n letters (n C-integer)omegaomega(x): number of distinct prime divisors of xpadicapprpadicappr(x,a): p-adic roots of the polynomial x congruent to a mod ppadicprecpadicprec(x,p): absolute p-adic precision of object xpermtonumpermtonum(vect): ordinal (between 1 and n!) of permutation vectpolcoeffpolcoeff(x,s,{v}): coefficient of degree s of x, or the s-th component for vectors or matrices (for which it is simpler to use x[]). With respect to the main variable if v is omitted, with respect to the variable v otherwisepolcompositumpolcompositum(pol1,pol2,{flag=0}): vector of all possible compositums of the number fields defined by the polynomials pol1 and pol2. If (optional) flag is set (i.e non-null), output for each compositum, not only the compositum polynomial pol, but a vector [pol,al1,al2,k] where al1 (resp. al2) is a root of pol1 (resp. pol2) expressed as a polynomial modulo pol, and a small integer k such that al2+k*al1 is the chosen root of polpolcycloLDnpolcyclo(n,{v=x}): n-th cyclotomic polynomial (in variable v)poldegreelGDnpoldegree(x,{v}): degree of the polynomial or rational function x with respect to main variable if v is omitted, with respect to v otherwise. For scalar x, return 0 is x is non-zero and a negative number otherwisepoldiscpoldisc(x,{v}): discriminant of the polynomial x, with respect to main variable if v is omitted, with respect to v otherwisepoldiscreducedpoldiscreduced(f): vector of elementary divisors of Z[a]/f'(a)Z[a], where a is a root of the polynomial fpolgaloispolgalois(x): Galois group of the polynomial x (see manual for group coding). Return [n, s, k, name] where n is the order, s the signature, k the index and name is the GAP4 name of the transitive group.polhenselliftGGGLpolhensellift(x, y, p, e): lift the factorization y of x modulo p to a factorization modulo p^e using Hensel lift. The factors in y must be pairwise relatively prime modulo ppolinterpolateGDGDGD&polinterpolate(xa,{ya},{x},{&e}): polynomial interpolation at x according to data vectors xa, ya (ie return P such that P(xa[i]) = ya[i] for all i). If ya is omitter, return P such that P(i) = xa[i]. If present, e will contain an error estimate on the returned valuepolisirreduciblepolisirreducible(x): true(1) if x is an irreducible non-constant polynomial, false(0) if x is reducible or constantpolleadpollead(x,{v}): leading coefficient of polynomial or series x, or x itself if x is a scalar. Error otherwise. With respect to the main variable of x if v is omitted, with respect to the variable v otherwisepollegendrepollegendre(n,{v=x}): legendre polynomial of degree n (n C-integer), in variable vpolrecippolrecip(x): reciprocal polynomial of xpolredpolred(x,{flag=0},{p}): reduction of the polynomial x (gives minimal polynomials only). Second and third args are optional. The following binary digits of flag are significant 1: partial reduction, 2: gives also elements. p, if present, contains the complete factorization matrix of the discriminantpolredabspolredabs(x,{flag=0}): a smallest generating polynomial of the number field for the T2 norm on the roots, with smallest index for the minimal T2 norm. flag is optional, whose binary digit mean 1: give the element whose characteristic polynomial is the given polynomial. 4: give all polynomials of minimal T2 norm (give only one of P(x) and P(-x)). 16: partial reductionpolredordpolredord(x): reduction of the polynomial x, staying in the same orderpolresultantGGDnD0,L,polresultant(x,y,{v},{flag=0}): resultant of the polynomials x and y, with respect to the main variables of x and y if v is omitted, with respect to the variable v otherwise. flag is optional, and can be 0: default, assumes that the polynomials have exact entries (uses the subresultant algorithm), 1 for arbitrary polynomials, using Sylvester's matrix, or 2: using a Ducos's modified subresultant algorithmpolrootspolroots(x,{flag=0}): complex roots of the polynomial x. flag is optional, and can be 0: default, uses Schonhage's method modified by Gourdon, or 1: uses a modified Newton methodpolrootsmodpolrootsmod(x,p,{flag=0}): roots mod p of the polynomial x. flag is optional, and can be 0: default, or 1: use a naive search, useful for small ppolrootspadicpolrootspadic(x,p,r): p-adic roots of the polynomial x to precision rpolsturmpolsturm(x,{a},{b}): number of real roots of the polynomial x in the interval]a,b] (which are respectively taken to be -oo or +oo when omitted)polsubcycloLLDnpolsubcyclo(n,d,{v=x}): finds an equation (in variable v) for the d-th degree subfields of Q(zeta_n). Output is a polynomial or a vector of polynomials is there are several such fields, or none.polsylvestermatrixpolsylvestermatrix(x,y): forms the sylvester matrix associated to the two polynomials x and y. Warning: the polynomial coefficients are in columns, not in rowspolsympolsym(x,n): vector of symmetric powers of the roots of x up to npoltchebipoltchebi(n,{v=x}): Tchebitcheff polynomial of degree n (n C-integer), in variable vpoltschirnhauspoltschirnhaus(x): random Tschirnhausen transformation of the polynomial xpolylogLGD0,L,ppolylog(m,x,{flag=0}): m-th polylogarithm of x. flag is optional, and can be 0: default, 1: D_m~-modified m-th polylog of x, 2: D_m-modified m-th polylog of x, 3: P_m-modified m-th polylog of xpolzagierLLpolzagier(n,m): Zagier's polynomials of index n,mprecisionprecision(x,{n}): change the precision of x to be n (n C-integer). If n is omitted, output real precision of object xprecprimeprecprime(x): largest pseudoprime <= x, 0 if x<=1primeprime(n): returns the n-th prime (n C-integer)primepiprimepi(x): the prime counting function pi(x) = #{p <= x, p prime}.primesprimes(n): returns the vector of the first n primes (n C-integer)printprint(a): outputs a (in raw format) ending with newlineprint1print1(a): outputs a (in raw format) without ending with newlineprintpprintp(a): outputs a (in beautified format) ending with newlineprintp1printp1(a): outputs a (in beautified format) without ending with newlineprinttexprinttex(a): outputs a in TeX formatprodprod(X=a,b,expr,{x=1}): x times the product (X runs from a to b) of expressionprodeulerV=GGEpprodeuler(X=a,b,expr): Euler product (X runs over the primes between a and b) of real or complex expressionprodinfV=GED0,L,pprodinf(X=a,expr,{flag=0}): infinite product (X goes from a to infinity) of real or complex expression. flag can be 0 (default) or 1, in which case compute the product of the 1+expr insteadpsipsi(x): psi-function at xqfbclassnoqfbclassno(x,{flag=0}): class number of discriminant x using Shanks's method by default. If (optional) flag is set to 1, use Euler productsqfbcomprawqfbcompraw(x,y): Gaussian composition without reduction of the binary quadratic forms x and yqfbhclassnoqfbhclassno(x): Hurwitz-Kronecker class number of x>0qfbnucompqfbnucomp(x,y,l): composite of primitive positive definite quadratic forms x and y using nucomp and nudupl, where l=[|D/4|^(1/4)] is precomputedqfbnupowqfbnupow(x,n): n-th power of primitive positive definite quadratic form x using nucomp and nuduplqfbpowrawqfbpowraw(x,n): n-th power without reduction of the binary quadratic form xqfbprimeformqfbprimeform(x,p): returns the prime form of discriminant x, whose first coefficient is pqfbredGD0,L,DGDGDGqfbred(x,{flag=0},{D},{isqrtD},{sqrtD}): reduction of the binary quadratic form x. All other args. are optional. D, isqrtD and sqrtD, if present, supply the values of the discriminant, floor(sqrt(D)) and sqrt(D) respectively. If D<0, its value is not used and all references to Shanks's distance hereafter are meaningless. flag can be any of 0: default, uses Shanks's distance function d; 1: use d, do a single reduction step; 2: do not use d; 3: do not use d, single reduction step.qfbsolveqfbsolve(Q,p): Return [x,y] so that Q(x,y)=p where Q is a binary quadratic form and p a prime number, or 0 if there is no solution.qfgaussredqfgaussred(x): square reduction of the (symmetric) matrix x (returns a square matrix whose i-th diagonal term is the coefficient of the i-th square in which the coefficient of the i-th variable is 1)qfjacobiqfjacobi(x): eigenvalues and orthogonal matrix of eigenvectors of the real symmetric matrix xqflllqflll(x,{flag=0}): LLL reduction of the vectors forming the matrix x (gives the unimodular transformation matrix). The columns of x must be linearly independent, unless specified otherwise below. flag is optional, and can be 0: default, 1: assumes x is integral, columns may be dependent, 2: assumes x is integral, returns a partially reduced basis, 4: assumes x is integral, returns [K,I] where K is the integer kernel of x and I the LLL reduced image, 5: same as 4 but x may have polynomial coefficients, 8: same as 0 but x may have polynomial coefficientsqflllgramqflllgram(x,{flag=0}): LLL reduction of the lattice whose gram matrix is x (gives the unimodular transformation matrix). flag is optional and can be 0: default,1: lllgramint algorithm for integer matrices, 4: lllgramkerim giving the kernel and the LLL reduced image, 5: lllgramkerimgen same when the matrix has polynomial coefficients, 8: lllgramgen, same as qflllgram when the coefficients are polynomialsqfminimGDGDGD0,L,pqfminim(x,{bound},{maxnum},{flag=0}): number of vectors of square norm <= bound, maximum norm and list of vectors for the integral and definite quadratic form x; minimal non-zero vectors if bound=0. flag is optional, and can be 0: default; 1: returns the first minimal vector found (ignore maxnum); 2: as 0 but uses a more robust, slower implementation, valid for non integral quadratic formsqfperfectionqfperfection(a): rank of matrix of xx~ for x minimal vectors of a gram matrix aqfrepqfrep(x,B,{flag=0}): vector of (half) the number of vectors of norms from 1 to B for the integral and definite quadratic form x. Binary digits of flag mean 1: count vectors of even norm from 1 to 2B, 2: return a t_VECSMALL instead of a t_VECqfsignqfsign(x): signature of the symmetric matrix xquadclassunitquadclassunit(D,{flag=0},{tech=[]}): compute the structure of the class group and the regulator of the quadratic field of discriminant D. If flag is non-null (and D>0), compute the narrow class group. See manual for the optional technical parametersquaddiscquaddisc(x): discriminant of the quadratic field Q(sqrt(x))quadgenquadgen(x): standard generator of quadratic order of discriminant xquadhilbertquadhilbert(D,{pq}): relative equation for the Hilbert class field of the quadratic field of discriminant D (which can also be a bnf). If D<0, pq (if supplied) is a 2-component vector [p,q], where p,q are the prime numbers needed for Schertz's method. In that case, return 0 if [p,q] not suitable.quadpolyquadpoly(D,{v=x}): quadratic polynomial corresponding to the discriminant D, in variable vquadrayquadray(D,f,{lambda}): relative equation for the ray class field of conductor f for the quadratic field of discriminant D (which can also be a bnf). For D < 0, lambda (if supplied) is the technical element of bnf necessary for Schertz's method. In that case, return 0 if lambda is not suitable.quadregulatorquadregulator(x): regulator of the real quadratic field of discriminant xquadunitquadunit(x): fundamental unit of the quadratic field of discriminant x where x must be positiverandomrandom({N=2^31}): random integer between 0 and N-1readvecD"",s,readvec({filename}): create a vector whose components are the evaluation of all the expressions found in the input file filenamerealreal(x): real part of xremoveprimesremoveprimes({x=[]}): remove primes in the vector x (with at most 100 components) from the prime table. x can also be a single integer. List the current extra primes if x is omittedreorder({x=[]}): reorder the variables for output according to the vector x. If x is void or omitted, print the current list of variablesreturnreturn({x=0}): return from current subroutine with result xrnfalgtobasisrnfalgtobasis(rnf,x): relative version of nfalgtobasis, where rnf is a relative numberfieldrnfbasisrnfbasis(bnf,order): given an order as output by rnfpseudobasis or rnfsteinitz, gives either a basis of the order if it is free, or an n+1-element generating setrnfbasistoalgrnfbasistoalg(rnf,x): relative version of nfbasistoalg, where rnf is a relative numberfieldrnfcharpolyGGGDnrnfcharpoly(nf,T,alpha,{var=x}): characteristic polynomial of alpha over nf, where alpha belongs to the algebra defined by T over nf. Returns a polynomial in variable var (x by default)rnfconductorrnfconductor(bnf,polrel,{flag=0}): conductor of the Abelian extension of bnf defined by polrel. The result is [conductor,rayclassgroup,subgroup], where conductor is the conductor itself, rayclassgroup the structure of the corresponding full ray class group, and subgroup the HNF defining the norm group (Artin or Takagi group) on the given generators rayclassgroup[3]. If flag is non-zero, check that polrel indeed defines an Abelian extensionrnfdedekindrnfdedekind(nf,T,pr): relative Dedekind criterion over nf, applied to the order defined by a root of irreducible polynomial T, modulo the prime ideal pr. Returns [flag,basis,val], where basis is a pseudo-basis of the enlarged order, flag is 1 iff this order is pr-maximal, and val is the valuation in pr of the order discriminantrnfdetrnfdet(nf,order): given a pseudomatrix, compute its pseudodeterminantrnfdiscrnfdisc(nf,pol): given a pol with coefficients in nf, gives a 2-component vector [D,d], where D is the relative ideal discriminant, and d is the relative discriminant in nf^*/nf*^2rnfeltabstorelrnfeltabstorel(rnf,x): transforms the element x from absolute to relative representationrnfeltdownrnfeltdown(rnf,x): expresses x on the base field if possible; returns an error otherwisernfeltreltoabsrnfeltreltoabs(rnf,x): transforms the element x from relative to absolute representationrnfeltuprnfeltup(rnf,x): expresses x (belonging to the base field) on the relative fieldrnfequationrnfequation(nf,pol,{flag=0}): given a pol with coefficients in nf, gives the absolute equation apol of the number field defined by pol. flag is optional, and can be 0: default, or non-zero, gives [apol,th], where th expresses the root of nf.pol in terms of the root of apolrnfhnfbasisrnfhnfbasis(bnf,order): given an order as output by rnfpseudobasis, gives either a true HNF basis of the order if it exists, zero otherwisernfidealabstorelrnfidealabstorel(rnf,x): transforms the ideal x from absolute to relative representationrnfidealdownrnfidealdown(rnf,x): finds the intersection of the ideal x with the base fieldrnfidealhnfrnfidealhnf(rnf,x): relative version of idealhnf, where rnf is a relative numberfieldrnfidealmulrnfidealmul(rnf,x,y): relative version of idealmul, where rnf is a relative numberfieldrnfidealnormabsrnfidealnormabs(rnf,x): absolute norm of the ideal xrnfidealnormrelrnfidealnormrel(rnf,x): relative norm of the ideal xrnfidealreltoabsrnfidealreltoabs(rnf,x): transforms the ideal x from relative to absolute representationrnfidealtwoeltrnfidealtwoelt(rnf,x): relative version of idealtwoelt, where rnf is a relative numberfieldrnfidealuprnfidealup(rnf,x): lifts the ideal x (of the base field) to the relative fieldrnfinitrnfinit(nf,pol): pol being a non constant irreducible polynomial defined over the number field nf, initializes a vector of data necessary for working in relative number fields (rnf functions). See manual for technical detailsrnfisfreernfisfree(bnf,order): given an order as output by rnfpseudobasis or rnfsteinitz, outputs true (1) or false (0) according to whether the order is free or notrnfisnormrnfisnorm(T,x,{flag=0}): T is as output by rnfisnorminit applied to L/K. Tries to tell whether x is a norm from L/K. Returns a vector [a,b] where x=Norm(a)*b. Looks for a solution which is a S-integer, with S a list of places in K containing the ramified primes, generators of the class group of ext, as well as those primes dividing x. If L/K is Galois, omit flag, otherwise it is used to add more places to S: all the places above the primes p <= flag (resp. p | flag) if flag > 0 (resp. flag < 0). The answer is guaranteed (i.e x norm iff b=1) if L/K is Galois or, under GRH, if S contains all primes less than 12.log(disc(M))^2, where M is the normal closure of L/KrnfisnorminitGGD2,L,rnfisnorminit(pol,polrel,{flag=2}): let K be defined by a root of pol, L/K the extension defined by polrel. Compute technical data needed by rnfisnorm to solve norm equations Nx = a, for x in L, and a in K. If flag=0, do not care whether L/K is Galois or not; if flag = 1, assume L/K is Galois; if flag = 2, determine whether L/K is Galoisrnfkummerrnfkummer(bnr,{subgroup},{deg=0}): bnr being as output by bnrinit, finds a relative equation for the class field corresponding to the module in bnr and the given congruence subgroup (the ray class field if subgroup is omitted). deg can be zero (default), or positive, and in this case the output is the list of all relative equations of degree deg for the given bnrrnflllgramrnflllgram(nf,pol,order): given a pol with coefficients in nf and an order as output by rnfpseudobasis or similar, gives [[neworder],U], where neworder is a reduced order and U is the unimodular transformation matrixrnfnormgrouprnfnormgroup(bnr,polrel): norm group (or Artin or Takagi group) corresponding to the Abelian extension of bnr.bnf defined by polrel, where the module corresponding to bnr is assumed to be a multiple of the conductor. The result is the HNF defining the norm group on the given generators in bnr[5][3]rnfpolredrnfpolred(nf,pol): given a pol with coefficients in nf, finds a list of relative polynomials defining some subfields, hopefully simplerrnfpolredabsrnfpolredabs(nf,pol,{flag=0}): given a pol with coefficients in nf, finds a relative simpler polynomial defining the same field. Binary digits of flag mean: 1: return also the element whose characteristic polynomial is the given polynomial, 2: return an absolute polynomial, 16: partial reductionrnfpseudobasisrnfpseudobasis(nf,pol): given a pol with coefficients in nf, gives a 4-component vector [A,I,D,d] where [A,I] is a pseudo basis of the maximal order in HNF on the power basis, D is the relative ideal discriminant, and d is the relative discriminant in nf^*/nf*^2rnfsteinitzrnfsteinitz(nf,order): given an order as output by rnfpseudobasis, gives [A,I,D,d] where (A,I) is a pseudo basis where all the ideals except perhaps the last are trivialroundround(x,{&e}): take the nearest integer to all the coefficients of x. If e is present, do not take into account loss of integer part precision, and set e = error estimate in bitsserconvolserconvol(x,y): convolution (or Hadamard product) of two power seriesserlaplaceserlaplace(x): replaces the power series sum of a_n*x^n/n! by sum of a_n*x^n. For the reverse operation, use serconvol(x,exp(X))serreverseserreverse(x): reversion of the power series xsetintersectsetintersect(x,y): intersection of the sets x and ysetissetsetisset(x): true(1) if x is a set (row vector with strictly increasing entries), false(0) if notsetminussetminus(x,y): set of elements of x not belonging to ysetrandlLsetrand(n): reset the seed of the random number generator to nsetsearchlGGD0,L,setsearch(x,y,{flag=0}): looks if y belongs to the set x. If flag is 0 or omitted, returns 0 if it is not, otherwise returns the index j such that y==x[j]. If flag is non-zero, return 0 if y belongs to x, otherwise the index j where it should be insertedsetunionsetunion(x,y): union of the sets x and yshiftshift(x,n): shift x left n bits if n>=0, right -n bits if n<0.shiftmulshiftmul(x,n): multiply x by 2^n (n>=0 or n<0)sigmaGD1,L,sigma(x,{k=1}): sum of the k-th powers of the divisors of x. k is optional and if omitted is assumed to be equal to 1signiGsign(x): sign of x, of type integer, real or fractionsimplifysimplify(x): simplify the object x as much as possiblesinsin(x): sine of xsinhsinh(x): hyperbolic sine of xsizebytesizebyte(x): number of bytes occupied by the complete tree of the object xsizedigitsizedigit(x): maximum number of decimal digits minus one of (the coefficients of) xsolvesolve(X=a,b,expr): real root of expression expr (X between a and b), where expr(a)*expr(b)<=0sqrsqr(x): square of x. NOT identical to x*xsqrtsqrt(x): square root of xsqrtintsqrtint(x): integer square root of x (x integer)sqrtnGGD&psqrtn(x,n,{&z}): nth-root of x, n must be integer. If present, z is set to a suitable root of unity to recover all solutions. If it was not possible, z is set to zerosubgrouplistsubgrouplist(bnr,{bound},{flag=0}): bnr being as output by bnrinit or a list of cyclic components of a finite Abelian group G, outputs the list of subgroups of G (of index bounded by bound, if not omitted), given as HNF left divisors of the SNF matrix corresponding to G. If flag=0 (default) and bnr is as output by bnrinit, gives only the subgroups for which the modulus is the conductorsubstGnGsubst(x,y,z): in expression x, replace the variable y by the expression zsubstpolsubstpol(x,y,z): in expression x, replace the polynomial y by the expression z, using remainder decomposition of x.substvecsubstvec(x,v,w): in expression x, make a best effort to replace the variables v1,...,vn by the expression w1,...,wnsumsum(X=a,b,expr,{x=0}): x plus the sum (X goes from a to b) of expression exprsumaltsumalt(X=a,expr,{flag=0}): Cohen-Villegas-Zagier's acceleration of alternating series expr, X starting at a. flag is optional, and can be 0: default, or 1: uses a slightly different method using Zagier's polynomialssumdivGVEsumdiv(n,X,expr): sum of expression expr, X running over the divisors of nsuminfV=GEpsuminf(X=a,expr): infinite sum (X goes from a to infinity) of real or complex expression exprsumnumV=GGEDGD0,L,psumnum(X=a,sig,expr,{tab},{flag=0}): numerical summation of expr from X = ceiling(a) to +infinity. sig is either a scalar or a two-component vector coding the function's decrease rate at infinity. It is assumed that the scalar part of sig is to the right of all poles of expr. If present, tab must be initialized by sumnuminit. If flag is nonzero, assumes that conj(expr(z)) = expr(conj(z)).sumnumaltsumnumalt(X=a,sig,s,{tab},{flag=0}): numerical summation of (-1)^X s from X = ceiling(a) to +infinity. Note that the (-1)^X must not be included. sig is either a scalar or a two-component vector coded as in intnum, and the scalar part is larger than all the real parts of the poles of s. Uses intnum, hence tab is as in intnum. If flag is nonzero, assumes that the function to be summed satisfies conj(f(z))=f(conj(z)), and then up to twice faster.sumnuminitGD0,L,D1,L,psumnuminit(sig, {m=0}, {sgn=1}): initialize tables for numerical summation. sgn is 1 (in fact >= 0), the default, for sumnum (ordinary sums) or -1 (in fact < 0) for sumnumalt (alternating sums). sig is as in sumnum and m is as in intnuminit.sumpossumpos(X=a,expr,{flag=0}): sum of positive series expr, the formal variable X starting at a. flag is optional, and can be 0: default, or 1: uses a slightly different method using Zagier's polynomialstantan(x): tangent of xtanhtanh(x): hyperbolic tangent of xtaylorGnPtaylor(x,y): taylor expansion of x with respect to the main variable of yteichmullerteichmuller(x): teichmuller character of p-adic number xthetatheta(q,z): Jacobi sine theta-functionthetanullkGLpthetanullk(q,k): k'th derivative at z=0 of theta(q,z)thuethue(tnf,a,{sol}): solve the equation P(x,y)=a, where tnf was created with thueinit(P), and sol, if present, contains the solutions of Norm(x)=a modulo units in the number field defined by P. If tnf was computed without assuming GRH (flag 1 in thueinit), the result is unconditionalthueinitthueinit(P,{flag=0}): initialize the tnf corresponding to P, that will be used to solve Thue equations P(x,y) = some-integer. If flag is non-zero, certify the result unconditionnaly. Otherwise, assume GRH (much faster of course)tracetrace(x): trace of xtrapD"",r,DIDItrap({err}, {rec}, {seq}): try to execute seq, trapping error err (all of them if err ommitted); sequence rec is executed if the error occurs and is the result of the command. When seq is omitted, define rec as a default handler for error err (a break loop will be started if rec omitted). If rec is the empty string "" pop out the last default handlertruncatetruncate(x,{&e}): truncation of x; when x is a power series,take away the O(X^). If e is present, do not take into account loss of integer part precision, and set e = error estimate in bitstypetype(x): return the type of the GEN x.untiluntil(a,seq): evaluate the expression sequence seq until a is nonzerovaluationvaluation(x,p): valuation of x with respect to pvariablevariable(x): main variable of object x. Gives p for p-adic x, error for scalarsvecextractvecextract(x,y,{z}): extraction of the components of the matrix or vector x according to y and z. If z is omitted, y designs columns, otherwise y corresponds to rows and z to columns. y and z can be vectors (of indices), strings (indicating ranges as in "1..10") or masks (integers whose binary representation indicates the indices to extract, from left to right 1, 2, 4, 8, etc.)vecmaxvecmax(x): maximum of the elements of the vector/matrix xvecminvecmin(x): minimum of the elements of the vector/matrix xvecsortvecsort(x,{k},{flag=0}): sorts the vector of vectors (or matrix) x in ascending order, according to the value of its k-th component if k is not omitted. Binary digits of flag (if present) mean: 1: indirect sorting, return the permutation instead of the permuted vector, 2: sort using lexicographic order, 4: use descending instead of ascending ordervectorGDVDIvector(n,{X},{expr=0}): row vector with n components of expression expr (X ranges from 1 to n). By default, fill with 0svectorsmallvectorsmall(n,{X},{expr=0}): VECSMALL with n components of expression expr (X ranges from 1 to n) which must be small integers. By default, fill with 0svectorvvectorv(n,{X},{expr=0}): column vector with n components of expression expr (X ranges from 1 to n). By default, fill with 0sweberweber(x,{flag=0}): One of Weber's f function of x. flag is optional, and can be 0: default, function f(x)=exp(-i*Pi/24)*eta((x+1)/2)/eta(x) such that (j=(f^24-16)^3/f^24), 1: function f1(x)=eta(x/2)/eta(x) such that (j=(f1^24+16)^3/f2^24), 2: function f2(x)=sqrt(2)*eta(2*x)/eta(x) such that (j=(f2^24+16)^3/f2^24)whilewhile(a,seq): while a is nonzero evaluate the expression sequence seq. Otherwise 0writevss*write(filename,a): write the string expression a (same output as print) to filenamewrite1write1(filename,a): write the string expression a (same output as print1) to filenamewritebinvsDGwritebin(filename,{x}): write x as a binary object to file filename. If x is omitted, write all session variableswritetexwritetex(filename,a): write the string expression a (same format as print) to filename, in TeX formatzetazeta(s): Riemann zeta function at s with s a complex or a p-adic numberzetakzetak(nfz,s,{flag=0}): Dedekind zeta function of the number field nfz at s, where nfz is the vector computed by zetakinit (NOT by nfinit) flag is optional, and can be 0: default, compute zetak, or non-zero: compute the lambdak function, i.e. with the gamma factorszetakinitzetakinit(x): compute number field information necessary to use zetak, where x is an irreducible polynomialzncoppersmithGGGDGzncoppersmith(P, N, X, {B=N}): finds all integers x0 with |x0| <= X such that gcd(N, P(x0)) > B. X should be smaller than exp((log B)^2 / (deg(P) log N)).znlogznlog(x,g): g as output by znprimroot (modulo a prime). Return smallest non-negative n such that g^n = xznorderznorder(x,{o}): order of the integermod x in (Z/nZ)*. Optional o is assumed to be a multiple of the order.znprimrootznprimroot(n): returns a primitive root of n when it existsznstarznstar(n): 3-component vector v, giving the structure of (Z/nZ)^*. v[1] is the order (i.e. eulerphi(n)), v[2] is a vector of cyclic components, and v[3] is a vector giving the corresponding generatorsuser interruptfloating point exception: bug in PARI or calling programbus error: bug in PARI or calling programsegmentation fault: bug in PARI or calling programunknown signalbroken pipebad object %Z"⍀"P ⍀ P⍀Pyt⍀P`[⍀PGB⍀P.)⍀P⍀Pz⍀zPe⍀ePP⍀PP;⍀;P&⍀&Pz⍀Pfa⍀PMH⍀P4/⍀P⍀P⍀P⍀P~⍀~Pi⍀iPT⍀TP?⍀?Plg*⍀*PSN⍀P:5⍀P!⍀P⍀P⍀P⍀P⍀P⍀Pm⍀mPrmX⍀XPYTC⍀CP@;.⍀.P'"⍀P ⍀P ⍀P ⍀P ⍀P ⍀P ⍀Px s ⍀P_ Z q⍀qPF A \⍀\P- ( G⍀GP  2⍀2P ⍀P ⍀P ⍀P ⍀P ⍀P~ y ⍀Pe ` ⍀PL G ⍀P3 . u⍀uP  `⍀`P K⍀KP 6⍀6P !⍀!P ⍀ P Ib{*C\u $=Vo7Pi1Jc|+D]v %>W$Ë$Ë $Ë$C CCC CC6C C"C CC CC! BBLBBBB! SBAAA! AAHk@A<k@AHk@yALk@mAHk@dADk@^A@k@UADk@OA<k@BAHk@>>>>>>d>>y>>h>>! >>z>0>t>h>T>F>d0>@>y0>:>h0>,>! >>> >! ====! ==V==P=5=h=-=='==!=== ===S=<! <<<<<<<" <<,<<,<<,<<,<}<,<w<,<m<,<e<,<\<,<S<,<J<,<><,<(<! <;;; ;;;;;;;;;;;;;o;;^;;X;;L;;F;;>;;6;;;:! ::9:B:9<:94:9999! 99 9y9,9 9"9 99 99! 888888888! ^88688"8888 8! 77777777! 7f7'7Z707'7#7! 7666666! 6>65.6655! 5555p5K5G5! 055544! 44444O4g4]4K4! 14433333! 33333! 3Li23x3j3S3/33Li22i222i22i22i2e2! I211111! U110000! j030L000/! //.//.! ..T.P.L.! .,,,! ,+u+q+! P+B*1*-*! * *))l))l)u)l)h)! H):)")('('('(L'(('('w('h(('(''''''! 'z'2'&'& '&'L&&&&&&&&&s&&]&&M&&"&& &! %%u#%p#%i#%`#b%Y#A%Q# %H#$A#$:#$$$$l#$#m$Y$A$-$#$$# $C##P########C###6#2##! "`"""""""! "q"a"Q"-0""-!!!!!h!`-]!M!E!w-8!S-+!`- !o-!f-! X-   M- I- G- C- 4-k +-Z &-H -; 3 -"  -----T--l-x-xd-maU<!-8!-4e-0!-,e-(` -$` - e-e-e-!-!- !-!-@-R -e-e-e-!-e-e-e-e-e-e-e-e-e-!-!-@-!-e-e-D -+ -!-e-e-e-!-@--yq"-^`-Nl--!d-h- T---T--w^-<d-)!  S`;2/rkdaB:"'`lhd! \{oTi ZhNlD>2* ! qq qqqvqm! bRJ6! ߇4tfV&4hT߇40! C C C " ~vkWJ|! {udS: (0pV=%@}w_Q(! 3}mV?3yYI!3v^p(! RLH! 6( LLLLLLtLfLULM(LLLLLLLLLLzRtLH! 7"         \    | t  n f  ` X  R J  D <  6 .  (       |      4  ,  0  0  (   | t  ] K  ? - | !  !    }  \}   \}  }{ d }\ T < }/  }  } }  }  x} } } } }  d}| `}v x}N 3 |}- |}& }  t}   |}  } }  } t}| d }^ x}X |}> 2 }  }4}}}(},}0}rm(}`[}NI}<(#} }}}}}}}}y! d|*|! # # xhXH8~>f8'f!f flffff`ffWffff fff~fqXfkOfb! 4|! |! SI09! ggc! DCCCuC?! kkkkkkkkkksg! CAAAAATAPAHA @A4A0A(AY AAAA A@@@ @@@@ @@@@ @@@@ @t@p@h@ `@T@P@H@ @@4@0@(@{ @@@@ @??? ?????? ???? ?t?p?h? `?T?P?H? @?4?0?(? ???? ?>>> >>>> >>>>w >>>>[ >t>`>T>P>H> @>4>0>(> >>>>>=== ==== ==== ==== =t=p=h= `=T=P=H= @=4=0=(= ==== =<<< <<<< <<<< <<<< <t<p<h< `<T<P<H< @<4<0<(< <<<< <;;; ;;;; ;;;; ;;;; ;t;p;h; `;T;P;H; @;4;0;(;h ;;;; ;::: :::: :::: :::::t:p:h:~ `:T:P:H: @:4:0:(: :::: :999 9999m 9999 9999 9t9p9h9 `9T9P9H9 @94909(9 9999 9888 8888l 8888 8888 8t8p8h8 `8T8P8H8 @84808(8 8888 8777 7777 7777 7777 7t7p7h7 `7T7P7H7 @74707(7 7777 7666 6666 6666 6666 6t6p6h6 `6T6P6H6 @64606(6 6666 6555 5555~ 5555} 5555| 5t5p5h5{ `5T5P5H5z @54505(5y 5555x 5444w 4444v 4444u 4444t 4t4p4h4s `4T4P4H4r @44404(4q 4444p 43333333o 3333| 3333u 3t3p3h3L `3T3P3H3V @34303(3} 3333g 3222f 2222e 2222d 2222c 2t2p2h2b `2T2P2H2 @24202(2` 2222. 2111_ 1111^ 1111] 1111 1t1p1h1 `1T1P1H1\ @14101(1[ 1111K 1000G 0000 0000 0000 0t0p0h0 `0T0P0H0Z @04000(0z 0000X 0///W ////Y ////V ////U /t/p/h/T `/T/P/H/R @/4/0/(/P ////M /...L ....I ....y ....H .t.p.h.D `.T.P.H.B @.4.0.(. .... .---A ---- ----@ ---- -t-p-h- `-T-P-H- @-4-0-(- ----? -,,, ,,,,> ,,,,= ,,,,< ,t,p,h, `,T,P,H,; @,4,0,(,^ ,,,,: ,+++9 ++++8 ++++m ++++6 +t+p+h+5 `+T+P+H+ @+4+0+(+4 ++++3 +***/ ****" ****! ****r *t*p*h* `*T*P*H* @*4*0*(*q **** *)))p ))))o )))) )))) )t)p)h) `)T)P)H) @)4)0)() )))) )((( (((( ((((  ((((  (t(p(h( `(T(P(H(  @(4(0(((  (((( ('''  ''''. ''''- '''' 't'p'h' `'T'P'H' @'4'0'(' '''' '&&& &&&& &&&& &&&& &t&p&h& `&T&P&H& @&4&0&(& &&&& &%%% %%%% %%%% %%%% %t%p%h% `%T%P%H% @%4%0%(%n %%%% %$$$ $$$$k $$$$C $$$$ $t$p$h$i `$T$P$H$h @$4$0$($ $$$$ $### ####= #### #### #t#p#h# `#T#P#H# @#4#0#(#i #### #""" """" """" """" "t"p"h" `"T"P"H" @"4"0"(" """" "!!! !!!! !!!! !!!! !t!p!h! `!T!P!H! @!4!0!(! !!!! !             t p h ` T P H @ 4 0 (       g f  tph `TPH @40(     e tphd `TPHc @40( a b ` _  tph] `TPH @40(      tph `TPH @40(      tph `TPH\ @4 O     tphN `TPHJ @40(      tph `TPH @40(      tph `TPH @40(   Q P tphO `TPH@40(E W X 7 6 5 tph4 `TPH3 @40(2 1 0 / U $ tph# `TPH" @40(!     T  tph `TPH @40(7      tph `TPH @40(S R v   M tph2 `TPH  @40(         tph `TPHF @40(      tph `TPH @40(      tph `TPH @40( 1     tph `TPH @40(              t p h ` T P H @ 4 0 (          J    G    I t p h ` T P H @ 4 0 ( 0             H    t p h ` T P H @ 4 0 (           F       t p h ` T P H @ 4 0 (                t p h ` T P H @ 4 0 (       n tph `TPH @40(      tph `TPH @40(  D C B A tph@ `TPH? @40(  >    tph `TPH @40(      tph `TPH @40(< ; 9 : 8  tph `TPH @40(   * + ) tph `TPH @40(      tph `TPH @40(     tph`TPH @40( # [O[O  W6W6  SS  OO  KK  GG  CCy t n?f?` [ U;M;G B <7n47n. ) #3U3U  /</<  +#+#  ' '   ##     z tlf a [SM H Bt:t4 / ) [! [  BB  ))          zrl g aYS N Hz@z: 5 /a'a!  HH  //          xr m g_Y T NF@ ; 5g-g' " NN  55          ~x s me_ Z TLF A ;m3m- ( "TT  ;;  ""        {{  ww~ y sskse ` ZoRoL G Aks9ks3 . (gZ gZ  cAcA |xtplhd`\XTPLHD@<840,($  (NjNQ-+*,(SEaxZ,lKWjF&' g)'k%&c{(NjNQ-+*,(SEaxZ,lKWjF&' g)'k%&c{ $#s%t$4=I?Yjd@CCl+,/AhBB16;`D0?UT?fA+ ]\Ad=H=# |E H   ::8`2,\x0(l1`P4<x@7;lwh`(<plCthD|.g&(*' L<@8w?9^D45k4{@57B3P367t88@$D}HTP D t,~qF}1c$>m><P8U , z$ `t$l,e0](P1( Xs4%2)P)d<4. .T=[>'#@I`" 3<G LOU] e #x)0;GWey!h #  # , ' = D yb *l s z       $     - ; P ] g {          T& . ] G P i |   6S  _         -&@M  ' 7 C T e u  kxq~-6?MU_ U  O Z     : A     o)5<+C5r4   _e 4;,         # 0 ; K U a       9 EF&P-:GTbr[iru "/EMT]iuVGG  '.u~{ s 0<[q{)3fqZ 6#*>   =Hi`^p?*5S7   ^i Jh E M  Xaz8'5>MWfs!2?Pas*4"?MWaju kizq? ,5>JVWjppw~x * p P_fw;_functions_tblsz_foreignExprSwitch_push_stack_pop_stack_newbloc___i686.get_pc_thunk.bx_DEBUGMEM_gclone_refc_gunclone_killbloc_pop_entree_bloc_gpmalloc_gprealloc_cgetalloc_pari_add_function_functions_hash_pari_add_module_pari_init_defaults_precreal_precdl_compatible_DEBUGLEVEL_DEBUGFILES_disable_color_logstyle_current_psfile_current_logfile_logfile_pari_datadir_grow_append_grow_copy_grow_init_grow_kill_pari_sig_init_pari_get_modules___i686.get_pc_thunk.dx_pari_get_oldmodules_gp_init_functions_pari_init_opts_top_bot_memused_avma_diffptr_varentries_ordvar_polvar_pol_x_pol_1_primetab_members_hash_funct_old_hash_whatnow_fun_sigint_fun_default_exception_handler_GP_DATA_pari_init_pari_close_opts_pari_close_getheap_gen_0_traverseheap_changevar_reorder_recover_disable_dbg___i686.get_pc_thunk.cx_errcontext_err_catch_err_leave_err_recover_global_err_data_pari_warn_pari_err_whatnow_new_syntax_trap0_gnil_lontyp_gcopy_gcopy_i_shallowcopy_gcopy_av_taille_taille2_gclone_copy_bin_copy_bin_canon_bin_copy_gerepilecopy_gerepilemany_gerepileall_gerepilecoeffs_gerepilecoeffs2_gerepileallsp_gerepilemanysp_gerepilecoeffssp_gerepileupto_gerepileuptoleaf_gerepileuptoint_ok_gerepileupto_gerepile_allocatemoremem_switch_stack_fill_stack_debug_stack_TIMER_TIMERstart_timer_timer2_msgTIMER_msgtimer_geni_gi_functions_basic_gtocol_mpeuler_gtolist_gtomat_Mod0_mppi_gtopoly_gtopolyrev_Qfb0_gtoser_gtoset_Str_Strchr_Strexpand_Strtex_gtovec_gtovecsmall_gabs_gacos_gach_addhelp_addprimes_agm_algdep0_alias0_allocatemem0_garg_gasin_gash_gatan_gath_bernfrac_bernreal_bernvec_hbessel1_hbessel2_ibessel_jbessel_jbesselh_kbessel0_nbessel_bestappr0_vecbezout_vecbezoutres_gbigomega_binaire_binomial_gbitand_gbitneg_gbitnegimply_gbitor_gbittest_gbitxor_certifybuchall_bnfclassunit0_classgrouponly_decodemodule_bnfinit0_bnfisintnorm_bnfisnorm_isprincipalall_bnfissunit_isunit_bnfmake_buchnarrow_regulator_signunits_bnfsunit_buchfu_bnrL1_bnrclass0_bnrclassno_bnrclassnolist_bnrconductor_bnrconductorofchar_bnrdisc0_bnrdisclist0_bnrinit0_bnrisconductor_bnrisprincipal_bnrrootnumber_bnrstark_break0_gceil_centerlift0_charpoly0_chinese_compo_concat_gconj_conjvec_content_contfrac0_pnqn_core0_coredisc0_gcos_gch_gcotan_default0_denom_deriv_dilog_dirdiv_direuler0_dirmul_dirzetak_divisors_divrem_veceint1_addell_akell_anell_ellap0_bilhell_coordch_pointch_ellconvertname_elleisnum_elleta_ellgenerators_ellglobalred_ellheight0_mathell_ellidentify_ellinit0_ellisoncurve_jell_elllocalred_elllseries_ellminimalmodel_orderell_ordell_zell_powell_ellrootno_ellsearch_ellsigma_subell_elltaniyama_elltors0_ellwp0_ellzeta_pointell_gerfc_error0_eta0_gphi_geval_gexp_factor0_factorback0_factcantor_factorff_mpfactr_factorint_factormod0_polfnf_factorpadic0_ffinit_fibo_gfloor_forpari_fordiv_forell_forprime_forstep_forsubgroup_forvec_gfrac_galoisexport_galoisfixedfield_galoisidentify_galoisinit_galoisisabelian_galoispermtopol_galoissubcyclo_galoissubfields_galoissubgroups_ggamma_ggamd_gcd0_getrand_getstack_gettime_hil0_hyperu_idealadd_idealaddtoone0_idealappr0_idealchinese_idealcoprime_idealdiv0_idealfactor_idealhnf0_idealintersect_idealinv_ideallist0_ideallistarch_zideallog_minideal_idealmul0_idealnorm_idealpow0_primedec_principalideal_ideallllred_idealstar0_ideal_two_elt0_idealval_principalidele_gimag_incgam0_incgamc_intcirc0_integ_intfourcos0_intfourexp0_intfoursin0_intfuncinit0_intlaplaceinv0_intmellininv0_intmellininvshort_intnum0_intnuminit_intnuminitgen0_intnumromb0_intnumstep_gisfundamental_ispower_gisprime_gispseudoprime_gissquarerem_gissquarefree_kill0_gkronecker_glcm0_glength_lexcmp_lift0_lindep0_listcreate_listinsert_listkill_listput_listsort_glngamma_glog_adj_matalgtobasis_matbasistoalg_assmat_det0_detint_diagonal_eigen_matfrobenius_hess_mathilbert_mathnf0_hnfmod_hnfmodid_matid_matimage0_imagecompl_indexrank_intersect_inverseimage_isdiagonal_matker0_matkerint0_matmuldiagonal_matmultodiagonal_matqpascal_rank_matrice_matrixqz0_matsize_matsnf0_gauss_matsolvemod0_suppl_gtrans_gmax_gmin_minpoly_polymodrecip_gmu_newtonpoly_next0_gnextprime_algtobasis_nfbasis0_basistoalg_nfdetint_nfdiscf0_element_div_nfdiveuc_element_divmodpr_nfdivrem_nfmod_element_mul_element_mulmodpr_element_pow_element_powmodpr_element_reduce_nfreducemodpr_element_val_nffactor_nffactormod_galoisapply_galoisconj0_nfhilbert0_nfhermite_nfhermitemod_nfinit0_isideal_nfisincl_nfisisom_nfkermodpr_nfmodprinit_nfnewprec_nfroots_rootsof1_nfsmith_nfsolvemodpr_subfields0_gnorm_gnorml2_numbpart_gnumbdiv_numer_numtoperm_gomega_padicappr_padicprec_permtonum_polcoeff0_polcompositum0_cyclo_poldegree_poldisc0_reduceddiscsmith_polgalois_polhensellift_polint_gisirreducible_pollead_legendre_polrecip_polred0_polredabs0_ordred_polresultant0_roots0_rootmod0_rootpadic_sturmpart_polsubcyclo_sylvestermatrix_polsym_tchebi_tschirnhaus_polylog0_polzag_precision0_gprecprime_prime_primepi_primes_print_print1_printp_printp1_printtex_produit_prodeuler0_prodinf0_gpsi_qfbclassno0_compraw_hclassno_nucomp_nupow_powraw_primeform_qfbred0_qfbsolve_sqred_jacobi_qflll0_qflllgram0_qfminim0_perf_qfrep0_signat_quadclassunit0_quaddisc_quadgen_quadhilbert_quadpoly0_quadray_gregula_gfundunit_genrand_gp_readvec_file_greal_removeprimes_return0_rnfalgtobasis_rnfbasis_rnfbasistoalg_rnfcharpoly_rnfconductor_rnfdedekind_rnfdet_rnfdiscf_rnfelementabstorel_rnfelementdown_rnfelementreltoabs_rnfelementup_rnfequation0_rnfhnfbasis_rnfidealabstorel_rnfidealdown_rnfidealhermite_rnfidealmul_rnfidealnormabs_rnfidealnormrel_rnfidealreltoabs_rnfidealtwoelement_rnfidealup_rnfinitalg_rnfisfree_rnfisnorm_rnfisnorminit_rnfkummer_rnflllgram_rnfnormgroup_rnfpolred_rnfpolredabs_rnfpseudobasis_rnfsteinitz_round0_convol_laplace_recip_setintersect_setisset_setminus_setrand_setsearch_setunion_gshift_gmul2n_gsumdivk_gsigne_simplify_gsin_gsh_sizedigit_zbrent0_gsqr_gsqrt_racine_gsqrtn_subgrouplist0_gsubst_gsubstpol_gsubstvec_somme_sumalt0_divsum_suminf0_sumnum0_sumnumalt0_sumnuminit_sumpos0_gtan_gth_tayl_teich_theta_thetanullk_thue_thueinit_gtrace_trunc0_type0_ggval_gpolvar_extract0_vecmax_vecmin_vecsort0_vecteur_vecteursmall_vvecteur_weber0_write0_write1_gpwritebin_writetex_gzeta_gzetakall_initzeta_zncoppersmith_znlog_znorder_ggener_znstar_pari_outfile_infile_errfile_bernzone_gpi_geuler_gen_m1_gen_1_gen_2_ghalf_foreignHandler_foreignExprHandler_foreignAutoload_foreignFuncFree_gp_colors___i686.get_pc_thunk.axdyld_stub_binding_helper_errmessage_pariOut_pariErr_gp_function_name_pari_compare_long_oldfonctions_gp_member_list_ftime_bcopy_set_analyseur_readseq_get_analyseur_type_name_print0_pariputs_vpariputs_pariprintf_term_color_pariflush_pariputc_pari_last_was_newline_longjmp_flusherr_strcat_strncpy_strcpy_term_get_color_sprintf_print_prefixed_text_kill_from_hashlist_pop_val_if_newer_qsort_gpowgs_ggrando_gadd_gmul_gvar_gdiv_gmodulo_delete_dirs_killallfiles_delete_var_fetch_named_var_manage_var_fetch_var_pari_init_floats_pari_kernel_init_initprimes_exit_setjmp_default_gp_data_os_signal_initout_os_getenv_pari_strdup_hashvalue_freeep_realloc_malloc_fprintferr_free_cur_bloc_next_bloc_try_to_recover_MODULES_OLDMODULES_init_hashtable_err_catch_stack_init_universal_constants_dft_handler_var_not_changed_universal_constants_listloc.0_oldval.1_BREAK_LOOP_gcopy_av0_gcopy_av0_canon_shiftaddress_canon_taille0_shiftaddress__ok_gerepileupto_T.2_T.3_reel4.4_dflt_sigint_fun_pari_sighandler_f_getheap