AlgebraicFunctionField(F, UP, UPUP, modulus)ΒΆ

curve.spad line 755

Function field defined by f(x, y) = 0.

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (%, Fraction Integer) -> %
from RightModule Fraction Integer
*: (%, Fraction UP) -> %
from RightModule Fraction UP
*: (Fraction Integer, %) -> %
from LeftModule Fraction Integer
*: (Fraction UP, %) -> %
from LeftModule Fraction UP
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
/: (%, %) -> %
from Field
=: (%, %) -> Boolean
from BasicType
^: (%, Integer) -> %
from DivisionRing
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
~=: (%, %) -> Boolean
from BasicType
absolutelyIrreducible?: () -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
algSplitSimple: (%, UP -> UP) -> Record(num: %, den: UP, derivden: UP, gd: UP)
from FunctionFieldCategory(F, UP, UPUP)
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
associates?: (%, %) -> Boolean
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
basis: () -> Vector %
from FramedModule Fraction UP
branchPoint?: F -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
branchPoint?: UP -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
branchPointAtInfinity?: () -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
characteristicPolynomial: % -> UPUP
from FiniteRankAlgebra(Fraction UP, UPUP)
charthRoot: % -> % if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
charthRoot: % -> Union(%, failed) if Fraction UP has CharacteristicNonZero
from CharacteristicNonZero
coerce: % -> %
from Algebra %
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: Fraction Integer -> %
from RetractableTo Fraction Integer
coerce: Fraction UP -> %
from Algebra Fraction UP
coerce: Integer -> %
from NonAssociativeRing
commutator: (%, %) -> %
from NonAssociativeRng
complementaryBasis: Vector % -> Vector %
from FunctionFieldCategory(F, UP, UPUP)
conditionP: Matrix % -> Union(Vector %, failed) if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
convert: % -> InputForm if Fraction UP has Finite
from ConvertibleTo InputForm
convert: % -> UPUP
from ConvertibleTo UPUP
convert: % -> Vector Fraction UP
from FramedModule Fraction UP
convert: UPUP -> %
from MonogenicAlgebra(Fraction UP, UPUP)
convert: Vector Fraction UP -> %
from FramedModule Fraction UP
coordinates: % -> Vector Fraction UP
from FramedModule Fraction UP
coordinates: (%, Vector %) -> Vector Fraction UP
from FiniteRankAlgebra(Fraction UP, UPUP)
coordinates: (Vector %, Vector %) -> Matrix Fraction UP
from FiniteRankAlgebra(Fraction UP, UPUP)
coordinates: Vector % -> Matrix Fraction UP
from FramedModule Fraction UP
createPrimitiveElement: () -> % if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
D: % -> % if Fraction UP has DifferentialRing
from DifferentialRing
D: (%, Fraction UP -> Fraction UP) -> %
from DifferentialExtension Fraction UP
D: (%, Fraction UP -> Fraction UP, NonNegativeInteger) -> %
from DifferentialExtension Fraction UP
D: (%, List Symbol) -> % if Fraction UP has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
D: (%, List Symbol, List NonNegativeInteger) -> % if Fraction UP has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
D: (%, NonNegativeInteger) -> % if Fraction UP has DifferentialRing
from DifferentialRing
D: (%, Symbol) -> % if Fraction UP has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
D: (%, Symbol, NonNegativeInteger) -> % if Fraction UP has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
definingPolynomial: () -> UPUP
from MonogenicAlgebra(Fraction UP, UPUP)
derivationCoordinates: (Vector %, Fraction UP -> Fraction UP) -> Matrix Fraction UP
from MonogenicAlgebra(Fraction UP, UPUP)
differentiate: % -> % if Fraction UP has DifferentialRing
from DifferentialRing
differentiate: (%, Fraction UP -> Fraction UP) -> %
from DifferentialExtension Fraction UP
differentiate: (%, Fraction UP -> Fraction UP, NonNegativeInteger) -> %
from DifferentialExtension Fraction UP
differentiate: (%, List Symbol) -> % if Fraction UP has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, List Symbol, List NonNegativeInteger) -> % if Fraction UP has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, NonNegativeInteger) -> % if Fraction UP has DifferentialRing
from DifferentialRing
differentiate: (%, Symbol) -> % if Fraction UP has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, Symbol, NonNegativeInteger) -> % if Fraction UP has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, UP -> UP) -> %
from FunctionFieldCategory(F, UP, UPUP)
discreteLog: % -> NonNegativeInteger if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
discreteLog: (%, %) -> Union(NonNegativeInteger, failed) if Fraction UP has FiniteFieldCategory
from FieldOfPrimeCharacteristic
discriminant: () -> Fraction UP
from FramedAlgebra(Fraction UP, UPUP)
discriminant: Vector % -> Fraction UP
from FiniteRankAlgebra(Fraction UP, UPUP)
divide: (%, %) -> Record(quotient: %, remainder: %)
from EuclideanDomain
elliptic: () -> Union(UP, failed)
from FunctionFieldCategory(F, UP, UPUP)
elt: (%, F, F) -> F
from FunctionFieldCategory(F, UP, UPUP)
enumerate: () -> List % if Fraction UP 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
factor: % -> Factored %
from UniqueFactorizationDomain
factorsOfCyclicGroupSize: () -> List Record(factor: Integer, exponent: Integer) if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
gcd: (%, %) -> %
from GcdDomain
gcd: List % -> %
from GcdDomain
gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %
from GcdDomain
generator: () -> %
from MonogenicAlgebra(Fraction UP, UPUP)
genus: () -> NonNegativeInteger
from FunctionFieldCategory(F, UP, UPUP)
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
hyperelliptic: () -> Union(UP, failed)
from FunctionFieldCategory(F, UP, UPUP)
index: PositiveInteger -> % if Fraction UP has Finite
from Finite
init: % if Fraction UP has FiniteFieldCategory
from StepThrough
integral?: % -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
integral?: (%, F) -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
integral?: (%, UP) -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
integralAtInfinity?: % -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
integralBasis: () -> Vector %
from FunctionFieldCategory(F, UP, UPUP)
integralBasisAtInfinity: () -> Vector %
from FunctionFieldCategory(F, UP, UPUP)
integralCoordinates: % -> Record(num: Vector UP, den: UP)
from FunctionFieldCategory(F, UP, UPUP)
integralDerivationMatrix: UP -> UP -> Record(num: Matrix UP, den: UP)
from FunctionFieldCategory(F, UP, UPUP)
integralMatrix: () -> Matrix Fraction UP
from FunctionFieldCategory(F, UP, UPUP)
integralMatrixAtInfinity: () -> Matrix Fraction UP
from FunctionFieldCategory(F, UP, UPUP)
integralRepresents: (Vector UP, UP) -> %
from FunctionFieldCategory(F, UP, UPUP)
inv: % -> %
from DivisionRing
inverseIntegralMatrix: () -> Matrix Fraction UP
from FunctionFieldCategory(F, UP, UPUP)
inverseIntegralMatrixAtInfinity: () -> Matrix Fraction UP
from FunctionFieldCategory(F, UP, UPUP)
knownInfBasis: NonNegativeInteger -> Void
knownInfBasis(n) is undocumented.
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
lift: % -> UPUP
from MonogenicAlgebra(Fraction UP, UPUP)
lookup: % -> PositiveInteger if Fraction UP has Finite
from Finite
minimalPolynomial: % -> UPUP
from FiniteRankAlgebra(Fraction UP, UPUP)
multiEuclidean: (List %, %) -> Union(List %, failed)
from EuclideanDomain
nextItem: % -> Union(%, failed) if Fraction UP has FiniteFieldCategory
from StepThrough
nonSingularModel: Symbol -> List Polynomial F
from FunctionFieldCategory(F, UP, UPUP)
norm: % -> Fraction UP
from FiniteRankAlgebra(Fraction UP, UPUP)
normalizeAtInfinity: Vector % -> Vector %
from FunctionFieldCategory(F, UP, UPUP)
numberOfComponents: () -> NonNegativeInteger
from FunctionFieldCategory(F, UP, UPUP)
one?: % -> Boolean
from MagmaWithUnit
opposite?: (%, %) -> Boolean
from AbelianMonoid
order: % -> OnePointCompletion PositiveInteger if Fraction UP has FiniteFieldCategory
from FieldOfPrimeCharacteristic
order: % -> PositiveInteger if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
prime?: % -> Boolean
from UniqueFactorizationDomain
primeFrobenius: % -> % if Fraction UP has FiniteFieldCategory
from FieldOfPrimeCharacteristic
primeFrobenius: (%, NonNegativeInteger) -> % if Fraction UP has FiniteFieldCategory
from FieldOfPrimeCharacteristic
primitive?: % -> Boolean if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
primitiveElement: () -> % if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
primitivePart: % -> %
from FunctionFieldCategory(F, UP, UPUP)
principalIdeal: List % -> Record(coef: List %, generator: %)
from PrincipalIdealDomain
quo: (%, %) -> %
from EuclideanDomain
ramified?: F -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
ramified?: UP -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
ramifiedAtInfinity?: () -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
random: () -> % if Fraction UP has Finite
from Finite
rank: () -> PositiveInteger
from FiniteRankAlgebra(Fraction UP, UPUP)
rationalPoint?: (F, F) -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
rationalPoints: () -> List List F if F has Finite
from FunctionFieldCategory(F, UP, UPUP)
recip: % -> Union(%, failed)
from MagmaWithUnit
reduce: Fraction UPUP -> Union(%, failed)
from MonogenicAlgebra(Fraction UP, UPUP)
reduce: UPUP -> %
from MonogenicAlgebra(Fraction UP, UPUP)
reduceBasisAtInfinity: Vector % -> Vector %
from FunctionFieldCategory(F, UP, UPUP)
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Fraction UP, vec: Vector Fraction UP)
from LinearlyExplicitOver Fraction UP
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if Fraction UP has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reducedSystem: Matrix % -> Matrix Fraction UP
from LinearlyExplicitOver Fraction UP
reducedSystem: Matrix % -> Matrix Integer if Fraction UP has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
regularRepresentation: % -> Matrix Fraction UP
from FramedAlgebra(Fraction UP, UPUP)
regularRepresentation: (%, Vector %) -> Matrix Fraction UP
from FiniteRankAlgebra(Fraction UP, UPUP)
rem: (%, %) -> %
from EuclideanDomain
representationType: () -> Union(prime, polynomial, normal, cyclic) if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
represents: (Vector Fraction UP, Vector %) -> %
from FiniteRankAlgebra(Fraction UP, UPUP)
represents: (Vector UP, UP) -> %
from FunctionFieldCategory(F, UP, UPUP)
represents: Vector Fraction UP -> %
from FramedModule Fraction UP
retract: % -> Fraction Integer if Fraction UP has RetractableTo Fraction Integer
from RetractableTo Fraction Integer
retract: % -> Fraction UP
from RetractableTo Fraction UP
retract: % -> Integer if Fraction UP has RetractableTo Integer
from RetractableTo Integer
retractIfCan: % -> Union(Fraction Integer, failed) if Fraction UP has RetractableTo Fraction Integer
from RetractableTo Fraction Integer
retractIfCan: % -> Union(Fraction UP, failed)
from RetractableTo Fraction UP
retractIfCan: % -> Union(Integer, failed) if Fraction UP has RetractableTo Integer
from RetractableTo Integer
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
sample: %
from AbelianMonoid
singular?: F -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
singular?: UP -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
singularAtInfinity?: () -> Boolean
from FunctionFieldCategory(F, UP, UPUP)
size: () -> NonNegativeInteger if Fraction UP has Finite
from Finite
sizeLess?: (%, %) -> Boolean
from EuclideanDomain
smaller?: (%, %) -> Boolean if Fraction UP has Finite
from Comparable
squareFree: % -> Factored %
from UniqueFactorizationDomain
squareFreePart: % -> %
from UniqueFactorizationDomain
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
tableForDiscreteLogarithm: Integer -> Table(PositiveInteger, NonNegativeInteger) if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory
trace: % -> Fraction UP
from FiniteRankAlgebra(Fraction UP, UPUP)
traceMatrix: () -> Matrix Fraction UP
from FramedAlgebra(Fraction UP, UPUP)
traceMatrix: Vector % -> Matrix Fraction UP
from FiniteRankAlgebra(Fraction UP, UPUP)
unit?: % -> Boolean
from EntireRing
unitCanonical: % -> %
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %)
from EntireRing
yCoordinates: % -> Record(num: Vector UP, den: UP)
from FunctionFieldCategory(F, UP, UPUP)
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

