Orders of Algebras#

IsCoercible(S, x): AlgEtQOrd, Any -> BoolElt, AlgEtQElt#: Return whether \(x\) is coercible into the order \(S\) and the result if so.

Order(gens): SeqEnum[AlgEtQElt] -> AlgEtQOrd#

Check            : RngIntElt                    Default: 100
CheckIsKnownOrder: BoolElt                      Default: true

Construct the order generated by \(gens\) over the rationals. The parameter Check (default 100) determines how many times the program tries to obtain a multiplicatively closed lattice by adding the product of the generators. If Check is 0 then this step is skipped. The parameter CheckIsKnownOrder determines whether the program checks if the order is already known, i.e. in the attribute KnownOrders of the algebra. This is to avoid the creation of multiple copies of the same order. The default value is true.

Order(A, orders): AlgEtQ, Tup -> AlgEtQOrd#: Given a sequence of orders in the number fields defining the étale algebra A, generates the direct sum order.

Algebra(S): AlgEtQOrd -> AlgEtQ#: Returns the algebra of the order \(S\).

ZBasis(S): AlgEtQOrd -> SeqEnum[AlgEtQElt]#: Return a Z-basis of the order \(S\).

Generators(S): AlgEtQOrd -> SeqEnum[AlgEtQElt]#: Return a set of generators (as a Z-algebra) of the order \(S\).

O1 eq O2: AlgEtQOrd, AlgEtQOrd -> BoolElt#

Checks equality of orders in an étale algebra.

Equality of orders is performed using the Hash attribute which is constructed as follows. Let \(S\) be an order. Let \(P\) be the upper triangular Hermite normal form of the integer square matrix \(d\cdot M\) where \(M\) is the matrix whose rows are the coefficients of a \({{\Bbb Z}}\)-basis of \(S\) and \(d\) is the least common denominator of its entries. The Hash of \(S\) is defined to be the sequence consisting of the least common denominator of \({1\over d}\cdot P\) and the entries of the upper triangular part of \({1\over d}\cdot P\). This hashing method has no collisions and it is independent of the choice of \({{\Bbb Z}}\)-basis from which we start the procedure.

x in O: AlgEtQElt, AlgEtQOrd -> BoolElt#
x in O: RngIntElt, AlgEtQOrd -> BoolElt#
x in O: FldRatElt, AlgEtQOrd -> BoolElt#: Return whether the element \(x\) is contained in the order \(O\) of an algebra.

AbsoluteCoordinates(seq, O): SeqEnum[AlgEtQElt], AlgEtQOrd -> SeqEnum#: Returns the coordinates of the elements in seq with respect to the stored Z-basis of \(O\).

One(S): AlgEtQOrd -> AlgEtQElt#: Returns the unit element of the order \(S\).

Zero(S): AlgEtQOrd -> AlgEtQElt#: Returns the zero element of the order \(S\).

Random(O, bd): AlgEtQOrd, RngIntElt -> AlgEtQElt#

ZeroDivisorsAllowed: BoolElt                    Default: false

Returns a random element of the order \(O\). The coefficients are bounded by the positive integer \(bd\). One can allow zero-divisors using the optional parameter ZeroDivisorsAllowed, which is set to false by default.

Random(O): AlgEtQOrd -> AlgEtQElt#

CoeffRange         : RngIntElt                    Default: 3
ZeroDivisorsAllowed: BoolElt                      Default: false

Returns a random (small coefficient) element of the order \(O\). The range of the random coefficients can be increased by giving the optional parameter CoeffRange. One can allow zero-divisors using the optional parameter ZeroDivisorsAllowed, which is set to false by default.

IsKnownOrder(~R): AlgEtQOrd#: This procedure checks whether the order \(R\) is already in the list of known orders of the algebra \(A\) containing \(R\). If so then it replaces \(R\) with the copy stored in the attribute KnownOrders. If not it adds it to KnownOrders. This is done to avoid creating multiple copies of the same order.

