AlgebraicallyClosedFunctionSpace(R)

algfunc.spad line 147 [edit on github]

• R : Join(Comparable, IntegralDomain)

Model for algebraically closed function spaces.

* : (%, %) -> %

from Magma

* : (%, R) -> %

from RightModule(R)

* : (%, Fraction(Integer)) -> %

from RightModule(Fraction(Integer))

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

from RightModule(Integer)

* : (R, %) -> %

from LeftModule(R)

* : (Fraction(Integer), %) -> %

from LeftModule(Fraction(Integer))

* : (Integer, %) -> %

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

/ : (%, %) -> %

from Group

/ : (SparseMultivariatePolynomial(R, Kernel(%)), SparseMultivariatePolynomial(R, Kernel(%))) -> %

from FunctionSpace2(R, Kernel(%))

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

D : (%, List(Symbol)) -> %

from PartialDifferentialRing(Symbol)

D : (%, List(Symbol), List(NonNegativeInteger)) -> %

from PartialDifferentialRing(Symbol)

D : (%, Symbol) -> %

from PartialDifferentialRing(Symbol)

D : (%, Symbol, NonNegativeInteger) -> %

from PartialDifferentialRing(Symbol)

^ : (%, Fraction(Integer)) -> %

from RadicalCategory

^ : (%, Integer) -> %

from Group

^ : (%, NonNegativeInteger) -> %

from MagmaWithUnit

^ : (%, PositiveInteger) -> %

from Magma

algtower : % -> List(Kernel(%))

from FunctionSpace2(R, Kernel(%))

algtower : List(%) -> List(Kernel(%))

from FunctionSpace2(R, Kernel(%))

annihilate? : (%, %) -> Boolean

from Rng

antiCommutator : (%, %) -> %

from NonAssociativeSemiRng

applyQuote : (Symbol, %) -> %

from FunctionSpace2(R, Kernel(%))

applyQuote : (Symbol, %, %) -> %

from FunctionSpace2(R, Kernel(%))

applyQuote : (Symbol, %, %, %) -> %

from FunctionSpace2(R, Kernel(%))

applyQuote : (Symbol, %, %, %, %) -> %

from FunctionSpace2(R, Kernel(%))

applyQuote : (Symbol, List(%)) -> %

from FunctionSpace2(R, Kernel(%))

associates? : (%, %) -> Boolean

from EntireRing

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

from NonAssociativeRng

belong? : BasicOperator -> Boolean

from ExpressionSpace2(Kernel(%))

box : % -> %

from ExpressionSpace2(Kernel(%))

characteristic : () -> NonNegativeInteger

from NonAssociativeRing

charthRoot : % -> Union(%, "failed") if R has CharacteristicNonZero

from CharacteristicNonZero

coerce : % -> %

from Algebra(%)

coerce : R -> %

from CoercibleFrom(R)

coerce : AlgebraicNumber -> % if R has RetractableTo(Integer)

from CoercibleFrom(AlgebraicNumber)

coerce : Fraction(R) -> %

from FunctionSpace2(R, Kernel(%))

coerce : Fraction(Integer) -> %

from CoercibleFrom(Fraction(Integer))

coerce : Fraction(Polynomial(R)) -> %

from CoercibleFrom(Fraction(Polynomial(R)))

coerce : Fraction(Polynomial(Fraction(R))) -> %

from FunctionSpace2(R, Kernel(%))

coerce : Integer -> %

from CoercibleFrom(Integer)

coerce : Kernel(%) -> %

from CoercibleFrom(Kernel(%))

coerce : Polynomial(R) -> %

from CoercibleFrom(Polynomial(R))

coerce : Polynomial(Fraction(R)) -> %

from FunctionSpace2(R, Kernel(%))

coerce : SparseMultivariatePolynomial(R, Kernel(%)) -> %

from FunctionSpace2(R, Kernel(%))

coerce : Symbol -> %

from CoercibleFrom(Symbol)

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

commutator : (%, %) -> %

from NonAssociativeRng

conjugate : (%, %) -> % if R has Group

from Group

convert : Factored(%) -> %

from FunctionSpace2(R, Kernel(%))