Algebra Fraction UP

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

BiModule(Fraction UP, Fraction UP)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicNonZero if Fraction UP has CharacteristicNonZero

CharacteristicZero if Fraction UP has CharacteristicZero

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable if Fraction UP has Finite

ConvertibleTo InputForm if Fraction UP has Finite

ConvertibleTo UPUP

DifferentialExtension Fraction UP

DifferentialRing if Fraction UP has DifferentialRing

DivisionRing

EntireRing

EuclideanDomain

Field

FieldOfPrimeCharacteristic if Fraction UP has FiniteFieldCategory

Finite if Fraction UP has Finite

FiniteFieldCategory if Fraction UP has FiniteFieldCategory

FiniteRankAlgebra(Fraction UP, UPUP)

FramedAlgebra(Fraction UP, UPUP)

FramedModule Fraction UP

FullyLinearlyExplicitOver Fraction UP

FullyRetractableTo Fraction UP

FunctionFieldCategory(F, UP, UPUP)

GcdDomain

IntegralDomain

LeftModule %

LeftModule Fraction Integer

LeftModule Fraction UP

LeftOreRing

LinearlyExplicitOver Fraction UP

LinearlyExplicitOver Integer if Fraction UP has LinearlyExplicitOver Integer

Magma

MagmaWithUnit

Module %

Module Fraction Integer

Module Fraction UP

MonogenicAlgebra(Fraction UP, UPUP)

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PartialDifferentialRing Symbol if Fraction UP has PartialDifferentialRing Symbol

PrincipalIdealDomain

RetractableTo Fraction Integer if Fraction UP has RetractableTo Fraction Integer

RetractableTo Fraction UP

RetractableTo Integer if Fraction UP has RetractableTo Integer

RightModule %

RightModule Fraction Integer

RightModule Fraction UP

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

StepThrough if Fraction UP has FiniteFieldCategory

UniqueFactorizationDomain

unitsKnown