## `Dom::AlgebraicExtension` -- simple algebraic field extensions

#### Introduction

For a given field F and a polynomial f ∈F[x], `Dom::AlgebraicExtension``(F, f, x)` creates the residue class field F[x]/⟨f⟩.

`Dom::AlgebraicExtension``(F, f1=f2, x)` does the same for f=f1-f2.

#### Domain

`Dom::AlgebraicExtension(F, f)`
`Dom::AlgebraicExtension(F, f, x)`
`Dom::AlgebraicExtension(F, f1=f2)`
`Dom::AlgebraicExtension(F, f1=f2, x)`

#### Parameters

`F` | - | the ground field: a domain of category `Cat::Field`
`f, f1, f2` | - | polynomials or polynomial expressions
`x` | - | identifier

#### Details

- `Dom::AlgebraicExtension``(F, f, x)` creates the field F[x]/⟨f⟩ of residue classes of polynomials modulo f. This field can also be written as F(x)/⟨f⟩, the field of residue classes of rational functions modulo f.
- The parameter `x` may be omitted if `f` is a univariate polynomial or a polynomial expression that contains exactly one indeterminate; it is then taken to be the indeterminate occurring in `f`.
- The field `F` must have normal representation.
- `f` must not be a constant polynomial.
- `f` must be irreducible; this is not checked.
- `f` may be a polynomial over a coefficient ring different from `F`, or multivariate; however, it must be possible to convert it to a univariate polynomial over `F`. See Example 2.

#### Introduction

`Dom::AlgebraicExtension``(F, f)(g)` creates the residue class of `g` modulo `f`.

#### Creating Elements

``Dom::AlgebraicExtension`(F,f)(g)`
``Dom::AlgebraicExtension`(F, f)(rat)`

#### Parameters

`g` | - | element of the residue class to be defined: polynomial over `F` in the variable `x`, or any object convertible to such.
`rat` | - | rational function that belongs to the residue class to be defined: expression whose numerator and denominator can be converted to polynomials over `F` in the variable `x`. The denominator must not be a multiple of `f`.

#### Details

- If `rat` has numerator and denominator `p` and `q`, respectively, then `Dom::AlgebraicExtension``(F,f)(rat)` equals `Dom::AlgebraicExtension``(F,f)(p)` divided by `Dom::AlgebraicExtension``(F,f)(q)`.

#### Categories

`Cat::Field`

, `Cat::Algebra(F)`, `Cat::VectorSpace(F)`,

if `F::hasProp(Cat::DifferentialRing)` then
`Cat::DifferentialRing`
if `F::hasProp(Cat::PartialDifferentialRing)` then
`Cat::PartialDifferentialRing`

#### Related Domains

`Dom::GaloisField`

#### Entries

zero

  the zero element of the field extension

one

  the unit element of the field extension

groundField

  the ground field of the extension

minpoly

  the minimal polynomial `f`

deg

  the degree of the extension, i.e., of `f`

variable

  the unknown of the minimal polynomial `f`

characteristic

  the characteristic, which always equals the characteristic of the ground field. This entry only exists if the characteristic of the ground field is known.

degreeOverPrimeField

  the dimension of the field when viewed as a vector space over the prime field. This entry only exists if the ground field is a prime field, or its degree over its prime field is known.

#### Method _plus: sum of field elements

- `_plus(dom a...)`
- - This method returns the sum of its arguments.
  - This method overloads the function `_plus` of the system kernel.

#### Method _mult: product of field elements

- `_mult(any a...)`
- - This method returns the product of its arguments. The arguments must be either field elements, or convertible to such, or integers.
  - This method overloads the function `_mult` of the system kernel.

#### Method _negate: negate a field element

- `_negate(dom a)`
- - This method returns the negative of `a`.
  - This method overloads the function `_negate` of the system kernel.

#### Method _subtract: difference of field elements

- `_subtract(dom a, dom b)`
- - This method returns the difference a-b.
  - This method overloads the function `_subtract` of the system kernel.

#### Method iszero: tests whether a field element is zero.

- `iszero(dom a)`
- - This method returns `TRUE` if `a` is known to be zero, and `FALSE` otherwise. If equality to zero can be decided for elements of the ground field, the answer `FALSE` implies that `a` cannot be zero.
  - This method overloads the function `iszero`.

#### Method intmult: multiply a field element by an integer

- `intmult(dom a, integer b)`
- - This method computes `a*b`.
  - This method is more efficient than `"_mult"` in this special case.

#### Method _invert: inverse of a field element

- `_invert(dom a)`
- - This method returns the inverse of `a` with respect to multiplication. `a` must be nonzero.
  - This method overloads the function `_invert`.

#### Method gcd: gcd of field elements

- `gcd(dom a...)`
- - If the arguments are not all zero, any nonzero field element is a gcd. This method tries to find a gcd such that dividing the arguments by it gives most ``simple'' objects.
  - This method overloads the function `gcd`.

#### Method conjNorm: norm of an element

- `conjNorm(dom a)`
- - This method computes the norm of `a`, i.e., the product of all conjugates of `a` (images of `a` under Galois automorphisms).

#### Method conjTrace: trace of an element

