SimpleAlgebraicExtension(R, UP, M)

algext.spad line 1 [edit on github]

• R : CommutativeRing
• UP : UnivariatePolynomialCategory(R)
• 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.

* : (%, %) -> %

from Magma

* : (%, R) -> %

from RightModule(R)

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

from RightModule(Fraction(Integer))

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

from RightModule(Integer)

* : (R, %) -> %

from LeftModule(R)

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

from LeftModule(Fraction(Integer))

* : (Integer, %) -> %

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

/ : (%, %) -> % if R has Field

from Field

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

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

from DifferentialExtension(R)

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

from DifferentialExtension(R)

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

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

from DivisionRing

^ : (%, NonNegativeInteger) -> %

from MagmaWithUnit

^ : (%, PositiveInteger) -> %

from Magma

annihilate? : (%, %) -> Boolean

from Rng

antiCommutator : (%, %) -> %

from NonAssociativeSemiRng

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

from PolynomialFactorizationExplicit

coerce : % -> %

from Algebra(%)

coerce : R -> %

from Algebra(R)

coerce : Fraction(Integer) -> % if R has RetractableTo(Fraction(Integer)) or R has Field

from Algebra(Fraction(Integer))

coerce : Integer -> %

from NonAssociativeRing

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

commutator : (%, %) -> %

from NonAssociativeRng

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

from PolynomialFactorizationExplicit

convert : UP -> %

from MonogenicAlgebra(R, UP)

convert : Vector(R) -> %

from FramedModule(R)

convert : % -> UP

from ConvertibleTo(UP)

convert : % -> InputForm if R has Finite

from ConvertibleTo(InputForm)

convert : % -> Vector(R)

from FramedModule(R)

coordinates : Vector(%) -> Matrix(R)

from FramedModule(R)

coordinates : (Vector(%), Vector(%)) -> Matrix(R)

from FiniteRankAlgebra(R, UP)

coordinates : % -> Vector(R)

from FramedModule(R)

coordinates : (%, Vector(%)) -> Vector(R)

from FiniteRankAlgebra(R, UP)

createPrimitiveElement : () -> % if R has FiniteFieldCategory

from FiniteFieldCategory

definingPolynomial : () -> UP

from MonogenicAlgebra(R, UP)

derivationCoordinates : (Vector(%), Mapping(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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

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

from DifferentialExtension(R)

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

from DifferentialExtension(R)

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

discreteLog : % -> NonNegativeInteger if R has FiniteFieldCategory

from FiniteFieldCategory

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

from FieldOfPrimeCharacteristic

discriminant : () -> R

from FramedAlgebra(R, UP)

discriminant : Vector(%) -> R

from FiniteRankAlgebra(R, UP)

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

from EuclideanDomain

enumerate : () -> List(%) if R has Finite

from Finite

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

factor : % -> Factored(%) if R has Field

from UniqueFactorizationDomain

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

from PolynomialFactorizationExplicit

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

from PolynomialFactorizationExplicit

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

from FiniteFieldCategory

gcd : (%, %) -> % if R has Field

from GcdDomain

gcd : List(%) -> % if R has Field

from GcdDomain

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

lcm : (%, %) -> % if R has Field

from GcdDomain

lcm : List(%) -> % if R has Field

from GcdDomain

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

from FieldOfPrimeCharacteristic

order : % -> PositiveInteger if R has FiniteFieldCategory

from FiniteFieldCategory

plenaryPower : (%, PositiveInteger) -> %

from NonAssociativeAlgebra(%)

prime? : % -> Boolean if R has Field

from UniqueFactorizationDomain

primeFrobenius : % -> % if R has FiniteFieldCategory

from FieldOfPrimeCharacteristic

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

from FieldOfPrimeCharacteristic

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

random : () -> % if R has Finite

from Finite

rank : () -> PositiveInteger

from FiniteRankAlgebra(R, UP)

recip : % -> Union(%, "failed")

from MagmaWithUnit

reduce : UP -> %

from MonogenicAlgebra(R, UP)

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

from MonogenicAlgebra(R, UP)

reducedSystem : Matrix(%) -> Matrix(R)

from LinearlyExplicitOver(R)

reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer)

from LinearlyExplicitOver(Integer)

reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(R), vec : Vector(R))

from LinearlyExplicitOver(R)

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

from LinearlyExplicitOver(Integer)

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) -> %

from FramedModule(R)

represents : (Vector(R), Vector(%)) -> %

from FiniteRankAlgebra(R, UP)

retract : % -> R

from RetractableTo(R)

retract : % -> Fraction(Integer) if R has RetractableTo(Fraction(Integer))

from RetractableTo(Fraction(Integer))

retract : % -> Integer if R has RetractableTo(Integer)

from RetractableTo(Integer)

retractIfCan : % -> Union(R, "failed")

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)

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

from PolynomialFactorizationExplicit

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

from UniqueFactorizationDomain

squareFreePart : % -> % if R has Field

from UniqueFactorizationDomain

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

from PolynomialFactorizationExplicit

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

from CancellationAbelianMonoid

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

~= : (%, %) -> Boolean

from BasicType

ConvertibleTo(UP)

Module(Fraction(Integer))

PrincipalIdealDomain

NonAssociativeSemiRing

LeftModule(R)

BiModule(%, %)

ConvertibleTo(InputForm)

Field

canonicalUnitNormal

Rng

BiModule(R, R)

CoercibleFrom(Integer)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

EntireRing

NonAssociativeAlgebra(Fraction(Integer))

unitsKnown

FullyLinearlyExplicitOver(R)

NonAssociativeSemiRng

CharacteristicNonZero

SetCategory

MagmaWithUnit

noZeroDivisors

RetractableTo(Fraction(Integer))

RightModule(%)

UniqueFactorizationDomain

SemiGroup

RightModule(Fraction(Integer))

Magma

RightModule(R)

GcdDomain

IntegralDomain

LeftModule(%)

NonAssociativeRing

NonAssociativeAlgebra(%)

MonogenicAlgebra(R, UP)

PartialDifferentialRing(Symbol)

CharacteristicZero

Module(R)

CommutativeRing

Ring

Algebra(%)

DifferentialRing

FieldOfPrimeCharacteristic

DivisionRing

DifferentialExtension(R)

CancellationAbelianMonoid

EuclideanDomain

canonicalsClosed

RetractableTo(Integer)

CommutativeStar

AbelianMonoid

Comparable

Hashable

FiniteRankAlgebra(R, UP)

StepThrough

Module(%)

LinearlyExplicitOver(Integer)

FramedAlgebra(R, UP)

CoercibleTo(OutputForm)

SemiRng

Monoid

PolynomialFactorizationExplicit

FiniteFieldCategory

LeftOreRing

Algebra(R)

FramedModule(R)

Finite

Algebra(Fraction(Integer))

BasicType

RightModule(Integer)

LeftModule(Fraction(Integer))

AbelianSemiGroup

CoercibleFrom(Fraction(Integer))

LinearlyExplicitOver(R)

NonAssociativeRng

CoercibleFrom(R)

BiModule(Fraction(Integer), Fraction(Integer))

RetractableTo(R)

AbelianGroup

NonAssociativeAlgebra(R)