Functionality#

Creation Functions#

HypergeometricData(A, B): SeqEnum, SeqEnum -> HypGeomData#

HypergeometricData(F, G): RngUPolElt, RngUPolElt -> HypGeomData#

Print: MonStgElt                    Default: "cyclotomic"

These are two of the principal ways of specifying hypergeometric data. The first takes two sequences \(A\) and \(B\) (of the same length) of rationals, which must be disjoint upon reduction modulo 1, and each of which must be Galois-invariant when taking the corresponding roots of unity (for instance, if \({1\over 6}\) is specified, \({5\over 6}\) is also given). The second takes two products \(F\) and \(G\) of cyclotomic polynomials, these products being coprime and of the same degree. Previous Magma versions could switch \(A\) and \(B\) in some cases; this is no longer the case.

The default can be specified with the Print vararg, the other option currently being "alpha_beta".

There is now also some functionality for non-disjoint \(A\) and \(B\), which mainly manifests itself at the \(L\)-series level.

HypergeometricData(G): SeqEnum[RngIntElt] -> HypGeomData#: This is a third way to specify hypergeometric data, by giving a sequence of integers \(G\) such that \(\sum_v vG[v]=0\). Here we have \(P_\alpha(T)/P_\beta(T)=\prod_v (T^v-1)^{G[v]}\), and the polynomials can be determined via Möbius inversion.

HypergeometricData(L): List -> HypGeomData#: This is a fourth way to specify hypergeometric data, by giving a list \(L\) of nonzero integers (with repetition possible) corresponding to the sequence \(L\) of the previous intrinsic, with negative integers for those where \(L[v]\) is negative. The sum of the members of the list must be 0.

HypergeometricData(F, G): SeqEnum[RngIntElt], SeqEnum[RngIntElt] -> HypGeomData#: This is a fifth way to specify hypergeometric data, by giving two arrays \(F\) and \(G\) of integers, corresponding to the cyclotomic polynomials to be used.

HypergeometricData(E): SeqEnum[SeqEnum] -> HypGeomData#: This is a utility intrinsic that take a sequence \(E\) of two sequences and then passes these two sequences to the intrinsics above.

Twist(H): HypGeomData -> HypGeomData#: This intrinsic takes hypergeometric data \(H\), and adds \(1/2\) to every element in \(\alpha\) and \(\beta\), returning new hypergeometric data. Magma no longer (ever) switches \(\alpha\) and \(\beta\) when twisting.

PrimitiveData(H): HypGeomData -> HypGeomData#: Given hypergeometric data \(H\), return its primitive associated data. This is most easily described in terms of GammaList, dividing all the elements by the gcd.

PossibleHypergeometricData(d): RngIntElt -> SeqEnum#

Weight        : RngIntElt                    Default: false
TwistMinimal  : BoolElt                      Default: false
CyclotomicData: BoolElt                      Default: false
Primitive     : RngIntElt                    Default: 0

Given a degree \(d\), generate all possible examples of hypergeometric data of that degree, returned as a sequence of pairs of sequences, each sequence therein having \(d\) rationals. If Weight is specified, restrict to data of this weight. If TwistMinimal is specified, only give twist-minimal data. If CyclotomicData is specified, return the sequences of cyclotomic data rather than rationals. If Primitive is true, only return data that are primitive; if Primitive is a positive integer, return the data that have this imprimitivity.

Access Functions#

Weight(H): HypGeomData -> RngIntElt#: The weight of the given hypergeometric data \(H\).

Degree(H): HypGeomData -> RngIntElt#: The degree of the given hypergeometric data \(H\).

DefiningPolynomials(H): HypGeomData -> RngUPolElt, RngUPolElt#: The (products of cyclotomic) polynomials corresponding to \(\alpha\) and \(\beta\) corresponding to hypergeometric data \(H\).

Bezoutian(H): HypGeomData -> RngIntElt#: The resultant of the defining polynomials of the hypergeometric data.

