# FunctionFieldCategory(F, UP, UPUP)¶

curve.spad line 1 [edit on github]

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

- coerce: % -> %
from Algebra %

- coerce: % -> OutputForm
from CoercibleTo OutputForm

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

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

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

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

returns the genus of one absolutely irreducible component

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

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

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

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

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

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