Exact \(p\)-Adic Rings

Introduction

The exact \(p\)-adic rings and fields use representations which contain a kind and a list of dependencies. These rings and their elements can then be approximated to as much precision as the objects they depend on allow, some to arbitrary precision depending on their construction. Approximations are calculated to some epoch \(n\) which is equivalent to precision \(2^n\). Such representations are often referred to as “lazy” as the work of computing to precision is delayed until it is necessary. The exact \(p\)-adic rings and fields use the inexact \(p\)-adic rings and fields described in the majority of this chapter for approximations.

For example, an element of an exact \(p\)-adic ring resulting from the addition of 2 elements will store that it is the sum of these two elements and approximations to this sum are computed by adding the corresponding approximations of the summands, when such approximations are required.

An advantage of this lazy representation is that a precision does not have be decided before computations are started. A disadvantage of this exact representation occurs when approximations are required to incredibly high precision, some precisions which may be considerably time and space expensive.

Exact \(p\)-adic rings have type RngXPad, exact \(p\)-adic fields FldXPad, their elements RngXPadElt and FldXPadElt respectively. There is also a dedicated polynomial ring type RngUPolXPad whose elements have type RngUPolXPadElt.

For further information see [Dor21].

IsExactpAdic(x): Any -> BoolElt: Returns true if \(x\) is an exact \(p\)-adic object, such as a ring, field, element, or polynomial.

Exact \(p\)-adic Rings and Fields

In this section we describe the construction and functionality of the exact \(p\)-adic rings and fields.

Construction of Exact \(p\)-adic Rings and Fields

pAdicField(p : parameters): RngIntElt -> FldXPad

Exact : BoolElt                    Default: false
Global: BoolElt                    Default: true

Returns \({\mathbb{Q}}_p\) as an exact \(p\)-adic field if Exact is set to true otherwise returns an inexact \(p\)-adic field. If Global is set to false then a new object is constructed rather than reusing an existing object.

pAdicRing(p : parameters): RngIntElt -> FldXPad

Exact : BoolElt                    Default: false
Global: BoolElt                    Default: true

Returns \({\mathbb{Z}}_p\) as an exact \(p\)-adic integer ring if Exact is set to true otherwise returns an inexact \(p\)-adic field. If Global is set to false then a new object is constructed rather than reusing an identical existing object.

ext<K | f>: FldXPad, RngUPolElt -> RngXPad
ext<K | f>: FldXPad, RngUPolXPadElt -> RngXPad
ext<K | f>: FldXPad, [RngXPadElt] -> RngXPad
ext<K | d>: FldXPad, RngIntElt -> RngXPad
ext<K | f>: RngXPad, RngUPolElt -> RngXPad
ext<K | f>: RngXPad, RngUPolXPadElt -> RngXPad
ext<K | f>: RngXPad, [RngXPadElt] -> RngXPad
ext<K | d>: RngXPad, RngIntElt -> RngXPad: Construct the extension defined by the polynomial \(f\), which must be inertial or Eisenstein, or an unramified extension of degree \(d\).

Example: Constructing Exact p-adic Fields (ex-72b734)

The construction of an exact \(p\)-adic field is shown as well as extensions, both unramified and ramified.

> Qp := pAdicField(11 : Exact);
> U := ext<Qp | 3>;
> U;
Unramified extension of degree 3 of 11-adic field (exact)
> R := ext<U | Polynomial([11, 11^2, 1])>;
> R;
Totally ramified extension of degree 2 of Unramified extension of degree 3 of
11-adic field (exact)
> ext<Qp | Polynomial([3, 5, 1])>;
Unramified extension of degree 2 of 11-adic field (exact)
> ext<Qp | Polynomial([11, 2*11^2, 1])>;
Totally ramified extension of degree 2 of 11-adic field (exact)

Run in calculator (opens in a new tab)

Generating Elements

R . i: FldXPad, RngIntElt -> FldXPadElt
R . i: RngXPad, RngIntElt -> RngXPadElt
Name(R, i): RngXPad, RngIntElt -> RngXPadElt
Name(R, i): FldXPad, RngIntElt -> FldXPadElt: Given an exact \(p\)-adic ring or field \(R\) and a positive integer \(i\) return the \(i\)-th generator of \(R\).

AssignNames(~R, S): RngXPad, SeqEnum[MonStgElt]
AssignNames(~R, S): FldXPad, SeqEnum[MonStgElt]: Given an exact \(p\)-adic ring or field \(R\) assign the string in the sequence \(S\) of length 1 to be the name used when printing elements of \(R\). On construction of \(R\), R<x> can be used to assign the string "x" as the name to be used when printing in which case the identifier x will be assigned the value of R.1.

Generator(R): FldXPad -> FldXPadElt
Generator(R): RngXPad -> RngXPadElt: Returns the generator of the exact \(p\)-adic ring or field \(R\) over its base field. For extensions \(R\), a root of its defining polynomial is returned, otherwise 1.

UniformizingElement(R): FldXPad -> FldXPadElt
UniformizingElement(R): RngXPad -> RngXPadElt: Returns an element of valuation 1 of the exact \(p\)-adic ring or field \(R\).

ResidueGenerator(R): FldXPad -> FldXPadElt
ResidueGenerator(R): RngXPad -> RngXPadElt: Returns an element of valuation 0 whose residue class generates the residue class field of the exact \(p\)-adic ring or field \(R\) over \({\mathbb{F}}_p\).

