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

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

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

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

from RightModule Fraction UP

*: (%, Integer) -> % if Fraction UP has LinearlyExplicitOver Integer
*: (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: (%, %) -> %
associates?: (%, %) -> Boolean

from EntireRing

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

from FiniteRankAlgebra(Fraction UP, UPUP)

charthRoot: % -> % if Fraction UP has FiniteFieldCategory
charthRoot: % -> Union(%, failed) if Fraction UP has CharacteristicNonZero
coerce: % -> %

from Algebra %

coerce: % -> OutputForm
coerce: Fraction Integer -> %
coerce: Fraction UP -> %

from Algebra Fraction UP

coerce: Integer -> %
commutator: (%, %) -> %
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
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
D: % -> % if Fraction UP has DifferentialRing

from DifferentialRing

D: (%, Fraction UP -> Fraction UP) -> %
D: (%, Fraction UP -> Fraction UP, NonNegativeInteger) -> %
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) -> %
differentiate: (%, Fraction UP -> Fraction UP, NonNegativeInteger) -> %
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
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)

enumerate: () -> List % if Fraction UP has Finite

from Finite

euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

expressIdealMember: (List %, %) -> Union(List %, failed)
exquo: (%, %) -> Union(%, failed)

from EntireRing

extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %)

from EuclideanDomain

extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed)

from EuclideanDomain

factor: % -> Factored %
factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if Fraction UP has FiniteFieldCategory
factorsOfCyclicGroupSize: () -> List Record(factor: Integer, exponent: NonNegativeInteger) if Fraction UP has FiniteFieldCategory
factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if Fraction UP has FiniteFieldCategory
gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

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

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
order: % -> PositiveInteger if Fraction UP has FiniteFieldCategory
plenaryPower: (%, PositiveInteger) -> %
prime?: % -> Boolean
primeFrobenius: % -> % if Fraction UP has FiniteFieldCategory
primeFrobenius: (%, NonNegativeInteger) -> % if Fraction UP has FiniteFieldCategory
primitive?: % -> Boolean if Fraction UP has FiniteFieldCategory
primitiveElement: () -> % if Fraction UP has FiniteFieldCategory
primitivePart: % -> %

from FunctionFieldCategory(F, UP, UPUP)

principalIdeal: List % -> Record(coef: List %, generator: %)
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 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)
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if Fraction UP has LinearlyExplicitOver Integer
reducedSystem: Matrix % -> Matrix 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
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
retract: % -> Fraction UP

from RetractableTo Fraction UP

retract: % -> Integer if Fraction UP has RetractableTo Integer
retractIfCan: % -> Union(Fraction Integer, failed) if Fraction UP has RetractableTo Fraction Integer
retractIfCan: % -> Union(Fraction UP, failed)

from RetractableTo Fraction UP

retractIfCan: % -> Union(Integer, failed) if Fraction UP has 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
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

BasicType

BiModule(%, %)

BiModule(Fraction UP, Fraction UP)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CommutativeRing

CommutativeStar

Comparable if Fraction UP has Finite

ConvertibleTo UPUP

DivisionRing

EntireRing

EuclideanDomain

Field

Finite if Fraction UP has Finite

FiniteRankAlgebra(Fraction UP, UPUP)

FramedAlgebra(Fraction UP, UPUP)

FunctionFieldCategory(F, UP, UPUP)

GcdDomain

Hashable if Fraction UP has Hashable

IntegralDomain

LeftOreRing

Magma

MagmaWithUnit

MonogenicAlgebra(Fraction UP, UPUP)

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PrincipalIdealDomain

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown