# SimpleAlgebraicExtension(R, UP, M)ΒΆ

algext.spad line 1 [edit on github]

M: UP

Domain which represents simple algebraic extensions of arbitrary rings. The first argument to the domain, `R`

, is the underlying ring, the second argument is a domain of univariate polynomials over `R`

, while the last argument specifies the defining minimal polynomial. The elements of the domain are canonically represented as polynomials of degree less than that of the minimal polynomial with coefficients in `R`

. The second argument is both the type of the third argument and the underlying representation used by SAE itself.

- 0: %
from AbelianMonoid

- 1: %
from MagmaWithUnit

- *: (%, %) -> %
from Magma

- *: (%, Fraction Integer) -> % if R has Field
from RightModule Fraction Integer

- *: (%, Integer) -> % if R has LinearlyExplicitOver Integer
from RightModule Integer

- *: (%, R) -> %
from RightModule R

- *: (Fraction Integer, %) -> % if R has Field
from LeftModule Fraction Integer

- *: (Integer, %) -> %
from AbelianGroup

- *: (NonNegativeInteger, %) -> %
from AbelianMonoid

- *: (PositiveInteger, %) -> %
from AbelianSemiGroup

- *: (R, %) -> %
from LeftModule R

- +: (%, %) -> %
from AbelianSemiGroup

- -: % -> %
from AbelianGroup

- -: (%, %) -> %
from AbelianGroup

- ^: (%, Integer) -> % if R has Field
from DivisionRing

- ^: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- ^: (%, PositiveInteger) -> %
from Magma

- annihilate?: (%, %) -> Boolean
from Rng

- antiCommutator: (%, %) -> %

- associates?: (%, %) -> Boolean if R has Field
from EntireRing

- associator: (%, %, %) -> %
from NonAssociativeRng

- basis: () -> Vector %
from FramedModule R

- characteristic: () -> NonNegativeInteger
from NonAssociativeRing

- characteristicPolynomial: % -> UP
from FiniteRankAlgebra(R, UP)

- charthRoot: % -> % if R has FiniteFieldCategory
from FiniteFieldCategory

- charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero or % has CharacteristicNonZero and R has PolynomialFactorizationExplicit and R has Field

- coerce: % -> %
from Algebra %

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: Fraction Integer -> % if R has RetractableTo Fraction Integer or R has Field
- coerce: Integer -> %
from NonAssociativeRing

- coerce: R -> %
from Algebra R

- commutator: (%, %) -> %
from NonAssociativeRng

- conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit and R has Field or R has FiniteFieldCategory

- convert: % -> InputForm if R has Finite
from ConvertibleTo InputForm

- convert: % -> UP
from ConvertibleTo UP

- convert: % -> Vector R
from FramedModule R

- convert: UP -> %
from MonogenicAlgebra(R, UP)

- convert: Vector R -> %
from FramedModule R

- coordinates: % -> Vector R
from FramedModule R

- coordinates: (%, Vector %) -> Vector R
from FiniteRankAlgebra(R, UP)

- coordinates: (Vector %, Vector %) -> Matrix R
from FiniteRankAlgebra(R, UP)

- coordinates: Vector % -> Matrix R
from FramedModule R

- createPrimitiveElement: () -> % if R has FiniteFieldCategory
from FiniteFieldCategory

- D: % -> % if R has FiniteFieldCategory or R has DifferentialRing and R has Field
from DifferentialRing