convert : % -> InputForm if R has ConvertibleTo(InputForm)

from ConvertibleTo(InputForm)

convert : % -> Pattern(Float) if R has ConvertibleTo(Pattern(Float))

from ConvertibleTo(Pattern(Float))

convert : % -> Pattern(Integer) if R has ConvertibleTo(Pattern(Integer))

from ConvertibleTo(Pattern(Integer))

definingPolynomial : % -> %

from ExpressionSpace2(Kernel(%))

denom : % -> SparseMultivariatePolynomial(R, Kernel(%))

from FunctionSpace2(R, Kernel(%))

denominator : % -> %

from FunctionSpace2(R, Kernel(%))

differentiate : (%, List(Symbol)) -> %

from PartialDifferentialRing(Symbol)

differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> %

from PartialDifferentialRing(Symbol)

differentiate : (%, Symbol) -> %

from PartialDifferentialRing(Symbol)

differentiate : (%, Symbol, NonNegativeInteger) -> %

from PartialDifferentialRing(Symbol)

distribute : % -> %

from ExpressionSpace2(Kernel(%))

distribute : (%, %) -> %

from ExpressionSpace2(Kernel(%))

divide : (%, %) -> Record(quotient : %, remainder : %)

from EuclideanDomain

elt : (BasicOperator, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, %, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, %, %, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, %, %, %, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, %, %, %, %, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, %, %, %, %, %, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, %, %, %, %, %, %, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, %, %, %, %, %, %, %, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, %, %, %, %, %, %, %, %, %) -> %

from ExpressionSpace2(Kernel(%))

elt : (BasicOperator, List(%)) -> %

from ExpressionSpace2(Kernel(%))

euclideanSize : % -> NonNegativeInteger

from EuclideanDomain

eval : (%, %, %) -> %

from InnerEvalable(%, %)

eval : (%, BasicOperator, %, Symbol) -> % if R has ConvertibleTo(InputForm)

from FunctionSpace2(R, Kernel(%))

eval : (%, BasicOperator, Mapping(%, %)) -> %

from ExpressionSpace2(Kernel(%))

eval : (%, BasicOperator, Mapping(%, List(%))) -> %

from ExpressionSpace2(Kernel(%))

eval : (%, Equation(%)) -> %

from Evalable(%)

eval : (%, Kernel(%), %) -> %

from InnerEvalable(Kernel(%), %)

eval : (%, List(%), List(%)) -> %

from InnerEvalable(%, %)

eval : (%, List(BasicOperator), List(%), Symbol) -> % if R has ConvertibleTo(InputForm)

from FunctionSpace2(R, Kernel(%))

eval : (%, List(BasicOperator), List(Mapping(%, %))) -> %

from ExpressionSpace2(Kernel(%))

eval : (%, List(BasicOperator), List(Mapping(%, List(%)))) -> %

from ExpressionSpace2(Kernel(%))

eval : (%, List(Equation(%))) -> %

from Evalable(%)

eval : (%, List(Kernel(%)), List(%)) -> %

from InnerEvalable(Kernel(%), %)

eval : (%, List(Symbol), List(Mapping(%, %))) -> %

from ExpressionSpace2(Kernel(%))

eval : (%, List(Symbol), List(Mapping(%, List(%)))) -> %

from ExpressionSpace2(Kernel(%))

eval : (%, List(Symbol), List(NonNegativeInteger), List(Mapping(%, %))) -> %

from FunctionSpace2(R, Kernel(%))

eval : (%, List(Symbol), List(NonNegativeInteger), List(Mapping(%, List(%)))) -> %

from FunctionSpace2(R, Kernel(%))

eval : (%, Symbol, Mapping(%, %)) -> %

from ExpressionSpace2(Kernel(%))

eval : (%, Symbol, Mapping(%, List(%))) -> %

from ExpressionSpace2(Kernel(%))

eval : (%, Symbol, NonNegativeInteger, Mapping(%, %)) -> %

from FunctionSpace2(R, Kernel(%))

eval : (%, Symbol, NonNegativeInteger, Mapping(%, List(%))) -> %

from FunctionSpace2(R, Kernel(%))