CyclotomicData(H): HypGeomData -> SeqEnum, SeqEnum#: Returns two arrays of integers, specifying which cyclotomic polynomials occur for \(\alpha\) and \(\beta\) corresponding to hypergeometric data \(H\). Thus, for example, \(\Phi_3\Phi_4^2\Phi_6\) would be represented by [3,4,4,6]).

AlphaBetaData(H): HypGeomData -> SeqEnum, SeqEnum#: Returns two arrays of rationals, giving the \(\alpha\) and \(\beta\) of the hypergeometric data \(H\).

MValue(H): HypGeomData -> FldRatElt#: This returns the scaling parameter \(M\) of the given hypergeometric data \(H\). This is defined by taking \(M_n=\prod_{d|n} d^{d\mu(n/d)}\) for the \(n\)th cyclotomic polynomial, and combining these into the products for \(\alpha\) and \(\beta\), and then dividing these. Another definition is \(M=\prod_v v^{v\gamma_v}\).

GammaArray(H): HypGeomData -> SeqEnum#: This returns an array of integers corresponding to \(\gamma_v\), where these are defined by \(P_\alpha(T)/P_\beta(T)=\prod_v (T^v-1)^{\gamma_v}\). We also have \(\sum_v v\gamma_v=0\).

GammaList(H): HypGeomData -> List#: This returns a list of integers corresponding to \(\gamma_v\), where \({\rm sign}(\gamma_v)\cdot v\) appears in the list \(|\gamma_v|\) times.

H1 eq H2: HypGeomData, HypGeomDat -> BoolElt#
H1 ne H2: HypGeomData, HypGeomDat -> BoolElt#: Two instances of hypergeometric data \(H1\) and \(H2\) are equal if they have the same \(\alpha\) and \(\beta\).

IsPrimitive(H): HypGeomData -> BoolElt, RngIntElt#: Returns true if the given hypergeometric data \(H\) is primitive, and the index of imprimitivity. The latter is the gcd of the elements in the GammaList.

Functionality with \(L\)-series and Euler Factors#

HypergeometricTrace(H, t, q): HypGeomData, RngQZElt, RngIntElt -> RngIntElt#: Given a hypergeometric datum \(H\), a rational \(t\neq 0\), and a prime power \(q=p^f\) for which \(p\) is good or multiplicative, return the hypergeometric trace. The intrinsic also works more generally when \(v_p(Mt)=0\), even if \(p\) is wild.

HypergeometricTraceK(A, B, t, q): SeqEnum, SeqEnum, RngQZElt, RngIntElt -> FldPadElt#

HypergeometricTraceK(A, B, t, q): SeqEnum, SeqEnum, FldPadElt, RngIntElt -> FldPadElt#

Precision: RngIntElt                    Default: 5

Given \(\alpha\)’s and \(\beta\)’s associated to a not-necessarily Galois datum, and a rational \(t\neq 0\), and a prime power \(q=p^f\) for which \(v_p(t)=0\) and \(p\) divides no denominator of the \(\alpha\)’s and \(\beta\)’s, return the hypergeometric trace according to the \(p\)-adic \(\Gamma\)-function definition, namely that

\[H_q(\alpha,\beta|t)= {q^D\over 1-q}\sum_{r=0}^{q-2}\omega_p(t)^r {q^{m_0}\over q^{m_r}}{X_q(r)\over X_q(0)}{(-p)^{T_f(r)}\over (-p)^{T_f(0)}}\]

where \(\omega_p\) is the Teichmüller as before, \(m_r\) is the multiplicity of \(-r/(q-1)\) in \(B\) (modulo 1), while

\[X_q(r)=\prod_{i=0}^{f-1} {{\prod_j\Gamma_p(\{p^i(\alpha_j+r/(q-1))\})}\over {\prod_j\Gamma_p(\{p^i(\beta_j+r/(q-1))\})}}\]

and

