FiniteAlgebraicExtensionField FΒΆ

ffcat.spad line 89

FiniteAlgebraicExtensionField F is the category of fields which are finite algebraic extensions of the field F. If F is finite then any finite algebraic extension of F is finite, too. Let K be a finite algebraic extension of the finite field F. The exponentiation of elements of K defines a Z-module structure on the multiplicative group of K. The additive group of K becomes a module over the ring of polynomials over F via the operation linearAssociatedExp(a: K, f: SparseUnivariatePolynomial F) which is linear over F, i.e. for elements a from K, c, d from F and f, g univariate polynomials over F we have linearAssociatedExp(a, cf+dg) equals c times linearAssociatedExp(a, f) plus d times linearAssociatedExp(a, g). Therefore linearAssociatedExp is defined completely by its action on monomials from F[X]: linearAssociatedExp(a, monomial(1, k)\$SUP(F)) is defined to be Frobenius(a, k) which is a^(q^k) where q=size()$F. The operations order and discreteLog associated with the multiplicative exponentiation have additive analogues associated to the operation linearAssociatedExp. These are the functions linearAssociatedOrder and linearAssociatedLog, respectively.

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (%, F) -> %
from RightModule F
*: (%, Fraction Integer) -> %
from RightModule Fraction Integer
*: (F, %) -> %
from LeftModule F
*: (Fraction Integer, %) -> %
from LeftModule Fraction Integer
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
/: (%, %) -> %
from Field
/: (%, F) -> %
from VectorSpace F
=: (%, %) -> Boolean
from BasicType
^: (%, Integer) -> %
from DivisionRing
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
~=: (%, %) -> Boolean
from BasicType
algebraic?: % -> Boolean
from ExtensionField F
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
associates?: (%, %) -> Boolean
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
basis: () -> Vector %
basis() returns a fixed basis of % as F-vector space.
basis: PositiveInteger -> Vector %
basis(n) returns a fixed basis of a subfield of % as F-vector space.
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
charthRoot: % -> % if F has Finite
from FiniteFieldCategory
charthRoot: % -> Union(%, failed) if F has Finite or F has CharacteristicNonZero
from CharacteristicNonZero
coerce: % -> %
from Algebra %
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: F -> %
from RetractableTo F
coerce: Fraction Integer -> %
from Algebra Fraction Integer
coerce: Integer -> %
from NonAssociativeRing
commutator: (%, %) -> %
from NonAssociativeRng
conditionP: Matrix % -> Union(Vector %, failed) if F has Finite
from FiniteFieldCategory
convert: % -> InputForm if F has Finite
from ConvertibleTo InputForm
coordinates: % -> Vector F
coordinates(a) returns the coordinates of a with respect to the fixed F-vector space basis.
coordinates: Vector % -> Matrix F
coordinates([v1, ..., vm]) returns the coordinates of the vi's with to the fixed basis. The coordinates of vi are contained in the ith row of the matrix returned by this function.
createNormalElement: () -> % if F has Finite
createNormalElement() computes a normal element over the ground field F, that is, a^(q^i), 0 <= i < extensionDegree() is an F-basis, where q = size()\$F. Reference: Such an element exists Lidl/Niederreiter: Theorem 2.35.
createPrimitiveElement: () -> % if F has Finite
from FiniteFieldCategory
D: % -> % if F has Finite
from DifferentialRing
D: (%, NonNegativeInteger) -> % if F has Finite
from DifferentialRing
definingPolynomial: () -> SparseUnivariatePolynomial F
definingPolynomial() returns the polynomial used to define the field extension.
degree: % -> OnePointCompletion PositiveInteger
from ExtensionField F
degree: % -> PositiveInteger
degree(a) returns the degree of the minimal polynomial of an element a over the ground field F.
differentiate: % -> % if F has Finite
from DifferentialRing
differentiate: (%, NonNegativeInteger) -> % if F has Finite
from DifferentialRing
dimension: () -> CardinalNumber
from VectorSpace F
discreteLog: % -> NonNegativeInteger if F has Finite
from FiniteFieldCategory
discreteLog: (%, %) -> Union(NonNegativeInteger, failed) if F has Finite or F has CharacteristicNonZero
from FieldOfPrimeCharacteristic
divide: (%, %) -> Record(quotient: %, remainder: %)
from EuclideanDomain
enumerate: () -> List % if F has Finite
from Finite
euclideanSize: % -> NonNegativeInteger
from EuclideanDomain
expressIdealMember: (List %, %) -> Union(List %, failed)
from PrincipalIdealDomain
exquo: (%, %) -> Union(%, failed)
from EntireRing
extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %)
from EuclideanDomain
extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed)
from EuclideanDomain
extensionDegree: () -> OnePointCompletion PositiveInteger
from ExtensionField F
extensionDegree: () -> PositiveInteger
extensionDegree() returns the degree of field extension.
factor: % -> Factored %
from UniqueFactorizationDomain
factorsOfCyclicGroupSize: () -> List Record(factor: Integer, exponent: Integer) if F has Finite
from FiniteFieldCategory
Frobenius: % -> % if F has Finite
from ExtensionField F
Frobenius: (%, NonNegativeInteger) -> % if F has Finite
from ExtensionField F
gcd: (%, %) -> %
from GcdDomain
gcd: List % -> %
from GcdDomain
gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %
from GcdDomain
generator: () -> % if F has Finite
generator() returns a root of the defining polynomial. This element generates the field as an algebra over the ground field.
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
index: PositiveInteger -> % if F has Finite
from Finite
inGroundField?: % -> Boolean
from ExtensionField F
init: % if F has Finite
from StepThrough
inv: % -> %
from DivisionRing
latex: % -> String
from SetCategory
lcm: (%, %) -> %
from GcdDomain
lcm: List % -> %
from GcdDomain
lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %)
from LeftOreRing
leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
leftPower: (%, PositiveInteger) -> %
from Magma
leftRecip: % -> Union(%, failed)
from MagmaWithUnit
linearAssociatedExp: (%, SparseUnivariatePolynomial F) -> % if F has Finite
linearAssociatedExp(a, f) is linear over F, i.e. for elements a from $, c, d form F and f, g univariate polynomials over F we have linearAssociatedExp(a, cf+dg) equals c times linearAssociatedExp(a, f) plus d times linearAssociatedExp(a, g). Therefore linearAssociatedExp is defined completely by its action on monomials from F[X]: linearAssociatedExp(a, monomial(1, k)\$SUP(F)) is defined to be Frobenius(a, k) which is a^(q^k), where q=size()$F.
linearAssociatedLog: % -> SparseUnivariatePolynomial F if F has Finite
linearAssociatedLog(a) returns a polynomial g, such that linearAssociatedExp(normalElement(), g) equals a.
linearAssociatedLog: (%, %) -> Union(SparseUnivariatePolynomial F, failed) if F has Finite
linearAssociatedLog(b, a) returns a polynomial g, such that the linearAssociatedExp(b, g) equals a. If there is no such polynomial g, then linearAssociatedLog fails.
linearAssociatedOrder: % -> SparseUnivariatePolynomial F if F has Finite
linearAssociatedOrder(a) retruns the monic polynomial g of least degree, such that linearAssociatedExp(a, g) is 0.
lookup: % -> PositiveInteger if F has Finite
from Finite
minimalPolynomial: % -> SparseUnivariatePolynomial F
minimalPolynomial(a) returns the minimal polynomial of an element a over the ground field F.
minimalPolynomial: (%, PositiveInteger) -> SparseUnivariatePolynomial % if F has Finite
minimalPolynomial(x, n) computes the minimal polynomial of x over the field of extension degree n over the ground field F.
multiEuclidean: (List %, %) -> Union(List %, failed)
from EuclideanDomain
nextItem: % -> Union(%, failed) if F has Finite
from StepThrough
norm: % -> F
norm(a) computes the norm of a with respect to the field considered as an algebra with 1 over the ground field F.
norm: (%, PositiveInteger) -> % if F has Finite
norm(a, d) computes the norm of a with respect to the field of extension degree d over the ground field of size. Error: if d does not divide the extension degree of a. Note: norm(a, d) = reduce(*, [a^(q^(d*i)) for i in 0..n/d])
normal?: % -> Boolean if F has Finite
normal?(a) tests whether the element a is normal over the ground field F, i.e. a^(q^i), 0 <= i <= extensionDegree()-1 is an F-basis, where q = size()\$F. Implementation according to Lidl/Niederreiter: Theorem 2.39.
normalElement: () -> % if F has Finite
normalElement() returns a element, normal over the ground field F, i.e. a^(q^i), 0 <= i < extensionDegree() is an F-basis, where q = size()\$F. At the first call, the element is computed by createNormalElement then cached in a global variable. On subsequent calls, the element is retrieved by referencing the global variable.
one?: % -> Boolean
from MagmaWithUnit
opposite?: (%, %) -> Boolean
from AbelianMonoid
order: % -> OnePointCompletion PositiveInteger if F has Finite or F has CharacteristicNonZero
from FieldOfPrimeCharacteristic
order: % -> PositiveInteger if F has Finite
from FiniteFieldCategory
prime?: % -> Boolean
from UniqueFactorizationDomain
primeFrobenius: % -> % if F has Finite or F has CharacteristicNonZero
from FieldOfPrimeCharacteristic
primeFrobenius: (%, NonNegativeInteger) -> % if F has Finite or F has CharacteristicNonZero
from FieldOfPrimeCharacteristic
primitive?: % -> Boolean if F has Finite
from FiniteFieldCategory
primitiveElement: () -> % if F has Finite
from FiniteFieldCategory
principalIdeal: List % -> Record(coef: List %, generator: %)
from PrincipalIdealDomain
quo: (%, %) -> %
from EuclideanDomain
random: () -> % if F has Finite
from Finite
recip: % -> Union(%, failed)
from MagmaWithUnit
rem: (%, %) -> %
from EuclideanDomain
representationType: () -> Union(prime, polynomial, normal, cyclic) if F has Finite
from FiniteFieldCategory
represents: Vector F -> %
represents([a1, .., an]) returns a1*v1 + ... + an*vn, where v1, ..., vn are the elements of the fixed basis.
retract: % -> F
from RetractableTo F
retractIfCan: % -> Union(F, failed)
from RetractableTo F
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
sample: %
from AbelianMonoid
size: () -> NonNegativeInteger if F has Finite
from Finite
sizeLess?: (%, %) -> Boolean
from EuclideanDomain
smaller?: (%, %) -> Boolean if F has Finite
from Comparable
squareFree: % -> Factored %
from UniqueFactorizationDomain
squareFreePart: % -> %
from UniqueFactorizationDomain
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
tableForDiscreteLogarithm: Integer -> Table(PositiveInteger, NonNegativeInteger) if F has Finite
from FiniteFieldCategory
trace: % -> F
trace(a) computes the trace of a with respect to the field considered as an algebra with 1 over the ground field F.
trace: (%, PositiveInteger) -> % if F has Finite
trace(a, d) computes the trace of a with respect to the field of extension degree d over the ground field of size q. Error: if d does not divide the extension degree of a. Note: trace(a, d) = reduce(+, [a^(q^(d*i)) for i in 0..n/d]).
transcendenceDegree: () -> NonNegativeInteger
from ExtensionField F
transcendent?: % -> Boolean
from ExtensionField F
unit?: % -> Boolean
from EntireRing
unitCanonical: % -> %
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %)
from EntireRing
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

BasicType

BiModule(%, %)

BiModule(F, F)

BiModule(Fraction Integer, Fraction Integer)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicNonZero if F has Finite or F has CharacteristicNonZero

CharacteristicZero if F has CharacteristicZero

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable if F has Finite

ConvertibleTo InputForm if F has Finite

DifferentialRing if F has Finite

DivisionRing

EntireRing

EuclideanDomain

ExtensionField F

Field

FieldOfPrimeCharacteristic if F has Finite or F has CharacteristicNonZero

Finite if F has Finite

FiniteFieldCategory if F has Finite

GcdDomain

IntegralDomain

LeftModule %

LeftModule F

LeftModule Fraction Integer

LeftOreRing

Magma

MagmaWithUnit

Module %

Module F

Module Fraction Integer

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PrincipalIdealDomain

RetractableTo F

RightModule %

RightModule F

RightModule Fraction Integer

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

StepThrough if F has Finite

UniqueFactorizationDomain

unitsKnown

VectorSpace F