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

curve.spad line 781 [edit on github]

F: Field

UPUP: UnivariatePolynomialCategory Fraction UP

modulus: UPUP

Function field defined by `f`

(`x`

, `y`

) = 0.

- 0: %
from AbelianMonoid

- 1: %
from MagmaWithUnit

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

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

- *: (%, Fraction UP) -> %
from RightModule Fraction UP

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

- *: (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

- ^: (%, Integer) -> %
from DivisionRing

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

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

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

- 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

- coerce: % -> %
from Algebra %

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: Fraction Integer -> %
- coerce: 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

- 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
- D: (%, List Symbol, List NonNegativeInteger) -> % if Fraction UP has PartialDifferentialRing Symbol
- D: (%, NonNegativeInteger) -> % if Fraction UP has DifferentialRing
from DifferentialRing

- D: (%, Symbol) -> % if Fraction UP has PartialDifferentialRing Symbol
- D: (%, Symbol, NonNegativeInteger) -> % if Fraction UP has 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
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if Fraction UP has PartialDifferentialRing Symbol
- differentiate: (%, NonNegativeInteger) -> % if Fraction UP has DifferentialRing
from DifferentialRing

- differentiate: (%, Symbol) -> % if Fraction UP has PartialDifferentialRing Symbol
- differentiate: (%, Symbol, NonNegativeInteger) -> % if Fraction UP has 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

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

- 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

- factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if Fraction UP has FiniteFieldCategory

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

- factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if Fraction UP has FiniteFieldCategory

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

- generator: () -> %
from MonogenicAlgebra(Fraction UP, UPUP)

- genus: () -> NonNegativeInteger
from FunctionFieldCategory(F, UP, UPUP)

- hash: % -> SingleInteger if Fraction UP has Hashable
from Hashable

- 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

- 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
- order: % -> PositiveInteger if Fraction UP has FiniteFieldCategory
from FiniteFieldCategory

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

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

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

- rank: () -> PositiveInteger
from FramedModule Fraction UP

- 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
- reducedSystem: Matrix % -> Matrix Fraction UP
from LinearlyExplicitOver Fraction UP

- reducedSystem: Matrix % -> Matrix Integer if Fraction UP has 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

- solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if Fraction UP has FiniteFieldCategory

- special_order: (%, List UP) -> Integer
from FunctionFieldCategory(F, UP, UPUP)

- squareFree: % -> Factored %

- squareFreePart: % -> %

- squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if Fraction UP has FiniteFieldCategory

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

- 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

Algebra %

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

BiModule(Fraction UP, Fraction UP)

CharacteristicNonZero if Fraction UP has CharacteristicNonZero

CharacteristicZero if Fraction UP has CharacteristicZero

CoercibleFrom Fraction Integer if Fraction UP has RetractableTo Fraction Integer

CoercibleFrom Integer if Fraction UP has RetractableTo Integer

Comparable if Fraction UP has Finite

ConvertibleTo InputForm if Fraction UP has Finite

ConvertibleTo UPUP

DifferentialExtension Fraction UP

DifferentialRing if Fraction UP has DifferentialRing

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)

FullyLinearlyExplicitOver Fraction UP

FullyRetractableTo Fraction UP

FunctionFieldCategory(F, UP, UPUP)

Hashable if Fraction UP has Hashable

LinearlyExplicitOver Fraction UP

LinearlyExplicitOver Integer if Fraction UP has LinearlyExplicitOver Integer

Module %

MonogenicAlgebra(Fraction UP, UPUP)

NonAssociativeAlgebra Fraction Integer

NonAssociativeAlgebra Fraction UP

PartialDifferentialRing Symbol if Fraction UP has PartialDifferentialRing Symbol

PolynomialFactorizationExplicit if Fraction UP has FiniteFieldCategory

RetractableTo Fraction Integer if Fraction UP has RetractableTo Fraction Integer

RetractableTo Integer if Fraction UP has RetractableTo Integer

RightModule Integer if Fraction UP has LinearlyExplicitOver Integer

StepThrough if Fraction UP has FiniteFieldCategory