AbsoluteGenerator(R): FldXPad -> FldXPadElt
AbsoluteGenerator(R): RngXPad -> RngXPadElt: An element which generates the exact \(p\)-adic ring or field \(R\) over its prime subfield. This will be either 1, a uniformizing element, a residue generator, or the sum of the two, depending on the inertia and ramification degrees.

Example: Generating Elements of Exact p-adic Rings (ex-1abc7d)

Run in calculator (opens in a new tab)

> Zp := pAdicRing(7 : Exact);
> Zp.1;
1 + O(7^20)
> UniformizingElement(Zp);
7 + O(7^20)
> ResidueGenerator(Zp);
1 + O(7^20)
> L := ext<ext<Zp | Polynomial([7, 77, 7*17, 1])> | 4>;
> BL := BaseRing(L);
> L.1;
L.1 + O($.1^20)
> Generator(L);
L.1 + O($.1^20)
> UniformizingElement(L);
BL.1 + O(BL.1^20)
> ResidueGenerator(L);
L.1 + O($.1^20)
> AbsoluteGenerator(L);
L.1 + BL.1 + O(BL.1^20)

Run in calculator (opens in a new tab)

Invariants

Prime(L): FldXPad -> RngIntElt
Prime(L): RngXPad -> RngIntElt: The (rational) prime \(p\) having valuation equal to the ramification degree of the exact \(p\)-adic ring or field \(L\).

Degree(L, K): FldXPad, FldXPad -> RngIntElt
Degree(L): FldXPad -> RngIntElt
Degree(L): RngXPad -> RngIntElt
Degree(L, K): RngXPad, RngXPad -> RngIntElt: The degree of the extension \(L\) over the exact \(p\)-adic ring or field \(K\) if given or the base ring of \(L\) otherwise.

InertiaDegree(L, K): FldXPad, FldXPad -> RngIntElt
InertiaDegree(L): FldXPad -> RngIntElt
InertiaDegree(L, K): RngXPad, RngXPad -> RngIntElt
InertiaDegree(L): RngXPad -> RngIntElt: The inertia degree of the extension \(L\) over the exact \(p\)-adic ring or field \(K\) if given or the base ring of \(L\) otherwise.

RamificationDegree(L, K): FldXPad, FldXPad -> RngIntElt
RamificationDegree(L): FldXPad -> RngIntElt
RamificationIndex(L): FldXPad -> RngIntElt
RamificationIndex(L, K): FldXPad, FldXPad -> RngIntElt
RamificationDegree(L): RngXPad -> RngIntElt
RamificationDegree(L, K): RngXPad, RngXPad -> RngIntElt
RamificationIndex(L): RngXPad -> RngIntElt
RamificationIndex(L, K): RngXPad, RngXPad -> RngIntElt: The ramification degree of the extension \(L\) over the exact \(p\)-adic ring or field \(K\) if given or the base ring of \(L\) otherwise.

DefiningPolynomial(R): RngXPad -> RngUPolElt

DefiningPolynomial(R): FldXPad -> RngUPolElt

Exact: BoolElt                    Default: true

Given an exact \(p\)-adic ring or field \(R\) returns the defining polynomial of \(R\) with type RngUPolElt, unless Exact is set to true, in which case the polynomial is returned with type RngUPolXPadElt.

AbsoluteDegree(F): FldXPad -> RngIntElt
AbsoluteInertiaDegree(L): FldXPad -> RngIntElt
AbsoluteInertiaIndex(L): FldXPad -> RngIntElt
AbsoluteRamificationDegree(L): FldXPad -> RngIntElt
AbsoluteRamificationIndex(L): FldXPad -> RngIntElt
AbsoluteDegree(F): RngXPad -> RngIntElt
AbsoluteInertiaDegree(L): RngXPad -> RngIntElt
AbsoluteInertiaIndex(L): RngXPad -> RngIntElt
AbsoluteRamificationDegree(L): RngXPad -> RngIntElt
AbsoluteRamificationIndex(L): RngXPad -> RngIntElt: The degree, inertia degree, or ramification degree of the exact \(p\)-adic ring or field \(L\) over its prime subfield.

DiscriminantValuation(L): FldXPad -> RngIntElt
DiscriminantValuation(L, K): FldXPad, FldXPad -> RngIntElt
DiscriminantValuation(L, K): RngXPad, RngXPad -> RngIntElt
DiscriminantValuation(L): RngXPad -> RngIntElt: The valuation of the discriminant of the extension \(L/K\) of exact \(p\)-adic rings or fields. This is computed as the height of the leftmost vertex of the ramification polygon (and so avoids actually computing the discriminant). If it is not specified \(K\) defaults to the base ring of \(L\).

RamificationPolygon(L): FldXPad -> NwtnPgon

RamificationPolygon(L, K): FldXPad, FldXPad -> NwtnPgon

RamificationPolygon(L, K): RngXPad, RngXPad -> NwtnPgon

RamificationPolygon(L): RngXPad -> NwtnPgon

RamificationPolygon(f): RngUPolXPadElt[FldXPad] -> NwtnPgon

RamificationPolygon(f): RngUPolXPadElt[RngXPad] -> NwtnPgon

Constructs the ramification polygon of the Eisenstein or inertial polynomial \(f\) over an exact \(p\)-adic ring or field. The input can instead be an extension \(L/K\), where \(K\) defaults to the base ring of \(L\) if it is not specified.