- D: (%, List Symbol) -> % if R has PartialDifferentialRing Symbol and R has Field
- D: (%, List Symbol, List NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol and R has Field
- D: (%, NonNegativeInteger) -> % if R has FiniteFieldCategory or R has DifferentialRing and R has Field
from DifferentialRing

- D: (%, R -> R) -> % if R has Field
from DifferentialExtension R

- D: (%, R -> R, NonNegativeInteger) -> % if R has Field
from DifferentialExtension R

- D: (%, Symbol) -> % if R has PartialDifferentialRing Symbol and R has Field
- D: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol and R has Field

- definingPolynomial: () -> UP
from MonogenicAlgebra(R, UP)

- derivationCoordinates: (Vector %, R -> R) -> Matrix R if R has Field
from MonogenicAlgebra(R, UP)

- differentiate: % -> % if R has FiniteFieldCategory or R has DifferentialRing and R has Field
from DifferentialRing

- differentiate: (%, List Symbol) -> % if R has PartialDifferentialRing Symbol and R has Field
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol and R has Field
- differentiate: (%, NonNegativeInteger) -> % if R has FiniteFieldCategory or R has DifferentialRing and R has Field
from DifferentialRing

- differentiate: (%, R -> R) -> % if R has Field
from DifferentialExtension R

- differentiate: (%, R -> R, NonNegativeInteger) -> % if R has Field
from DifferentialExtension R

- differentiate: (%, Symbol) -> % if R has PartialDifferentialRing Symbol and R has Field
- differentiate: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol and R has Field

- discreteLog: % -> NonNegativeInteger if R has FiniteFieldCategory
from FiniteFieldCategory

- discreteLog: (%, %) -> Union(NonNegativeInteger, failed) if R has FiniteFieldCategory

- discriminant: () -> R
from FramedAlgebra(R, UP)

- discriminant: Vector % -> R
from FiniteRankAlgebra(R, UP)

- divide: (%, %) -> Record(quotient: %, remainder: %) if R has Field
from EuclideanDomain

- euclideanSize: % -> NonNegativeInteger if R has Field
from EuclideanDomain

- expressIdealMember: (List %, %) -> Union(List %, failed) if R has Field
from PrincipalIdealDomain

- exquo: (%, %) -> Union(%, failed) if R has Field
from EntireRing

- extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %) if R has Field
from EuclideanDomain

- extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed) if R has Field
from EuclideanDomain

- factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit and R has Field or R has FiniteFieldCategory

- factorsOfCyclicGroupSize: () -> List Record(factor: Integer, exponent: NonNegativeInteger) if R has FiniteFieldCategory
from FiniteFieldCategory

- factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit and R has Field or R has FiniteFieldCategory

- gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial % if R has Field
from GcdDomain

- generator: () -> %
from MonogenicAlgebra(R, UP)

- hash: % -> SingleInteger
from Hashable

- hashUpdate!: (HashState, %) -> HashState
from Hashable

- index: PositiveInteger -> % if R has Finite
from Finite

- init: % if R has FiniteFieldCategory
from StepThrough

- inv: % -> % if R has Field
from DivisionRing

- latex: % -> String
from SetCategory

- lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %) if R has Field
from LeftOreRing

- leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- leftPower: (%, PositiveInteger) -> %
from Magma

- leftRecip: % -> Union(%, failed)
from MagmaWithUnit

- lift: % -> UP
from MonogenicAlgebra(R, UP)

- lookup: % -> PositiveInteger if R has Finite
from Finite

- minimalPolynomial: % -> UP if R has Field
from FiniteRankAlgebra(R, UP)

- multiEuclidean: (List %, %) -> Union(List %, failed) if R has Field
from EuclideanDomain

- nextItem: % -> Union(%, failed) if R has FiniteFieldCategory
from StepThrough

- norm: % -> R
from FiniteRankAlgebra(R, UP)

- one?: % -> Boolean
from MagmaWithUnit

- opposite?: (%, %) -> Boolean
from AbelianMonoid

- order: % -> OnePointCompletion PositiveInteger if R has FiniteFieldCategory
- order: % -> PositiveInteger if R has FiniteFieldCategory
from FiniteFieldCategory

- plenaryPower: (%, PositiveInteger) -> %
from NonAssociativeAlgebra %

- primeFrobenius: % -> % if R has FiniteFieldCategory
- primeFrobenius: (%, NonNegativeInteger) -> % if R has FiniteFieldCategory

- primitive?: % -> Boolean if R has FiniteFieldCategory
from FiniteFieldCategory

- primitiveElement: () -> % if R has FiniteFieldCategory
from FiniteFieldCategory

- principalIdeal: List % -> Record(coef: List %, generator: %) if R has Field
from PrincipalIdealDomain

- quo: (%, %) -> % if R has Field
from EuclideanDomain

- rank: () -> PositiveInteger
from FiniteRankAlgebra(R, UP)

- recip: % -> Union(%, failed)
from MagmaWithUnit

- reduce: Fraction UP -> Union(%, failed) if R has Field
from MonogenicAlgebra(R, UP)

