passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/complete_discrete_valuation.py

@@ -0,0 +1,293 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Complete Discrete Valuation Rings (CDVR) and Fields (CDVF)
+"""
+#**************************************************************************
+#  Copyright (C) 2013 Xavier Caruso <xavier.caruso@normalesup.org>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#**************************************************************************
+
+
+try:
+    from typing import Self  # type: ignore (Python >= 3.11)
+except ImportError:
+    from typing_extensions import Self  # type: ignore (Python 3.10)
+
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.discrete_valuation import (
+    DiscreteValuationFields,
+    DiscreteValuationRings,
+)
+from sage.misc.abstract_method import abstract_method
+
+#from sage.misc.cachefunc import cached_method
+
+
+class CompleteDiscreteValuationRings(Category_singleton):
+    """
+    The category of complete discrete valuation rings.
+
+    EXAMPLES::
+
+        sage: Zp(7) in CompleteDiscreteValuationRings()                                 # needs sage.rings.padics
+        True
+        sage: QQ in CompleteDiscreteValuationRings()
+        False
+        sage: QQ[['u']] in CompleteDiscreteValuationRings()
+        True
+        sage: Qp(7) in CompleteDiscreteValuationRings()                                 # needs sage.rings.padics
+        False
+        sage: TestSuite(CompleteDiscreteValuationRings()).run()
+    """
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: CompleteDiscreteValuationRings().super_categories()
+            [Category of discrete valuation rings]
+        """
+        return [DiscreteValuationRings()]
+
+    class ElementMethods:
+        @abstract_method
+        def valuation(self):
+            """
+            Return the valuation of this element.
+
+            EXAMPLES::
+
+                sage: R = Zp(7)                                                         # needs sage.rings.padics
+                sage: x = R(7); x                                                       # needs sage.rings.padics
+                7 + O(7^21)
+                sage: x.valuation()                                                     # needs sage.rings.padics
+                1
+            """
+
+        def denominator(self):
+            """
+            Return the denominator of this element normalized
+            as a power of the uniformizer
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.padics
+                sage: K = Qp(7)
+                sage: x = K(1/21)
+                sage: x.denominator()
+                7 + O(7^21)
+                sage: x = K(7)
+                sage: x.denominator()
+                1 + O(7^20)
+
+            Note that the denominator lives in the ring of integers::
+
+                sage: x.denominator().parent()                                          # needs sage.rings.padics
+                7-adic Ring with capped relative precision 20
+
+            When the denominator is indistinguishable from 0 and the
+            precision on the input is `O(p^n)`, the return value is `1`
+            if `n` is nonnegative and `p^(-n)` otherwise::
+
+                sage: # needs sage.rings.padics
+                sage: x = K(0, 5); x
+                O(7^5)
+                sage: x.denominator()
+                1 + O(7^20)
+                sage: x = K(0, -5); x
+                O(7^-5)
+                sage: x.denominator()
+                7^5 + O(7^25)
+            """
+            return self.parent()(1)
+
+        def numerator(self) -> Self:
+            """
+            Return the numerator of this element, normalized in such a
+            way that `x = x.numerator() / x.denominator()` always holds
+            true.
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.padics
+                sage: K = Qp(7, 5)
+                sage: x = K(1/21)
+                sage: x.numerator()
+                5 + 4*7 + 4*7^2 + 4*7^3 + 4*7^4 + O(7^5)
+                sage: x == x.numerator() / x.denominator()
+                True
+
+            Note that the numerator lives in the ring of integers::
+
+                sage: x.numerator().parent()                                            # needs sage.rings.padics
+                7-adic Ring with capped relative precision 5
+
+            TESTS::
+
+                sage: x = K(0, -5); x                                                   # needs sage.rings.padics
+                O(7^-5)
+                sage: x.numerator()                                                     # needs sage.rings.padics
+                O(7^0)
+                sage: x.denominator()                                                   # needs sage.rings.padics
+                7^5 + O(7^10)
+            """
+            return self
+
+        @abstract_method
+        def lift_to_precision(self, absprec=None):
+            """
+            Return another element of the same parent with absolute precision
+            at least ``absprec``, congruent to this element modulo the
+            precision of this element.
+
+            INPUT:
+
+            - ``absprec`` -- integer or ``None`` (default: ``None``); the
+              absolute precision of the result. If ``None``, lifts to the maximum
+              precision allowed.
+
+            .. NOTE::
+
+                If setting ``absprec`` that high would violate the precision cap,
+                raises a precision error.  Note that the new digits will not
+                necessarily be zero.
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.padics
+                sage: R = ZpCA(17)
+                sage: R(-1, 2).lift_to_precision(10)
+                16 + 16*17 + O(17^10)
+                sage: R(1, 15).lift_to_precision(10)
+                1 + O(17^15)
+                sage: R(1, 15).lift_to_precision(30)
+                Traceback (most recent call last):
+                ...
+                PrecisionError: precision higher than allowed by the precision cap
+                sage: (R(-1, 2).lift_to_precision().precision_absolute()
+                ....:   == R.precision_cap())
+                True
+
+                sage: R = Zp(5); c = R(17, 3); c.lift_to_precision(8)                   # needs sage.rings.padics
+                2 + 3*5 + O(5^8)
+                sage: c.lift_to_precision().precision_relative() == R.precision_cap()   # needs sage.rings.padics
+                True
+            """
+
+
+class CompleteDiscreteValuationFields(Category_singleton):
+    """
+    The category of complete discrete valuation fields.
+
+    EXAMPLES::
+
+        sage: Zp(7) in CompleteDiscreteValuationFields()                                # needs sage.rings.padics
+        False
+        sage: QQ in CompleteDiscreteValuationFields()
+        False
+        sage: LaurentSeriesRing(QQ, 'u') in CompleteDiscreteValuationFields()
+        True
+        sage: Qp(7) in CompleteDiscreteValuationFields()                                # needs sage.rings.padics
+        True
+        sage: TestSuite(CompleteDiscreteValuationFields()).run()
+    """
+
+    def super_categories(self):
+        """
+        EXAMPLES::
+
+            sage: CompleteDiscreteValuationFields().super_categories()
+            [Category of discrete valuation fields]
+        """
+        return [DiscreteValuationFields()]
+
+    class ElementMethods:
+        @abstract_method
+        def valuation(self):
+            """
+            Return the valuation of this element.
+
+            EXAMPLES::
+
+                sage: K = Qp(7)                                                         # needs sage.rings.padics
+                sage: x = K(7); x                                                       # needs sage.rings.padics
+                7 + O(7^21)
+                sage: x.valuation()                                                     # needs sage.rings.padics
+                1
+            """
+
+        def denominator(self):
+            """
+            Return the denominator of this element normalized
+            as a power of the uniformizer
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.padics
+                sage: K = Qp(7)
+                sage: x = K(1/21)
+                sage: x.denominator()
+                7 + O(7^21)
+                sage: x = K(7)
+                sage: x.denominator()
+                1 + O(7^20)
+
+            Note that the denominator lives in the ring of integers::
+
+                sage: x.denominator().parent()                                          # needs sage.rings.padics
+                7-adic Ring with capped relative precision 20
+
+            When the denominator is indistinguishable from 0 and the
+            precision on the input is `O(p^n)`, the return value is `1`
+            if `n` is nonnegative and `p^(-n)` otherwise::
+
+                sage: # needs sage.rings.padics
+                sage: x = K(0, 5); x
+                O(7^5)
+                sage: x.denominator()
+                1 + O(7^20)
+                sage: x = K(0, -5); x
+                O(7^-5)
+                sage: x.denominator()
+                7^5 + O(7^25)
+            """
+            val = self.valuation()
+            R = self.parent().integer_ring()
+            if val >= 0:
+                return R(1)
+            else:
+                return R(1) << (-val)
+
+        def numerator(self):
+            """
+            Return the numerator of this element, normalized in such a
+            way that `x = x.numerator() / x.denominator()` always holds
+            true.
+
+            EXAMPLES::
+
+                sage: # needs sage.rings.padics
+                sage: K = Qp(7, 5)
+                sage: x = K(1/21)
+                sage: x.numerator()
+                5 + 4*7 + 4*7^2 + 4*7^3 + 4*7^4 + O(7^5)
+                sage: x == x.numerator() / x.denominator()
+                True
+
+            Note that the numerator lives in the ring of integers::
+
+                sage: x.numerator().parent()                                            # needs sage.rings.padics
+                7-adic Ring with capped relative precision 5
+
+            TESTS::
+
+                sage: x = K(0, -5); x                                                   # needs sage.rings.padics
+                O(7^-5)
+                sage: x.numerator()                                                     # needs sage.rings.padics
+                O(7^0)
+                sage: x.denominator()                                                   # needs sage.rings.padics
+                7^5 + O(7^10)
+            """
+            R = self.parent().integer_ring()
+            return R(self * self.denominator())