even? : % -> Boolean if % has RetractableTo(Integer)

from ExpressionSpace2(Kernel(%))

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

factor : % -> Factored(%)

from UniqueFactorizationDomain

freeOf? : (%, %) -> Boolean

from ExpressionSpace2(Kernel(%))

freeOf? : (%, Symbol) -> Boolean

from ExpressionSpace2(Kernel(%))

gcd : (%, %) -> %

from GcdDomain

gcd : List(%) -> %

from GcdDomain

gcdPolynomial : (SparseUnivariatePolynomial(%), SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%)

from GcdDomain

ground : % -> R

from FunctionSpace2(R, Kernel(%))

ground? : % -> Boolean

from FunctionSpace2(R, Kernel(%))

height : % -> NonNegativeInteger

from ExpressionSpace2(Kernel(%))

inv : % -> %

from Group

is? : (%, BasicOperator) -> Boolean

from ExpressionSpace2(Kernel(%))

is? : (%, Symbol) -> Boolean

from ExpressionSpace2(Kernel(%))

isExpt : % -> Union(Record(var : Kernel(%), exponent : Integer), "failed")

from FunctionSpace2(R, Kernel(%))

isExpt : (%, BasicOperator) -> Union(Record(var : Kernel(%), exponent : Integer), "failed")

from FunctionSpace2(R, Kernel(%))

isExpt : (%, Symbol) -> Union(Record(var : Kernel(%), exponent : Integer), "failed")

from FunctionSpace2(R, Kernel(%))

isMult : % -> Union(Record(coef : Integer, var : Kernel(%)), "failed")

from FunctionSpace2(R, Kernel(%))

isPlus : % -> Union(List(%), "failed")

from FunctionSpace2(R, Kernel(%))

isPower : % -> Union(Record(val : %, exponent : Integer), "failed")

from FunctionSpace2(R, Kernel(%))

isTimes : % -> Union(List(%), "failed")

from FunctionSpace2(R, Kernel(%))

kernel : (BasicOperator, %) -> %

from ExpressionSpace2(Kernel(%))

kernel : (BasicOperator, List(%)) -> %

from ExpressionSpace2(Kernel(%))

kernels : % -> List(Kernel(%))

from ExpressionSpace2(Kernel(%))

kernels : List(%) -> List(Kernel(%))

from ExpressionSpace2(Kernel(%))

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

mainKernel : % -> Union(Kernel(%), "failed")

from ExpressionSpace2(Kernel(%))

map : (Mapping(%, %), Kernel(%)) -> %

from ExpressionSpace2(Kernel(%))

minPoly : Kernel(%) -> SparseUnivariatePolynomial(%)

from ExpressionSpace2(Kernel(%))

multiEuclidean : (List(%), %) -> Union(List(%), "failed")

from EuclideanDomain

nthRoot : (%, Integer) -> %

from RadicalCategory

numer : % -> SparseMultivariatePolynomial(R, Kernel(%))

from FunctionSpace2(R, Kernel(%))

numerator : % -> %

from FunctionSpace2(R, Kernel(%))

odd? : % -> Boolean if % has RetractableTo(Integer)

from ExpressionSpace2(Kernel(%))

one? : % -> Boolean

from MagmaWithUnit

operator : BasicOperator -> BasicOperator

from ExpressionSpace2(Kernel(%))

operators : % -> List(BasicOperator)

from ExpressionSpace2(Kernel(%))

opposite? : (%, %) -> Boolean

from AbelianMonoid

paren : % -> %

from ExpressionSpace2(Kernel(%))

patternMatch : (%, Pattern(Float), PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if R has PatternMatchable(Float)

from PatternMatchable(Float)

patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if R has PatternMatchable(Integer)

from PatternMatchable(Integer)

plenaryPower : (%, PositiveInteger) -> %

from NonAssociativeAlgebra(R)

prime? : % -> Boolean

from UniqueFactorizationDomain

principalIdeal : List(%) -> Record(coef : List(%), generator : %)

from PrincipalIdealDomain

quo : (%, %) -> %

from EuclideanDomain

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

from MagmaWithUnit

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)

rem : (%, %) -> %

from EuclideanDomain