The locations and slopes of the vertices correspond to different subfields fixed by different ramification subgroups of the Galois group. For example a horizontal face corresponds to an unramified subfield, and a face of slope -1 corresponds to a tame subfield. This is represented as a Newton Polygon (type NwtnPgon).

Example: Invariants of Exact p-adic Fields (ex-5789a2)

Run in calculator (opens in a new tab)

> Qp := pAdicField(17 : Exact);
> Prime(Qp);
17
> Degree(Qp);
1
> L := ext<ext<Qp | 7> | Polynomial([3*17, 4*17^2, 2*17, 1])>;
> Prime(L);
17
> Degree(L);
3
> Degree(L, Qp);
21
> Degree(L, BaseField(L));
3
> InertiaDegree(L);
1
> RamificationDegree(L);
3
> DefiningPolynomial(L);
(1 + O(17^20))*$.1^3 + (2*17 + O(17^21))*$.1^2 + (4*17^2 + O(17^22))*$.1 + 3*17
    + O(17^21)
> Parent($1);
Univariate Polynomial Ring over Unramified extension of degree 7 of 17-adic
field (exact)
> DefiningPolynomial(CoefficientField(L));
(1 + O(17^20))*$.1^7 + O(17^2048)*$.1^6 + O(17^2048)*$.1^5 + O(17^2048)*$.1^4 +
    O(17^2048)*$.1^3 + O(17^2048)*$.1^2 + (12 + O(17^20))*$.1 + 14 + O(17^20)
> DefiningPolynomial(L : Exact);
(1 + O(17^20))*$.1^3 + (2*17 + O(17^21))*$.1^2 + (4*17^2 + O(17^22))*$.1 + 3*17
    + O(17^21)
> Parent($1);
Univariate polynomial ring (exact) over Unramified extension of degree 7 of
17-adic field (exact)
> AbsoluteDegree(L);
21
> DiscriminantValuation(L);
2
> DiscriminantValuation(L, Qp);
2
> RamificationPolygon(L);
Newton Polygon with vertices {(1, 2), (3, 0)} and defining points {(1, 2), (2,
1), (3, 0)}

Run in calculator (opens in a new tab)

Exact \(p\)-adic Elements

In this section we describe the construction and functionality related to elements of exact \(p\)-adic rings and fields.

GetExactpAdicsPrintPrecision() -> RngIntElt: Returns the precision to which exact \(p\)-adic objects are printed by default.

SetExactpAdicsPrintPrecision(k): Infty
SetExactpAdicsPrintPrecision(k): RngIntElt: Set the precision to which exact \(p\)-adic objects are printed by default to the integer \(k\) or \(\infty\).

K ! x: FldXPad, Any -> FldXPadElt

R ! x: RngXPad, Any -> RngXPadElt

elt<K | x>: FldXPad, Any -> FldXPadElt

elt<R | x>: RngXPad, Any -> RngXPadElt

Elements of an exact \(p\)-adic ring or field may be coerced from:

Integers or rationals
Any base field
The residue class field
Any compatible finite-precision \(p\)-adic field, ring, or quotient ring

In the latter two cases, the coerced element has its precision capped to the precision of \(x\), so is not really “exact”. To select a full-precision lift, use CoerceAndLift(K,x).

AbsolutePrecision(x): FldXPadElt -> RngIntElt
AbsolutePrecision(x): RngXPadElt -> RngIntElt: The precision of the exact \(p\)-adic element \(x\) relative to valuation 0.

RelativePrecision(x): FldXPadElt -> RngIntElt
RelativePrecision(x): RngXPadElt -> RngIntElt: The precision of the exact \(p\)-adic element \(x\) relative to its weak valuation. The relative precision is zero if and only if \(x\) is weakly zero.

Valuation(x): FldXPadElt -> RngIntElt
Valuation(x): RngXPadElt -> RngIntElt: The valuation of the exact \(p\)-adic element \(x\). Note that if \(x\) is weakly zero, its epoch will be increased until it is no longer weakly zero, or until its weak valuation is infinite. If \(x\) is actually zero, this could compute forever.

WeakValuation(x): RngXPadElt -> RngIntElt
WeakValuation(x): FldXPadElt -> RngIntElt: A lower bound on the valuation of the exact \(p\)-adic element \(x\). It is equal to the true valuation unless \(x\) is weakly zero.

ShiftValuation(x, n): FldXPadElt, RngIntElt -> FldXPadElt
ShiftValuation(x, n): RngXPadElt, RngIntElt -> RngXPadElt: Multiply the exact \(p\)-adic element \(x\) by the \(m\)th power of the uniformizing element. This returns an element whose valuation is \(m\) more than that of \(x\).