sage/categories/complex_reflection_groups.py

@@ -0,0 +1,145 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Complex reflection groups
+"""
+#*****************************************************************************
+#       Copyright (C) 2011-2015 Christian Stump <christian.stump at gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_import import LazyImport
+from sage.categories.category_singleton import Category_singleton
+from sage.categories.complex_reflection_or_generalized_coxeter_groups import ComplexReflectionOrGeneralizedCoxeterGroups
+
+
+class ComplexReflectionGroups(Category_singleton):
+    r"""
+    The category of complex reflection groups.
+
+    Let `V` be a complex vector space. A *complex reflection* is an
+    element of `\operatorname{GL}(V)` fixing a hyperplane pointwise
+    and acting by multiplication by a root of unity on a complementary
+    line.
+
+    A *complex reflection group* is a group `W` that is (isomorphic
+    to) a subgroup of some general linear group `\operatorname{GL}(V)`
+    generated by a distinguished set of complex reflections.
+
+    The dimension of `V` is the *rank* of `W`.
+
+    For a comprehensive treatment of complex reflection groups and
+    many definitions and theorems used here, we refer to [LT2009]_.
+    See also :wikipedia:`Reflection_group`.
+
+    .. SEEALSO::
+
+        :func:`ReflectionGroup` for usage examples of this category.
+
+    EXAMPLES::
+
+        sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
+        sage: ComplexReflectionGroups()
+        Category of complex reflection groups
+        sage: ComplexReflectionGroups().super_categories()
+        [Category of complex reflection or generalized Coxeter groups]
+        sage: ComplexReflectionGroups().all_super_categories()
+        [Category of complex reflection groups,
+         Category of complex reflection or generalized Coxeter groups,
+         Category of groups,
+         Category of monoids,
+         Category of finitely generated semigroups,
+         Category of semigroups,
+         Category of finitely generated magmas,
+         Category of inverse unital magmas,
+         Category of unital magmas,
+         Category of magmas,
+         Category of enumerated sets,
+         Category of sets,
+         Category of sets with partial maps,
+         Category of objects]
+
+    An example of a reflection group::
+
+        sage: W = ComplexReflectionGroups().example(); W                                # needs sage.combinat
+        5-colored permutations of size 3
+
+    ``W`` is in the category of complex reflection groups::
+
+        sage: W in ComplexReflectionGroups()                                            # needs sage.combinat
+        True
+
+    TESTS::
+
+        sage: TestSuite(W).run()                                                        # needs sage.combinat
+        sage: TestSuite(ComplexReflectionGroups()).run()
+    """
+
+    @cached_method
+    def super_categories(self):
+        r"""
+        Return the super categories of ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
+            sage: ComplexReflectionGroups().super_categories()
+            [Category of complex reflection or generalized Coxeter groups]
+        """
+        return [ComplexReflectionOrGeneralizedCoxeterGroups()]
+
+    def additional_structure(self):
+        r"""
+        Return ``None``.
+
+        Indeed, all the structure complex reflection groups have in
+        addition to groups (simple reflections, ...) is already
+        defined in the super category.
+
+        .. SEEALSO:: :meth:`Category.additional_structure`
+
+        EXAMPLES::
+
+            sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
+            sage: ComplexReflectionGroups().additional_structure()
+        """
+        return None
+
+    def example(self):
+        r"""
+        Return an example of a complex reflection group.
+
+        EXAMPLES::
+
+            sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
+            sage: ComplexReflectionGroups().example()                                   # needs sage.combinat
+            5-colored permutations of size 3
+        """
+        from sage.combinat.colored_permutations import ColoredPermutations
+        return ColoredPermutations(5, 3)
+
+    class ParentMethods:
+
+        @cached_method
+        def rank(self):
+            r"""
+            Return the rank of ``self``.
+
+            The rank of ``self`` is the dimension of the smallest
+            faithfull reflection representation of ``self``.
+
+            EXAMPLES::
+
+                sage: W = CoxeterGroups().example(); W
+                The symmetric group on {0, ..., 3}
+                sage: W.rank()
+                3
+            """
+
+    Finite = LazyImport('sage.categories.finite_complex_reflection_groups',
+                        'FiniteComplexReflectionGroups', as_name='Finite')