retract : % -> R

from RetractableTo(R)

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

from RetractableTo(AlgebraicNumber)

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

from RetractableTo(Fraction(Integer))

retract : % -> Fraction(Polynomial(R))

from RetractableTo(Fraction(Polynomial(R)))

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

from RetractableTo(Integer)

retract : % -> Kernel(%)

from RetractableTo(Kernel(%))

retract : % -> Polynomial(R)

from RetractableTo(Polynomial(R))

retract : % -> Symbol

from RetractableTo(Symbol)

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

from RetractableTo(R)

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

from RetractableTo(AlgebraicNumber)

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

from RetractableTo(Fraction(Integer))

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

from RetractableTo(Fraction(Polynomial(R)))

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

from RetractableTo(Integer)

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

from RetractableTo(Kernel(%))

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

from RetractableTo(Polynomial(R))

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

from RetractableTo(Symbol)

rightPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower : (%, PositiveInteger) -> %

from Magma

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

from MagmaWithUnit

rootOf : % -> %

rootOf(p) returns y such that p(y) = 0. Error: if p has more than one variable y.

rootOf : (%, Symbol) -> %

rootOf(p, y) returns y such that p(y) = 0. The object returned displays as 'y.

rootOf : Polynomial(%) -> %

from AlgebraicallyClosedField

rootOf : SparseUnivariatePolynomial(%) -> %

from AlgebraicallyClosedField

rootOf : (SparseUnivariatePolynomial(%), Symbol) -> %

from AlgebraicallyClosedField

rootSum : (%, SparseUnivariatePolynomial(%), Symbol) -> %

rootsOf : % -> List(%)

rootsOf(p, y) returns [y1, ..., yn] such that p(yi) = 0; Note: the returned values y1, ..., yn contain new symbols which are bound in the interpreter to the respective values. Error: if p has more than one variable y.

rootsOf : (%, Symbol) -> List(%)

rootsOf(p, y) returns [y1, ..., yn] such that p(yi) = 0; The returned roots contain new symbols '%z0, '%z1 ...; Note: the new symbols are bound in the interpreter to the respective values.

rootsOf : Polynomial(%) -> List(%)

from AlgebraicallyClosedField

rootsOf : SparseUnivariatePolynomial(%) -> List(%)

from AlgebraicallyClosedField

rootsOf : (SparseUnivariatePolynomial(%), Symbol) -> List(%)

from AlgebraicallyClosedField

sample : () -> %

from AbelianMonoid

sizeLess? : (%, %) -> Boolean

from EuclideanDomain

smaller? : (%, %) -> Boolean

from Comparable

sqrt : % -> %

from RadicalCategory

squareFree : % -> Factored(%)

from UniqueFactorizationDomain

squareFreePart : % -> %

from UniqueFactorizationDomain

subst : (%, Equation(%)) -> %

from ExpressionSpace2(Kernel(%))

subst : (%, List(Equation(%))) -> %

from ExpressionSpace2(Kernel(%))

subst : (%, List(Kernel(%)), List(%)) -> %

from ExpressionSpace2(Kernel(%))

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

from CancellationAbelianMonoid

tower : % -> List(Kernel(%))

from ExpressionSpace2(Kernel(%))

tower : List(%) -> List(Kernel(%))

from ExpressionSpace2(Kernel(%))

unit? : % -> Boolean

from EntireRing

unitCanonical : % -> %

from EntireRing

unitNormal : % -> Record(unit : %, canonical : %, associate : %)

from EntireRing

univariate : (%, Kernel(%)) -> Fraction(SparseUnivariatePolynomial(%))

from FunctionSpace2(R, Kernel(%))

variables : % -> List(Symbol)

from FunctionSpace2(R, Kernel(%))

variables : List(%) -> List(Symbol)

from FunctionSpace2(R, Kernel(%))

zero? : % -> Boolean

from AbelianMonoid

zeroOf : % -> %

zeroOf(p) returns y such that p(y) = 0. The value y is expressed in terms of radicals if possible, and otherwise as an implicit algebraic quantity. Error: if p has more than one variable.

zeroOf : (%, Symbol) -> %

