# FunctionFieldCategory(F, UP, UPUP)ΒΆ

- F: UniqueFactorizationDomain
- UP: UnivariatePolynomialCategory F
- UPUP: UnivariatePolynomialCategory Fraction UP

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

- 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
`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: (%, %) -> %
- from NonAssociativeSemiRng
- associates?: (%, %) -> Boolean
- from EntireRing
- associator: (%, %, %) -> %
- from NonAssociativeRng
- 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
- 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 %
`complementaryBasis(b1, ..., bn)`

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

of`(b1, ..., bn)`

.- 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) -> %
`differentiate(x, d)`

extends the derivation`d`

from UP to $ and applies it to`x`

.- 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)
`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)
- 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
`genus()`

returns the genus of one absolutely irreducible component- hash: % -> SingleInteger
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState
- from SetCategory

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

- 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
- 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: % -> %
`primitivePart(f)`

removes the content of the denominator and the common content of the numerator of`f`

.- principalIdeal: List % -> Record(coef: List %, generator: %)
- from PrincipalIdealDomain
- 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 FiniteRankAlgebra(Fraction UP, UPUP)

- 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)
- 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) -> %
`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
- 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
`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
- 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)
`yCoordinates(f)`

returns`[[A1, ..., An], D]`

such that`f = (A1 + A2 y +...+ An y^(n-1)) / D`

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

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

LinearlyExplicitOver Fraction UP

LinearlyExplicitOver Integer if Fraction UP has LinearlyExplicitOver Integer

Module %

MonogenicAlgebra(Fraction UP, UPUP)

PartialDifferentialRing Symbol if Fraction UP has PartialDifferentialRing Symbol

RetractableTo Fraction Integer if Fraction UP has RetractableTo Fraction Integer

RetractableTo Integer if Fraction UP has RetractableTo Integer

StepThrough if Fraction UP has FiniteFieldCategory