ValuationEq(x, n): FldXPadElt, RngIntElt -> BoolElt
ValuationEq(x, n): FldXPadElt, Infty -> BoolElt
ValuationEq(x, n): RngXPadElt, RngIntElt -> BoolElt
ValuationEq(x, n): RngXPadElt, Infty -> BoolElt
ValuationNe(x, n): FldXPadElt, RngIntElt -> BoolElt
ValuationNe(x, n): FldXPadElt, Infty -> BoolElt
ValuationNe(x, n): RngXPadElt, RngIntElt -> BoolElt
ValuationNe(x, n): RngXPadElt, Infty -> BoolElt
ValuationGe(x, n): FldXPadElt, RngIntElt -> BoolElt
ValuationGe(x, n): FldXPadElt, Infty -> BoolElt
ValuationGe(x, n): RngXPadElt, RngIntElt -> BoolElt
ValuationGe(x, n): RngXPadElt, Infty -> BoolElt
ValuationGt(x, n): FldXPadElt, Infty -> BoolElt
ValuationGt(x, n): FldXPadElt, RngIntElt -> BoolElt
ValuationGt(x, n): RngXPadElt, RngIntElt -> BoolElt
ValuationGt(x, n): RngXPadElt, Infty -> BoolElt
ValuationLe(x, n): FldXPadElt, Infty -> BoolElt
ValuationLe(x, n): FldXPadElt, RngIntElt -> BoolElt
ValuationLe(x, n): RngXPadElt, RngIntElt -> BoolElt
ValuationLe(x, n): RngXPadElt, Infty -> BoolElt
ValuationLt(x, n): FldXPadElt, RngIntElt -> BoolElt
ValuationLt(x, n): FldXPadElt, Infty -> BoolElt
ValuationLt(x, n): RngXPadElt, Infty -> BoolElt
ValuationLt(x, n): RngXPadElt, RngIntElt -> BoolElt: Compare the valuation of the exact \(p\)-adic element \(x\) to \(n\). These always terminate.

IsUnit(x): RngXPadElt -> BoolElt
IsUnit(x): FldXPadElt -> BoolElt: Return true if the exact \(p\)-adic element \(x\) is a unit.

IsIntegral(x): RngXPadElt -> BoolElt
IsIntegral(x): FldXPadElt -> BoolElt: Returns true if the exact \(p\)-adic element \(x\) is an integer.

IsWeaklyZero(x): StrAnyXPadElt -> BoolElt
IsWeaklyEqual(x, y): StrAnyXPadElt, StrAnyXPadElt -> BoolElt: Returns true if the exact \(p\)-adic element \(x\), respectively \(x-y\), is zero up to its current precision. If \(x\), respectively \(x-y\), is zero then it is weakly zero, but not necessarily the other way around.

IsDefinitelyZero(x): StrAnyXPadElt -> BoolElt
IsDefinitelyEqual(x, y): StrAnyXPadElt, StrAnyXPadElt -> BoolElt: Returns true if the exact \(p\)-adic element \(x\) is definitely zero, respectively, \(x\) and \(y\) are identical or both definitely zero.

CoerceAndLift(S, x): StrAnyXPad, Any -> StrAnyXPadElt: Coerce \(x\) into the exact \(p\)-adic structure \(S\), and ensure its precision is unbounded. If \(x\) is a finite-precision object, then ordinary coercion S!x will have capped precision whereas CoerceAndLift(S,x) will “lift” this to have unbounded precision

Arithmetic with Elements

x * y: FldXPadElt, FldXPadElt -> FldXPadElt
x * y: RngXPadElt, RngXPadElt -> RngXPadElt
x + y: FldXPadElt, FldXPadElt -> FldXPadElt
x + y: RngXPadElt, RngXPadElt -> RngXPadElt
- y: FldXPadElt -> FldXPadElt
- y: RngXPadElt -> RngXPadElt
x - y: RngXPadElt, RngXPadElt -> RngXPadElt
x - y: FldXPadElt, FldXPadElt -> FldXPadElt
x ^ n: FldXPadElt, RngIntElt -> FldXPadElt
x ^ n: RngXPadElt, RngIntElt -> RngXPadElt
x / y: FldXPadElt, FldXPadElt -> FldXPadElt
x / y: RngXPadElt, RngXPadElt -> RngXPadElt
x div y: RngXPadElt, RngXPadElt -> RngXPadElt
Quotrem(x, y): RngXPadElt, RngXPadElt -> RngXPadElt, RngXPadElt
GCD(x, y): FldXPadElt, FldXPadElt -> FldXPadElt
Gcd(x, y): FldXPadElt, FldXPadElt -> FldXPadElt
GreatestCommonDivisor(x, y): FldXPadElt, FldXPadElt -> FldXPadElt
GCD(x, y): RngXPadElt, RngXPadElt -> RngXPadElt
Gcd(x, y): RngXPadElt, RngXPadElt -> RngXPadElt
GreatestCommonDivisor(x, y): RngXPadElt, RngXPadElt -> RngXPadElt: Given exact \(p\)-adic elements \(x\) and \(y\) return their greatest common divisor.

ExtendedGreatestCommonDivisor(x, y): FldXPadElt, FldXPadElt -> FldXPadElt, FldXPadElt, FldXPadElt
XGCD(x, y): FldXPadElt, FldXPadElt -> FldXPadElt, FldXPadElt, FldXPadElt
Xgcd(x, y): FldXPadElt, FldXPadElt -> FldXPadElt, FldXPadElt, FldXPadElt
ExtendedGreatestCommonDivisor(x, y): RngXPadElt, RngXPadElt -> RngXPadElt, RngXPadElt, RngXPadElt
XGCD(x, y): RngXPadElt, RngXPadElt -> RngXPadElt, RngXPadElt, RngXPadElt
Xgcd(x, y): RngXPadElt, RngXPadElt -> RngXPadElt, RngXPadElt, RngXPadElt: Given exact \(p\)-adic elements \(x\) and \(y\) return their greatest common divisor \(g\) as well as \(a\) and \(b\) such that \(g = a x + b y\).