EquationOrder(A): AlgEtQ -> AlgEtQOrd#: Given an étale algebra defined by a polynomial, returns the monogenic order defined by the same polynomial.

ProductOfEquationOrders(A): AlgEtQ -> AlgEtQOrd#: Given an étale algebra \(A\), returns the order consisting of the product of the equation orders of the number fields.

MaximalOrder(A): AlgEtQ -> AlgEtQOrd#: Returns the maximal order of the étale algebra \(A\). It is the direct sum of the ring of integers of the number fields composing the algebra.

IsMaximal(S): AlgEtQOrd -> BoolElt#: Returns whether the order \(S\) is the maximal order of the étale algebra.

IsProductOfOrders(O): AlgEtQOrd -> BoolElt, Tup#: Return if the order \(O\) is a product of orders in number fields, and if so return also the sequence of these orders.

IsProductOfOrdersInComponents(O): AlgEtQOrd -> BoolElt, Tup#: Returns whether the argument is a product of orders in the components of its parent algebra. If so, it returns also a tuple containing these orders.

IsProductOfOrdersInFactorAlgebras(S): AlgEtQOrd -> BoolElt, SeqEnum[AlgEtQElt]#: Returns whether the given order is a product of orders living in some factor algebras of the parent algebra. This is equivalent to containing some idempotents of the algebra other than \(0\) and \(1\). If this is the case, it returns also the idempotents.

Example: Orders Factor Algebras (ex-f008b6)#

> _<x> := PolynomialRing(Integers());
> // We consider the following three number fields
> K1 := NumberField(x^2-2);
> K2 := NumberField(x^2-3);
> K3 := NumberField(x^2-5);
> // We define the product \'etale algebra A and the factor algebras B and C
> // consisting of only the first two components and the last one, respectively.
> B := EtaleAlgebra([K1,K2]);
> C := EtaleAlgebra([K3]);
> A, embs, projs := DirectProduct([B,C]);
> // The maximal order of A is the product of the three ring of integers.
> OA := MaximalOrder(A);
> IsProductOfOrdersInComponents(OA);
true <Maximal Equation Order with defining polynomial x^2 - 2 over its ground
order, Maximal Equation Order with defining polynomial x^2 - 3 over its ground
order, Maximal Order of Equation Order with defining polynomial x^2 - 5 over
its ground order>
> // The equation order of A is not a product in any factor algebra
> EA := EquationOrder(A);
> IsProductOfOrdersInFactorAlgebras(EA);
false []
> // Now we construct an order that is a product of an order in B and one in C,
> // but does not admit further splittings.
> a := PrimitiveElement(A);
> e1 := A![1,0,0];
> e2 := A![0,1,1];
> R := Order([a*e1,a*e2]);
> IsProductOfOrdersInFactorAlgebras(R);
true [ <1, 0, 0>, <0, 1, 1> ]

Run in calculator

Index(T): AlgEtQOrd -> FldRatElt#: Given an order \(T\) compute its index with respect to the basis of the algebra of \(T\) as a free \({{\Bbb Z}}\)-module.

Index(S, T): AlgEtQOrd, AlgEtQOrd -> FldRatElt#: Given two orders \(T \subset S\), returns \([S:T] = \#S/T\).

O1 subset O2: AlgEtQOrd, AlgEtQOrd -> BoolElt#: Checks whether \(O1\) is contained in \(O2\).

O1 * O2: AlgEtQOrd, AlgEtQOrd -> AlgEtQOrd#: Returns the order generated by the orders \(O1\) and \(O2\).

O1 meet O2: AlgEtQOrd, AlgEtQOrd -> AlgEtQOrd#: Return the intersection of orders \(O1\) and \(O2\).

MultiplicatorRing(R): AlgEtQOrd -> AlgEtQOrd#: Returns the multiplicator ring of an order \(R\), that is \(R\) itself.