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: # needs sage.rings.function_field
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: # needs sage.rings.number_field
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: # needs sage.rings.function_field
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 thanbase_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 sendsG
to infinity.G
– a squarefree polynomial in the domain ofbase_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: # needs sage.rings.function_field 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 # needs sage.rings.function_field [ Gauss valuation induced by (x)-adic valuation, v(y) = 1/2 ]
- reduce(f, check=True)#
Return the reduction of
f
as an element of theresidue_ring()
.INPUT:
f
– an element in the domain of this valuation of non-negative valuationcheck
– whether or not to check thatf
has non-negative valuation (default:True
)
EXAMPLES:
sage: # needs sage.rings.function_field 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: # needs sage.rings.number_field 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: # needs sage.rings.number_field 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: # needs sage.rings.number_field 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 theresidue_ring()
to the domain of this valuation.EXAMPLES:
sage: # needs sage.rings.function_field 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: # needs sage.rings.number_field 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: # needs sage.rings.number_field 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: # needs sage.rings.number_field 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 off
(or strictly greater thanerror
if set.)EXAMPLES:
sage: # needs sage.rings.number_field 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: # needs sage.rings.function_field 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: # needs sage.rings.number_field 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.