zeroOf(p, y) returns y such that p(y) = 0. The value y is expressed in terms of radicals if possible, and otherwise as an implicit algebraic quantity which displays as 'y.

zeroOf : Polynomial(%) -> %

from AlgebraicallyClosedField

zeroOf : SparseUnivariatePolynomial(%) -> %

from AlgebraicallyClosedField

zeroOf : (SparseUnivariatePolynomial(%), Symbol) -> %

from AlgebraicallyClosedField

zerosOf : % -> List(%)

zerosOf(p) returns [y1, ..., yn] such that p(yi) = 0. The yi's are expressed in radicals if possible. Note: the returned values y1, ..., yn contain new symbols which are bound in the interpreter to the respective values. Error: if p has more than one variable.

zerosOf : (%, Symbol) -> List(%)

zerosOf(p, y) returns [y1, ..., yn] such that p(yi) = 0. The yi's are expressed in radicals if possible, and otherwise as implicit algebraic quantities containing new symbols which display as '%z0, '%z1, ...; The new symbols are bound in the interpreter to the respective values.

zerosOf : Polynomial(%) -> List(%)

from AlgebraicallyClosedField

zerosOf : SparseUnivariatePolynomial(%) -> List(%)

from AlgebraicallyClosedField

zerosOf : (SparseUnivariatePolynomial(%), Symbol) -> List(%)

from AlgebraicallyClosedField

~= : (%, %) -> Boolean

from BasicType

Module(Fraction(Integer))

PrincipalIdealDomain

NonAssociativeSemiRing

LeftModule(R)

BiModule(%, %)

RetractableTo(Symbol)

ConvertibleTo(InputForm)

Field

canonicalUnitNormal

Rng

CoercibleFrom(Integer)

FullyRetractableTo(R)

SemiRing

EntireRing

PatternMatchable(Float)

NonAssociativeAlgebra(Fraction(Integer))

unitsKnown

RadicalCategory

FullyLinearlyExplicitOver(R)

NonAssociativeRng

CharacteristicNonZero

RetractableTo(Fraction(Polynomial(R)))

PartialDifferentialRing(Symbol)

CoercibleFrom(R)

InnerEvalable(%, %)

SemiGroup

RightModule(Fraction(Integer))

CoercibleFrom(AlgebraicNumber)

Magma

RightModule(R)

GcdDomain

IntegralDomain

LeftModule(%)

NonAssociativeRing

UniqueFactorizationDomain

ExpressionSpace2(Kernel(%))

CharacteristicZero

RetractableTo(Kernel(%))

Algebra(%)

Module(R)

FunctionSpace(R)

CoercibleFrom(Fraction(Integer))

BiModule(R, R)

DivisionRing

Algebra(R)

CommutativeRing

canonicalsClosed

LinearlyExplicitOver(R)

NonAssociativeSemiRng

CancellationAbelianMonoid

EuclideanDomain

Comparable

TwoSidedRecip

Group

RetractableTo(Integer)

AlgebraicallyClosedField

FunctionSpace2(R, Kernel(%))

ExpressionSpace

CommutativeStar

AbelianMonoid

MagmaWithUnit

SemiRng

CoercibleFrom(Symbol)

RightModule(%)

CoercibleFrom(Polynomial(R))

InnerEvalable(Kernel(%), %)

CoercibleFrom(Kernel(%))

Module(%)

ConvertibleTo(Pattern(Float))

LinearlyExplicitOver(Integer)

CoercibleTo(OutputForm)

RetractableTo(AlgebraicNumber)

ConvertibleTo(Pattern(Integer))

Patternable(R)

Monoid

LeftOreRing

NonAssociativeAlgebra(%)

Algebra(Fraction(Integer))

BasicType

RetractableTo(Polynomial(R))

Ring

RightModule(Integer)

LeftModule(Fraction(Integer))

AbelianSemiGroup

SetCategory

noZeroDivisors

CoercibleFrom(Fraction(Polynomial(R)))

PatternMatchable(Integer)

Evalable(%)

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

FullyPatternMatchable(R)

RetractableTo(R)

AbelianGroup

RetractableTo(Fraction(Integer))

NonAssociativeAlgebra(R)