Example: Arithmetic with Exact p-adic Elements (ex-bdd87d)

Run in calculator (opens in a new tab)

> Zp := pAdicRing(19 :  Exact);
> x := Zp!3948701;
> y := Zp!748873*19;
> x;
3948701 + O(19^20)
> y;
14228587 + O(19^20)
> FieldOfFractions(Zp)!x;
3948701 + O(19^20)
> FieldOfFractions(Zp)!y;
748873*19 + O(19^21)
> AbsolutePrecision(x);
32
> RelativePrecision(x);
32
> Valuation(x);
0
> WeakValuation(x);
0
> ShiftValuation(x, 5);
9777374597399 + O(19^20)
> ValuationGe($1, 5);
true
> IsUnit(x);
true
> IsIntegral(x);
true
> Valuation(y);
1
> x + y;
18177288 + O(19^20)
> x*y;
56184435715487 + O(19^20)
> Valuation(y^5);
5
> x/y;
-14678086202175978502286566*19^-1 + O(19^19)
> Quotrem(x, y);
O(19^20) 3948701 + O(19^20)
> Quotrem(y, x);
15372121930607214329737477 + O(19^20) O(19^20)
> Gcd(x, y);
3948701 + O(19^20)
> Xgcd(19*x, y);
75025319 + O(19^20) 1 + O(19^20) O(19^20)
> IsWeaklyZero(Zp!0);
true
> IsDefinitelyZero(Zp!0);
false
> IsDefinitelyZero(FieldOfFractions(Zp)!0);
true
> IsDefinitelyEqual(x, x);
true
> CoerceAndLift(Zp, 0);
O(19^20)
> IsWeaklyZero($1);
true
> IsDefinitelyZero($2);
false
> CoerceAndLift(FieldOfFractions(Zp), 0);
0
> IsDefinitelyZero($1);
true

Run in calculator (opens in a new tab)

Polynomials over Exact \(p\)-adic Rings and Fields

While polynomial rings of type RngUPol and polynomials of type RngUPolElt can be constructed in the regular way over exact \(p\)-adic rings and fields there is also a specific type of polynomial rings which can be constructed over the exact \(p\)-adic rings and fields. These polynomial rings have type RngUPolXPad and their elements have type RngUPolXPadElt.

Exact Polynomial Rings

In this section we describe the construction and functionality for polynomial rings of type RngUPolXPad.

PolynomialRing(R : parameters): Rng -> RngUPol

Global: BoolElt                    Default: true
Exact : BoolElt                    Default: false

A polynomial ring specifically to parent polynomials with exact \(p\)-adic coefficients exists to be able to implement new kinds of polynomials which are best implemented by giving approximations of the entire polynomial wholesale, instead of giving each coefficient individually. This ring is constructed when the Exact parameter is set to true, otherwise an ordinary polynomial ring over the exact \(p\)-adic ring or field \(R\) is constructed.

R eq T: RngUPolXPad, RngUPolXPad -> BoolElt: Given polynomial rings \(R\) and \(T\) over exact \(p\)-adic rings or fields, return whether \(R\) and \(T\) are equal.

BaseRing(R): RngUPolXPad -> Rng
CoefficientRing(R): RngUPolXPad -> Rng: Returns the coefficient ring of the polynomial ring \(R\) over an exact \(p\)-adic ring or field.

R . i: RngUPolXPad, RngIntElt -> RngXPadElt
Name(R, i): RngUPolXPad, RngIntElt -> RngUPolXPadElt
Generator(R): RngUPolXPad -> RngUPolXPadElt: Returns the polynomial variable of the polynomial ring \(R\) over an exact \(p\)-adic ring of field.

AssignNames(~R, S): RngUPolXPad, SeqEnum[MonStgElt]: Given a polynomial ring over an exact \(p\)-adic ring or field \(R\) assign the string in the sequence \(S\) of length 1 to be the name used for the variable of \(R\) when printing elements of \(R\). On construction of \(R\), R<x> can be used to assign the string "x" as the name to be used when printing in which case the identifier x will be assigned the value of R.1.

Example: Exact p-adic Polynomial Rings (ex-b44a56)

> Zp := pAdicRing(7 : Exact);
> PolynomialRing(Zp);
Univariate Polynomial Ring over 7-adic ring (exact)
> PolynomialRing(Zp : Exact);
Univariate polynomial ring (exact) over 7-adic ring (exact)

Run in calculator (opens in a new tab)

Polynomials

In these next sections we describe the construction and functionality for polynomials of type RngUPolXPadElt.

R ! f: RngUPolXPad, Any -> RngUPolXPadElt

Polynomials with exact \(p\)-adic coefficients can be constructed from:

Other polynomials, either exact or ordinary, over any exact p-adic ring.
Sequences of coefficients coercible to the base ring.
Anything coercible to the base ring. If you are coercing from finite-precision rings, CoerceAndLift(R,f) may be appropriate.

BaseRing(f): RngUPolXPadElt -> Rng
CoefficientRing(f): RngUPolXPadElt -> Rng: Returns the coefficient ring of the polynomial \(f\) over an exact \(p\)-adic ring or field.

