Module order

Return True if R an order in a number field or R is the ring ZZ of integers.

EXAMPLES:
    sage: is_NumberFieldOrder(NumberField(x^2+1,'a').maximal_order())
    True
    sage: is_NumberFieldOrder(ZZ)
    True
    sage: is_NumberFieldOrder(QQ)
    False
    sage: is_NumberFieldOrder(45)
    False

Return the equation order generated by a root of the irreducible
polynomial f or list of polynomials f (to construct a relative
equation order).

IMPORTANT: Note that the generators of the returned order need
*not* be a root of f, since the generators of an order are -- in
SAGE -- module generators.

EXAMPLES:
    sage: O.<a,b> = EquationOrder([x^2+1, x^2+2])
    sage: O
    Relative Order in Number Field in a with defining polynomial x^2 + 1 over its base field
    sage: O.0
    (-b)*a - 1
    sage: O.1
    (-3)*a + 2*b

Of course the input polynomial must be integral:
    sage: R = EquationOrder(x^3 + x + 1/3, 'alpha'); R
    Traceback (most recent call last):
    ...
    ValueError: each generator must be integral

    sage: R = EquationOrder( [x^3 + x + 1, x^2 + 1/2], 'alpha'); R
    Traceback (most recent call last):
    ...
    ValueError: each generator must be integral

Return True if each element of the list v of elements of a number
field is integral.

EXAMPLES:
    sage: W.<sqrt5> = NumberField(x^2 - 5)
    sage: from sage.rings.number_field.order import each_is_integral
    sage: each_is_integral([sqrt5, 2, (1+sqrt5)/2])
    True
    sage: each_is_integral([sqrt5, (1+sqrt5)/3])
    False    

INPUT:
    gens -- list of integral elements of an absolute order.
    check_is_integral -- bool (default: True), whether to check
                         that each generator is integral.
    check_rank -- bool (default: True), whether to check that
                  the ring generated by gens is of full rank.
    is_maximal -- bool (or None); set if maximality of the generated order is known
    allow_subfield -- bool (default: False), if True and the generators
          do not generate an order, i.e., they generate a subring
          of smaller rank, instead of raising an error, return
          an order in a smaller number field.
    
EXAMPLES:
    sage: K.<a> = NumberField(x^4 - 5)
    sage: K.order(a)
    Order in Number Field in a with defining polynomial x^4 - 5
    
We have to explicitly import this function, since typically
it is called with \code{K.order} as above.
    sage: from sage.rings.number_field.order import absolute_order_from_ring_generators
    sage: absolute_order_from_ring_generators([a])
    Order in Number Field in a with defining polynomial x^4 - 5
    sage: absolute_order_from_ring_generators([3*a, 2, 6*a+1])
    Order in Number Field in a with defining polynomial x^4 - 5

If one of the inputs is non-integral, it is an error.
    sage: absolute_order_from_ring_generators([a/2])
    Traceback (most recent call last):
    ...
    ValueError: each generator must be integral

If the gens do not generate an order, i.e., generate a ring of full
rank, then it is an error. 
    sage: absolute_order_from_ring_generators([a^2])
    Traceback (most recent call last):
    ...
    ValueError: the rank of the span of gens is wrong

Both checking for integrality and checking for full rank can be
turned off in order to save time, though one can get nonsense as
illustrated below.
    sage: absolute_order_from_ring_generators([a/2], check_is_integral=False)
    Order in Number Field in a with defining polynomial x^4 - 5
    sage: absolute_order_from_ring_generators([a^2], check_rank=False)
    Order in Number Field in a with defining polynomial x^4 - 5

INPUT:
    gens -- list of elements of an absolute number field
            that generates an order in that number field as a ZZ
            *module*.
    check_integral -- check that each gen is integral
    check_rank -- check that the gens span a module of the correct rank
    check_is_ring -- check that the module is closed under multiplication
                     (this is very expensive)
    is_maximal -- bool (or None); set if maximality of the generated order is known                  

OUTPUT:
    an absolute order

