def create_object(self, version, key, **extra_args): r""" Create a Gauss valuation from normalized parameters. TESTS:: sage: v = QQ.valuation(2) sage: R.<x> = QQ[] sage: GaussValuation.create_object(0, (R, v)) Gauss valuation induced by 2-adic valuation """ domain, v = key from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace parent = DiscretePseudoValuationSpace(domain) return parent.__make_element_class__(GaussValuation_generic)(parent, v)
def create_object(self, version, key, **extra_args): r""" Create a Gauss valuation from normalized parameters. TESTS:: sage: v = QQ.valuation(2) sage: R.<x> = QQ[] sage: GaussValuation.create_object(0, (R, v)) Gauss valuation induced by 2-adic valuation """ domain, v = key from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace parent = DiscretePseudoValuationSpace(domain) return parent.__make_element_class__(GaussValuation_generic)(parent, v)
def create_object(self, version, key): r""" Return the valuation described by ``key``. TESTS:: sage: from henselization import * sage: K = QQ.henselization(5) sage: K.valuation() # indirect doctest 5-adic valuation """ domain, = key from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace parent = DiscretePseudoValuationSpace(domain) return parent.__make_element_class__(HenselizationValuation)(parent)
def create_object(self, version, key, **extra_args): r""" Create the valuation specified by ``key``. EXAMPLES:: sage: K.<x> = FunctionField(QQ) sage: R.<x> = QQ[] sage: w = valuations.GaussValuation(R, QQ.valuation(2)) sage: v = K.valuation(w); v # indirect doctest 2-adic valuation """ domain, valuation = key from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace parent = DiscretePseudoValuationSpace(domain) if isinstance(valuation, tuple) and len(valuation) == 3: valuation, to_valuation_domain, from_valuation_domain = valuation if domain is domain.base() and valuation.domain() is valuation.domain().base() and to_valuation_domain == domain.hom([~valuation.domain().gen()]) and from_valuation_domain == valuation.domain().hom([~domain.gen()]): # valuation on the rational function field after x |--> 1/x if valuation == valuation.domain().valuation(valuation.domain().gen()): # the classical valuation at the place 1/x return parent.__make_element_class__(InfiniteRationalFunctionFieldValuation)(parent) from sage.structure.dynamic_class import dynamic_class clazz = RationalFunctionFieldMappedValuation if valuation.is_discrete_valuation(): clazz = dynamic_class("RationalFunctionFieldMappedValuation_discrete", (clazz, DiscreteValuation)) else: clazz = dynamic_class("RationalFunctionFieldMappedValuation_infinite", (clazz, InfiniteDiscretePseudoValuation)) return parent.__make_element_class__(clazz)(parent, valuation, to_valuation_domain, from_valuation_domain) return parent.__make_element_class__(FunctionFieldExtensionMappedValuation)(parent, valuation, to_valuation_domain, from_valuation_domain) if domain is valuation.domain(): # we can not just return valuation in this case # as this would break uniqueness and pickling raise ValueError("valuation must not be a valuation on domain yet but %r is a valuation on %r"%(valuation, domain)) if domain.base_field() is domain: # valuation is a base valuation on K[x] that induces a valuation on K(x) if valuation.restriction(domain.constant_base_field()).is_trivial() and valuation.is_discrete_valuation(): # valuation corresponds to a finite place return parent.__make_element_class__(FiniteRationalFunctionFieldValuation)(parent, valuation) else: from sage.structure.dynamic_class import dynamic_class clazz = NonClassicalRationalFunctionFieldValuation if valuation.is_discrete_valuation(): clazz = dynamic_class("NonClassicalRationalFunctionFieldValuation_discrete", (clazz, DiscreteFunctionFieldValuation_base)) else: clazz = dynamic_class("NonClassicalRationalFunctionFieldValuation_negative_infinite", (clazz, NegativeInfiniteDiscretePseudoValuation)) return parent.__make_element_class__(clazz)(parent, valuation) else: # valuation is a limit valuation that singles out an extension return parent.__make_element_class__(FunctionFieldFromLimitValuation)(parent, valuation, domain.polynomial(), extra_args['approximants']) raise NotImplementedError("valuation on %r from %r on %r"%(domain, valuation, valuation.domain()))
def create_object(self, version, key, **extra_args): r""" Create a Gauss valuation from normalized parameters. TESTS:: sage: sys.path.append(os.getcwd()); from mac_lane import * # optional: standalone sage: v = pAdicValuation(QQ, 2) sage: R.<x> = QQ[] sage: GaussValuation.create_object(0, (R, v)) Gauss valuation induced by 2-adic valuation """ domain, v = key from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace parent = DiscretePseudoValuationSpace(domain) return parent.__make_element_class__(GaussValuation_generic)(parent, v)
def create_object(self, version, key, **extra_args): r""" Create a `p`-adic valuation from ``key``. EXAMPLES:: sage: ZZ.valuation(5) # indirect doctest 5-adic valuation """ from sage.rings.all import ZZ, QQ from sage.rings.padics.padic_generic import pAdicGeneric from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace from sage.rings.polynomial.polynomial_quotient_ring import is_PolynomialQuotientRing from sage.rings.number_field.number_field import is_NumberField R = key[0] parent = DiscretePseudoValuationSpace(R) if isinstance(R, pAdicGeneric): assert(len(key)==1) return parent.__make_element_class__(pAdicValuation_padic)(parent) elif R is ZZ or R is QQ: prime = key[1] assert(len(key)==2) return parent.__make_element_class__(pAdicValuation_int)(parent, prime) else: v = key[1] approximants = extra_args['approximants'] parent = DiscretePseudoValuationSpace(R) K = R.fraction_field() if is_NumberField(K): G = K.relative_polynomial() elif is_PolynomialQuotientRing(R): G = R.modulus() else: raise NotImplementedError return parent.__make_element_class__(pAdicFromLimitValuation)(parent, v, G.change_ring(R.base_ring()), approximants)
def _extensions_to_quotient(self, ring, approximants=None): r""" Return the extensions of this valuation to an integral quotient over the domain of this valuation. EXAMPLES:: sage: R.<x> = QQ[] sage: QQ.valuation(2)._extensions_to_quotient(R.quo(x^2 + x + 1)) [2-adic valuation] """ from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace parent = DiscretePseudoValuationSpace(ring) approximants = approximants or self.mac_lane_approximants( ring.modulus().change_ring(self.domain()), assume_squarefree=True, require_incomparability=True) return [ pAdicValuation(ring, approximant, approximants) for approximant in approximants ]
def create_object(self, version, key, **extra_args): r""" Create a `p`-adic valuation from ``key``. EXAMPLES:: sage: ZZ.valuation(5) # indirect doctest 5-adic valuation """ from sage.rings.integer_ring import ZZ from sage.rings.rational_field import QQ from sage.rings.padics.padic_generic import pAdicGeneric from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace from sage.rings.polynomial.polynomial_quotient_ring import is_PolynomialQuotientRing from sage.rings.number_field.number_field import is_NumberField R = key[0] parent = DiscretePseudoValuationSpace(R) if isinstance(R, pAdicGeneric): assert (len(key) == 1) return parent.__make_element_class__(pAdicValuation_padic)(parent) elif R is ZZ or R is QQ: prime = key[1] assert (len(key) == 2) return parent.__make_element_class__(pAdicValuation_int)(parent, prime) else: v = key[1] approximants = extra_args['approximants'] parent = DiscretePseudoValuationSpace(R) K = R.fraction_field() if is_NumberField(K): G = K.relative_polynomial() elif is_PolynomialQuotientRing(R): G = R.modulus() else: raise NotImplementedError return parent.__make_element_class__(pAdicFromLimitValuation)( parent, v, G.change_ring(R.base_ring()), approximants)
def extensions(self, ring): r""" Return the extensions of this valuation to ``ring``. EXAMPLES:: sage: v = ZZ.valuation(2) sage: v.extensions(GaussianIntegers()) [2-adic valuation] TESTS:: sage: R.<a> = QQ[] sage: L.<a> = QQ.extension(x^3 - 2) sage: R.<b> = L[] sage: M.<b> = L.extension(b^2 + 2*b + a) sage: M.valuation(2) 2-adic valuation Check that we can extend to a field written as a quotient:: sage: R.<x> = QQ[] sage: K.<a> = QQ.extension(x^2 + 1) sage: R.<y> = K[] sage: L.<b> = R.quo(x^2 + a) sage: QQ.valuation(2).extensions(L) [2-adic valuation] A case where there was at some point an internal error in the approximants code:: sage: R.<x> = QQ[] sage: L.<a> = NumberField(x^4 + 2*x^3 + 2*x^2 + 8) sage: QQ.valuation(2).extensions(L) [[ 2-adic valuation, v(x + 2) = 3/2 ]-adic valuation, [ 2-adic valuation, v(x) = 1/2 ]-adic valuation] A case where the extension was incorrect at some point:: sage: v = QQ.valuation(2) sage: L.<a> = NumberField(x^2 + 2) sage: M.<b> = L.extension(x^2 + 1) sage: w = v.extension(L).extension(M) sage: w(w.uniformizer()) 1/4 A case where the extensions could not be separated at some point:: sage: v = QQ.valuation(2) sage: R.<x> = QQ[] sage: F = x^48 + 120*x^45 + 56*x^42 + 108*x^36 + 32*x^33 + 40*x^30 + 48*x^27 + 80*x^24 + 112*x^21 + 96*x^18 + 96*x^15 + 24*x^12 + 96*x^9 + 16*x^6 + 96*x^3 + 68 sage: L.<a> = QQ.extension(F) sage: v.extensions(L) [[ 2-adic valuation, v(x) = 1/24, v(x^24 + 4*x^18 + 10*x^12 + 12*x^6 + 8*x^3 + 6) = 29/8 ]-adic valuation, [ 2-adic valuation, v(x) = 1/24, v(x^24 + 4*x^18 + 2*x^12 + 12*x^6 + 8*x^3 + 6) = 29/8 ]-adic valuation] """ if self.domain() is ring: return [self] domain_fraction_field = _fraction_field(self.domain()) if domain_fraction_field is not self.domain(): if domain_fraction_field.is_subring(ring): return pAdicValuation(domain_fraction_field, self).extensions(ring) if self.domain().is_subring(ring): from sage.rings.polynomial.polynomial_quotient_ring import is_PolynomialQuotientRing if is_PolynomialQuotientRing(ring): if is_PolynomialQuotientRing(self.domain()): if self.domain().modulus() == ring.modulus(): base_extensions = self._base_valuation.extensions( self._base_valuation.domain().change_ring( self._base_valuation.domain().base_ring( ).fraction_field())) return [ pAdicValuation(ring, base._initial_approximation) for base in base_extensions ] if ring.base_ring() is self.domain(): from sage.categories.all import IntegralDomains if ring in IntegralDomains(): return self._extensions_to_quotient(ring) elif self.domain().is_subring(ring.base_ring()): return sum([ w.extensions(ring) for w in self.extensions(ring.base_ring()) ], []) from sage.rings.number_field.number_field import is_NumberField if is_NumberField(ring.fraction_field()): if ring.base_ring().fraction_field() is self.domain( ).fraction_field(): from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace parent = DiscretePseudoValuationSpace(ring) approximants = self.mac_lane_approximants( ring.fraction_field().relative_polynomial( ).change_ring(self.domain()), assume_squarefree=True, require_incomparability=True) return [ pAdicValuation(ring, approximant, approximants) for approximant in approximants ] if ring.base_ring() is not ring and self.domain().is_subring( ring.base_ring()): return sum([ w.extensions(ring) for w in self.extensions(ring.base_ring()) ], []) return super(pAdicValuation_base, self).extensions(ring)
def create_key_and_extra_args(self, domain, prime): r""" Create a unique key which identifies the valuation given by ``prime`` on ``domain``. TESTS: We specify a valuation on a function field by two different means and get the same object:: sage: K.<x> = FunctionField(QQ) sage: v = K.valuation(x - 1) # indirect doctest sage: R.<x> = QQ[] sage: w = GaussValuation(R, valuations.TrivialValuation(QQ)).augmentation(x - 1, 1) sage: K.valuation(w) is v True The normalization is, however, not smart enough, to unwrap substitutions that turn out to be trivial:: sage: w = GaussValuation(R, QQ.valuation(2)) sage: w = K.valuation(w) sage: w is K.valuation((w, K.hom([~K.gen()]), K.hom([~K.gen()]))) False """ from sage.categories.function_fields import FunctionFields if domain not in FunctionFields(): raise ValueError("Domain must be a function field.") if isinstance(prime, tuple): if len(prime) == 3: # prime is a triple of a valuation on another function field with # isomorphism information return self.create_key_and_extra_args_from_valuation_on_isomorphic_field(domain, prime[0], prime[1], prime[2]) from sage.rings.valuation.valuation_space import DiscretePseudoValuationSpace if prime.parent() is DiscretePseudoValuationSpace(domain): # prime is already a valuation of the requested domain # if we returned (domain, prime), we would break caching # because this element has been created from a different key # Instead, we return the key that was used to create prime # so the caller gets back a correctly cached version of prime if not hasattr(prime, "_factory_data"): raise NotImplementedError("Valuations on function fields must be unique and come out of the FunctionFieldValuation factory but %r has been created by other means"%(prime,)) return prime._factory_data[2], {} if prime in domain: # prime defines a place return self.create_key_and_extra_args_from_place(domain, prime) if prime.parent() is DiscretePseudoValuationSpace(domain._ring): # prime is a discrete (pseudo-)valuation on the polynomial ring # that the domain is constructed from return self.create_key_and_extra_args_from_valuation(domain, prime) if domain.base_field() is not domain: # prime might define a valuation on a subring of domain and have a # unique extension to domain base_valuation = domain.base_field().valuation(prime) return self.create_key_and_extra_args_from_valuation(domain, base_valuation) from sage.rings.ideal import is_Ideal if is_Ideal(prime): raise NotImplementedError("a place can not be given by an ideal yet") raise NotImplementedError("argument must be a place or a pseudo-valuation on a supported subring but %r does not satisfy this for the domain %r"%(prime, domain))