CanChangeRing(f, R): RngUPolXPadElt, Rng -> BoolElt, RngUPolXPadElt
ChangeRing(f, R): RngUPolXPadElt, Rng -> RngUPolXPadElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field and a ring \(R\), return whether the coefficients of \(f\) can be coerced into \(R\) and the polynomial with those coefficients in \(R\) if so.

Degree(f): RngUPolXPadElt -> RngIntElt: Given a polynomial \(f\) returns the true degree of \(f\). That is, the corresponding leading coefficient is known to be non-zero.

WeakDegree(f): RngUPolXPadElt -> RngIntElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field, returns an upper bound on the degree of \(f\). That is, the corresponding leading coefficient may be weakly zero.

Coefficient(f, i): RngUPolXPadElt, RngIntElt -> RngElt
Coefficients(f): RngUPolXPadElt -> SeqEnum: Given a polynomial \(f\) return the \(i\)th coefficient and all coefficients of \(f\) respectively.

ExactPolynomial(f): RngUPolXPadElt -> RngUPolXPadElt
ExactPolynomial(f): RngUPolElt -> RngUPolXPadElt: Given a polynomial \(f\) of type RngUPolElt over an exact \(p\)-adic ring or field, convert \(f\) into a polynomial of type RngUPolXPadElt.

Evaluate(f, x): RngUPolXPadElt, Any -> RngAnyXPadElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field and an element \(x\) coercible into the coefficient ring of \(f\) return the value of \(f\) when the variable is replaced by \(x\).

Derivative(f, m): RngUPolXPadElt, RngIntElt -> RngUPolXPadElt
Derivative(f): RngUPolXPadElt -> RngUPolXPadElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field and an integer \(m\), return the \(m\)th derivative of \(f\) or the first derivative if \(m\) is not specified.

Discriminant(f): RngUPolXPadElt -> RngAnyXPadElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field, return the discriminant, the product of the differences between the roots of \(f\).

Resultant(f, g): RngUPolXPadElt, RngUPolXPadElt -> RngAnyXPadElt: Given polynomials \(f\) and \(g\) over an exact \(p\)-adic ring or field, return their resultant.

IsInertial(f): RngUPolXPadElt -> BoolElt
IsEisenstein(f): RngUPolXPadElt -> BoolElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field, return whether the polynomial is inertial or Eisenstein, respectively.

IsWeaklyZero(f): StrAnyXPadElt -> BoolElt
IsWeaklyEqual(f, g): StrAnyXPadElt, StrAnyXPadElt -> BoolElt: Returns true if the exact \(p\)-adic polynomial \(f\), respectively \(f-g\), is zero up to its current precision. If \(f\), respectively \(f-g\), is zero then it is weakly zero, but not necessarily the other way around.

IsDefinitelyZero(f): StrAnyXPadElt -> BoolElt
IsDefinitelyEqual(f, g): StrAnyXPadElt, StrAnyXPadElt -> BoolElt: Returns true if the exact \(p\)-adic polynomial \(f\) is definitely zero, respectively, \(f\) and \(g\) are identical or both definitely zero.

CoerceAndLift(S, x): StrAnyXPad, Any -> StrAnyXPadElt: Coerce \(x\) into the exact \(p\)-adic structure \(S\), and ensure its precision is unbounded. If \(x\) is a finite-precision object, then ordinary coercion S!x will have capped precision whereas CoerceAndLift(S,x) will “lift” this to have unbounded precision

Arithmetic

x * y: RngUPolXPadElt, RngUPolXPadElt -> RngUPolXPadElt

- y: RngUPolXPadElt -> RngUPolXPadElt

x + y: RngUPolXPadElt, RngUPolXPadElt -> RngUPolXPadElt

x - y: RngUPolXPadElt, RngUPolXPadElt -> RngUPolXPadElt

x / c: RngUPolXPadElt, RngElt -> RngUPolXPadElt

x ^ n: RngUPolXPadElt, RngIntElt -> RngUPolXPadElt

Quotrem(x, y): RngUPolXPadElt, RngUPolXPadElt -> RngUPolXPadElt

x div y: RngUPolXPadElt, RngUPolXPadElt -> RngUPolXPadElt

x mod y: RngUPolXPadElt, RngUPolXPadElt -> RngUPolXPadElt

Example: Arithmetic with Exact p-adic Polynomials (ex-88ff30)

Run in calculator (opens in a new tab)

> Qp := pAdicField(11 : Exact);
> f := Polynomial(Qp, [3241, 245, 134, 1345, 125, 1542]);
> f;
(1542 + O(11^20))*$.1^5 + (125 + O(11^20))*$.1^4 + (1345 + O(11^20))*$.1^3 +
    (134 + O(11^20))*$.1^2 + (245 + O(11^20))*$.1 + 3241 + O(11^20)
> f := ExactPolynomial(f); f;
(1542 + O(11^20))*$.1^5 + (125 + O(11^20))*$.1^4 + (1345 + O(11^20))*$.1^3 +
    (134 + O(11^20))*$.1^2 + (245 + O(11^20))*$.1 + 3241 + O(11^20)
> BaseRing(f);
11-adic field (exact)
> CanChangeRing(f, Integers(Qp));
true (1542 + O(11^20))*$.1^5 + (125 + O(11^20))*$.1^4 + (1345 + O(11^20))*$.1^3
    + (134 + O(11^20))*$.1^2 + (245 + O(11^20))*$.1 + 3241 + O(11^20)
