|
A local ring in Magma can be constructed in two ways: as either a p-adic
ring, or as an extension of another local ring. Magma supports the
construction of towers of extensions of local rings; the only restriction is
that each extension must be either unramified or totally ramified. As
discussed in Section Background, Magma requires that the
defining polynomial is either inertial or Eisenstein.
Additionally, the user must specify whether to construct a fixed precision or
free precision structure, and, if necessary, assign a precision to the
structure. For local rings the precision is interpreted as an absolute
precision, specifying to what precision the element is known,
but for local fields it is interpreted as a relative precision, specifying to
what precision the unit part of the element is known.
pAdicField(p, k) : RngIntElt, RngIntElt -> FldPad
Given a prime integer p and non-negative single-precision integer k,
construct the bounded free precision ring (field) of p-adic integers with
maximum precision k.
pAdicField(p) : RngIntElt -> FldPad
Precision: RngIntElt Default: 20
Given a prime integer p, construct the unbounded free precision ring (field)
of p-adic numbers. The optional parameter Precision, which must be a
non-negative single precision integer, controls the default precision to which
elements are created, e.g., when coercing precise elements such as integers or
rationals into the ring.
Given a prime integer p and non-negative single precision integer k,
construct the fixed precision quotient ring Zp / pk Zp.
Given a local ring L, construct the quotient ring L / xL, where x is an
element of L.
The creation of p-adic rings using the above functions is illustrated below.
> R := pAdicRing(5);
> R;
5-adic ring
> R`DefaultPrecision;
20
> R!1;
1 + O(5^20)
> R := pAdicRing(5 : Precision := 20);
> R!1;
1 + O(5^20)
> Q := quo<R | 5^20>;
> Q;
Quotient of the 5-adic ring modulo the ideal generated by 5^20
> Q!1;
1
> Q eq pAdicQuotientRing(5, 20);
true
UnramifiedExtension(L, n) : FldPad, RngIntElt -> FldPad
UnramifiedExtension(L, n) : RngPadRes, RngIntElt -> RngPadResExt
UnramifiedExtension(L, n) : RngPadResExt, RngIntElt -> RngPadResExt
ext<L | n> : RngPad, RngIntElt -> RngPad
ext<L | n> : FldPad, RngIntElt -> FldPad
ext<L | n> : RngPadRes, RngIntElt -> RngPadResExt
ext<L | n> : RngPadResExt, RngIntElt -> RngPadResExt
Cyclotomic: BoolElt Default: false
GNBType: RngIntElt Default: 0
Given a local ring or field L and a positive single precision integer n,
construct the default unramified extension of L of degree n. If K is the
residue class field of L, then the defining polynomial of the default degree
n extension of K is lifted to be an inertial polynomial of L; this
polynomial is used as the defining polynomial of the extension. If Cyclotomic is true, then the lift of the defining polynomial will be such
that pn - 1-st root of unity will be adjoined to L (this representation
makes computation of the Frobenius automorphism particularly efficient). The
angle bracket notation can be used to assign a name to the generator of the
extension, e.g. K<t> := UnramifiedExtension(L, n).
If Cyclotomic is false but GNBType is t > 0 then a Gaussian normal
basis of type t is used. This allows extremely fast multiple Frobenius
computations but multiplication is slower than the usual or Cyclotomic
representation if t > 2. Because of this, currently only 1 or 2
are legal values for t. Only certain extension degrees will have a Gaussian
normal basis of type 1 or 2. To determine if this is true, the HasGNB
functions described below may be used.
Given a finite field K and a non-negative single precision integer k,
construct the fixed precision quotient ring which has residue class field K
and precision k. The angle bracket notation can be used to assign a name to
the generator of the extension, e.g. L<t> := UnramifiedExtension(K, f).
UnramifiedExtension(L, f) : FldPad, RngUPolElt -> FldPad
UnramifiedExtension(L, f) : RngPadRes, RngUPolElt -> RngPadResExt
UnramifiedExtension(L, f) : RngPadResExt, RngUPolElt -> RngPadResExt
ext<L | f> : RngPad, RngUPolElt -> RngPad
ext<L | f> : FldPad, RngUPolElt -> FldPad
ext<L | f> : RngPadRes, RngUPolElt -> RngPadResExt
ext<L | f> : RngPadResExt, RngUPolElt -> RngPadResExt
Given a local ring or field L and a polynomial f with coefficients
coercible to L, construct the unramified extension of L defined by f.
The polynomial f must be an inertial polynomial over L. The angle bracket
notation can be used to assign a name to the generator of the extension, e.g.
K<t> := UnramifiedExtension(L, f). Free precision rings can only be
extended by a polynomial if they are of bounded precision, in which case f
must be specified to the maximum precision of the ring.
Given a polynomial f with coefficients over a local ring or field L, return
true if and only if f is an inertial polynomial. A polynomial is inertial
over L if it is irreducible over the residue class field of L.
HasGNB(R, n, t) : RngPad, RngIntElt, RngIntElt -> BoolElt
HasGNB(L, n, t) : FldPad, RngIntElt, RngIntElt -> BoolElt
HasGNB(R, n, t) : RngPadRes, RngIntElt, RngIntElt -> BoolElt
HasGNB(R, n, t) : RngPadResExt, RngIntElt, RngIntElt -> BoolElt
Given a local ring or field, returns true iff the unramified extension of
degree n can be generated by a Gaussian Normal Basis (GNB) of Type t.
A GNB allows particularly fast multiple Frobenius and Norm computations.
Multiplication will tend to be slower though, unless t = 1.
CyclotomicUnramifiedExtension(R, f) : RngPad, RngIntElt -> RngPad
CyclotomicUnramifiedExtension(R, f) : RngPadRes, RngIntElt -> RngPadRes
CyclotomicUnramifiedExtension(R, f) : RngPadResExt, RngIntElt -> RngPadResExt
Given a local ring of field R, construct the unramified degree f extension
by adjoining a pf - 1-th root of unity to R. Functionally equivalent to
calling UnramifiedExtension(R, f:Cyclotomic := true).
The creation of unramified extensions of local rings using the above functions
is illustrated below.
> R1 := pAdicRing(2, 20);
> R2 := ext<R1 | 5>;
> R2;
Unramified extension defined by the polynomial x^5 + x^2 + 1
over 2-adic ring mod 2^20
> DefiningPolynomial(R2);
x^5 + x^2 + 1
> R3 := ext<R1 | 5 : Cyclotomic>;
> R3;
Cyclotomic unramified extension of degree 5 over 2-adic ring mod 2^20
> DefiningPolynomial(R3);
x^5 + 426248*x^4 - 14172*x^3 - 147105*x^2 + 293314*x - 1
> R3.1^(2^5-1);
1
> P1<x> := PolynomialRing(R1);
> f1 := x^3 + 3*x + 1;
> IsInertial(f1);
true
> R4 := ext<R1 | f1>;
> R4;
Unramified extension defined by the polynomial x^3 + 3*x + 1
over 2-adic ring mod 2^20
> P2<y> := PolynomialRing(R2);
> f2 := y^3 + 3*y + 1;
> IsInertial(f2);
true
> ext<R2 | f2>;
Unramified extension defined by the polynomial x^3 + 3*x + 1
over Unramified extension defined by the polynomial x^5 + x^2 + 1
over 2-adic ring mod 2^20
TotallyRamifiedExtension(L, f) : FldPad, RngUPolElt -> FldPad
TotallyRamifiedExtension(L, f) : RngPadRes, RngUPolElt -> RngPadResExt
TotallyRamifiedExtension(L, f) : RngPadResExt, RngUPolElt -> RngPadResExt
ext<L | f> : RngPad, RngUPolElt -> RngPad
ext<L | f> : FldPad, RngUPolElt -> FldPad
ext<L | f> : RngPadRes, RngUPolElt -> RngPadResExt
ext<L | f> : RngPadResExt, RngUPolElt -> RngPadResExt
Given a local ring or field L and a polynomial f with coefficients
coercible to L, construct the totally ramified extension of L defined by
f. The polynomial f must be an Eisenstein polynomial, that is, the leading
coefficient is a unit, the constant coefficient has valuation 1 and all other
coefficients have valuation greater than or equal to 1. The angle bracket
notation can be used to assign a name to the generator of the extension, e.g.
K<t> := TotallyRamifiedExtension(L, f). Free precision rings can only be
extended by a polynomial if they are of bounded precision, in which case f
must be specified to the maximum precision of the ring.
Given a polynomial f with coefficients over a local ring or field L, return
true if and only if f is an Eisenstein polynomial over L. An Eisenstein
polynomial satisfies the following properties: the leading coefficient is a
unit, the constant coefficient has valuation 1 and all other coefficients
have valuation greater than or equal to 1.
The creation of totally ramified extensions of local rings using the above
functions is illustrated below.
> L1<a> := ext<pAdicRing(5, 20) | 4>;
> L1;
Unramified extension defined by the polynomial x^4 + 4*x^2 + 4*x + 2
over 5-adic ring mod 5^20
> L2<b> := ext<L1 | x^4 + 125*x^2 + 5>;
> L2;
Totally ramified extension defined by the polynomial x^4 + 125*x^2 + 5
over Unramified extension defined by the polynomial x^4 + 4*x^2 + 4*x + 2
over 5-adic ring mod 5^20
> P<y> := PolynomialRing(L2);
> L3<c> := TotallyRamifiedExtension(L2, y^3 + b^4*a^5*y + b*a^2);
> L3;
Totally ramified extension defined by the polynomial x^3 + ((500*a^3 + 500*a^2 +
250*a)*b^2 + 20*a^3 + 20*a^2 + 10*a)*x + a^2*b
over Totally ramified extension defined by the polynomial x^4 + 125*x^2 + 5
over Unramified extension defined by the polynomial x^4 + 4*x^2 + 4*x + 2
over 5-adic ring mod 5^20
If the precision of the base ring is only 1, then it is not possible to
construct a ramified extension, as there is not enough precision to allow the
constant coefficient to be non-zero to that precision.
> R<x> := PolynomialRing(Integers());
> L<a> := UnramifiedExtension(pAdicRing(5, 1), 3);
> TotallyRamifiedExtension(L, x^4 + 5);
>> TotallyRamifiedExtension(L, x^4 + 5);
^
Runtime error in 'TotallyRamifiedExtension': Polynomial must be Eisenstein
> L<a> := UnramifiedExtension(pAdicRing(5, 2), x^5 + x^2 + 2);
> TotallyRamifiedExtension(L, x^4 + 5);
Totally ramified extension defined by the polynomial x^4 + 5 over Unramified
extension defined by the polynomial x^5 + x^2 + 2 over 5-adic ring mod 5^2
> ext<L | x^4 + 125*x^2 + 5>;
Totally ramified extension defined by the polynomial x^4 + 5 over Unramified
extension defined by the polynomial x^5 + x^2 + 2 over 5-adic ring mod 5^2
Suppose we have an unbounded precision local ring or field L, and we wish to
create a finite extension of it. If we need the default degree n unramified
extension, then we can use the construction functions defined in Section
Creation of Unramified Extensions to construct this extension. However,
suppose we wish to define the extension by some polynomial f. As there is no
upper bound on the precision of elements of L, it is impossible for us to
represent the polynomial f sufficiently precisely, and hence we cannot use the
creation functions defined in previous sections for this task. To allow such
extensions to be created, Magma allows extensions to be defined by a map
φ: Z≥0 to R[x], where R is a ring whose elements are coercible
to the quotient rings L / πk L for all k ∈Z≥0. The map
φ, given an input precision k, returns the defining polynomial of the
extension to precision k. Internally, whenever Magma needs to represent an
element of the extension to some precision, it will use φ to compute the
defining polynomial up to this precision. Magma may call φ on any
precision between zero and the precision of the most precise element created
by the user.
ext<L | m> : FldPad, Map -> RngPad
Given a free precision local ring or field L and a map m with domain Z
and codomain R[x], where elements of R are coercible to the quotient rings
L / πk L for all k ∈Z≥0, construct an extension of L defined
by m. Given a non-negative single precision integer k, the map m must
return the defining polynomial of the extension to precision k, as a
polynomial over R. The map m's behaviour for other input values is
undefined. Internally, Magma will coerce the value returned by the map m
to be a polynomial over L / πk L. Examples of suitable codomains R
include the integers, rationals, or L itself.
The creation of extensions of local rings using maps is illustrated below. We
show how it is possible to define an extension of a free precision ring using
an "exact" polynomial.
> R := pAdicRing(2);
> Z := Integers();
> P<x> := PolynomialRing(Z);
> m := map<Z -> P | k :-> x^3 + x + 1>;
> R2 := ext<R | m>;
> R2;
Unramified extension defined by a map over 2-adic ring
> DefiningPolynomial(R2);
(1 + O(2^20))*$.1^3 + O(2^20)*$.1^2 + (1 + O(2^20))*$.1 + 1 + O(2^20)
> R2`DefaultPrecision := 1000;
> DefiningPolynomial(R2);
(1 + O(2^1000))*$.1^3 + O(2^1000)*$.1^2 + (1 + O(2^1000))*$.1 + 1 + O(2^1000)
Integers(F) : FldPad -> RngPad
RingOfIntegers(F) : FldPad -> RngPad
Given a local field F, construct the ring of integers R of F. The ring
R is the set of elements of F of non-negative valuation.
Given a ring R, this function simply returns it, it is provided
to support generic functionality for finite extensions of rings and fields.
Given a local ring R, construct the field of fractions F of R. The
relative precision of F is equal to the precision of R.
Given a polynomial f over the integers and a p-adic ring R,
compute an extension S over R such that f splits into linear
factors over S. The algorithms uses the R4-methods as developed by
Pauli ([Pau01b]).
Given a tower of ramified extensions over some unramified ring S,
compute a more efficient representation of R, ie. an extension
of S that is totally ramified and defined by a single Eisenstein
polynomial. The map returned allows to convert between the new and old
representations.
For two p-adic fields that are normal over Qp, compute the
compositum of R and S, ie. the smallest field containing both
R and S.
Used to retrieve or set the default precision of the local ring or field L.
This attribute is only relevant if L is an unbounded free precision ring, in
which case this will change the precision with which elements are created by
default. For bounded precision structures, the default precision of the ring
is equal to the upper bound on precision; attempting to set this attribute will
result in an error in this case.
This attribute controls whether elements of the ring or field L are printed
as a series in the uniformizing element of L. This attribute cannot be set
for unramified extensions with Gaussian Normal bases of type 2.
> Zp := pAdicRing(5, 10);
> Zp`SeriesPrinting := true;
> Zp!9348752038967;
2 + 3*5 + 3*5^2 + 5^3 + 2*5^4 + 2*5^5 + 5^7 + 5^9 + O(5^10)
> U := UnramifiedExtension(Zp, 4);
> U`SeriesPrinting := true;
> U![3294875629, 324, 1254234, 13454];
4*U.1^3 + 4*U.1^2 + 4*U.1 + 4 + (U.1^2 + 4*U.1)*5 + (3*U.1^3 + 4*U.1^2 +
2*U.1)*5^2 + (2*U.1^3 + 3*U.1^2 + 2*U.1)*5^3 + (U.1^3 + U.1^2 + 1)*5^4 +
(4*U.1^3 + U.1^2)*5^5 + 2*5^6 + (U.1^2 + 4)*5^7 + (3*U.1^2 + 4)*5^8 + 5^9 +
O(5^10)
> R := TotallyRamifiedExtension(U, Polynomial([10, 25, 125, 1]));
> R![[345, 21, 351345], [234, 2354,214], [2134, 2153254]];
(4*U.1 + 4 + 5 + (U.1 + 2)*5^3 + 3*5^4 + 4*U.1*5^5 + 2*U.1*5^6 + 2*U.1*5^7 +
U.1*5^9)*R.1^2 + (4*U.1^2 + 4*U.1 + 4 + (2*U.1^2 + 1)*5 + (3*U.1^2 + 4*U.1 +
4)*5^2 + (U.1^2 + 3*U.1 + 1)*5^3 + 3*U.1*5^4)*R.1 + U.1 + (4*U.1^2 + 4*U.1 +
4)*5 + (3*U.1^2 + 3)*5^2 + 2*5^3 + 2*U.1^2*5^4 + 2*U.1^2*5^5 + 2*U.1^2*5^6 +
4*U.1^2*5^7 + O(R.1^30)
> R`SeriesPrinting := true;
> R![[345, 21, 351345], [234, 2354,214], [2134, 2153254]];
U.1 + (4*U.1^2 + 4*U.1 + 4)*R.1 + (4*U.1 + 4)*R.1^2 + (3*U.1^2 + 3*U.1 +
3)*R.1^3 + (4*U.1^2 + 2)*R.1^4 + 2*R.1^5 + 3*U.1*R.1^6 + (2*U.1^2 + 3*U.1 +
2)*R.1^7 + (U.1^2 + 2)*R.1^8 + (3*U.1^2 + 4*U.1 + 2)*R.1^9 + (3*U.1^2 +
3)*R.1^10 + (U.1 + 3)*R.1^11 + (2*U.1^2 + U.1)*R.1^12 + (U.1^2 + 4*U.1 +
3)*R.1^13 + 3*R.1^14 + (4*U.1^2 + 3*U.1 + 2)*R.1^15 + (2*U.1^2 + 2)*R.1^16 +
3*U.1^2*R.1^17 + (2*U.1^2 + 3*U.1 + 3)*R.1^18 + (4*U.1^2 + 3*U.1 + 4)*R.1^19 +
(3*U.1^2 + 4)*R.1^20 + (U.1^2 + U.1 + 1)*R.1^21 + (3*U.1^2 + 4)*R.1^22 +
(4*U.1^2 + 2*U.1)*R.1^23 + (2*U.1^2 + 4)*R.1^24 + (4*U.1 + 1)*R.1^25 +
(4*U.1^2 + 2*U.1 + 1)*R.1^26 + (4*U.1^2 + 2)*R.1^27 + (U.1^2 + 2*U.1 +
1)*R.1^28 + (U.1^2 + U.1 + 2)*R.1^29 + O(R.1^30)
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|