Valuations which are defined as limits of valuations.#

The discrete valuation of a complete field extends uniquely to a finite field extension. This is not the case anymore for fields which are not complete with respect to their discrete valuation. In this case, the extensions essentially correspond to the factors of the defining polynomial of the extension over the completion. However, these factors only exist over the completion and this makes it difficult to write down such valuations with a representation of finite length.

More specifically, let \(v\) be a discrete valuation on \(K\) and let \(L=K[x]/(G)\) a finite extension thereof. An extension of \(v\) to \(L\) can be represented as a discrete pseudo-valuation \(w'\) on \(K[x]\) which sends \(G\) to infinity. However, such \(w'\) might not be described by an augmented valuation over a Gauss valuation anymore. Instead, we may need to write is as a limit of augmented valuations.

The classes in this module provide the means of writing down such limits and resulting valuations on quotients.

AUTHORS:

Julian Rüth (2016-10-19): initial version

EXAMPLES:

In this function field, the unique place of K which corresponds to the zero point has two extensions to L. The valuations corresponding to these extensions can only be approximated:

sage: K.<x> = FunctionField(QQ)
sage: R.<y> = K[]
sage: L.<y> = K.extension(y^2 - x)

sage: v = K.valuation(1)
sage: w = v.extensions(L); w
[[ (x - 1)-adic valuation, v(y + 1) = 1 ]-adic valuation,
 [ (x - 1)-adic valuation, v(y - 1) = 1 ]-adic valuation]

The same phenomenon can be observed for valuations on number fields:

sage: K = QQ
sage: R.<t> = K[]
sage: L.<t> = K.extension(t^2 + 1)
sage: v = QQ.valuation(5)
sage: w = v.extensions(L); w
[[ 5-adic valuation, v(t + 2) = 1 ]-adic valuation,
 [ 5-adic valuation, v(t + 3) = 1 ]-adic valuation]

Note

We often rely on approximations of valuations even if we could represent the valuation without using a limit. This is done to improve performance as many computations already can be done correctly with an approximation:

sage: K.<x> = FunctionField(QQ)
sage: R.<y> = K[]
sage: L.<y> = K.extension(y^2 - x)

sage: v = K.valuation(1/x)
sage: w = v.extension(L); w
Valuation at the infinite place
sage: w._base_valuation._base_valuation._improve_approximation()
sage: w._base_valuation._base_valuation._approximation
[ Gauss valuation induced by Valuation at the infinite place, v(y) = 1/2, v(y^2 - 1/x) = +Infinity ]

REFERENCES:

Limits of inductive valuations are discussed in [Mac1936I] and [Mac1936II]. An overview can also be found in Section 4.6 of [Rüt2014].

class sage.rings.valuation.limit_valuation.LimitValuationFactory#

Bases: UniqueFactory

Return a limit valuation which sends the polynomial G to infinity and is greater than or equal than base_valuation.

INPUT:

base_valuation – a discrete (pseudo-)valuation on a polynomial ring which is a discrete valuation on the coefficient ring which can be uniquely augmented (possibly only in the limit) to a pseudo-valuation that sends G to infinity.
G – a squarefree polynomial in the domain of base_valuation.

EXAMPLES:

sage: R.<x> = QQ[]
sage: v = GaussValuation(R, QQ.valuation(2))
sage: w = valuations.LimitValuation(v, x)
sage: w(x)
+Infinity

create_key(base_valuation, G)#

Create a key from the parameters of this valuation.

EXAMPLES:

Note that this does not normalize base_valuation in any way. It is easily possible to create the same limit in two different ways:

sage: R.<x> = QQ[]
sage: v = GaussValuation(R, QQ.valuation(2))
sage: w = valuations.LimitValuation(v, x) # indirect doctest
sage: v = v.augmentation(x, infinity)
sage: u = valuations.LimitValuation(v, x)
sage: u == w
False

The point here is that this is not meant to be invoked from user code. But mostly from other factories which have made sure that the parameters are normalized already.

create_object(version, key)#

Create an object from key.

EXAMPLES:

sage: R.<x> = QQ[]
sage: v = GaussValuation(R, QQ.valuation(2))
sage: w = valuations.LimitValuation(v, x^2 + 1) # indirect doctest

class sage.rings.valuation.limit_valuation.LimitValuation_generic(parent, approximation)#

Bases: DiscretePseudoValuation

Base class for limit valuations.

A limit valuation is realized as an approximation of a valuation and means to improve that approximation when necessary.

EXAMPLES:

sage: K.<x> = FunctionField(QQ)
sage: R.<y> = K[]
sage: L.<y> = K.extension(y^2 - x)

sage: v = K.valuation(0)
sage: w = v.extension(L)
sage: w._base_valuation
[ Gauss valuation induced by (x)-adic valuation, v(y) = 1/2 , … ]

The currently used approximation can be found in the _approximation field:

sage: w._base_valuation._approximation
[ Gauss valuation induced by (x)-adic valuation, v(y) = 1/2 ]

reduce(f, check=True)#

Return the reduction of f as an element of the residue_ring().

