passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/examples/facade_sets.py

@@ -0,0 +1,187 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Example of facade set
+"""
+#*****************************************************************************
+#  Copyright (C) 2010 Nicolas M. Thiery <nthiery at users.sf.net>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.categories.sets_cat import Sets
+from sage.categories.monoids import Monoids
+from sage.structure.parent import Parent
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.rings.integer_ring import ZZ
+from sage.rings.infinity import infinity
+from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
+
+
+class PositiveIntegerMonoid(UniqueRepresentation, Parent):
+    r"""
+
+    An example of a facade parent: the positive integers viewed as a
+    multiplicative monoid
+
+    This class illustrates a minimal implementation of a facade parent
+    which models a subset of a set.
+
+    EXAMPLES::
+
+        sage: S = Sets().Facade().example(); S
+        An example of facade set: the monoid of positive integers
+
+    TESTS::
+
+        sage: TestSuite(S).run(verbose = True)
+        running ._test_an_element() . . . pass
+        running ._test_associativity() . . . pass
+        running ._test_cardinality() . . . pass
+        running ._test_category() . . . pass
+        running ._test_construction() . . . pass
+        running ._test_elements() . . .
+          Running the test suite of self.an_element()
+          running ._test_category() . . . pass
+          running ._test_eq() . . . pass
+          running ._test_new() . . . pass
+          running ._test_nonzero_equal() . . . pass
+          running ._test_not_implemented_methods() . . . pass
+          running ._test_pickling() . . . pass
+          pass
+        running ._test_elements_eq_reflexive() . . . pass
+        running ._test_elements_eq_symmetric() . . . pass
+        running ._test_elements_eq_transitive() . . . pass
+        running ._test_elements_neq() . . . pass
+        running ._test_eq() . . . pass
+        running ._test_new() . . . pass
+        running ._test_not_implemented_methods() . . . pass
+        running ._test_one() . . . pass
+        running ._test_pickling() . . . pass
+        running ._test_prod() . . . pass
+        running ._test_some_elements() . . . pass
+    """
+    def __init__(self):
+        r"""
+        EXAMPLES::
+
+            sage: from sage.categories.examples.facade_sets import PositiveIntegerMonoid
+            sage: S = PositiveIntegerMonoid(); S
+            An example of facade set: the monoid of positive integers
+
+        TESTS::
+
+            sage: TestSuite(S).run()
+        """
+        Parent.__init__(self, facade=ZZ, category=Monoids())
+
+    def _repr_(self):
+        r"""
+
+        EXAMPLES::
+
+            sage: S = Sets().Facade().example()   # indirect doctest
+        """
+        return "An example of facade set: the monoid of positive integers"
+
+    def _element_constructor_(self, object):
+        r"""
+        Construction of elements.
+
+        Since ``self`` is a strict subset of the parent it is a facade
+        for, it is mandatory to override this method. This method
+        indirectly influences membership testing (see
+        :meth:`Parent.__contains__`).
+
+        EXAMPLES::
+
+            sage: S = Sets().Facade().example(); S
+            An example of facade set: the monoid of positive integers
+            sage: S(1)
+            1
+            sage: S(int(1))
+            1
+            sage: S(2/1)
+            2
+            sage: (parent(S(1)) == ZZ, parent(S(int(1))) == ZZ, parent(S(2/1)))
+            (True, True, Integer Ring)
+            sage: S(1), S(int(1)), S(2/1)
+            (1, 1, 2)
+            sage: 1 in S
+            True
+            sage: 2/1 in S, int(1) in S
+            (True, True)
+            sage: -1 in S, 1/2 in S
+            (False, False)
+        """
+        object = ZZ(object)
+        if object > ZZ(0):
+            return object
+        else:
+            raise ValueError("%s should be positive")
+
+
+class IntegersCompletion(UniqueRepresentation, Parent):
+    r"""
+    An example of a facade parent: the set of integers completed with
+    `+-\infty`
+
+    This class illustrates a minimal implementation of a facade parent
+    that models the union of several other parents.
+
+    EXAMPLES::
+
+        sage: S = Sets().Facade().example("union"); S
+        An example of a facade set: the integers completed by +-infinity
+
+    TESTS::
+
+        sage: TestSuite(S).run(verbose = True)
+        running ._test_an_element() . . . pass
+        running ._test_cardinality() . . . pass
+        running ._test_category() . . . pass
+        running ._test_construction() . . . pass
+        running ._test_elements() . . .
+          Running the test suite of self.an_element()
+          running ._test_category() . . . pass
+          running ._test_eq() . . . pass
+          running ._test_new() . . . pass
+          running ._test_nonzero_equal() . . . pass
+          running ._test_not_implemented_methods() . . . pass
+          running ._test_pickling() . . . pass
+          pass
+        running ._test_elements_eq_reflexive() . . . pass
+        running ._test_elements_eq_symmetric() . . . pass
+        running ._test_elements_eq_transitive() . . . pass
+        running ._test_elements_neq() . . . pass
+        running ._test_eq() . . . pass
+        running ._test_new() . . . pass
+        running ._test_not_implemented_methods() . . . pass
+        running ._test_pickling() . . . pass
+        running ._test_some_elements() . . . pass
+    """
+    def __init__(self):
+        r"""
+        EXAMPLES::
+
+            sage: from sage.categories.examples.facade_sets import IntegersCompletion
+            sage: S = IntegersCompletion(); S
+            An example of a facade set: the integers completed by +-infinity
+
+        TESTS::
+
+            sage: TestSuite(S).run()
+        """
+        # We can't use InfinityRing, because this ring contains 3
+        # elements besides +-infinity. We can not use Set either for the
+        # moment, because Set([1,2])(1) raises an error
+        Parent.__init__(self, facade=(ZZ, FiniteEnumeratedSet([-infinity, +infinity])), category=Sets())
+
+    def _repr_(self):
+        r"""
+
+        EXAMPLES::
+
+            sage: S = Sets().Facade().example()   # indirect doctest
+        """
+        return "An example of a facade set: the integers completed by +-infinity"

sage/categories/examples/filtered_algebras_with_basis.py

@@ -0,0 +1,204 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Examples of filtered algebra with basis
+"""
+#*****************************************************************************
+#  Copyright (C) 2014 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.categories.filtered_algebras_with_basis import FilteredAlgebrasWithBasis
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.monoids.indexed_free_monoid import IndexedFreeAbelianMonoid
+from sage.sets.family import Family
+
+
+class PBWBasisCrossProduct(CombinatorialFreeModule):
+    r"""
+    This class illustrates an implementation of a filtered algebra
+    with basis: the universal enveloping algebra of the Lie algebra
+    of `\RR^3` under the cross product.
+
+    The Lie algebra is generated by `x,y,z` with brackets defined by
+    `[x, y] = z`, `[y, z] = x`, and `[x, z] = -y`. The universal enveloping
+    algebra has a (PBW) basis consisting of monomials `x^i y^j z^k`.
+    Despite these monomials not commuting with each other, we
+    nevertheless label them by the elements of the free abelian monoid
+    on three generators.
+
+    INPUT:
+
+    - ``R`` -- base ring
+
+    The implementation involves the following:
+
+    - A set of algebra generators -- the set of generators `x,y,z`
+
+    - The index of the unit element -- the unit element in the monoid
+      of monomials
+
+    - A product -- this is given on basis elements by using
+      :meth:`product_on_basis`
+
+    - A degree function -- this is determined on the basis elements
+      by using :meth:`degree_on_basis` which returns the sum of exponents
+      of the monomial
+    """
+    def __init__(self, base_ring):
+        """
+        EXAMPLES::
+
+            sage: A = AlgebrasWithBasis(QQ).Filtered().example()
+            sage: x,y,z = A.algebra_generators()
+            sage: TestSuite(A).run(elements=[x*y+z])
+        """
+        I = IndexedFreeAbelianMonoid(['x', 'y', 'z'], prefix='U')
+
+        CombinatorialFreeModule.__init__(self, base_ring, I, bracket=False,
+                                         prefix='',
+                                         sorting_key=self._sort_key,
+                                         category=FilteredAlgebrasWithBasis(base_ring))
+
+    def _sort_key(self, x):
+        """
+        Return the key used to sort the terms.
+
+        INPUT:
+
+        - ``x`` -- a basis index (here an element in a free Abelian monoid)
+
+        EXAMPLES::
+
+            sage: A = AlgebrasWithBasis(QQ).Filtered().example()
+            sage: S = sorted(A.an_element().support()); S
+            [1, U['x'], U['x']^2*U['y']^2*U['z']^3, U['y']]
+            sage: [A._sort_key(m) for m in S]
+            [(0, []), (-1, ['x']), (-7, ['x', 'x', 'y', 'y', 'z', 'z', 'z']),
+            (-1, ['y'])]
+        """
+        return (-len(x), x.to_word_list())
+
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: AlgebrasWithBasis(QQ).Filtered().example()
+            An example of a filtered algebra with basis:
+             the universal enveloping algebra of
+             Lie algebra of RR^3 with cross product over Rational Field
+        """
+        return "An example of a filtered algebra with basis: the universal enveloping algebra of Lie algebra of RR^3 with cross product over {}".format(self.base_ring())
+
+    def algebra_generators(self):
+        """
+        Return the algebra generators of ``self``.
+
+        EXAMPLES::
+
+            sage: A = AlgebrasWithBasis(QQ).Filtered().example()
+            sage: list(A.algebra_generators())
+            [U['x'], U['y'], U['z']]
+        """
+        G = self._indices.monoid_generators()
+        I = sorted(G.keys())
+        return Family(I, lambda x: self.monomial(G[x]))
+
+    def one_basis(self):
+        """
+        Return the index of the unit of ``self``.
+
+        EXAMPLES::
+
+            sage: A = AlgebrasWithBasis(QQ).Filtered().example()
+            sage: A.one_basis()
+            1
+        """
+        return self._indices.one()
+
+    def degree_on_basis(self, m):
+        """
+        The degree of the basis element of ``self`` labelled by ``m``.
+
+        INPUT:
+
+        - ``m`` -- an element of the free abelian monoid
+
+        OUTPUT: integer; the degree of the corresponding basis element
+
+        EXAMPLES::
+
+            sage: A = AlgebrasWithBasis(QQ).Filtered().example()
+            sage: x = A.algebra_generators()['x']
+            sage: A.degree_on_basis((x^4).leading_support())
+            4
+            sage: a = A.an_element(); a
+            U['x']^2*U['y']^2*U['z']^3 + 2*U['x'] + 3*U['y'] + 1
+            sage: A.degree_on_basis(a.leading_support())
+            1
+            sage: s = sorted(a.support(), key=str)[2]; s
+            U['x']^2*U['y']^2*U['z']^3
+            sage: A.degree_on_basis(s)
+            7
+        """
+        return len(m)
+
+    # TODO: This is a general procedure of expanding multiplication defined
+    #  on generators to arbitrary monomials and could likely be factored out
+    #  and be useful elsewhere.
+    def product_on_basis(self, s, t):
+        """
+        Return the product of two basis elements indexed by ``s`` and ``t``.
+
+        EXAMPLES::
+
+            sage: A = AlgebrasWithBasis(QQ).Filtered().example()
+            sage: G = A.algebra_generators()
+            sage: x,y,z = G['x'], G['y'], G['z']
+            sage: A.product_on_basis(x.leading_support(), y.leading_support())
+            U['x']*U['y']
+            sage: y*x
+            U['x']*U['y'] - U['z']
+            sage: x*y*x
+            U['x']^2*U['y'] - U['x']*U['z']
+            sage: z*y*x
+            U['x']*U['y']*U['z'] - U['x']^2 + U['y']^2 - U['z']^2
+        """
+        if len(s) == 0:
+            return self.monomial(t)
+        if len(t) == 0:
+            return self.monomial(s)
+        if s.trailing_support() <= t.leading_support():
+            return self.monomial(s*t)
+
+        if len(t) == 1:
+            if len(s) == 1:
+                # Do the product of the generators
+                a = s.leading_support()
+                b = t.leading_support()
+                cur = self.monomial(s*t)
+                if a <= b:
+                    return cur
+                if a == 'z':
+                    if b == 'y':
+                        return cur - self.monomial(self._indices.gen('x'))
+                    # b == 'x'
+                    return cur + self.monomial(self._indices.gen('y'))
+                # a == 'y' and b == 'x'
+                return cur - self.monomial(self._indices.gen('z'))
+
+            cur = self.monomial(t)
+            for a in reversed(s.to_word_list()):
+                cur = self.monomial(self._indices.gen(a)) * cur
+            return cur
+
+        cur = self.monomial(s)
+        for a in t.to_word_list():
+            cur = cur * self.monomial(self._indices.gen(a))
+        return cur
+
+
+Example = PBWBasisCrossProduct

sage/categories/examples/filtered_modules_with_basis.py

@@ -0,0 +1,154 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: needs sage.combinat
+r"""
+Examples of filtered modules with basis
+"""
+# ****************************************************************************
+#  Copyright (C) 2013 Frédéric Chapoton <fchapoton2@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.categories.filtered_modules_with_basis import FilteredModulesWithBasis
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.combinat.partition import Partitions
+
+
+class FilteredPartitionModule(CombinatorialFreeModule):
+    r"""
+    This class illustrates an implementation of a filtered module
+    with basis: the free module on the set of all partitions.
+
+    INPUT:
+
+    - ``R`` -- base ring
+
+    The implementation involves the following:
+
+    - A choice of how to represent elements.  In this case, the basis
+      elements are partitions. The algebra is constructed as a
+      :class:`CombinatorialFreeModule
+      <sage.combinat.free_module.CombinatorialFreeModule>` on the
+      set of partitions, so it inherits all of the methods for such
+      objects, and has operations like addition already defined.
+
+      ::
+
+          sage: A = ModulesWithBasis(QQ).Filtered().example()                           # needs sage.modules
+
+    - If the algebra is called ``A``, then its basis function is
+      stored as ``A.basis``.  Thus the function can be used to
+      find a basis for the degree `d` piece: essentially, just call
+      ``A.basis(d)``.  More precisely, call ``x`` for
+      each ``x`` in ``A.basis(d)``.
+
+      ::
+
+          sage: [m for m in A.basis(4)]                                                 # needs sage.modules
+          [P[4], P[3, 1], P[2, 2], P[2, 1, 1], P[1, 1, 1, 1]]
+
+    - For dealing with basis elements: :meth:`degree_on_basis`, and
+      :meth:`_repr_term`. The first of these defines the degree of any
+      monomial, and then the :meth:`degree
+      <FilteredModules.Element.degree>` method for elements --
+      see the next item -- uses it to compute the degree for a linear
+      combination of monomials.  The last of these determines the
+      print representation for monomials, which automatically produces
+      the print representation for general elements.
+
+      ::
+
+          sage: A.degree_on_basis(Partition([4,3]))                                     # needs sage.modules
+          7
+          sage: A._repr_term(Partition([4,3]))                                          # needs sage.modules
+          'P[4, 3]'
+
+    - There is a class for elements, which inherits from
+      :class:`IndexedFreeModuleElement
+      <sage.modules.with_basis.indexed_element.IndexedFreeModuleElement>`.
+      An element is determined by a dictionary whose keys are partitions and
+      whose corresponding values are the coefficients.  The class implements
+      two things: an :meth:`is_homogeneous
+      <FilteredModules.Element.is_homogeneous>` method and a
+      :meth:`degree <FilteredModules.Element.degree>` method.
+
+      ::
+
+          sage: p = A.monomial(Partition([3,2,1])); p                                   # needs sage.modules
+          P[3, 2, 1]
+          sage: p.is_homogeneous()                                                      # needs sage.modules
+          True
+          sage: p.degree()                                                              # needs sage.modules
+          6
+    """
+    def __init__(self, base_ring):
+        """
+        EXAMPLES::
+
+            sage: A = ModulesWithBasis(QQ).Filtered().example(); A                      # needs sage.modules
+            An example of a filtered module with basis: the free module on partitions over Rational Field
+            sage: TestSuite(A).run()                                                    # needs sage.modules
+        """
+        CombinatorialFreeModule.__init__(self, base_ring, Partitions(),
+                                         category=FilteredModulesWithBasis(base_ring))
+
+    # FIXME: this is currently required, because the implementation of ``basis``
+    # in CombinatorialFreeModule overrides that of GradedModulesWithBasis
+    basis = FilteredModulesWithBasis.ParentMethods.__dict__['basis']
+
+    # This could be a default implementation
+    def degree_on_basis(self, t):
+        """
+        The degree of the basis element indexed by the partition ``t``
+        in this filtered module.
+
+        INPUT:
+
+        - ``t`` -- the index of an element of the basis of this module,
+          i.e. a partition
+
+        OUTPUT: integer; the degree of the corresponding basis element
+
+        EXAMPLES::
+
+            sage: # needs sage.modules
+            sage: A = ModulesWithBasis(QQ).Filtered().example()
+            sage: A.degree_on_basis(Partition((2,1)))
+            3
+            sage: A.degree_on_basis(Partition((4,2,1,1,1,1)))
+            10
+            sage: type(A.degree_on_basis(Partition((1,1))))
+            <class 'sage.rings.integer.Integer'>
+        """
+        return t.size()
+
+    def _repr_(self):
+        """
+        Print representation of ``self``.
+
+        EXAMPLES::
+
+            sage: ModulesWithBasis(QQ).Filtered().example()  # indirect doctest         # needs sage.modules
+            An example of a filtered module with basis: the free module on partitions over Rational Field
+        """
+        return "An example of a filtered module with basis: the free module on partitions over %s" % self.base_ring()
+
+    def _repr_term(self, t):
+        """
+        Print representation for the basis element represented by the
+        partition ``t``.
+
+        This governs the behavior of the print representation of all elements
+        of the algebra.
+
+        EXAMPLES::
+
+            sage: A = ModulesWithBasis(QQ).Filtered().example()                         # needs sage.modules
+            sage: A._repr_term(Partition((4,2,1)))                                      # needs sage.modules
+            'P[4, 2, 1]'
+        """
+        return 'P' + t._repr_()
+
+
+Example = FilteredPartitionModule