EXAMPLES:
We have to explicitly import the function, since it isn't meant
for regular usage:
    sage: from sage.rings.number_field.order import absolute_order_from_module_generators

    sage: K.<a> = NumberField(x^4 - 5)
    sage: O = K.maximal_order(); O
    Maximal Order in Number Field in a with defining polynomial x^4 - 5
    sage: O.basis()
    [1/2*a^2 + 1/2, 1/2*a^3 + 1/2*a, a^2, a^3]
    sage: O.module()
    Free module of degree 4 and rank 4 over Integer Ring
    Echelon basis matrix:
    [1/2   0 1/2   0]
    [  0 1/2   0 1/2]
    [  0   0   1   0]
    [  0   0   0   1]
    sage: g = O.gens(); g
    [1/2*a^2 + 1/2, 1/2*a^3 + 1/2*a, a^2, a^3]
    sage: absolute_order_from_module_generators(g)
    Order in Number Field in a with defining polynomial x^4 - 5

We illustrate each check flag -- the output is the same but in case
the function would run ever so slightly faster:
    sage: absolute_order_from_module_generators(g,  check_is_ring=False)
    Order in Number Field in a with defining polynomial x^4 - 5
    sage: absolute_order_from_module_generators(g,  check_rank=False)
    Order in Number Field in a with defining polynomial x^4 - 5
    sage: absolute_order_from_module_generators(g,  check_integral=False)
    Order in Number Field in a with defining polynomial x^4 - 5

Next we illustrate constructing "fake" orders to illustrate turning
off various check flags:
    sage: k.<i> = NumberField(x^2 + 1)
    sage: R = absolute_order_from_module_generators([2, 2*i],  check_is_ring=False); R
    Order in Number Field in i with defining polynomial x^2 + 1
    sage: R.basis()
    [2, 2*i]
    sage: R = absolute_order_from_module_generators([k(1)],  check_rank=False); R
    Order in Number Field in i with defining polynomial x^2 + 1
    sage: R.basis()
    [1]

If the order contains a non-integral element, even if we don't check
that, we'll find that the rank is wrong or that the order isn't closed
under multiplication:
    sage: absolute_order_from_module_generators([1/2, i],  check_integral=False)
    Traceback (most recent call last):
    ...
    ValueError: the module span of the gens is not closed under multiplication.
    sage: R = absolute_order_from_module_generators([1/2, i],  check_is_ring=False, check_integral=False); R
    Order in Number Field in i with defining polynomial x^2 + 1
    sage: R.basis()
    [1/2, i]

We turn off all check flags and make a really messed up order. 
    sage: R = absolute_order_from_module_generators([1/2, i],  check_is_ring=False, check_integral=False, check_rank=False); R
    Order in Number Field in i with defining polynomial x^2 + 1
    sage: R.basis()
    [1/2, i]

An order that lives in a subfield:
    sage: F.<alpha> = NumberField(x**4+3)
    sage: F.order([alpha**2], allow_subfield=True)
    Order in Number Field in alpha with defining polynomial x^4 + 3

INPUT:
    gens -- list of integral elements of an absolute order.
    check_is_integral -- bool (default: True), whether to check
                         that each generator is integral.
    check_rank -- bool (default: True), whether to check that
                  the ring generated by gens is of full rank.
    is_maximal -- bool (or None); set if maximality of the generated order is known
    
EXAMPLES:
We have to explicitly import this function, since it isn't meant
for regular usage:

    sage: from sage.rings.number_field.order import relative_order_from_ring_generators
    sage: K.<i, a> = NumberField([x^2 + 1, x^2 - 17])
    sage: R = K.base_field().maximal_order()
    sage: S = relative_order_from_ring_generators([i,a]); S
    Relative Order in Number Field in i with defining polynomial x^2 + 1 over its base field

Basis for the relative order, which is obtained by computing the algebra generated
by i and a.
    sage: S.basis()
    [1, 7*i - 2*a, (-a)*i + 8, 25*i - 7*a]