Creation of Local Rings and Fields

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.

Creation Functions for the \(p\)-adics

pAdicRing(p, k): RngIntElt, RngIntElt -> RngPad

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

pAdicRing(p): RngIntElt -> RngPad

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.

pAdicQuotientRing(p, k): RngIntElt, RngIntElt -> RngPadRes

Given a prime integer \(p\) and non-negative single precision integer \(k\), construct the fixed precision quotient ring \({\mathbb{Z}}_{p} / p^{k} {\mathbb{Z}}_{p}\).

quo<L | x>: RngPad, RngPadElt -> .

Given a local ring \(L\), construct the quotient ring \(L / xL\), where \(x\) is an element of \(L\).

Example: Creating p-adic Rings (ex-65d82a)

Run in calculator (opens in a new tab)Copy input

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

Run in calculator (opens in a new tab)Copy input

Creation of Unramified Extensions

UnramifiedExtension(L, n): RngPad, RngIntElt -> RngPad

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 \(p^n - 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.

UnramifiedQuotientRing(K, k): FldFin, RngIntElt -> Rng

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): RngPad, RngUPolElt -> RngPad

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.

IsInertial(f): RngUPolElt -> BoolElt

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): FldPad, RngIntElt -> FldPad

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 \(p^f-1\)-th root of unity to \(R\). Functionally equivalent to calling UnramifiedExtension(R, f:Cyclotomic := true).

Example: Creating Unramified Extensions (ex-f8037d)

Run in calculator (opens in a new tab)Copy input

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

Run in calculator (opens in a new tab)Copy input

Creation of Totally Ramified Extensions

TotallyRamifiedExtension(L, f): RngPad, RngUPolElt -> RngPad

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.

IsEisenstein(f): RngUPolElt -> BoolElt

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

Example: Creating Totally Ramified Extensions (ex-11c692)

Run in calculator (opens in a new tab)Copy input

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

Run in calculator (opens in a new tab)Copy input

Creation of Unbounded Precision Extensions

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 \(\phi: {\mathbb{Z}}_{\ge 0} \to R[x]\), where \(R\) is a ring whose elements are coercible to the quotient rings \(L / \pi^k L\) for all \(k \in {\mathbb{Z}}_{\ge 0}\). The map \(\phi\), 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 \(\phi\) to compute the defining polynomial up to this precision. Magma may call \(\phi\) on any precision between zero and the precision of the most precise element created by the user.

ext<L | m>: RngPad, Map -> RngPad

ext<L | m>: FldPad, Map -> RngPad

Given a free precision local ring or field \(L\) and a map \(m\) with domain \({\mathbb{Z}}\) and codomain \(R[x]\), where elements of \(R\) are coercible to the quotient rings \(L / \pi^k L\) for all \(k \in {\mathbb{Z}}_{\ge 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 / \pi^k L\). Examples of suitable codomains \(R\) include the integers, rationals, or \(L\) itself.

Example: Unbounded Precision Extensions from Maps (ex-2d52e1)

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)

Run in calculator (opens in a new tab)Copy input

Creation of Related Rings

IntegerRing(F): FldPad -> RngPad

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.

RingOfIntegers(R): RngPad -> RngPad

Given a ring \(R\), this function simply returns it, it is provided to support generic functionality for finite extensions of rings and fields.

FieldOfFractions(R): RngPad -> FldPad

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

SplittingField(f, R): RngUPolElt[RngInt], RngPad -> RngPad

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

AbsoluteTotallyRamifiedExtension(R): RngPad -> RngPad, Map

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.

Other Elementary Constructions

Composite(R, S): RngPad, RngPad -> RngPad

For two \(p\)-adic fields that are normal over \({\mathbb{Q}}_p\), compute the compositum of \(R\) and \(S\), ie. the smallest field containing both \(R\) and \(S\).

Attributes of Local Rings and Fields

L`DefaultPrecision: RngPad -> RngIntElt

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.

L`SeriesPrinting: RngPad -> BoolElt

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.

L`SeriesPrinting: FldPad -> BoolElt

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.

L`SeriesPrinting: RngPadRes -> BoolElt

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.

L`SeriesPrinting: RngPadResExt -> BoolElt

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.

Example: Printing Elements as Series (ex-29e3f4)

Run in calculator (opens in a new tab)Copy input

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

Run in calculator (opens in a new tab)Copy input