> Degree(f);
5
> WeakDegree(ExactPolynomial(f));
5
> Coefficient(f, 2);
134 + O(11^20)
> Evaluate(f, Qp.1);
6632 + O(11^20)
> Derivative(f, 2);
(30840 + O(11^20))*$.1^3 + (1500 + O(11^20))*$.1^2 + (8070 + O(11^20))*$.1 + 268
    + O(11^20)
> Discriminant(f);
-77083727534419762054 + O(11^20)
> Resultant(f, Derivative(f));
213641244987848541309 + O(11^20)
> IsInertial(f);
true
> IsEisenstein(f);
false
> IsWeaklyZero(PolynomialRing(Qp : Exact)!0);
true
> IsDefinitelyZero(PolynomialRing(Qp : Exact)!0);
true
> IsWeaklyZero(f-f);
true
> IsDefinitelyZero(f-f);
false
> IsDefinitelyEqual(f, f);
true

Run in calculator (opens in a new tab)

Factorization and Roots

The functionality in this section is related to taking roots and computing factorizations of polynomials. For some of these intrinsics there are restrictions on the input polynomial regarding multiple factors. Since no finite precision \(p\)-adic algorithm can provbably identify equal roots multiple factors are not checked for and some intrinsics may run forever on input having multiple factors.

NewtonPolygon(f): RngUPolXPadElt[RngXPad] -> NwtnPgon
NewtonPolygon(f): RngUPolXPadElt[FldXPad] -> NwtnPgon: Returns the Newton polygon of the polynomial \(f\) over an exact \(p\)-adic ring or field.

Roots(f, R): RngUPolElt, FldXPad -> SeqEnum

Roots(f, R): RngUPolElt, RngXPad -> SeqEnum

Roots(f, R): RngUPolXPadElt, RngXPad -> SeqEnum

Roots(f, R): RngUPolXPadElt, FldXPad -> SeqEnum

Roots(f): RngUPolXPadElt[FldXPad] -> SeqEnum

Roots(f): RngUPolXPadElt[RngXPad] -> SeqEnum

Max: Infty                    Default: Infinity()

Given a polynomial \(f\) over an exact \(p\)-adic ring or field, return the roots of \(f\) in the exact \(p\)-adic field or ring \(R\) or the base ring of \(f\) if \(R\) is not specified. The polynomial \(f\) must have no repeated roots (without further assumptions on the structure of the polynomial, no finite-precision \(p\)-adic algorithm can provably identify a set of equal roots).

HasRoot(f): RngUPolXPadElt[RngXPad] -> BoolElt, RngXPadElt
HasRoot(f): RngUPolXPadElt[FldXPad] -> BoolElt, FldXPadElt
HasRoot(f): RngUPolElt[RngXPad] -> BoolElt, RngXPadElt
HasRoot(f): RngUPolElt[FldXPad] -> BoolElt, FldXPadElt
HasRoot(f, R): RngUPolElt, FldXPad -> BoolElt, FldXPadElt
HasRoot(f, R): RngUPolElt, RngXPad -> BoolElt, RngXPadElt
HasRoot(f, R): RngUPolXPadElt, FldXPad -> BoolElt, FldXPadElt
HasRoot(f, R): RngUPolXPadElt, RngXPad -> BoolElt, RngXPadElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field, return whether \(f\) has a root in the exact \(p\)-adic ring or field \(R\) or the base ring of \(f\) if \(R\) is not specified. If \(f\) does have such a root then also return one root. The polynomial \(f\) must have no repeated roots (see Roots above).

Factorization(f, R): RngUPolXPadElt, FldXPad -> SeqEnum, RngXPadElt, SeqEnum

Factorisation(f, R): RngUPolXPadElt, FldXPad -> SeqEnum, RngXPadElt, SeqEnum

Factorisation(f, R): RngUPolXPadElt, RngXPad -> SeqEnum, RngXPadElt, SeqEnum

Factorization(f, R): RngUPolXPadElt, RngXPad -> SeqEnum, RngXPadElt, SeqEnum

Factorization(f, R): RngUPolElt, RngXPad -> SeqEnum, RngXPadElt, SeqEnum

Factorisation(f, R): RngUPolElt, RngXPad -> SeqEnum, RngXPadElt, SeqEnum

Factorisation(f, R): RngUPolElt, FldXPad -> SeqEnum, RngXPadElt, SeqEnum

Factorization(f, R): RngUPolElt, FldXPad -> SeqEnum, RngXPadElt, SeqEnum

Factorization(f): RngUPolXPadElt[RngXPad] -> SeqEnum, RngXPadElt, SeqEnum

Factorization(f): RngUPolXPadElt[FldXPad] -> SeqEnum, FldXPadElt, SeqEnum

Factorisation(f): RngUPolXPadElt[RngXPad] -> SeqEnum, RngXPadElt, SeqEnum

Factorisation(f): RngUPolXPadElt[FldXPad] -> SeqEnum, FldXPadElt, SeqEnum

Certificates : BoolElt                      Default: false
Extensions   : BoolElt                      Default: false
Max          : Infty                        Default: Infinity()
DegreeDivides: RngIntElt                    Default: 0
DegreeGe     : RngIntElt                    Default: 1