- `conjTrace(dom a)`
- - This method computes the trace of `a`, i.e., the sum of all conjugates of `a` (images of `a` under Galois automorphisms).

#### Method minimalPolynomial: minimal polynomial of an element

- `minimalPolynomial(dom a)`
- - This method chooses a free identifier and computes the (uniquely determined) monic irreducible polynomial over the ground field in that variable of which `a` is a root.

#### Method D: differential operator

- `D(dom a)`
- - This method implements the continuation of the differential operator of the ground field; it exists only if the ground field has a method `"D"`, too.
  - This method overloads the function `D`.
  - This method must not be called for inseparable extensions; note that MuPAD cannot check whether an extension is separable.
  - See Example 3.

#### Method diff: partial differentiation

- `diff(dom a, identifier x1...)`
- - This method computes (&partial;a)/(&partial;x1).
  - Differentiation is defined to be the continuation of differentiation of the ground field; this method exists only if the ground field has a method `"diff"`, too.
  - Differentiation is not possible in inseparable extensions.
  - This method overloads the function `diff`.
  - This method must not be called for inseparable extensions; note that MuPAD cannot check whether an extension is separable.
  - See Example 3.

#### Method random: random element of the field

- `random()`
- - This method returns a random element of the field.
  - The `random` method of the ground field is used to generate coefficients of a random polynomial of the ground field; the residue class of that polynomial is the return value. Hence the probability distribution of the elements returned depends on that of the `random` method of the ground field.

#### Method convert: convert into a field element

- `convert(any x)`
- - This method tries to convert `x` into a field element.
  - If the conversion fails, then `FAIL` is returned.

#### Method convert_to: convert a field element into another type

- `convert_to(dom a, domain T)`
- - This method converts `a` into an element of `T`, or returns `FAIL` if the conversion is impossible.
  - Field elements can be converted to polynomials or expressions. Field elements represented by constant polynomials can also be converted to the same types as the elements of the ground field; in particular, they can be converted to elements of the ground field.

#### Method expr: convert an element of the field into an expression

- `expr(dom a)`
- - This method converts the polynomial representing `a` into an expression.
  - This method overloads the function `expr`.

#### Example 1

We adjoin a cubic root `alpha` of `2` to the rationals.

    >> G := Dom::AlgebraicExtension(Dom::Rational, alpha^3 = 2)

                                                       3
           Dom::AlgebraicExtension(Dom::Rational, alpha  - 2 = 0, alpha)

The third power of a cubic root of `2` equals `2`, of course.

    >> G(alpha)^3

                                         2

The trace of α is zero:

    >> G::conjTrace(G(alpha))

                                         0

You can also create random elements:

    >> G::random()

                                                 2
                           - 65 alpha - 814 alpha  + 824

#### Example 2

The ground field may be an algebraic extension itself. In this way, it is possible to construct a tower of fields. In the following example, an algebraic extension is defined using a primitive element `alpha`, and the primitive element `beta` of a further extension is defined in terms of `alpha`. In such cases, when a minimal equation contains more than one identifier, a third argument to `Dom::AlgebraicExtension` must be explicitly given.

    >> F := Dom::AlgebraicExtension(Dom::Rational, alpha^2 = 2):
       G := Dom::AlgebraicExtension(F, bet^2 + bet = alpha, bet)

          Dom::AlgebraicExtension(Dom::AlgebraicExtension(Dom::Rational,

                  2                                   2
             alpha  - 2 = 0, alpha), bet - alpha + bet  = 0, bet)

#### Example 3

We want to define an extension of the field of fractions of the ring of bivariate polynomials over the rationals.

    >> P:= Dom::DistributedPolynomial([x, y], Dom::Rational):
       F:= Dom::Fraction(P):
       K:= Dom::AlgebraicExtension(F, alpha^2 = x, alpha)

          Dom::AlgebraicExtension(Dom::Fraction(

             Dom::DistributedPolynomial([x, y], Dom::Rational, LexOrder))

                    2
             , alpha  - x = 0, alpha)

Now K = Q[sqrt(x), y] . Of course, the square root function has the usual derivative; note that 1/sqrt(x) can be expressed as α/x:

    >> diff(K(alpha), x)

                                       alpha
                                       -----
                                        2 x

On the other hand, the derivative of sqrt(x) with respect to y is zero, of course:

    >> diff(K(alpha), y)

                                         0

We must not use `D` here. This works only if we start our construction with a ring of univariate polynomials:

    >> P:= Dom::DistributedPolynomial([x], Dom::Rational):
       F:= Dom::Fraction(P):
       K:= Dom::AlgebraicExtension(F, alpha^2 = x, alpha):
       D(K(alpha))

                                       alpha
                                       -----
                                        2 x

#### Super-Domain

`Dom::BaseDomain`

#### Axioms

if `F::hasProp(Ax::canonicalRep)` then
`Ax::canonicalRep`
else
`Ax::normalRep`

#### Changes

- An additional method `minimalPolynomial` is now available.
- Methods `diff` and `D` are now available for (partial) differential fields if such methods exist in the ground field.

Do you have questions or comments?
Copyright © SciFace Software GmbH & Co. KG 2000