passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/examples/finite_coxeter_groups.py

@@ -0,0 +1,252 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: needs sage.combinat sage.groups
+r"""
+Examples of finite Coxeter groups
+"""
+# ****************************************************************************
+#  Copyright (C) 2008 Nicolas M. Thiery <nthiery at users.sf.net>
+#  Copyright (C) 2009 Nicolas Borie <nicolas dot borie at math.u-psud.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+from sage.misc.cachefunc import cached_method
+from sage.structure.parent import Parent
+from sage.structure.element_wrapper import ElementWrapper
+from sage.categories.finite_coxeter_groups import FiniteCoxeterGroups
+from sage.structure.unique_representation import UniqueRepresentation
+from sage.misc.functional import is_odd, is_even
+from sage.combinat.root_system.coxeter_matrix import CoxeterMatrix
+
+
+class DihedralGroup(UniqueRepresentation, Parent):
+    r"""
+    An example of finite Coxeter group: the `n`-th dihedral group of order `2n`.
+
+    The purpose of this class is to provide a minimal template for
+    implementing finite Coxeter groups. See
+    :class:`~sage.groups.perm_gps.permgroup_named.DihedralGroup` for a
+    full featured and optimized implementation.
+
+    EXAMPLES::
+
+        sage: G = FiniteCoxeterGroups().example()
+
+    This group is generated by two simple reflections `s_1` and `s_2`
+    subject to the relation `(s_1s_2)^n = 1`::
+
+        sage: G.simple_reflections()
+        Finite family {1: (1,), 2: (2,)}
+
+        sage: s1, s2 = G.simple_reflections()
+        sage: (s1*s2)^5 == G.one()
+        True
+
+    An element is represented by its reduced word (a tuple of elements
+    of `self.index_set()`)::
+
+        sage: G.an_element()
+        (1, 2)
+
+        sage: list(G)
+        [(),
+         (1,),
+         (2,),
+         (1, 2),
+         (2, 1),
+         (1, 2, 1),
+         (2, 1, 2),
+         (1, 2, 1, 2),
+         (2, 1, 2, 1),
+         (1, 2, 1, 2, 1)]
+
+    This reduced word is unique, except for the longest element where
+    the chosen reduced word is `(1,2,1,2\dots)`::
+
+        sage: G.long_element()
+        (1, 2, 1, 2, 1)
+
+    TESTS::
+
+        sage: TestSuite(G).run()
+
+        sage: c = FiniteCoxeterGroups().example(3).cayley_graph()
+        sage: c.edges(sort=True)
+        [((), (1,), 1),
+         ((), (2,), 2),
+         ((1,), (), 1),
+         ((1,), (1, 2), 2),
+         ((1, 2), (1,), 2),
+         ((1, 2), (1, 2, 1), 1),
+         ((1, 2, 1), (1, 2), 1),
+         ((1, 2, 1), (2, 1), 2),
+         ((2,), (), 2),
+         ((2,), (2, 1), 1),
+         ((2, 1), (1, 2, 1), 2),
+         ((2, 1), (2,), 1)]
+    """
+
+    def __init__(self, n=5):
+        r"""
+        Construct the `n`-th DihedralGroup of order `2 n`.
+
+        INPUT:
+
+        - ``n`` -- integer with `n \geq 2`
+
+        EXAMPLES::
+
+            sage: from sage.categories.examples.finite_coxeter_groups import DihedralGroup
+            sage: DihedralGroup(3)
+            The 3-th dihedral group of order 6
+        """
+        assert n >= 2
+        Parent.__init__(self, category=FiniteCoxeterGroups())
+        self.n = n
+
+    def _repr_(self):
+        r"""
+        EXAMPLES::
+
+            sage: FiniteCoxeterGroups().example()
+            The 5-th dihedral group of order 10
+            sage: FiniteCoxeterGroups().example(6)
+            The 6-th dihedral group of order 12
+        """
+        return "The %s-th dihedral group of order %s" % (self.n, 2 * self.n)
+
+    def __contains__(self, x):
+        r"""
+        Check if the element ``x`` is in the mathematical parent ``self``.
+
+        EXAMPLES::
+
+            sage: D5 = FiniteCoxeterGroups().example()
+            sage: D5.an_element() in D5
+            True
+            sage: 1 in D5
+            False
+
+        (also tested by :meth:`test_an_element` :meth:`test_some_elements`)
+        """
+        from sage.structure.all import parent
+        return parent(x) is self
+
+    @cached_method
+    def one(self):
+        r"""
+        Implement :meth:`Monoids.ParentMethods.one`.
+
+        EXAMPLES::
+
+            sage: D6 = FiniteCoxeterGroups().example(6)
+            sage: D6.one()
+            ()
+        """
+        return self(())
+
+    def index_set(self):
+        r"""
+        Implement :meth:`CoxeterGroups.ParentMethods.index_set`.
+
+        EXAMPLES::
+
+            sage: D4 = FiniteCoxeterGroups().example(4)
+            sage: D4.index_set()
+            (1, 2)
+        """
+        return (1, 2)
+
+    def degrees(self):
+        """
+        Return the degrees of ``self``.
+
+        EXAMPLES::
+
+            sage: FiniteCoxeterGroups().example(6).degrees()
+            (2, 6)
+        """
+        from sage.rings.integer_ring import ZZ
+        return (ZZ(2), ZZ(self.n))
+
+    def coxeter_matrix(self):
+        """
+        Return the Coxeter matrix of ``self``.
+
+        EXAMPLES::
+
+            sage: FiniteCoxeterGroups().example(6).coxeter_matrix()
+            [1 6]
+            [6 1]
+        """
+        return CoxeterMatrix([[1, self.n], [self.n, 1]])
+
+    class Element(ElementWrapper):
+        wrapped_class = tuple
+        __lt__ = ElementWrapper._lt_by_value
+
+        def has_right_descent(self, i, positive=False, side='right') -> bool:
+            r"""
+            Implement :meth:`SemiGroups.ElementMethods.has_right_descent`.
+
+            EXAMPLES::
+
+                sage: D6 = FiniteCoxeterGroups().example(6)
+                sage: s = D6.simple_reflections()
+                sage: s[1].has_descent(1)
+                True
+                sage: s[1].has_descent(1)
+                True
+                sage: s[1].has_descent(2)
+                False
+                sage: D6.one().has_descent(1)
+                False
+                sage: D6.one().has_descent(2)
+                False
+                sage: D6.long_element().has_descent(1)
+                True
+                sage: D6.long_element().has_descent(2)
+                True
+
+            TESTS::
+
+                sage: D6._test_has_descent()
+            """
+            reduced_word = self.value
+            if len(reduced_word) == self.parent().n:
+                return not positive
+            elif len(reduced_word) == 0:
+                return positive
+            else:
+                return (i == reduced_word[0 if side == "left" else -1]) == (not positive)
+
+        def apply_simple_reflection_right(self, i):
+            r"""
+            Implement :meth:`CoxeterGroups.ElementMethods.apply_simple_reflection`.
+
+            EXAMPLES::
+
+                sage: D5 = FiniteCoxeterGroups().example(5)
+                sage: [i^2 for i in D5]  # indirect doctest
+                [(), (), (), (1, 2, 1, 2), (2, 1, 2, 1), (), (), (2, 1), (1, 2), ()]
+                sage: [i^5 for i in D5]  # indirect doctest
+                [(), (1,), (2,), (), (), (1, 2, 1), (2, 1, 2), (), (), (1, 2, 1, 2, 1)]
+            """
+            from copy import copy
+            reduced_word = copy(self.value)
+            n = self.parent().n
+            if len(reduced_word) == n:
+                if (i == 1 and is_odd(n)) or (i == 2 and is_even(n)):
+                    return self.parent()(reduced_word[:-1])
+                else:
+                    return self.parent()(reduced_word[1:])
+            elif (len(reduced_word) == n - 1 and (not self.has_descent(i))) and (reduced_word[0] == 2):
+                return self.parent()((1,) + reduced_word)
+            else:
+                if self.has_descent(i):
+                    return self.parent()(reduced_word[:-1])
+                else:
+                    return self.parent()(reduced_word + (i,))
+
+
+Example = DihedralGroup