- reduce: UP -> %
from MonogenicAlgebra(R, UP)

- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
from LinearlyExplicitOver R

- reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
- reducedSystem: Matrix % -> Matrix R
from LinearlyExplicitOver R

- regularRepresentation: % -> Matrix R
from FramedAlgebra(R, UP)

- regularRepresentation: (%, Vector %) -> Matrix R
from FiniteRankAlgebra(R, UP)

- rem: (%, %) -> % if R has Field
from EuclideanDomain

- representationType: () -> Union(prime, polynomial, normal, cyclic) if R has FiniteFieldCategory
from FiniteFieldCategory

- represents: (Vector R, Vector %) -> %
from FiniteRankAlgebra(R, UP)

- represents: Vector R -> %
from FramedModule R

- retract: % -> Fraction Integer if R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retract: % -> Integer if R has RetractableTo Integer
from RetractableTo Integer

- retract: % -> R
from RetractableTo R

- retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer
from RetractableTo Integer

- retractIfCan: % -> Union(R, failed)
from RetractableTo R

- rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- rightPower: (%, PositiveInteger) -> %
from Magma

- rightRecip: % -> Union(%, failed)
from MagmaWithUnit

- sample: %
from AbelianMonoid

- size: () -> NonNegativeInteger if R has Finite
from Finite

- sizeLess?: (%, %) -> Boolean if R has Field
from EuclideanDomain

- smaller?: (%, %) -> Boolean if R has Finite
from Comparable

- solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if R has PolynomialFactorizationExplicit and R has Field or R has FiniteFieldCategory

- squareFree: % -> Factored % if R has Field

- squareFreePart: % -> % if R has Field

- squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit and R has Field or R has FiniteFieldCategory

- subtractIfCan: (%, %) -> Union(%, failed)

- tableForDiscreteLogarithm: Integer -> Table(PositiveInteger, NonNegativeInteger) if R has FiniteFieldCategory
from FiniteFieldCategory

- trace: % -> R
from FiniteRankAlgebra(R, UP)

- traceMatrix: () -> Matrix R
from FramedAlgebra(R, UP)

- traceMatrix: Vector % -> Matrix R
from FiniteRankAlgebra(R, UP)

- unit?: % -> Boolean if R has Field
from EntireRing

- unitCanonical: % -> % if R has Field
from EntireRing

- unitNormal: % -> Record(unit: %, canonical: %, associate: %) if R has Field
from EntireRing

- zero?: % -> Boolean
from AbelianMonoid

Algebra %

Algebra Fraction Integer if R has Field

Algebra R

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer) if R has Field

BiModule(R, R)

canonicalsClosed if R has Field

canonicalUnitNormal if R has Field

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleFrom Fraction Integer if R has RetractableTo Fraction Integer

CoercibleFrom Integer if R has RetractableTo Integer

Comparable if R has Finite

ConvertibleTo InputForm if R has Finite

DifferentialExtension R if R has Field

DifferentialRing if R has FiniteFieldCategory or R has DifferentialRing and R has Field

DivisionRing if R has Field

EntireRing if R has Field

EuclideanDomain if R has Field

FieldOfPrimeCharacteristic if R has FiniteFieldCategory

FiniteFieldCategory if R has FiniteFieldCategory

FiniteRankAlgebra(R, UP)

FramedAlgebra(R, UP)

IntegralDomain if R has Field

LeftModule Fraction Integer if R has Field

LeftOreRing if R has Field

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

Module %

Module Fraction Integer if R has Field

Module R

MonogenicAlgebra(R, UP)

NonAssociativeAlgebra Fraction Integer if R has Field

noZeroDivisors if R has Field

PartialDifferentialRing Symbol if R has PartialDifferentialRing Symbol and R has Field

PolynomialFactorizationExplicit if R has FiniteFieldCategory or R has PolynomialFactorizationExplicit and R has Field

PrincipalIdealDomain if R has Field

RetractableTo Fraction Integer if R has RetractableTo Fraction Integer

RetractableTo Integer if R has RetractableTo Integer

RightModule Fraction Integer if R has Field

RightModule Integer if R has LinearlyExplicitOver Integer

StepThrough if R has FiniteFieldCategory

UniqueFactorizationDomain if R has Field