passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/examples/graded_modules_with_basis.py

@@ -0,0 +1,168 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: needs sage.combinat
+r"""
+Examples of graded 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.graded_modules_with_basis import GradedModulesWithBasis
+from sage.categories.filtered_modules_with_basis import FilteredModulesWithBasis
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.combinat.partition import Partitions
+
+
+class GradedPartitionModule(CombinatorialFreeModule):
+    r"""
+    This class illustrates an implementation of a graded module
+    with basis: the free module over 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 = GradedModulesWithBasis(QQ).example()                                # needs sage.modules
+
+    - A basis function - this module is graded by the nonnegative
+      integers, so there is a function defined in this module,
+      creatively called :func:`basis`, which takes an integer
+      `d` as input and returns a family of partitions representing a basis
+      for the algebra in degree `d`.
+
+      ::
+
+          sage: A.basis(2)                                                              # needs sage.modules
+          Lazy family (Term map from Partitions to An example of a graded module with basis: the free module on partitions over Rational Field(i))_{i in Partitions of the integer 2}
+          sage: A.basis(6)[Partition([3,2,1])]                                          # needs sage.modules
+          P[3, 2, 1]
+
+    - 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
+      <GradedModules.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
+      <GradedModules.Element.is_homogeneous>` method and a
+      :meth:`degree <GradedModules.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 = GradedModulesWithBasis(QQ).example(); A                           # needs sage.modules
+            An example of a graded 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=GradedModulesWithBasis(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 element determined by the partition ``t`` in
+        this graded 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 = GradedModulesWithBasis(QQ).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.
+
+        EXAMPLES::
+
+            sage: GradedModulesWithBasis(QQ).example()  # indirect doctest              # needs sage.modules
+            An example of a graded module with basis: the free module on partitions over Rational Field
+        """
+        return "An example of a graded 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 = GradedModulesWithBasis(QQ).example()                              # needs sage.modules
+            sage: A._repr_term(Partition((4,2,1)))                                      # needs sage.modules
+            'P[4, 2, 1]'
+        """
+        return 'P' + t._repr_()
+
+
+Example = GradedPartitionModule

sage/categories/examples/graphs.py

@@ -0,0 +1,122 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Examples of graphs
+"""
+# ****************************************************************************
+#  Copyright (C) 2015 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+from sage.structure.parent import Parent
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.structure.element_wrapper import ElementWrapper
+from sage.categories.graphs import Graphs
+
+
+class Cycle(UniqueRepresentation, Parent):
+    r"""
+    An example of a graph: the cycle of length `n`.
+
+    This class illustrates a minimal implementation of a graph.
+
+    EXAMPLES::
+
+        sage: from sage.categories.graphs import Graphs
+        sage: C = Graphs().example(); C
+        An example of a graph: the 5-cycle
+
+        sage: C.category()
+        Category of graphs
+
+    We conclude by running systematic tests on this graph::
+
+        sage: TestSuite(C).run()
+    """
+    def __init__(self, n=5):
+        r"""
+        EXAMPLES::
+
+            sage: from sage.categories.graphs import Graphs
+            sage: C = Graphs().example(6); C
+            An example of a graph: the 6-cycle
+
+        TESTS::
+
+            sage: TestSuite(C).run()
+        """
+        self._n = n
+        Parent.__init__(self, category=Graphs())
+
+    def _repr_(self):
+        r"""
+        TESTS::
+
+            sage: from sage.categories.graphs import Graphs
+            sage: Graphs().example()
+            An example of a graph: the 5-cycle
+        """
+        return "An example of a graph: the {}-cycle".format(self._n)
+
+    def an_element(self):
+        r"""
+        Return an element of the graph, as per
+        :meth:`Sets.ParentMethods.an_element`.
+
+        EXAMPLES::
+
+            sage: from sage.categories.graphs import Graphs
+            sage: C = Graphs().example()
+            sage: C.an_element()
+            0
+        """
+        return self(0)
+
+    def vertices(self):
+        """
+        Return the vertices of ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.categories.graphs import Graphs
+            sage: C = Graphs().example()
+            sage: C.vertices()
+            [0, 1, 2, 3, 4]
+        """
+        return [self(i) for i in range(self._n)]
+
+    def edges(self):
+        """
+        Return the edges of ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.categories.graphs import Graphs
+            sage: C = Graphs().example()
+            sage: C.edges()
+            [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]
+        """
+        return [self( (i, (i+1) % self._n) ) for i in range(self._n)]
+
+    class Element(ElementWrapper):
+        def dimension(self):
+            """
+            Return the dimension of ``self``.
+
+            EXAMPLES::
+
+                sage: from sage.categories.graphs import Graphs
+                sage: C = Graphs().example()
+                sage: e = C.edges()[0]
+                sage: e.dimension()
+                2
+                sage: v = C.vertices()[0]
+                sage: v.dimension()
+                1
+            """
+            if isinstance(self.value, tuple):
+                return 2
+            return 1
+
+
+Example = Cycle

sage/categories/examples/hopf_algebras_with_basis.py

@@ -0,0 +1,145 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: needs sage.groups sage.modules
+r"""
+Examples of Hopf algebras with basis
+"""
+#*****************************************************************************
+#  Copyright (C) 2008-2009 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.misc.cachefunc import cached_method
+from sage.sets.family import Family
+from sage.categories.hopf_algebras_with_basis import HopfAlgebrasWithBasis
+from sage.combinat.free_module import CombinatorialFreeModule
+from sage.categories.tensor import tensor
+
+
+class MyGroupAlgebra(CombinatorialFreeModule):
+    r"""
+    An example of a Hopf algebra with basis: the group algebra of a group.
+
+    This class illustrates a minimal implementation of a Hopf algebra with basis.
+    """
+
+    def __init__(self, R, G):
+        """
+        EXAMPLES::
+
+            sage: from sage.categories.examples.hopf_algebras_with_basis import MyGroupAlgebra
+            sage: A = MyGroupAlgebra(QQ, DihedralGroup(6))
+            sage: A.category()
+            Category of finite dimensional Hopf algebras with basis over Rational Field
+            sage: TestSuite(A).run()
+        """
+        self._group = G
+        CombinatorialFreeModule.__init__(self, R, G,
+                                         category=HopfAlgebrasWithBasis(R))
+
+    def _repr_(self):
+        """
+        EXAMPLES::
+
+            sage: HopfAlgebrasWithBasis(QQ).example() # indirect doctest
+            An example of Hopf algebra with basis: the group algebra of the Dihedral group of order 6 as a permutation group over Rational Field
+        """
+        return "An example of Hopf algebra with basis: the group algebra of the %s over %s" % (self._group, self.base_ring())
+
+    @cached_method
+    def one_basis(self):
+        """
+        Return the one of the group, which index the one of this algebra,
+        as per :meth:`AlgebrasWithBasis.ParentMethods.one_basis`.
+
+        EXAMPLES::
+
+            sage: A = HopfAlgebrasWithBasis(QQ).example()
+            sage: A.one_basis()
+            ()
+            sage: A.one()
+            B[()]
+        """
+        return self._group.one()
+
+    def product_on_basis(self, g1, g2):
+        r"""
+        Product, on basis elements, as per
+        :meth:`AlgebrasWithBasis.ParentMethods.product_on_basis`.
+
+        The product of two basis elements is induced by the product of
+        the corresponding elements of the group.
+
+        EXAMPLES::
+
+            sage: A = HopfAlgebrasWithBasis(QQ).example()
+            sage: (a, b) = A._group.gens()
+            sage: a*b
+            (1,2)
+            sage: A.product_on_basis(a, b)
+            B[(1,2)]
+        """
+        return self.basis()[g1 * g2]
+
+    @cached_method
+    def algebra_generators(self):
+        r"""
+        Return the generators of this algebra, as per :meth:`~.magmatic_algebras.MagmaticAlgebras.ParentMethods.algebra_generators`.
+
+        They correspond to the generators of the group.
+
+        EXAMPLES::
+
+            sage: A = HopfAlgebrasWithBasis(QQ).example(); A
+            An example of Hopf algebra with basis: the group algebra of the Dihedral group of order 6 as a permutation group over Rational Field
+            sage: A.algebra_generators()
+            Finite family {(1,2,3): B[(1,2,3)], (1,3): B[(1,3)]}
+        """
+        return Family(self._group.gens(), self.monomial)
+
+    def coproduct_on_basis(self, g):
+        r"""
+        Coproduct, on basis elements, as per :meth:`HopfAlgebrasWithBasis.ParentMethods.coproduct_on_basis`.
+
+        The basis elements are group like: `\Delta(g) = g \otimes g`.
+
+        EXAMPLES::
+
+            sage: A = HopfAlgebrasWithBasis(QQ).example()
+            sage: (a, b) = A._group.gens()
+            sage: A.coproduct_on_basis(a)
+            B[(1,2,3)] # B[(1,2,3)]
+        """
+        g = self.monomial(g)
+        return tensor([g, g])
+
+    def counit_on_basis(self, g):
+        r"""
+        Counit, on basis elements, as per :meth:`HopfAlgebrasWithBasis.ParentMethods.counit_on_basis`.
+
+        The counit on the basis elements is 1.
+
+        EXAMPLES::
+
+            sage: A = HopfAlgebrasWithBasis(QQ).example()
+            sage: (a, b) = A._group.gens()
+            sage: A.counit_on_basis(a)
+            1
+        """
+        return self.base_ring().one()
+
+    def antipode_on_basis(self, g):
+        r"""
+        Antipode, on basis elements, as per :meth:`HopfAlgebrasWithBasis.ParentMethods.antipode_on_basis`.
+
+        It is given, on basis elements, by `\nu(g) = g^{-1}`
+
+        EXAMPLES::
+
+            sage: A = HopfAlgebrasWithBasis(QQ).example()
+            sage: (a, b) = A._group.gens()
+            sage: A.antipode_on_basis(a)
+            B[(1,3,2)]
+        """
+        return self.monomial(~g)

sage/categories/examples/infinite_enumerated_sets.py

@@ -0,0 +1,190 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Examples of infinite enumerated sets
+"""
+# ****************************************************************************
+#  Copyright (C) 2009 Florent Hivert <Florent.Hivert@univ-rouen.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.structure.parent import Parent
+from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.rings.integer import Integer
+
+
+class NonNegativeIntegers(UniqueRepresentation, Parent):
+    r"""
+    An example of infinite enumerated set: the nonnegative integers.
+
+    This class provides a minimal implementation of an infinite enumerated set.
+
+    EXAMPLES::
+
+        sage: NN = InfiniteEnumeratedSets().example()
+        sage: NN
+        An example of an infinite enumerated set: the nonnegative integers
+        sage: NN.cardinality()
+        +Infinity
+        sage: NN.list()
+        Traceback (most recent call last):
+        ...
+        NotImplementedError: cannot list an infinite set
+        sage: NN.element_class
+        <class 'sage.rings.integer.Integer'>
+        sage: it = iter(NN)
+        sage: [next(it), next(it), next(it), next(it), next(it)]
+        [0, 1, 2, 3, 4]
+        sage: x = next(it); type(x)
+        <class 'sage.rings.integer.Integer'>
+        sage: x.parent()
+        Integer Ring
+        sage: x+3
+        8
+        sage: NN(15)
+        15
+        sage: NN.first()
+        0
+
+    This checks that the different methods of `NN` return consistent
+    results::
+
+        sage: TestSuite(NN).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_enumerated_set_contains() . . . pass
+        running ._test_enumerated_set_iter_cardinality() . . . pass
+        running ._test_enumerated_set_iter_list() . . . 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):
+        """
+        TESTS::
+
+            sage: NN = InfiniteEnumeratedSets().example()
+            sage: NN
+            An example of an infinite enumerated set: the nonnegative integers
+            sage: NN.category()
+            Category of infinite enumerated sets
+            sage: TestSuite(NN).run()
+        """
+        Parent.__init__(self, category=InfiniteEnumeratedSets())
+
+    def _repr_(self):
+        """
+        TESTS::
+
+            sage: InfiniteEnumeratedSets().example() # indirect doctest
+            An example of an infinite enumerated set: the nonnegative integers
+        """
+        return "An example of an infinite enumerated set: the nonnegative integers"
+
+    def __contains__(self, elt):
+        """
+        EXAMPLES::
+
+            sage: NN = InfiniteEnumeratedSets().example()
+            sage: 1 in NN
+            True
+            sage: -1 in NN
+            False
+        """
+        return Integer(elt) >= Integer(0)
+
+    def __iter__(self):
+        """
+        EXAMPLES::
+
+            sage: NN = InfiniteEnumeratedSets().example()
+            sage: g = iter(NN)
+            sage: next(g), next(g), next(g), next(g)
+            (0, 1, 2, 3)
+        """
+        i = Integer(0)
+        while True:
+            yield self._element_constructor_(i)
+            i += 1
+
+    def __call__(self, elt):
+        """
+        EXAMPLES::
+
+            sage: NN = InfiniteEnumeratedSets().example()
+            sage: NN(3)         # indirect doctest
+            3
+            sage: NN(3).parent()
+            Integer Ring
+            sage: NN(-1)
+            Traceback (most recent call last):
+            ...
+            ValueError: Value -1 is not a nonnegative integer.
+        """
+        if elt in self:
+            return self._element_constructor_(elt)
+        raise ValueError("Value %s is not a nonnegative integer." % (elt))
+
+    def an_element(self):
+        """
+        EXAMPLES::
+
+            sage: InfiniteEnumeratedSets().example().an_element()
+            42
+        """
+        return self._element_constructor_(Integer(42))
+
+    def next(self, o):
+        """
+        EXAMPLES::
+
+            sage: NN = InfiniteEnumeratedSets().example()
+            sage: NN.next(3)
+            4
+        """
+        return self._element_constructor_(o+1)
+
+    def _element_constructor_(self, i):
+        """
+        The default implementation of _element_constructor_ assumes
+        that the constructor of the element class takes the parent as
+        parameter. This is not the case for ``Integer``, so we need to
+        provide an implementation.
+
+
+        TESTS::
+
+            sage: NN = InfiniteEnumeratedSets().example()
+            sage: x = NN(42); x
+            42
+            sage: type(x)
+            <class 'sage.rings.integer.Integer'>
+            sage: x.parent()
+            Integer Ring
+        """
+        return self.element_class(i)
+
+    Element = Integer
+
+
+Example = NonNegativeIntegers