Navigation

This package contains all the functionality described and developed in [FM2014].
It allows for computations with fundamental domains of the Bruhat-Tits tree,
under the action of arithmetic groups arising from units in definite
quaternion algebras.

EXAMPLES:

Create the quotient attached to a maximal order of the quaternion algebra of
discriminant \(13\), at the prime \(p = 5\):

This function computes the quotient of the Bruhat-Tits tree
by an arithmetic quaternionic group. The group in question is the
group of norm 1 elements in an Eichler \(\ZZ[1/p]\)-order of some (tame)
level inside of a definite quaternion algebra that is unramified
at the prime \(p\). Note that this routine relies in Magma in the case
\(p = 2\) or when \(N^{+} > 1\).

INPUT:

p - a prime number

Nminus - squarefree integer divisible by an odd number of
distinct primes and relatively prime to p. This is the
discriminant of the definite quaternion algebra that one is
quotienting by.

Nplus - an integer coprime to pNminus (Default: 1). This is
the tame level. It need not be squarefree! If Nplus is not 1
then the user currently needs magma installed due to sage’s
inability to compute well with nonmaximal Eichler orders in
rational (definite) quaternion algebras.

character - a Dirichlet character (Default: None) of modulus
\(pN^-N^+\).

Compute the stabilizers in the arithmetic group of all
edges in the Bruhat-Tits tree within a fundamental domain for
the quotient graph. The stabilizers of an edge and its
opposite are equal, and so we only store half the data.

OUTPUT:

A list of lists encoding edge stabilizers. It contains one
entry for each edge. Each entry is a list of data
corresponding to the group elements in the stabilizer of the
edge. The data consists of: (0) a column matrix representing
a quaternion, (1) the power of \(p\) that one needs to divide
by in order to obtain a quaternion of norm 1, and hence an
element of the arithmetic group \(\Gamma\), (2) a boolean that
is only used to compute spaces of modular forms.

The precision is very low (currently set to 5 digits),
since these embeddings are only used to apply a character.

EXAMPLES:

This portion of the code is only relevant when working with a
nontrivial Dirichlet character. If there is no such character
then the code returns an empty list. Even if the character is
not trivial it might return an empty list:

Use a fundamental domain in the Bruhat-Tits tree, and
certain gluing data for boundary vertices, in order to compute
a collection of generators for the arithmetic quaternionic
group that one is quotienting by. This is analogous to using a
polygonal rep. of a compact real surface to present its
fundamental domain.

Use a fundamental domain in the Bruhat-Tits tree, and
certain gluing data for boundary vertices, in order to compute
a collection of generators for the nontorsion part
of the arithmetic quaternionic group that one is quotienting by.
This is analogous to using a polygonal rep. of a compact real
surface to present its fundamental domain.

Return a quadratic field that splits the quaternion
algebra attached to self. Currently requires Magma.

EXAMPLES:

sage: X=BruhatTitsQuotient(5,11)sage: X.get_splitting_field()Traceback (most recent call last):...NotImplementedError: Sage does not know yet how to work with the kind of orders that you are trying to use. Try installing Magma first and set it up so that Sage can use it.

Compute the stabilizers in the arithmetic group of all
edges in the Bruhat-Tits tree within a fundamental domain for
the quotient graph. This is similar to get_edge_stabilizers, except
that here we also store the stabilizers of the opposites.

OUTPUT:

A list of lists encoding edge stabilizers. It contains one
entry for each edge. Each entry is a list of data
corresponding to the group elements in the stabilizer of the
edge. The data consists of: (0) a column matrix representing
a quaternion, (1) the power of \(p\) that one needs to divide
by in order to obtain a quaternion of norm 1, and hence an
element of the arithmetic group \(\Gamma\), (2) a boolean that
is only used to compute spaces of modular forms.

Given an elliptic curve \(E\) having a conductor \(N\) of the form \(pN^-N^+\),
return the harmonic cocycle over self which is attached to E via
modularity. The result is only well-defined up to scaling.

INPUT:

E – an elliptic curve over the rational numbers

prec – (default: None) If specified, the harmonic cocycle will take values
in \(\QQ_p\) with precision prec. Otherwise it will take values in \(\ZZ\).

OUTPUT:

A harmonic cocycle attached via modularity to the given elliptic curve.

