Example AlgQuat_Hilbert_Symbols (H95E12)

> 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. Note that this takes substantially more time.

> 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(A, p) : AlgQuat, RngOrdIdl -> AlgMat, Map, Map

pMatrixRing(A, p) : AlgQuat, RngElt -> AlgMat, Map, Map

pMatrixRing(O, p) : AlgAssVOrd, RngOrdIdl -> AlgMat, Map, Map

pMatrixRing(O, p) : AlgQuatOrd, RngElt -> AlgMat, Map, Map

pMatrixRing(O, p) : AlgQuatOrd[RngInt], RngInt -> AlgMat, Map, Map

    Precision: RngIntElt                Default: 

Let A be a quaternion algebra A over a field F where F is the rationals, a number field or F_q(x) with q odd. Given A and a prime (ideal) p of the ring of integers R of F such that p is unramified in A, this function returns the matrix ring over the completion F_p of F at p, a map from A to M₂(F_p) and the embedding F to F_p.

Given a p-maximal order O in A, the map from A to M₂(F_p) induces a map from O to <Meta>-₂(R_p).

IsSplittingField(K, A) : Fld, AlgQuat -> BoolElt, AlgQuatElt, Map

HasEmbedding(K, A) : Fld, AlgQuat -> BoolElt, AlgQuatElt, Map

    ComputeEmbedding: BoolElt           Default: false

Given a quaternion algebra A defined over Q, F_q(X) (with q odd) or a number field F and K a quadratic extension of F, the function returns true if and only if there exists an embedding K to A over F. This is done by comparison of ramified places in K and A (see [Vig80, Cor. III.3.5]). If no embedding exists, the second return value will be a witness place. If an embedding exists and the optional argument ComputeEmbedding is set to true, the second and third return values contain the result of a call to Embed as described below.

Embed(K, A) : Fld, AlgQuat -> AlgQuatElt, Map

    Al: MonStgElt                       Default: "NormEquation"

Given a quaternion algebra A defined over Q, F_q(X) (with q odd) 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).

Embed(Oc, O) : RngOrd, AlgAssVOrd -> AlgAssVOrdElt, Map

    Al: MonStgElt                       Default: "NormEquation"

Given a quadratic order O_c with base number ring R and a quaternion order O with base ring R, the function computes an embedding O_c -> O over R. It returns the image of the second generator Oc.2 of Oc; secondly it returns the embedding map O_c 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