|
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
Let A be a quaternion algebra over a number field F with defining
elements a, b, and let v be
a noncomplex place of F. If v is unramified in A
(i.e. A tensor F Fv isomorphic to M2(Fv), we define the Hilbert symbol
(a, b)v to be 1, and otherwise we define (a, b)v= - 1.
HilbertSymbol(A, p) : AlgQuat[FldRat], RngIntElt -> RngIntElt
HilbertSymbol(a, b, p) : FldNumElt, FldNumElt, RngOrdIdl -> RngIntElt
HilbertSymbol(A, p) : AlgQuat, RngOrdIdl -> RngIntElt
Al: MonStgElt Default: "NormResidueSymbol"
Computes the Hilbert symbol for the quaternion algebra A, namely (a, b)p, where a, b are elements of a number field, and p is either a prime number (if a, b ∈Q) or
a prime ideal. If a, b ∈Q, by default one uses table-lookup to compute the Hilbert symbol; one can optionally insist on using the full algorithm by
passing the optional argument "Evaluate" to Al.
IsUnramified(p, A) : RngIntElt, AlgQuat[FldRat] -> BoolElt
IsRamified(p, A) : RngOrdIdl, AlgQuat[FldAlg] -> BoolElt
IsUnramified(p, A) : RngOrdIdl, AlgQuat[FldAlg] -> BoolElt
Returns true if and only if the integer or ideal of an order of a number field
p is ramified or unramified in the quaternion
algebra A, respectively.
We first verify the correctness of all Hilbert symbols over the rationals.
> QQ := Rationals();
> for a,b in [1..8] do
> bl := HilbertSymbol(QQ ! a, QQ ! b,2 : Al := "Evaluate")
> eq NormResidueSymbol(a,b,2);
> print <a,b,bl>;
> if not bl then
> break a;
> end if;
> end for;
<1, 1, true>
<1, 2, true>
<1, 3, true>
...
For a second test, we input a quaternion algebra which is unramified at all finite
places.
> P<x> := PolynomialRing(Rationals());
> F<b> := NumberField(x^3-3*x-1);
> Z_F := MaximalOrder(F);
> A := QuaternionAlgebra<F | -3,b>;
> symbols := [];
> for p in [p : p in [2..100] | IsPrime(p)] do
> pps := Decomposition(Z_F,p);
> for pp in pps do
> Append(~symbols,HilbertSymbol(A,pp[1]));
> end for;
> end for;
> symbols;
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
Finally, we test "random" quaternion algebras over quadratic extensions at
even primes, the hardest case. We use the fact that the quaternion algebra (a, b)
is ramified at a prime ideal p if and only if b is a norm from the extension
F(Sqrt(a)), so we can test this condition using IsLocalNorm (which we
remark runs substantially slower).
> for c in [2,-2,6,-6,-1,3,-3] do
> K<s> := NumberField(x^2-c);
> Z_K := MaximalOrder(K);
> Z_Kmod8, f8 := quo<Z_K | 8>;
> PPK<xK> := PolynomialRing(K);
> for i := 1 to 10 do
> S := [x+y*Z_K.2 : x,y in [0..7] | x*y ne 0];
> a := Random(S);
> b := Random(S);
> A := QuaternionAlgebra<K | a,b>;
> for pp in Decomposition(Z_K,2) do
> hsym := HilbertSymbol(A,pp[1]);
> if not IsIrreducible(xK^2-a) then
> print <c, a, b, hsym eq 1>;
> if hsym ne 1 then
> break c;
> end if;
> else
> lclsym := IsLocalNorm(AbelianExtension(ext<K | xK^2-a>),Z_K ! b,pp[1]);
> bl := (hsym eq 1) eq lclsym;
> print <c, a, b, bl>;
> if not bl then
> break c;
> end if;
> end if;
> end for;
> end for;
> end for;
<2, 5/1*Z_K.1 + 3/1*Z_K.2, Z_K.1 + 7/1*Z_K.2, true>
<2, 6/1*Z_K.1 + 4/1*Z_K.2, 4/1*Z_K.1 + Z_K.2, true>
<2, 7/1*Z_K.1 + Z_K.2, 2/1*Z_K.1 + 2/1*Z_K.2, true>
...
pMatrixRing(O, p) : AlgAssVOrd, RngOrdIdl -> AlgQuat, Map, Map
Precision: RngIntElt Default:
Given a prime ideal p of a number ring R which is unramified
in an order O defined over R or an algebra A defined over the
field of fractions of R, returns the matrix ring over the
completion Fp of F at p, a map from A to M2(Fp)
and the embedding F to Fp.
IsSplittingField(A, K) : AlgQuat, FldQuad -> BoolElt
HasEmbedding(K, A) : FldAlg, AlgQuat -> BoolElt, .
ComputeEmbedding: BoolElt Default: false
Given a quaternion algebra A defined over Q or
a number field F and K a quadratic extension of F,
returns true if and only if there exists an embedding
K to A over F. If the optional argument
ComputeEmbedding for the intrinsic HasEmbedding
is set to true, computes an embedding as below.
Al: MonStgElt Default: "NormEquation"
Given a quaternion algebra A defined over Q or
a number field F and K a quadratic extension of F,
returns an embedding K to A over F, given as
an element of A, the image of the primitive
generator of K, and the map K to A.
The algorithm by default involves solving a relative
norm equation. Alternatively, a naive search algorithm
may be selected by setting the optional parameter
Al:="Search".
If there is no embedding, a runtime error occurs
(or the "Search" runs forever).
To check whether an embedding exists, use HasEmbedding
(see immediately above).
Al: MonStgElt Default: "NormEquation"
Given a quadratic order Oc with base number ring R
and a quaternion order O with base ring R, the function
computes an embedding Oc -> O over R.
It returns the image of the second generator Oc.2 of
Oc; secondly it returns the embedding map Oc to O.
The algorithm by default involves solving a relative
norm equation. Alternatively, a naive search algorithm
may be selected by setting the optional parameter
Al:="Search".
Notes. Let K be the number field containing Oc.
(i) Oc.1, Oc.2 are the generators of Oc as a
module, and Oc.2 is unrelated to K.1,
where K is the number field containing Oc.
(ii) To check whether an embedding of K into the algebra exists,
one can use HasEmbedding(K, Algebra(O) : ComputeEmbedding:=false).
> F<b> := NumberField(Polynomial([1,-3,0,1]));
> A := QuaternionAlgebra<F | -3, b>;
> K := ext<F | Polynomial([2,-1,1])>;
> mu, iota := Embed(K, A);
> mu;
1/2 + 1/6*(-2*b^2 + 2*b + 7)*i + 1/2*(2*b^2 + b - 6)*j + 1/6*(-2*b^2 - b + 4)*k
> MinimalPolynomial(mu);
$.1^2 - $.1 + 2
> iota(K.1) eq mu;
true
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
