passagemath-pari 10.6.32__cp314-cp314-musllinux_1_2_x86_64.whl

sage/rings/valuation/scaled_valuation.py

@@ -0,0 +1,322 @@
+# sage_setup: distribution = sagemath-pari
+r"""
+Valuations which are scaled versions of another valuation
+
+EXAMPLES::
+
+    sage: 3*ZZ.valuation(3)
+    3 * 3-adic valuation
+
+AUTHORS:
+
+- Julian Rüth (2016-11-10): initial version
+"""
+# ****************************************************************************
+#       Copyright (C) 2016-2017 Julian Rüth <julian.rueth@fsfe.org>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.structure.factory import UniqueFactory
+
+from .valuation import DiscreteValuation
+
+
+class ScaledValuationFactory(UniqueFactory):
+    r"""
+    Return a valuation which scales the valuation ``base`` by the factor ``s``.
+
+    EXAMPLES::
+
+        sage: 3*ZZ.valuation(2) # indirect doctest
+        3 * 2-adic valuation
+    """
+    def create_key(self, base, s):
+        r"""
+        Create a key which uniquely identifies a valuation.
+
+        TESTS::
+
+            sage: 3*ZZ.valuation(2) is 2*(3/2*ZZ.valuation(2)) # indirect doctest
+            True
+        """
+        from sage.rings.infinity import infinity
+        from sage.rings.rational_field import QQ
+        if s is infinity or s not in QQ or s <= 0:
+            # for these values we can not return a TrivialValuation() in
+            # create_object() because that would override that instance's
+            # _factory_data and lead to pickling errors
+            raise ValueError("s must be a positive rational")
+        if base.is_trivial():
+            # for the same reason we can not accept trivial valuations here
+            raise ValueError("base must not be trivial")
+        s = QQ.coerce(s)
+        if s == 1:
+            # we would override the _factory_data of base if we just returned
+            # it in create_object() so we just refuse to do so
+            raise ValueError("s must not be 1")
+
+        if isinstance(base, ScaledValuation_generic):
+            return self.create_key(base._base_valuation, s * base._scale)
+
+        return base, s
+
+    def create_object(self, version, key):
+        r"""
+        Create a valuation from ``key``.
+
+        TESTS::
+
+            sage: 3*ZZ.valuation(2) # indirect doctest
+            3 * 2-adic valuation
+        """
+        base, s = key
+
+        assert not isinstance(base, ScaledValuation_generic)
+
+        from .valuation_space import DiscretePseudoValuationSpace
+        parent = DiscretePseudoValuationSpace(base.domain())
+        return parent.__make_element_class__(ScaledValuation_generic)(parent, base, s)
+
+
+ScaledValuation = ScaledValuationFactory("sage.rings.valuation.scaled_valuation.ScaledValuation")
+
+
+class ScaledValuation_generic(DiscreteValuation):
+    r"""
+    A valuation which scales another ``base_valuation`` by a finite positive factor ``s``.
+
+    EXAMPLES::
+
+        sage: v = 3*ZZ.valuation(3); v
+        3 * 3-adic valuation
+
+    TESTS::
+
+        sage: TestSuite(v).run()                # long time                             # needs sage.geometry.polyhedron
+    """
+    def __init__(self, parent, base_valuation, s):
+        r"""
+        .. TODO::
+
+            It is annoying that we have to wrap any possible method on
+            ``base_valuation`` in this class. It would be nice if this would
+            somehow be done automagically, e.g., by adding annotations to the
+            methods in ``base_valuation`` that explain which parameters and
+            return values need to be scaled.
+
+        TESTS::
+
+            sage: v = 3*ZZ.valuation(2)
+            sage: from sage.rings.valuation.scaled_valuation import ScaledValuation_generic
+            sage: isinstance(v, ScaledValuation_generic)
+            True
+        """
+        DiscreteValuation.__init__(self, parent)
+        self._base_valuation = base_valuation
+        self._scale = s
+
+    def _repr_(self):
+        r"""
+        Return a printable representation of this valuation.
+
+        EXAMPLES::
+
+            sage: 3*ZZ.valuation(2) # indirect doctest
+            3 * 2-adic valuation
+        """
+        return "%r * %r" % (self._scale, self._base_valuation)
+
+    def residue_ring(self):
+        r"""
+        Return the residue field of this valuation.
+
+        EXAMPLES::
+
+            sage: v = 3*ZZ.valuation(2)
+            sage: v.residue_ring()
+            Finite Field of size 2
+        """
+        return self._base_valuation.residue_ring()
+
+    def uniformizer(self):
+        r"""
+        Return a uniformizing element of this valuation.
+
+        EXAMPLES::
+
+            sage: v = 3*ZZ.valuation(2)
+            sage: v.uniformizer()
+            2
+        """
+        return self._base_valuation.uniformizer()
+
+    def _call_(self, f):
+        r"""
+        Evaluate this valuation at ``f``.
+
+        EXAMPLES::
+
+            sage: v = 3*ZZ.valuation(2)
+            sage: v(2)
+            3
+        """
+        return self._scale * self._base_valuation(f)
+
+    def reduce(self, f):
+        r"""
+        Return the reduction of ``f`` in the :meth:`~sage.rings.valuation.valuation_space.DiscretePseudoValuationSpace.ElementMethods.residue_field` of this valuation.
+
+        EXAMPLES::
+
+            sage: v = 3*ZZ.valuation(2)
+            sage: v.reduce(1)
+            1
+        """
+        return self._base_valuation.reduce(f)
+
+    def lift(self, F):
+        r"""
+        Lift ``F`` from the :meth:`~sage.rings.valuation.valuation_space.DiscretePseudoValuationSpace.ElementMethods.residue_field`
+        of this valuation into its
+        domain.
+
+        EXAMPLES::
+
+            sage: v = 3*ZZ.valuation(2)
+            sage: v.lift(1)
+            1
+        """
+        return self._base_valuation.lift(F)
+
+    def extensions(self, ring):
+        r"""
+        Return the extensions of this valuation to ``ring``.
+
+        EXAMPLES::
+
+            sage: v = 3*ZZ.valuation(5)
+            sage: v.extensions(GaussianIntegers().fraction_field())                     # needs sage.geometry.polyhedron sage.rings.number_field
+            [3 * [ 5-adic valuation, v(x + 2) = 1 ]-adic valuation,
+             3 * [ 5-adic valuation, v(x + 3) = 1 ]-adic valuation]
+        """
+        return [ScaledValuation(w, self._scale) for w in self._base_valuation.extensions(ring)]
+
+    def restriction(self, ring):
+        r"""
+        Return the restriction of this valuation to ``ring``.
+
+        EXAMPLES::
+
+            sage: v = 3*QQ.valuation(5)
+            sage: v.restriction(ZZ)
+            3 * 5-adic valuation
+        """
+        restricted = self._base_valuation.restriction(ring)
+        if restricted.is_trivial():
+            # trivial valuations can not be scaled explicitly for caching reasons
+            return restricted
+        return ScaledValuation(restricted, self._scale)
+
+    def _strictly_separating_element(self, other):
+        r"""
+        Return an element in the domain of this valuation which has positive
+        valuation with respect to this valuation but negative valuation with
+        respect to ``other``.
+
+        EXAMPLES::
+
+            sage: v2 = QQ.valuation(2)
+            sage: v3 = 12 * QQ.valuation(3)
+            sage: v2._strictly_separating_element(v3)
+            2/3
+        """
+        return self._base_valuation._strictly_separating_element(other)
+
+    def _weakly_separating_element(self, other):
+        r"""
+        Return an element in the domain of this valuation which has
+        positive valuation with respect to this valuation and higher
+        valuation with respect to this valuation than with respect to
+        ``other``.
+
+        EXAMPLES::
+
+            sage: v2 = QQ.valuation(2)
+            sage: v3 = 12 * QQ.valuation(3)
+            sage: v2._weakly_separating_element(v3)
+            2
+        """
+        return self._base_valuation._weakly_separating_element(other)
+
+    def _ge_(self, other):
+        r"""
+        Return whether this valuation is greater or equal to ``other``, a
+        valuation on the same domain.
+
+        EXAMPLES::
+
+            sage: v2 = QQ.valuation(2)
+            sage: 2*v2 >= v2
+            True
+            sage: v2/2 >= 2*v2
+            False
+            sage: 3*v2 > 2*v2
+            True
+
+        Test that non-scaled valuations call through to this method to resolve
+        the scaling::
+
+            sage: v2 > v2/2
+            True
+        """
+        if self == other:
+            return True
+        if isinstance(other, ScaledValuation_generic):
+            return (self._scale / other._scale) * self._base_valuation >= other._base_valuation
+        if self._scale >= 1:
+            if self._base_valuation >= other:
+                return True
+        else:
+            assert not self.is_trivial()
+            if self._base_valuation <= other:
+                return False
+        return super()._ge_(other)
+
+    def _le_(self, other):
+        r"""
+        Return whether this valuation is smaller or equal to ``other``, a
+        valuation on the same domain.
+
+        EXAMPLES::
+
+            sage: v2 = QQ.valuation(2)
+            sage: 2*v2 <= v2
+            False
+            sage: v2/2 <= 2*v2
+            True
+            sage: 3*v2 < 2*v2
+            False
+
+        Test that non-scaled valuations call through to this method to resolve
+        the scaling::
+
+            sage: v2 < v2/2
+            False
+        """
+        return other / self._scale >= self._base_valuation
+
+    def value_semigroup(self):
+        r"""
+        Return the value semigroup of this valuation.
+
+        EXAMPLES::
+
+            sage: v2 = QQ.valuation(2)
+            sage: (2*v2).value_semigroup()
+            Additive Abelian Semigroup generated by -2, 2
+        """
+        return self._scale * self._base_valuation.value_semigroup()