\[T_f(r)=\sum_j\bigl[S_f(\alpha_j+r/(q-1))-S_f(\beta_j+r/(q-1))\bigr] \quad{\rm where}\quad S_f(x)=\sum_{i=0}^{f-1}\{p^ix\}.\]

In the version where \(t\) is a \(p\)-adic, it must be compatible with \(q\). The precision of \(t\) should exceed that with the Precision parameter, those this is not mandated, and could cause an incompatibility problem later in the computation.

This intrinsic is (much) slower than the optimized version in the Galois case.

EulerFactor(H, t, p): HypGeomData, RngQZElt, RngIntElt -> RngUPolElt#

Degree: RngIntElt                    Default: 0
Check : BoolElt                      Default: false
Fake  : BoolElt                      Default: false

This intrinsic is the heart of the hypergeometric motive package. It takes hypergeometric data \(H\), a rational \(t\neq 0,1\), and a prime \(p\), and computes the \(p\)th Euler factor of the hypergeometric motive at \(t\). This uses \(p\)-adic \(\Gamma\)-functions, as indicated by Cohen. The Degree vararg specifies how many terms in the Euler factor should be computed – if this is 0, then the whole polynomial is computed. The Check vararg allows one to turn off the use of the (local) functional equation that is used to expedite the computation process.

The Fake vararg allows one to compute the hypergeometric trace(s) for \(t\) with \(v_p(Mt)=0\) (including wild primes). Whether or not this is the actual Euler factor depends on how inertia acts. The use of this vararg inhibits the use of the local functional equation, but one can curtail via Degree, and apply it manually (if known).

In general, the given prime must not be wild, that is, it must not divide the denominator of any of the \(\alpha\) or \(\beta\).

At other bad primes, the Euler factor will depend upon the relevant monodromy. The primes for which \(v_p(t-1)>0\) can perhaps be called multiplicative, in that \(p\) should divide the conductor only once (this is related to the pseudoreflection). Since \(v_p(Mt)=0\) here, the Euler factor (of degree \(d-1\)) can be recovered by the \(p\)-adic \(\Gamma\)-function methods (even when \(p=2\)). Also it is often possible to relate the (presumed) hypergeometric motive to objects from a deformation. When \(v_p(t-1)\) is even and the weight is also even, the prime \(p\) is actually good and has a degree \(d\) Euler factor, even though the hypergeometric trace only gives one of degree \((d-1)\). In such a case, the EulerFactor intrinsic with the Fake vararg will return the part from the hypergeometric trace.

The \(p\) with \(v_p(1/t)>0\) correspond to monodromy at \(\infty\). The associated inertia is given by the roots of unity with the \(\beta\), with maximal Jordan blocks when eigenvalues are repeated. The same is true for \(p\) with \(v_p(t)>0\), where the monodromy is around 0 (so that the \(\alpha\) are used). In Example Example: Hg Quintic 3fold), an instance is given where the inertia is trivialised due to having \(\zeta^{v_p(t)}=1\).

We can compute the Euler factors at such tame primes as follows. Suppose that \(t=t_0p^{vm}\) with \(v>0\), where \(m\) occurs as a denominator of the \(\alpha\) (similarly with \(v<0\) and \(\beta\)). Then one takes the smallest \(q=p^f\) that is 1 mod \(m\), and from the hypergeometric trace formula extracts the terms

\[\omega_p(Mt_0)^{j(q-1)/m}Q_q\biggl({j(q-1)\over m}\biggr)\]

for \(0\le j<m\) with \(\gcd(j,m)=1\). Denoting these by \(\eta\), we then have that \(\prod_\eta (1-\eta T^f)\) is an \(f\)th power (due to repetitions in the above extraction), and the \(f\)th root of this is the desired Euler factor of degree \(\phi(m)\).

When \(m\) does not divide \(v_p(t)\), the Euler factor from it is trivial. One then multiplies together all such Euler factors corresponding to the \(m\) from the \(\alpha\) and \(\beta\). Each \(m\) is only considered once, even if it appears multiple times in the CyclotomicData, as the Jordan blocks of the eigenvalues are maximal. Note that the local functional equation is not used for tame primes, though the computation should not be too onerous unless \(q=p^f\) is large.

