[Next][Prev] [Right] [Left] [Up] [Index] [Root]

Differentials

Spaces of differentials of function fields can be created and the differentials belonging to them manipulated. Divisors can be created from differentials and modules generated by a collection of differentials can be formed.

Subsections

Creation of Structures

DifferentialSpace(F) : FldFunG -> DiffFun
The space of differentials of the algebraic function field F/k.

Creation of Elements

The simplest ways of creating a differential are given below.

Differential(a) : FldFunGElt -> DiffFunElt
Differential(a) : RngFunOrdElt -> DiffFunElt
Create the differential d(a).
Identity(D) : DiffFun -> DiffFunElt
Id(D) : DiffFun -> DiffFunElt
The identity differential.
IsCanonical(D) : DivFunElt -> BoolElt, DiffFunElt
Returns true iff the divisor D is canonical and a differential having D as its divisor.

Related Structures

FunctionField(D) : DiffFun -> FldFun
The function field of the differentials in D.
FunctionField(d) : DiffFunElt -> FldFun
The function field of the differential d.

Subspaces

SpaceOfDifferentialsFirstKind(F) : FldFunG -> ModFld, Map
SpaceOfHolomorphicDifferentials(F) : FldFunG -> ModFld, Map
A vector space and the isomorphism from this space to the space of differentials of the first kind (holomorphic differentials) of F/k.
BasisOfDifferentialsFirstKind(F) : FldFunG -> SeqEnum[DiffFunElt]
BasisOfHolomorphicDifferentials(F) : FldFunG -> SeqEnum[DiffFunElt]
A basis of the space of differentials of the first kind (holomorphic differentials) of F/k.
DifferentialBasis(D) : DivFunElt -> [DiffFunElt]
A basis of the space of differentials of the divisor D:

Computes a basis for the space of differentials Omega(D) := { omegain Omega(F/k) | (omega) >= D } for a divisor D of an algebraic function field F/k.

DifferentialSpace(D) : DivFunElt -> ModFld, Map
A vector space and the isomorphism from this space to the differential space of the divisor D.

Example FldFunG_div_diff (H57E16)

This example illustrates the differential space of a divisor and some of the operations that can be done with it.

> Q := Rationals();
> Qx<x> := PolynomialRing(Q);
> Qxy<y> := PolynomialRing(Qx);
> f1 := y^2 - (x-1)*(x-2)*(x-3)*(x-5)*(x-6);
> F := FunctionField(f1);
> d := Divisor(F.1) + Divisor(F!BaseRing(F).1);
> V1 := DifferentialSpace(d);
> d := 2*Divisor(F.1) - Divisor(F!BaseRing(F).1);
> V2 := DifferentialSpace(d);
> V1;
KModule V1 of dimension 2 over Rational Field
> V2;
KModule V2 of dimension 2 over Rational Field
> V1 meet V2;
KModule of dimension 0 over Rational Field
> D := DifferentialSpace(F);
> v := V1 ! [2/9, 4/9]; v;
V1: (2/9 4/9)
> D!v;
((4/9) ^ 1 * (x + 1/2) ^ 1 * (x) ^ 1) d(x)
> V1!$1;
V1: (2/9 4/9)

Structure Predicates

D1 eq D2 : DiffFun, DiffFun -> BoolElt
Return true if D1 and D2 are the same.

Operations on Elements

A number of general operations for elements are also provided for differentials as well as a number of specific functions for differentials.

Arithmetic Operators
r * x : RngElt, DiffFunElt -> DiffFunElt
x * r : DiffFunElt, RngElt -> DiffFunElt
x + y : DiffFunElt, DiffFunElt -> DiffFunElt
- x : DiffFunElt -> DiffFunElt
x - y : DiffFunElt, DiffFunElt -> DiffFunElt
x / y : DiffFunElt, DiffFunElt -> FldFunGElt
x / r : DiffFunElt, RngElt -> DiffFunElt
The operations on differentials are inherited from the vector space structure of the space of differentials. Additionally, this space is one--dimensional as a vector space over the function field itself. The quotient x/y of two differentials x and y then gives the unique r in F such that x = ry.
Equality and Membership
x eq y : DiffFunElt, DiffFunElt -> BoolElt
Returns true if x and y are the same differential.
x in D : Any, DiffFun -> BoolElt
Returns true if x is in D.
Predicates on Elements
IsExact(d) : DiffFunElt -> BoolElt, FldFunGElt
Return whether d is known to be an exact differential. If true additionally return a generator. If d is not already known to be exact then no attempts to determine whether d is exact or not are currently undertaken.
IsZero(d) : DiffFunElt -> BoolElt
Return true if d is the zero differential.
Functions on Elements
Valuation(d, P) : DiffFunElt, PlcFunElt -> RngIntElt
The valuation of the differential d at the place P.
Divisor(d) : DiffFunElt -> DivFunElt
The divisor (d) of the differential d.
Residue(d, P) : DiffFunElt, PlcFunElt -> RngElt
Module(L, R) : SeqEnum[ DiffFunElt ], Rng -> Mod, Map, SeqEnum[ ModElt ]
    IsBasis: BoolElt                    Default: false
    PreImages: BoolElt                  Default: false
The R-module generated by the elements in the sequence L as an abstract module, together with the map into the space of differentials. The resulting modules can be used for intersection and inner sum computations.

If the optional parameter IsBasis is set true the function assumes that the given elements form a basis of the module to be computed.

If the optional parameter PreImages is set true then the preimages of the given elements under the map are returned as the third return value.

Both optional parameters are mainly used to save computation time.

Relations(L, R) : SeqEnum[ DiffFunElt ], Rng -> ModTupRng
Relations(L, R, m) : SeqEnum[ DiffFunElt ], Rng -> ModTupRng
The module of R-linear relations between the elements of the sequence L. The parameter m is used for the following: Let the elements of L be a_1, ..., a_n, V be the relation module subseteq R^n and define M := { sum_(i=1)^m v_i a_i | v = (v_i)_i in V }. The function tries to compute a generating system of V such that the corresponding generating system of M consists of "small" elements.
Cartier(b) : DiffFunElt -> DiffFunElt
Cartier(b, r) : DiffFunElt, RngIntElt -> DiffFunElt
The result of applying the Cartier operator r times to b. More precisely:

Let F/k be a function field over the perfect field k, x in F be a separating variable and b = g dx in Omega(F/k) with g in F be a differential. The Cartier operator is defined by C(b) := ( - d^(p - 1) g / dx^(p - 1) )^(1/p) dx. This function computes the r-th iterated application of C to b.

Other
CartierRepresentation(F) : FldFunG -> AlgMatElt, SeqEnum[DiffFunElt]
CartierRepresentation(F, r) : FldFunG, RngIntElt -> AlgMatElt, SeqEnum[DiffFunElt]
Compute a row representation matrix of the Cartier operator on a basis of the space of holomorphic differentials of F/k (applied r times). More precisely: Let F/k be a function field over the perfect field k, omega_1, ..., omega_g in Omega(F/k) be a basis for the holomorphic differentials and r in Z^( >= 1). Let M = (lambda_(i, j))_(i, j) in k^(g x g) be the matrix such that C^r(omega_i) = sum_(m=1)^g lambda_(i, m) omega_m for all 1 <= i <= g. This function returns M and (omega_1, ..., omega_g).
 [Next][Prev] [Right] [Left] [Up] [Index] [Root]