Given a polynomial \(f\) over an exact \(p\)-adic ring or field, return the factorization of \(f\) over \(R\) if given or the coefficient ring of \(f\) otherwise. The polynomial \(f\) must have no repeated factors (for similar reasons to Roots above). A scaling factor is also returned, so that the product of the factors equals \(f\) multiplied by the scaling factor.

If the parameter Certificates is set to true, a corresponding sequence of certificates for each factor is also returned. If the parameter Extensions is set to true, (which implies Certificates) then each certificate also includes the extension defined by the factor.

IsIrreducible(f): RngUPolXPadElt[RngXPad] -> BoolElt, Rec

IsIrreducible(f): RngUPolXPadElt[FldXPad] -> BoolElt, Rec

IsIrreducible(f): RngUPolElt[RngXPad] -> BoolElt, Rec

IsIrreducible(f): RngUPolElt[FldXPad] -> BoolElt, Rec

Extension  : BoolElt                    Default: false
Certificate: BoolElt                    Default: false

Given a polynomial \(f\) over an exact \(p\)-adic ring or field, return whether \(f\) is irreducible. It must have at least one non-repeated factor (for similar reasons to Roots above). If the parameters Extension or Certificate are given, the second return value is as in Factorization.

IsHenselLiftable(f, x): RngUPolElt, FldXPadElt -> BoolElt, FldXPadElt
IsHenselLiftable(f, x): RngUPolElt, RngXPadElt -> BoolElt, RngXPadElt
IsHenselLiftable(f, x): RngUPolXPadElt, FldXPadElt -> BoolElt, FldXPadElt
IsHenselLiftable(f, x): RngUPolXPadElt, RngXPadElt -> BoolElt, RngXPadElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field and an element \(x\) of an exact \(p\)-adic ring or field return whether \(x\) is close enough to a root of \(f\) to be Hensel lifted to that root. If so, returns the lifted root.

RamificationResidualPolynomial(f, face): RngUPolElt[FldXPad], NwtnPgonFace -> RngUPolElt
RamificationResidualPolynomial(f, face): RngUPolElt[RngXPad], NwtnPgonFace -> RngUPolElt
RamificationResidualPolynomial(f, face): RngUPolXPadElt[FldXPad], NwtnPgonFace -> RngUPolElt
RamificationResidualPolynomial(f, face): RngUPolXPadElt[RngXPad], NwtnPgonFace -> RngUPolElt: Given a polynomial \(f\) over an exact \(p\)-adic ring or field, return the residual polynomial associated to the given \(face\) of the ramifcation polygon of \(f\).

RamificationResidualPolynomials(f): RngUPolElt[FldXPad] -> SeqEnum, NwtnPgon
RamificationResidualPolynomials(f): RngUPolElt[RngXPad] -> SeqEnum, NwtnPgon
RamificationResidualPolynomials(f): RngUPolXPadElt[FldXPad] -> SeqEnum, NwtnPgon
RamificationResidualPolynomials(f): RngUPolXPadElt[RngXPad] -> SeqEnum, NwtnPgon: Given an inertial or Eisenstein polynomial \(f\) over an exact \(p\)-adic ring or field, return the residual polynomials assiociated to each face of the ramification polygon of \(f\), and the ramification polygon itself.

Example: Factorization over Exact p-adic Fields (ex-95a032)

Run in calculator (opens in a new tab)

> Qp := pAdicField(17 : Exact);
> P<x> := PolynomialRing(Qp : Exact);
> f := (x - 14)*(x - Qp.1)*(x - Qp.1 - 1);
> NewtonPolygon(f);
Newton Polygon with vertices {(0, 0), (3, 0)} and defining points {(0, 0), (3,
0)}
> HasRoot(f);
true 14 + O(17^20)
> Roots(f);
[ <14 + O(17^20), 1>, <2 + O(17^20), 1>, <1 + O(17^20), 1> ]
> Factorization(f);
[ <(1 + O(17^20))*x - 14 + O(17^20), 1>, <(1 + O(17^20))*x - 2 + O(17^20), 1>,
<(1 + O(17^20))*x - 1 + O(17^20), 1> ]
1 + O(17^20)
> IsIrreducible(f);
false
> IsHenselLiftable(f, Qp!14);
true 14 + O(17^20)
> IsHenselLiftable(f, Qp!10);
false
> RamificationResidualPolynomials(x^3 + 3*17*x^2 + 2*17^2*x + 5*17);
[
    $.1^2 + 3*$.1 + 3
]
Newton Polygon with vertices {(1, 2), (3, 0)} and defining points {(1, 2), (2,
    1), (3, 0)}

Run in calculator (opens in a new tab)

Exact \(p\)-Adic Rings#

Introduction#

Exact \(p\)-adic Rings and Fields#

Construction of Exact \(p\)-adic Rings and Fields#

Related Structures#

Generating Elements#

Invariants#

Exact \(p\)-adic Elements#

Arithmetic with Elements#

Polynomials over Exact \(p\)-adic Rings and Fields#

Exact Polynomial Rings#

Polynomials#

Arithmetic#

Factorization and Roots#

Exact \(p\)-Adic Rings

Introduction

Exact \(p\)-adic Rings and Fields

Construction of Exact \(p\)-adic Rings and Fields

Related Structures

Generating Elements

Invariants

Exact \(p\)-adic Elements

Arithmetic with Elements

Polynomials over Exact \(p\)-adic Rings and Fields

Exact Polynomial Rings

Polynomials

Arithmetic

Factorization and Roots