LSeries(H, t): HypGeomData, RngQZElt -> LSer, LSer#

BadPrimes     : SeqEnum                       Default: []
HodgeStructure: HodgeStruc                    Default: false
GAMMA         : SeqEnum                       Default: []
Identify      : BoolElt                       Default: true
Precision     : RngIntElt                     Default: 0
Weight01      : BoolElt                       Default: false
QuadraticTwist: Any                           Default: false
PoleOrder     : RngIntElt                     Default: 0
SaveEuler     : RngIntElt                     Default: false

Given hypergeometric data \(H\) and a rational \(t\neq 0,1\), try to construct the \(L\)-series of the associated motive. This will usually need the Euler factors at wild primes to be specified. Everything else, including tame/multiplicative Euler factors and \(\gamma\)-factors, can be computed automatically by Magma (these can also be given respectively via BadPrimes, and GAMMA and/or HodgeStructure).

The Identify vararg indicates whether an attempt should be made to identify motives of weight 0 as Artin representations, and similarly with (hyper)elliptic curves for weight 1. The Weight01 vararg when true will Translate the \(L\)-series (essentially a Tate twist) so that the weight is 0 or 1. Setting Weight01 to an (odd) integer \(r\) will Translate so that the (motivic) weight is \(r\) plus the number of zero entries in the AlphaBetaData. A typical choice is \(r=-1\).

The QuadraticTwist vararg can be used to take the tensor product with the given quadratic Dirichlet character. This can be given as a nonzero rational or as a character, or alternatively can be set to true, when Magma will use a default twisting factor. However, this option can conflict with BadPrimes (Magma does not know whether to apply such primes to the original \(L\)-function or the twist), and so should be used sparingly.

The PoleOrder vararg allows the user to specify that the given power of the (shifted) Riemann \(\zeta\)-function is expected to divide the \(L\)-series of the hypergeometric motive. The routines will then act accordingly, decomposing the \(L\)-series into a factorisation and moving the poles into the \(\zeta\)-function part.

Finally, the SaveEuler option takes a nonnegative integer (or a boolean), and indicates how large of primes should have their EulerFactor saved when computed. This is useful when (say) dealing with such \(L\)-function constructs as Symmetrization, for which the underlying work with hypergeometric traces is being done on one \(L\)-function, and then used multiple times. This option will be (silently) ignored if Magma is able to Identify the \(L\)-function as coming from somewhere else.

The intrinsic actually returns two \(L\)-series, the first corresponding to the disjoint parts of \(A\) and \(B\), and the second an Artin part (weight 0) corresponding to the common part. For most purposes the second can be ignored (it will typically be the trivial LSeries).

Identification of Hypergeometric Data as Other Objects#

ArtinRepresentation(H, t): HypGeomData, RngQZElt -> ArtRep#

Check   : BoolElt                    Default: true
Optimize: BoolElt                    Default: true

Given hypergeometric data \(H\) of weight 0 and a rational \(t\neq 0,1\), try to determine the associated Artin representation. This is implemented for all Belyi cases where the GammaList of \(H\) or its Twist has size 3 (this includes all cases up through degree 3), and for isolated cases (most due to Bartosz Nasrecki) in higher degree. When Check is true, good primes up to 100 have their Euler factors checked for correctness. When Optimize is true, the number field representation will be optimized.

EllipticCurve(H): HypGeomData -> CrvEll#

EllipticCurve(H, t): HypGeomData, RngQZElt -> CrvEll#

Given hypergeometric data \(H\) of degree 2 and weight 1 (there are 10 such families) and a rational \(t\neq 0,1\), return the associated elliptic curve, as catalogued by Cohen. When \(t\) is not given, return the result over a function field.

For each of the 10 families, the same function can be called for the corresponding imprimitive data of index \(r\), and the result will generically be an elliptic curve over an extension of degree \(r\). However, when the \(x^r-1/Mt\) splits, the intrinsic will return an array of elliptic curves corresponding to this splitting.