U – A distributions module or an integer. If U is a
distributions module then this creates the relevant space of
automorphic forms. If U is an integer then the coefficients
are the (\(U-2\))nd power of the symmetric representation of
\(GL_2(\QQ_p)\).

prec – A precision (default : None). If not None should
be a positive integer.

t – (default : None). The number of additional moments to store. If None, determine
it automatically from prec, U and the overconvergent flag.

R – (default : None). If specified, coefficient field of the automorphic forms.
If not specified it defaults to the base ring of the distributions U, or to \(\QQ_p\)
with the working precision prec.

sage: X=BruhatTitsQuotient(11,5)sage: X.padic_automorphic_forms(2,prec=10)Space of automorphic forms on Quotient of the Bruhat Tits tree of GL_2(QQ_11) with discriminant 5 and level 1 with values in Sym^0 Q_11^2

This function is used to compute certain Coleman integrals
on \(P^1\). That’s why the input consists of two points of
the \(p\)-adic upper half plane, but decomposes
\(P^1(\QQ_p)\). This decomposition is what allows us to
represent the relevant integrand as a locally analytic
function. The z1 and z2 appear in the integrand.

Compute a path from a vertex to a given set of so-called
boundary vertices, whose interior must contain the origin
vertex. In the case that the boundary is not specified, it
computes the geodesic between the given vertex and the origin.
In the case that the boundary contains more than one vertex,
it computes the geodesic to some point of the boundary.

INPUT:

v - a 2x2 matrix representing a vertex boundary

a list of matrices (default: None). If ommitted, finds the
geodesic from v to the central vertex.

OUTPUT:

An ordered list of vertices describing the geodesic from
v to boundary, followed by the vertex in the boundary
that is closest to v.

(Ordered) edges of self may be regarded as open balls in
\(P^1(\QQ_p)\). Given a list of edges, this function return a list
of edges corresponding to the level-th subdivision of the
corresponding opens. That is, each open ball of the input is
broken up into \(p^{\mbox{level}}\) subballs of equal radius.

Edges in the Bruhat-Tits tree are represented by cosets of
matrices in \(GL_2\). Given a matrix \(x\) in \(GL_2\), this
class computes and stores the data corresponding to the
double coset representation of \(x\) in terms of a fundamental
domain of edges for the action of the arithmetic group \(\Gamma\).

More precisely:

Initialized with an element \(x\) of \(GL_2(\ZZ)\), finds elements
\(\gamma\) in \(\Gamma\), \(t\) and an edge \(e\) such that \(get=x\). It
stores these values as members gamma, label and functions
self.sign(), self.t() and self.igamma(), satisfying:

if self.sign()==+1:
igamma()*edge_list[label].rep*t()==x

if self.sign()==-1:
igamma()*edge_list[label].opposite.rep*t()==x

It also stores a member called power so that:

p**(2*power)=gamma.reduced_norm()

The usual decomposition \(get=x\) would be:

g = gamma / (p ** power)

e = edge_list[label]

t’ = t * p ** power

Here usual denotes that we have rescaled gamma to have unit
determinant, and so that the result is honestly an element
of the arithmetic quaternion group under consideration. In
practice we store integral multiples and keep track of the
powers of \(p\).

INPUT:

Y - BruhatTitsQuotient object in which to work

x - Something coercible into a matrix in \(GL_2(\ZZ)\). In

principle we should allow elements in \(GL_2(\QQ_p)\), but it is
enough to work with integral entries

Elements of the arithmetic group can be regarded as elements
of the global quaternion order, and hence may be represented
exactly. This function computes the image of such an element
under the local splitting and returns the corresponding \(p\)-adic
approximation.

INPUT:

embedding - an integer, or a function (default:
none). If embedding is None, then the image of
self.gamma under the local splitting associated to
self.Y is used. If embedding is an integer, then
the precision of the local splitting of self.Y is raised
(if necessary) to be larger than this integer, and this
new local splitting is used. If a function is passed, then
map self.gamma under embedding.

scale – (default: 1) scaling factor applied to the output

OUTPUT:

a 2x2 matrix with \(p\)-adic entries encoding the image of self
under the local splitting

The Bruhat-Tits quotients are directed graphs but we only store
half the edges (we treat them more like unordered graphs).
The sign tells whether the matrix self.x is equivalent to the
representative in the quotient (sign = +1), or to the
opposite of one of the representatives (sign = -1).