INPUT:

f – an element in the domain of this valuation of non-negative valuation
check – whether or not to check that f has non-negative valuation (default: True)

EXAMPLES:

sage: K.<x> = FunctionField(QQ)
sage: R.<y> = K[]
sage: L.<y> = K.extension(y^2 - (x - 1))

sage: v = K.valuation(0)
sage: w = v.extension(L)
sage: w.reduce(y) # indirect doctest
u1

class sage.rings.valuation.limit_valuation.MacLaneLimitValuation(parent, approximation, G)#

Bases: LimitValuation_generic, InfiniteDiscretePseudoValuation

A limit valuation that is a pseudo-valuation on polynomial ring \(K[x]\) which sends a square-free polynomial \(G\) to infinity.

This uses the MacLane algorithm to compute the next element in the limit.

It starts from a first valuation approximation which has a unique augmentation that sends \(G\) to infinity and whose uniformizer must be a uniformizer of the limit and whose residue field must contain the residue field of the limit.

EXAMPLES:

sage: R.<x> = QQ[]
sage: K.<i> = QQ.extension(x^2 + 1)

sage: v = K.valuation(2)
sage: u = v._base_valuation; u
[ Gauss valuation induced by 2-adic valuation, v(x + 1) = 1/2 , … ]

element_with_valuation(s)#: Return an element with valuation s.

extensions(ring)#

Return the extensions of this valuation to ring.

EXAMPLES:

sage: v = GaussianIntegers().valuation(2)
sage: u = v._base_valuation
sage: u.extensions(QQ['x'])
[[ Gauss valuation induced by 2-adic valuation, v(x + 1) = 1/2 , … ]]

is_negative_pseudo_valuation()#

Return whether this valuation attains \(-\infty\).

EXAMPLES:

For a Mac Lane limit valuation, this is never the case, so this method always returns False:

sage: K = QQ
sage: R.<t> = K[]
sage: L.<t> = K.extension(t^2 + 1)
sage: v = QQ.valuation(2)
sage: u = v.extension(L)
sage: u.is_negative_pseudo_valuation()
False

lift(F)#

Return a lift of F from the residue_ring() to the domain of this valuation.

EXAMPLES:

sage: K.<x> = FunctionField(QQ)
sage: R.<y> = K[]
sage: L.<y> = K.extension(y^4 - x^2 - 2*x - 1)

sage: v = K.valuation(1)
sage: w = v.extensions(L)[1]; w
[ (x - 1)-adic valuation, v(y^2 - 2) = 1 ]-adic valuation
sage: s = w.reduce(y); s
u1
sage: w.lift(s) # indirect doctest
y

lower_bound(f)#

Return a lower bound of this valuation at x.

Use this method to get an approximation of the valuation of x when speed is more important than accuracy.

EXAMPLES:

sage: K = QQ
sage: R.<t> = K[]
sage: L.<t> = K.extension(t^2 + 1)
sage: v = QQ.valuation(2)
sage: u = v.extension(L)
sage: u.lower_bound(1024*t + 1024)
10
sage: u(1024*t + 1024)
21/2

residue_ring()#

Return the residue ring of this valuation, which is always a field.

EXAMPLES:

sage: K = QQ
sage: R.<t> = K[]
sage: L.<t> = K.extension(t^2 + 1)
sage: v = QQ.valuation(2)
sage: w = v.extension(L)
sage: w.residue_ring()
Finite Field of size 2

restriction(ring)#

Return the restriction of this valuation to ring.

EXAMPLES:

sage: K = QQ
sage: R.<t> = K[]
sage: L.<t> = K.extension(t^2 + 1)
sage: v = QQ.valuation(2)
sage: w = v.extension(L)
sage: w._base_valuation.restriction(K)
2-adic valuation

simplify(f, error=None, force=False)#

Return a simplified version of f.

Produce an element which differs from f by an element of valuation strictly greater than the valuation of f (or strictly greater than error if set.)

EXAMPLES:

sage: K = QQ
sage: R.<t> = K[]
sage: L.<t> = K.extension(t^2 + 1)
sage: v = QQ.valuation(2)
sage: u = v.extension(L)
sage: u.simplify(t + 1024, force=True)
t

uniformizer()#

Return a uniformizing element for this valuation.

EXAMPLES:

sage: K.<x> = FunctionField(QQ)
sage: R.<y> = K[]
sage: L.<y> = K.extension(y^2 - x)

sage: v = K.valuation(0)
sage: w = v.extension(L)
sage: w.uniformizer() # indirect doctest
y

upper_bound(f)#

Return an upper bound of this valuation at x.

Use this method to get an approximation of the valuation of x when speed is more important than accuracy.

EXAMPLES:

sage: K = QQ
sage: R.<t> = K[]
sage: L.<t> = K.extension(t^2 + 1)
sage: v = QQ.valuation(2)
sage: u = v.extension(L)
sage: u.upper_bound(1024*t + 1024)
21/2
sage: u(1024*t + 1024)
21/2

value_semigroup()#: Return the value semigroup of this valuation.