HyperellipticCurve(H): HypGeomData -> CrvHyp#
HyperellipticCurve(H, t): HypGeomData, RngQZElt -> CrvHyp#: Given hypergeometric data \(H\) of degree 4 and weight 1 and a rational \(t\neq 0,1\), return the associated hyperelliptic curve, if this data is known to correspond to such. When \(t\) is not given, return the result over a function field. There are 18 cases where one gets a genus 2 curve from the CanonicalCurve (making 36 cases when twisting is considered), and a few others where CanonicalCurve gives a higher genus curve and there is a genus 2 quotient. In general, one can try to call IsHyperelliptic on the CanonicalCurve.

Identify(H, t): HypGeomData, RngQZElt -> Any#: Given hypergeometric data \(H\) and a rational \(t\neq 0,1\), return any known associated object (else returns false). The return value can (currently) be: an Artin representation (weight 0); an elliptic curve over Q (weight 1 in degree 2); an elliptic curve over a number field (weight 1 in degree \(2r\) with imprimitivity \(r\)), or possibly multiple such curves; or a hyperelliptic curve over Q (weight 1 in degree 4).

Associated Schemes and Curves#

CanonicalScheme(H): HypGeomData -> Sch#

CanonicalScheme(H, t): HypGeomData, RngQZElt -> Sch#

Given hypergeometric data \(H\), this constructs a canonical associated scheme. When the parameter \(t\) is given, the specialization is returned, otherwise the result returned will be a scheme over a function field.

The scheme is determined from the GammaList, with a variable (\(X_i\) or \(Y_j\)) for every element in the list. The scheme is the intersection of \(\sum_i X_i=\sum_j Y_j=1\) with

\[\prod_i X_i^{g_i^+}\prod_j Y_j^{g_j^-}={1\over Mt},\]

where the \(g_i^+\) are the positive elements in the GammaList and the \(g_j^-\) are the negative ones (one usually moves the latter to the other side of the equation, to make the exponents positive).

CanonicalCurve(H): HypGeomData -> Crv#
CanonicalCurve(H, t): HypGeomData, RngQZElt -> Crv#: Given suitable hypergeometric datum \(H\), this tries to construct an associated plane curve. When the parameter \(t\) is given, the specialization at \(t\) is returned, otherwise the return value will be a plane curve over a function field. The curve is constructed using the GammaList (which indicates the Jacobi sums that need to be taken). When this list has four elements, it is always possible to get a curve. When the list has six elements, it is sometimes possible, depending on whether the largest element (in absolute value) is the negation of the sum of two of the other elements. If it is not possible to construct such a curve, the intrinsic returns false.

AssociatedSchemes(H): HypGeomData -> List, SeqEnum, RngIntElt#
AssociatedSchemes(H, t): HypGeomData, RngElt -> List, SeqEnum, RngIntElt#: Given a hypergeometric datum \(H\), construct the associated schemes in product projective space of minimal dimension. This involves finding maximal zero-sumset splittings of the GammaList. The first returned value is a list of schemes, the second is a corresponding list of splittings, and the third is the resulting dimension. In the second version, the parameter \(t\) is nominally a rational not 0 nor 1, though no checks are made. Similarly, the vararg in the first version allows one to define the parameter over a different function field than the rationals, if desired.

Utility Functions#

HypergeometricMotiveSaveLimit(n): RngIntElt#
HypergeometricMotiveClearTable()#: These are utility intrinsics that will cache the pre-computation of \(p\)-adic \(\Gamma\)-functions. The first indicates to save all computed values when the prime power is less than \(n\), and the second clears the table. The \(q\)th table entry will have \((q-1)\) elements in it.

pPart(H, p): HypGeomMot, RngIntElt -> Tup#
pParts(H): HypGeomMot -> List#: Given a hypergeometric datum, reduce the cyclotomic indices modulo either the given prime or all wild primes.