sage/rings/valuation/trivial_valuation.py

@@ -0,0 +1,382 @@
+# sage_setup: distribution = sagemath-pari
+r"""
+Trivial valuations
+
+AUTHORS:
+
+- Julian Rüth (2016-10-14): initial version
+
+EXAMPLES::
+
+    sage: v = valuations.TrivialValuation(QQ); v
+    Trivial valuation on Rational Field
+    sage: v(1)
+    0
+"""
+# ****************************************************************************
+#       Copyright (C) 2016-2017 Julian Rüth <julian.rueth@fsfe.org>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from .valuation import DiscretePseudoValuation, DiscreteValuation, InfiniteDiscretePseudoValuation
+from .valuation_space import DiscretePseudoValuationSpace
+from sage.structure.factory import UniqueFactory
+
+
+class TrivialValuationFactory(UniqueFactory):
+    r"""
+    Create a trivial valuation on ``domain``.
+
+    EXAMPLES::
+
+        sage: v = valuations.TrivialValuation(QQ); v
+        Trivial valuation on Rational Field
+        sage: v(1)
+        0
+    """
+    def __init__(self, clazz, parent, *args, **kwargs):
+        r"""
+        TESTS::
+
+            sage: from sage.rings.valuation.trivial_valuation import TrivialValuationFactory
+            sage: isinstance(valuations.TrivialValuation, TrivialValuationFactory)
+            True
+        """
+        UniqueFactory.__init__(self, *args, **kwargs)
+        self._class = clazz
+        self._parent = parent
+
+    def create_key(self, domain):
+        r"""
+        Create a key that identifies this valuation.
+
+        EXAMPLES::
+
+            sage: valuations.TrivialValuation(QQ) is valuations.TrivialValuation(QQ) # indirect doctest
+            True
+        """
+        return domain,
+
+    def create_object(self, version, key, **extra_args):
+        r"""
+        Create a trivial valuation from ``key``.
+
+        EXAMPLES::
+
+            sage: valuations.TrivialValuation(QQ) # indirect doctest
+            Trivial valuation on Rational Field
+        """
+        domain, = key
+        parent = self._parent(domain)
+        return parent.__make_element_class__(self._class)(parent)
+
+
+class TrivialDiscretePseudoValuation_base(DiscretePseudoValuation):
+    r"""
+    Base class for code shared by trivial valuations.
+
+    EXAMPLES::
+
+        sage: v = valuations.TrivialPseudoValuation(ZZ); v
+        Trivial pseudo-valuation on Integer Ring
+
+    TESTS::
+
+        sage: TestSuite(v).run() # long time
+    """
+    def uniformizer(self):
+        r"""
+        Return a uniformizing element for this valuation.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialPseudoValuation(ZZ)
+            sage: v.uniformizer()
+            Traceback (most recent call last):
+            ...
+            ValueError: Trivial valuations do not define a uniformizing element
+        """
+        raise ValueError("Trivial valuations do not define a uniformizing element")
+
+    def is_trivial(self):
+        r"""
+        Return whether this valuation is trivial.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: v.is_trivial()
+            True
+        """
+        return True
+
+    def is_negative_pseudo_valuation(self):
+        r"""
+        Return whether this valuation attains the value `-\infty`.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: v.is_negative_pseudo_valuation()
+            False
+        """
+        return False
+
+
+class TrivialDiscretePseudoValuation(TrivialDiscretePseudoValuation_base, InfiniteDiscretePseudoValuation):
+    r"""
+    The trivial pseudo-valuation that is `\infty` everywhere.
+
+    EXAMPLES::
+
+        sage: v = valuations.TrivialPseudoValuation(QQ); v
+        Trivial pseudo-valuation on Rational Field
+
+    TESTS::
+
+        sage: TestSuite(v).run() # long time
+    """
+    def __init__(self, parent):
+        r"""
+        TESTS::
+
+            sage: from sage.rings.valuation.trivial_valuation import TrivialDiscretePseudoValuation
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: isinstance(v, TrivialDiscretePseudoValuation)
+            True
+        """
+        TrivialDiscretePseudoValuation_base.__init__(self, parent)
+        InfiniteDiscretePseudoValuation.__init__(self, parent)
+
+    def _call_(self, x):
+        r"""
+        Evaluate this valuation at ``x``.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: v(0)
+            +Infinity
+            sage: v(1)
+            +Infinity
+        """
+        from sage.rings.infinity import infinity
+        return infinity
+
+    def _repr_(self):
+        r"""
+        Return a printable representation of this valuation.
+
+        EXAMPLES::
+
+            sage: valuations.TrivialPseudoValuation(QQ) # indirect doctest
+            Trivial pseudo-valuation on Rational Field
+        """
+        return "Trivial pseudo-valuation on %r" % (self.domain(),)
+
+    def value_group(self):
+        r"""
+        Return the value group of this valuation.
+
+        EXAMPLES:
+
+        A trivial discrete pseudo-valuation has no value group::
+
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: v.value_group()
+            Traceback (most recent call last):
+            ...
+            ValueError: The trivial pseudo-valuation that is infinity everywhere does not have a value group.
+        """
+        raise ValueError("The trivial pseudo-valuation that is infinity everywhere does not have a value group.")
+
+    def residue_ring(self):
+        r"""
+        Return the residue ring of this valuation.
+
+        EXAMPLES::
+
+            sage: valuations.TrivialPseudoValuation(QQ).residue_ring()
+            Quotient of Rational Field by the ideal (1)
+        """
+        return self.domain().quo(self.domain().one())
+
+    def reduce(self, x):
+        r"""
+        Reduce ``x`` modulo the positive elements of this valuation.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: v.reduce(1)
+            0
+        """
+        self.domain().coerce(x)
+        return self.residue_ring().zero()
+
+    def lift(self, X):
+        r"""
+        Return a lift of ``X`` to the domain of this valuation.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: v.lift(v.residue_ring().zero())
+            0
+        """
+        self.residue_ring().coerce(X)  # ignore the output
+        return self.domain().zero()
+
+    def _ge_(self, other):
+        r"""
+        Return whether this valuation is bigger or equal than ``other``
+        everywhere.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: w = valuations.TrivialValuation(QQ)
+            sage: v >= w
+            True
+        """
+        # the trivial discrete valuation is the biggest valuation
+        return True
+
+
+class TrivialDiscreteValuation(TrivialDiscretePseudoValuation_base, DiscreteValuation):
+    r"""
+    The trivial valuation that is zero on nonzero elements.
+
+    EXAMPLES::
+
+        sage: v = valuations.TrivialValuation(QQ); v
+        Trivial valuation on Rational Field
+
+    TESTS::
+
+        sage: TestSuite(v).run() # long time
+    """
+    def __init__(self, parent):
+        r"""
+        TESTS::
+
+            sage: from sage.rings.valuation.trivial_valuation import TrivialDiscreteValuation
+            sage: v = valuations.TrivialValuation(QQ)
+            sage: isinstance(v, TrivialDiscreteValuation)
+            True
+        """
+        TrivialDiscretePseudoValuation_base.__init__(self, parent)
+        DiscreteValuation.__init__(self, parent)
+
+    def _call_(self, x):
+        r"""
+        Evaluate this valuation at ``x``.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialValuation(QQ)
+            sage: v(0)
+            +Infinity
+            sage: v(1)
+            0
+        """
+        from sage.rings.infinity import infinity
+        return infinity if x == 0 else self.codomain().zero()
+
+    def _repr_(self):
+        r"""
+        Return a printable representation of this valuation.
+
+        EXAMPLES::
+
+            sage: valuations.TrivialValuation(QQ) # indirect doctest
+            Trivial valuation on Rational Field
+        """
+        return "Trivial valuation on %r" % (self.domain(),)
+
+    def value_group(self):
+        r"""
+        Return the value group of this valuation.
+
+        EXAMPLES:
+
+        A trivial discrete valuation has a trivial value group::
+
+            sage: v = valuations.TrivialValuation(QQ)
+            sage: v.value_group()
+            Trivial Additive Abelian Group
+        """
+        from .value_group import DiscreteValueGroup
+        return DiscreteValueGroup(0)
+
+    def residue_ring(self):
+        r"""
+        Return the residue ring of this valuation.
+
+        EXAMPLES::
+
+            sage: valuations.TrivialValuation(QQ).residue_ring()
+            Rational Field
+        """
+        return self.domain()
+
+    def reduce(self, x):
+        r"""
+        Reduce ``x`` modulo the positive elements of this valuation.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialValuation(QQ)
+            sage: v.reduce(1)
+            1
+        """
+        return self.domain().coerce(x)
+
+    def lift(self, X):
+        r"""
+        Return a lift of ``X`` to the domain of this valuation.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialValuation(QQ)
+            sage: v.lift(v.residue_ring().zero())
+            0
+        """
+        return self.residue_ring().coerce(X)
+
+    def extensions(self, ring):
+        r"""
+        Return the unique extension of this valuation to ``ring``.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialValuation(ZZ)
+            sage: v.extensions(QQ)
+            [Trivial valuation on Rational Field]
+        """
+        if self.domain().is_subring(ring):
+            return [TrivialValuation(ring)]
+        return super(DiscretePseudoValuation, self).extensions(ring)
+
+    def _ge_(self, other):
+        r"""
+        Return whether this valuation is bigger or equal than ``other``
+        everywhere.
+
+        EXAMPLES::
+
+            sage: v = valuations.TrivialPseudoValuation(QQ)
+            sage: w = valuations.TrivialValuation(QQ)
+            sage: w >= v
+            False
+        """
+        # the trivial discrete valuation is the smallest valuation
+        return self is other
+
+
+TrivialValuation = TrivialValuationFactory(TrivialDiscreteValuation, DiscretePseudoValuationSpace, "sage.rings.valuation.trivial_valuation.TrivialValuation")
+TrivialPseudoValuation = TrivialValuationFactory(TrivialDiscretePseudoValuation, DiscretePseudoValuationSpace, "sage.rings.valuation.trivial_valuation.TrivialPseudoValuation")