sage/categories/examples/finite_dimensional_algebras_with_basis.py

@@ -0,0 +1,148 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: needs sage.modules
+r"""
+Example of a finite dimensional algebra with basis
+"""
+#*****************************************************************************
+#  Copyright (C) 2008-2015 Franco Saliola <saliola@gmail.com>
+#
+#  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.categories.finite_dimensional_algebras_with_basis import FiniteDimensionalAlgebrasWithBasis
+from sage.combinat.free_module import CombinatorialFreeModule
+
+
+class KroneckerQuiverPathAlgebra(CombinatorialFreeModule):
+    r"""
+    An example of a finite dimensional algebra with basis: the path
+    algebra of the Kronecker quiver.
+
+    This class illustrates a minimal implementation of a finite
+    dimensional algebra with basis. See
+    :class:`sage.quivers.algebra.PathAlgebra` for a full-featured
+    implementation of path algebras.
+    """
+
+    def __init__(self, base_ring):
+        r"""
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebrasWithBasis(QQ).example(); A
+            An example of a finite dimensional algebra with basis:
+            the path algebra of the Kronecker quiver
+            (containing the arrows a:x->y and b:x->y) over Rational Field
+            sage: TestSuite(A).run()
+        """
+        basis_keys = ['x', 'y', 'a', 'b']
+        self._nonzero_products = {
+            'xx':'x', 'xa':'a', 'xb':'b',
+            'yy':'y', 'ay':'a', 'by':'b'
+            }
+
+        CombinatorialFreeModule.__init__(
+            self, base_ring, basis_keys,
+            category=FiniteDimensionalAlgebrasWithBasis(base_ring))
+
+    def _repr_(self):
+        r"""
+        EXAMPLES::
+
+            sage: FiniteDimensionalAlgebrasWithBasis(QQ).example() # indirect doctest
+            An example of a finite dimensional algebra with basis:
+            the path algebra of the Kronecker quiver
+            (containing the arrows a:x->y and b:x->y) over Rational Field
+        """
+        return "An example of a finite dimensional algebra with basis: " \
+            "the path algebra of the Kronecker quiver " \
+            "(containing the arrows a:x->y and b:x->y) over %s " % (self.base_ring())
+
+    def one(self):
+        r"""
+        Return the unit of this algebra.
+
+        .. SEEALSO:: :meth:`AlgebrasWithBasis.ParentMethods.one_basis`
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebrasWithBasis(QQ).example()
+            sage: A.one()
+            x + y
+        """
+        return self.sum_of_monomials(['x', 'y'])
+
+    def product_on_basis(self, w1, w2):
+        r"""
+        Return the product of the two basis elements indexed by ``w1`` and ``w2``.
+
+        .. SEEALSO:: :meth:`AlgebrasWithBasis.ParentMethods.product_on_basis`.
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebrasWithBasis(QQ).example()
+
+        Here is the multiplication table for the algebra::
+
+            sage: matrix([[p*q for q in A.basis()] for p in A.basis()])
+            [x 0 a b]
+            [0 y 0 0]
+            [0 a 0 0]
+            [0 b 0 0]
+
+        Here we take some products of linear combinations of basis elements::
+
+            sage: x, y, a, b = A.basis()
+            sage: a * (1-b)^2 * x
+            0
+            sage: x*a + b*y
+            a + b
+            sage: x*x
+            x
+            sage: x*y
+            0
+            sage: x*a*y
+            a
+        """
+        if w1+w2 in self._nonzero_products:
+            return self.monomial(self._nonzero_products[w1+w2])
+        else:
+            return self.zero()
+
+    @cached_method
+    def algebra_generators(self):
+        r"""
+        Return algebra generators for this algebra.
+
+        .. SEEALSO:: :meth:`Algebras.ParentMethods.algebra_generators`.
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebrasWithBasis(QQ).example(); A
+            An example of a finite dimensional algebra with basis:
+            the path algebra of the Kronecker quiver
+            (containing the arrows a:x->y and b:x->y) over Rational Field
+            sage: A.algebra_generators()
+            Finite family {'x': x, 'y': y, 'a': a, 'b': b}
+        """
+        return self.basis()
+
+    def _repr_term(self, p):
+        r"""
+        This method customizes the string representation of the basis
+        element indexed by ``p``.
+
+        In this example, we just return the string representation of
+        ``p`` itself.
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebrasWithBasis(QQ).example()
+            sage: A.one()
+            x + y
+        """
+        return str(p)
+
+
+Example = KroneckerQuiverPathAlgebra