# FunctionFieldCategory(F, UP, UPUP)¶

This category is a model for the function field of a plane algebraic curve.

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

`absolutelyIrreducible?()` tests if the curve absolutely irreducible?

algSplitSimple: (%, UP -> UP) -> Record(num: %, den: UP, derivden: UP, gd: UP)

`algSplitSimple(f, D)` returns `[h, d, d', g]` such that `f=h/d`, `h` is integral at all the normal places `w`.`r`.`t`. `D`, `d' = Dd`, `g = gcd(d, discriminant())` and `D` is the derivation to use. `f` must have at most simple finite poles.

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %
associates?: (%, %) -> Boolean

from EntireRing

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

from FramedModule Fraction UP

branchPoint?: F -> Boolean

`branchPoint?(a)` tests whether `x = a` is a branch point.

branchPoint?: UP -> Boolean

`branchPoint?(p)` tests whether `p(x) = 0` is a branch point.

branchPointAtInfinity?: () -> Boolean

`branchPointAtInfinity?()` tests if there is a branch point at infinity.

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 %

`complementaryBasis(b1, ..., bn)` returns the complementary basis `(b1', ..., bn')` of `(b1, ..., bn)`.

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

`differentiate(x, d)` extends the derivation `d` from UP to \$ and applies it to `x`.

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)

`elliptic()` returns `p(x)` if the curve is the elliptic defined by `y^2 = p(x)`, “failed” otherwise.

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

`elt(f, a, b)` or `f`(a, `b`) returns the value of `f` at the point `(x = a, y = b)` if it is not singular.

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

`genus()` returns the genus of one absolutely irreducible component

hash: % -> SingleInteger if Fraction UP has Hashable

from Hashable

hashUpdate!: (HashState, %) -> HashState if Fraction UP has Hashable

from Hashable

hyperelliptic: () -> Union(UP, failed)

`hyperelliptic()` returns `p(x)` if the curve is the hyperelliptic defined by `y^2 = p(x)`, “failed” otherwise.

index: PositiveInteger -> % if Fraction UP has Finite

from Finite

init: % if Fraction UP has FiniteFieldCategory

from StepThrough

integral?: % -> Boolean

`integral?(f)` tests if `f` is integral over `k[x]`.

integral?: (%, F) -> Boolean

`integral?(f, a)` tests whether `f` is locally integral at `x = a`.

integral?: (%, UP) -> Boolean

`integral?(f, p)` tests whether `f` is locally integral at `p(x) = 0`.

integralAtInfinity?: % -> Boolean

`integralAtInfinity?(f)` tests if `f` is locally integral at infinity.

integralBasis: () -> Vector %

`integralBasis()` returns the integral basis for the curve.

integralBasisAtInfinity: () -> Vector %

`integralBasisAtInfinity()` returns the local integral basis at infinity.

integralCoordinates: % -> Record(num: Vector UP, den: UP)

`integralCoordinates(f)` returns `[[A1, ..., An], D]` such that `f = (A1 w1 +...+ An wn) / D` where `(w1, ..., wn)` is the integral basis returned by `integralBasis()`.

integralDerivationMatrix: (UP -> UP) -> Record(num: Matrix UP, den: UP)

`integralDerivationMatrix(d)` extends the derivation `d` from UP to \$ and returns (`M`, `Q`) such that the i^th row of `M` divided by `Q` form the coordinates of `d(wi)` with respect to `(w1, ..., wn)` where `(w1, ..., wn)` is the integral basis returned by integralBasis().

integralMatrix: () -> Matrix Fraction UP

`integralMatrix()` returns `M` such that `(w1, ..., wn) = M (1, y, ..., y^(n-1))`, where `(w1, ..., wn)` is the integral basis of integralBasis.

integralMatrixAtInfinity: () -> Matrix Fraction UP

`integralMatrixAtInfinity()` returns `M` such that `(v1, ..., vn) = M (1, y, ..., y^(n-1))` where `(v1, ..., vn)` is the local integral basis at infinity returned by `infIntBasis()`.

integralRepresents: (Vector UP, UP) -> %

`integralRepresents([A1, ..., An], D)` returns `(A1 w1+...+An wn)/D` where `(w1, ..., wn)` is the integral basis of `integralBasis()`.

inv: % -> %

from DivisionRing

inverseIntegralMatrix: () -> Matrix Fraction UP

`inverseIntegralMatrix()` returns `M` such that `M (w1, ..., wn) = (1, y, ..., y^(n-1))` where `(w1, ..., wn)` is the integral basis of integralBasis.

inverseIntegralMatrixAtInfinity: () -> Matrix Fraction UP

`inverseIntegralMatrixAtInfinity()` returns `M` such that `M (v1, ..., vn) = (1, y, ..., y^(n-1))` where `(v1, ..., vn)` is the local integral basis at infinity returned by `infIntBasis()`.

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 if F has Field

`nonSingularModel(u)` returns the equations in `u1`, …, un of an affine non-singular model for the curve.

norm: % -> Fraction UP

from FiniteRankAlgebra(Fraction UP, UPUP)

normalizeAtInfinity: Vector % -> Vector %

`normalizeAtInfinity(v)` makes `v` normal at infinity.

numberOfComponents: () -> NonNegativeInteger

`numberOfComponents()` returns the number of absolutely irreducible components.

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

`primitivePart(f)` removes the content of the denominator and the common content of the numerator of `f`.

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

from EuclideanDomain

ramified?: F -> Boolean

`ramified?(a)` tests whether `x = a` is ramified.

ramified?: UP -> Boolean

`ramified?(p)` tests whether `p(x) = 0` is ramified.

ramifiedAtInfinity?: () -> Boolean

`ramifiedAtInfinity?()` tests if infinity is ramified.

random: () -> % if Fraction UP has Finite

from Finite

rank: () -> PositiveInteger

from FramedModule Fraction UP

rationalPoint?: (F, F) -> Boolean

`rationalPoint?(a, b)` tests if `(x=a, y=b)` is on the curve.

rationalPoints: () -> List List F if F has Finite

`rationalPoints()` returns the list of all the affine rational points.

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 %

`reduceBasisAtInfinity(b1, ..., bn)` returns `(x^i * bj)` for all `i`, `j` such that `x^i*bj` is locally integral at infinity.

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

`represents([A0, ..., A(n-1)], D)` returns `(A0 + A1 y +...+ A(n-1)*y^(n-1))/D`.

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

`singular?(a)` tests whether `x = a` is singular.

singular?: UP -> Boolean

`singular?(p)` tests whether `p(x) = 0` is singular.

singularAtInfinity?: () -> Boolean

`singularAtInfinity?()` tests if there is a singularity at infinity.

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

`special_order(f, lp)` computes sum of orders at special places, that is at infinite places and at places over zeros in polynomials in `lp`. Elements of `lp` must be relatively prime.

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)

`yCoordinates(f)` returns `[[A1, ..., An], D]` such that `f = (A1 + A2 y +...+ An y^(n-1)) / D`.

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)

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