|
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
The right (or left) ideals of an R-order O in a quaternion algebra A
defined over a number field come in finitely many
isomorphism classes. Already for number rings, it is a
computationally difficult problem to compute the class group,
and due to the noncommutativity of quaternion algebras, the problem of
enumerating ideal classes of quaternion orders is even more difficult
because this set does not have the structure of a group.
The algorithms used for routines in this section, in particular for
determining ideal classes, are described in [KV].
The methods depend on whether A is definite or indefinite.
For a definite algebra, we have an upper bound on the possible reduced
norm of an ideal coming from lattice theory which reduces the
problem to finite enumeration. We then test if two right (or left)
ideals I, J are isomorphic. Over Z, to accomplish this task we compute
a Minkowski-reduced Gram matrix which produces an element of smallest norm.
Over other number rings R, we compute the colon ideal
(J:I) = {x ∈A: xI ⊂J}
(similarly defined if I is a left ideal) and then search (J:I)
for an element of the required specified norm by computing a reduced
basis. This method runs very quickly for "reasonably small" input.
For an indefinite quaternion algebra, we use a theorem of Eichler which
states that the reduced norm gives rise to an bijection of sets between
the class groups of the order and the number ring. (Over Z, therefore,
every ideal of an indefinite quaternion order is principal.)
We may compute
representative ideals I of O whose reduced norm is in a specified
ideal class. We then reduce the problem of testing for an isomorphism
I isomorphic to J between two ideals to that over R. Here, the problem of
explicitly computing such an isomorphism is much more difficult, as an
order (or ideal) will have infinitely many elements of bounded norm,
and in most cases a search amongst reduced bases will find a desired
element.
Ideals of quaternion orders are given type AlgQuatOrdIdl and
AlgAssVOrdIdl according as the order O is defined over Z
(of type AlgQuatOrd) or over a number ring (of type AlgAssVOrd).
For more on the constructions and functions for ideals of the latter type,
see Section Orders.
Subsections
lideal<S | X> : AlgQuatOrd, [AlgQuatOrdElt] -> AlgQuatOrdIdl
RightIdeal(S, X) : AlgQuatOrd, [AlgQuatOrdElt] -> AlgQuatOrdIdl
rideal<S | X> : AlgQuatOrd, [AlgQuatOrdElt] -> AlgQuatOrd
ideal<S | X> : AlgQuatOrd, [AlgQuatOrdElt] -> AlgQuatOrdIdl
These commands construct a left, right or two-sided ideal of the
order S generated by the sequence X, which should contain elements
that are coercible to S.
In the constructors lideal< | > and rideal< | >,
the right hand side may also be a matrix or pseudo-matrix
giving the basis of the ideal with respect to the basis of S.
Given a quaternion order S over Z, returns the unique two-sided
prime ideal P of S over the prime pZ. If p is a ramified
prime then P properly contains pS and need not be principal, and
otherwise P is equal to pS.
CommutatorIdeal(S) : AlgAssVOrd -> AlgAssVOrdIdl
The two-sided ideal of the quaternion order S
generated by elements of the form xy - yx.
We demonstrate the construction of the 2-sided prime ideals and the
relation with the commutator ideal.
> S := QuaternionOrder(2*5*11);
> P := PrimeIdeal(S, 2);
> I := ideal< S | [2] cat [ x*y-y*x : x, y in Basis(S) ] >;
> P eq I;
true
> Q := PrimeIdeal(S, 5);
> R := PrimeIdeal(S, 11);
> P*Q*R eq CommutatorIdeal(S);
true
By way of explanation, we note that the ideal composition is
well-defined, since each of these ideals is a 2-sided ideal
for S, that is, a left ideal whose right order is also S.
The collection of prime ideals over the ramified primes of a
maximal order forms an elementary 2-abelian class group, and
the commutator ideal is the product of these prime ideals.
Here we look at the basis of an ideal.
> S := QuaternionOrder(11);
> i := Algebra(S).1;
> P<x> := PolynomialRing(Integers());
> MinimalPolynomial(i);
x^2 + 1
> // Create an ideal generated by 2, 1 + i (of norm 2)
> I := LeftIdeal(S, [2,1+i]);
> I;
Left Ideal with basis Pseudo-matrix over Integer Ring
1 * [2 1 0 1]
[0 1 0 0]
[0 0 2 1]
[0 0 0 1]
> Basis(I);
[ [2 0 0 0], [1 1 0 0], [0 0 2 0], [1 0 1 1] ]
> [ Eltseq(x) : x in Basis(I) ];
[
[ 2, 0, 0, 0 ],
[ 1, 1, 0, 0 ],
[ 0, 0, 2, 0 ],
[ 1, 0, 1, 1 ]
]
To get the rational coordinates with respect to the quaternion
algebra, it is necessary to explicitly coerce into the algebra.
> A := QuaternionAlgebra(S);
> [ Eltseq(A!x) : x in Basis(I) ];
[
[ 2, 0, 0, 0 ],
[ 1, 1, 0, 0 ],
[ 0, 0, 2, 0 ],
[ 1, 0, 1, 1 ]
]
> BasisMatrix(I);
[2 0 0 0]
[1 1 0 0]
[0 0 2 0]
[1 0 1 1]
LeftOrder(I) : AlgAssVOrdIdl[RngOrd] -> AlgAssVOrd
Given an ideal I of a quaternion order defined over Z or a
number ring, returns the left order of I, defined as the ring
of all elements of the quaternion algebra of I mapping I to itself
under left multiplication.
RightOrder(I) : AlgAssVOrdIdl[RngOrd] -> AlgAssVOrd
Given an ideal I of a quaternion order defined over Z or a
number ring, returns the right order of I, defined as the ring
of all elements of the quaternion algebra of I mapping I to itself
under right multiplication.
> K := NumberField(Polynomial([5,0,1]));
> K;
Number Field with defining polynomial $.1^2 + 5 over the Rational Field
> A := QuaternionAlgebra<K | 3, K.1>;
> O := MaximalOrder(A);
> I := lideal<O | O.2, Norm(O.2)>;
> Norm(I);
Principal Ideal
Generator:
2/1*$.1
> LeftOrder(I) eq O;
true
> RightOrder(I) eq O;
true
LeftIdealClasses(S) : AlgAssVOrd[RngOrd] -> [AlgAssVOrdIdl]
RightIdealClasses(S) : AlgQuatOrd -> [AlgQuatOrdIdl]
RightIdealClasses(S) : AlgAssVOrd[RngOrd] -> [AlgAssVOrdIdl]
Al: MonStgElt Default:
Support: [RngOrdIdl] Default:
This computes representatives for the left or right locally free ideal
classes of S, where S is an order in a quaternion algebra
(defined over the rationals or a number field).
The algorithms are guaranteed to work only when S is a maximal
order or an Eichler order.
For definite algebras, two algorithms are available,
which may be selected by setting the optional argument Al.
When this is not specified, the algorithm chosen will depend on the situation.
When set to "FixOrder", the ideal class represenatives are obtained
by searching through sublattices of small index in the given order S.
When set to "AllOrders", the representatives are obtained from
the integral representatives of the two-sided ideal classes of S and
from maximal ideals that relate orders in different conjugacy classes.
In both algorithms, the stopping criterion comes from a mass formula.
For definite algebras, the Support of the returned ideals may be
specified; this should be a sequence of prime ideals in the base ring
that generate the narrow class group. In that case, the algorithm used is
"AllOrders", and the routine will find ideal class representatives
whose norms are divisible only by primes in the specified Support
or in the set of primes that divide the discriminant of S.
For indefinite algebras, the representatives are obtained from a
ray class group of the base field.
TwoSidedIdealClasses(S : Support) : AlgAssVOrd[RngOrd] -> [AlgAssVOrdIdl]
Support: [RngOrdIdl] Default:
Given an order S in a definite quaternion algebra (over the rationals
or a number field), this returns a sequence containing representatives
for the two-sided locally free ideal classes of S.
The algorithm is only guaranteed to work when S is a maximal
order or an Eichler order.
If the optional argument Support is specified, it should be
a sequence of prime ideals in the base ring that generate the class
group of the base ring. In that case, representatives that have norm
divisible by primes in Support or primes that divide the discriminant
of O will be constructed.
Support: [RngOrdIdl] Default:
Given an order S in a definite quaternion algebra (over the rationals
or a number field), this returns the two-sided ideal class group of S
as an abstract abelian group, together with a map from the group to some
set of ideal class representatives.
The algorithm is only guaranteed to work when S is a maximal
order or an Eichler order.
The optional parameter Support is described above.
Al: MonStgElt Default:
Given a maximal order (or an Eichler order S of level N) in a quaternion algebra A,
this returns representatives for the conjugacy classes of maximal orders
(or orders of level N) in A.
The optional argument Al is the same as in RightIdealClasses.
The algorithm involves computing the right ideal classes (in fact,
the two problems are computationally equivalent in practice).
In the following example we construct a maximal order in the quaternion
algebra ramified at 37, and enumerate the left ideal classes.
> S := QuaternionOrder(37);
> ideals := LeftIdealClasses(S);
> [ Basis(I) : I in ideals ];
[
[ 1, i, j, k ],
[ 2, 2*i, 1 + i + j, i + k ],
[ 2, 2*i, i + j, k ]
]
We now compute the right orders of the two nontrivial left ideal classes.
> _, I, J := Explode(ideals);
> R1 := RightOrder(I);
> R2 := RightOrder(J);
> IsIsomorphic(R1,R2);
true
Although the ideals I and J are nonisomorphic left ideals over
S, they have isomorphic right orders. In the example following
the next section we explore this phenomenon further.
In this example, we enumerate ideal classes for a definite quaternion
algebra (over a totally real field).
> SetSeed(1);
> P<x> := PolynomialRing(Rationals());
> F<b> := NumberField(x^3-3*x-1);
> Z_F := MaximalOrder(F);
> Foo := InfinitePlaces(F);
> pp := Decomposition(Z_F, 17)[1][1];
> A := QuaternionAlgebra(pp, Foo);
> O := MaximalOrder(A);
> time Rideals := RightIdealClasses(O);
Time: 0.870
> #Rideals;
2
In this example the classgroup of the base field is not trivial and
there are some ramified prime ideals in the algebra. Hence we expect
nontrival two-sided ideal classes.
> SetSeed(1);
> K:= QuadraticField(401);
> A:= QuaternionAlgebra< K | -1, -1>;
> RamifiedPlaces(A);
[
Prime Ideal
Two element generators:
2
$.2 + 1,
Prime Ideal
Two element generators:
2
$.2 + 2
]
[ 1st place at infinity, 2nd place at infinity ]
> M:= MaximalOrder(A);
> #TwoSidedIdealClasses(M);
10
Since there are several two-sided ideal classes, it is advantageous to use
the "AllOrders" algorithm in the enumeration of all right ideal classes.
> time #RightIdealClasses(M: Al:= "AllOrders");
140
Time: 18.260
In this section, we treat ideals of orders of quaternion algebras over Q.
For more general orders over number rings, see Section Orders.
The composite of I and J, where the right order of I equals the
left order of J.
Given ideals or orders I and J, returns the intersection I ∩J.
Conjugate(I) : AlgAssVOrdIdl -> AlgAssVOrdIdl
Given an ideal I (of a quaternion algebra), returns the conjugate ideal.
In the base of an order this is tautologically the same object.
Norm(I) : AlgAssVOrdIdl -> RngOrdIdl
Given an ideal I over Z, returns the reduced norm of the ideal,
defined as the positive generator of the image of the reduced norm map in
Z. Given an ideal I over a commutative order, returns the reduced
norm of I as an ideal of the order.
Factorization(I) : AlgAssVOrdIdl -> SeqEnum
Given a twosided ideal I of an hereditary order O, returns the unique
factorization of I into twosided O-ideals. The result is a sequence of
tuples. The first entry of each tuple is a two-sided ideal of O, the
second is its exponent.
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
