passagemath-modules 10.6.31rc3__cp314-cp314-musllinux_1_2_aarch64.whl

sage/combinat/root_system/type_A_infinity.py

@@ -0,0 +1,241 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Root system data for type A infinity
+"""
+# ***************************************************************************
+# Copyright (C) 2016 Andrew Mathas <Andrew dot Mathas at Sydney dot edu dot au>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+from .cartan_type import CartanType_standard, CartanType_simple
+from sage.rings.integer_ring import ZZ
+
+
+class CartanType(CartanType_standard, CartanType_simple):
+    r"""
+    The Cartan type `A_{\infty}`.
+
+    We use ``NN`` and ``ZZ`` to explicitly differentiate between the
+    `A_{+\infty}` and `A_{\infty}` root systems, respectively.
+    While ``oo`` is the same as ``+Infinity`` in Sage, it is used as
+    an alias for ``ZZ``.
+    """
+    # We do not inherit from CartanType_crystallographic because it provides
+    # methods that are not implemented for A_oo.
+
+    def __init__(self, index_set):
+        """
+        EXAMPLES::
+
+            sage: CartanType(['A',oo]) is CartanType(['A', ZZ])
+            True
+            sage: CartanType(['A',oo]) is CartanType(['A', NN])
+            False
+            sage: ct=CartanType(['A',ZZ])
+            sage: ct
+            ['A', ZZ]
+            sage: ct._repr_(compact = True)
+            'A_ZZ'
+            sage: ct.is_irreducible()
+            True
+            sage: ct.is_finite()
+            False
+            sage: ct.is_affine()
+            False
+            sage: ct.is_untwisted_affine()
+            False
+            sage: ct.is_crystallographic()
+            True
+            sage: ct.is_simply_laced()
+            True
+            sage: ct.dual()
+            ['A', ZZ]
+
+        TESTS::
+
+            sage: TestSuite(ct).run()
+        """
+        super().__init__()
+        self.letter = 'A'
+        self.n = index_set
+
+    def _repr_(self, compact=False):
+        """
+        Return a representation of ``self``.
+
+        TESTS::
+
+            sage: CartanType(['A',ZZ])
+            ['A', ZZ]
+            sage: CartanType(['A',NN])._repr_(compact=True)
+            'A_NN'
+        """
+        ret = '%s_%s' if compact else "['%s', %s]"
+        return ret % (self.letter, 'ZZ' if self.n == ZZ else 'NN')
+
+    def _latex_(self):
+        r"""
+        Return a latex representation of ``self``.
+
+        EXAMPLES::
+
+            sage: latex( CartanType(['A',NN]) )
+            A_{\Bold{N}}
+            sage: latex( CartanType(['A',ZZ]) )
+            A_{\Bold{Z}}
+        """
+        return 'A_{{{}}}'.format(self.n._latex_())
+
+    def ascii_art(self, label=None, node=None):
+        """
+        Return an ascii art representation of the extended Dynkin diagram.
+
+        EXAMPLES::
+
+            sage: print(CartanType(['A', ZZ]).ascii_art())
+            ..---O---O---O---O---O---O---O---..
+                -3  -2  -1   0   1   2   3
+            sage: print(CartanType(['A', NN]).ascii_art())
+            O---O---O---O---O---O---O---..
+            0   1   2   3   4   5   6
+        """
+        if label is None:
+            label = lambda i: i
+        if node is None:
+            node = self._ascii_art_node
+
+        if self.n == ZZ:
+            ret = '..---' + '---'.join(node(label(i)) for i in range(7)) + '---..\n'
+            ret += '  ' + ''.join("{:4}".format(label(i)) for i in range(-3, 4))
+        else:
+            ret = '---'.join(node(label(i)) for i in range(7)) + '---..\n'
+            ret += '0' + ''.join("{:4}".format(label(i)) for i in range(1, 7))
+
+        return ret
+
+    def dual(self):
+        """
+        Simply laced Cartan types are self-dual, so return ``self``.
+
+        EXAMPLES::
+
+            sage: CartanType(["A", NN]).dual()
+            ['A', NN]
+            sage: CartanType(["A", ZZ]).dual()
+            ['A', ZZ]
+        """
+        return self
+
+    def is_simply_laced(self):
+        """
+        Return ``True`` because ``self`` is simply laced.
+
+        EXAMPLES::
+
+            sage: CartanType(['A', NN]).is_simply_laced()
+            True
+            sage: CartanType(['A', ZZ]).is_simply_laced()
+            True
+        """
+        return True
+
+    def is_crystallographic(self):
+        """
+        Return ``False`` because ``self`` is not crystallographic.
+
+        EXAMPLES::
+
+            sage: CartanType(['A', NN]).is_crystallographic()
+            True
+            sage: CartanType(['A', ZZ]).is_crystallographic()
+            True
+        """
+        return True
+
+    def is_finite(self):
+        """
+        Return ``True`` because ``self`` is not finite.
+
+        EXAMPLES::
+
+            sage: CartanType(['A', NN]).is_finite()
+            False
+            sage: CartanType(['A', ZZ]).is_finite()
+            False
+        """
+        return False
+
+    def is_affine(self):
+        """
+        Return ``False`` because ``self`` is not (untwisted) affine.
+
+        EXAMPLES::
+
+            sage: CartanType(['A', NN]).is_affine()
+            False
+            sage: CartanType(['A', ZZ]).is_affine()
+            False
+        """
+        return False
+
+    def is_untwisted_affine(self):
+        """
+        Return ``False`` because ``self`` is not (untwisted) affine.
+
+        EXAMPLES::
+
+            sage: CartanType(['A', NN]).is_untwisted_affine()
+            False
+            sage: CartanType(['A', ZZ]).is_untwisted_affine()
+            False
+        """
+        return False
+
+    def rank(self):
+        """
+        Return the rank of ``self`` which for type `X_n` is `n`.
+
+        EXAMPLES::
+
+            sage: CartanType(['A', NN]).rank()
+            +Infinity
+            sage: CartanType(['A', ZZ]).rank()
+            +Infinity
+
+        As this example shows, the rank is slightly ambiguous because the root
+        systems of type `['A',NN]` and type `['A',ZZ]` have the same rank.
+        Instead, it is better ot use :meth:`index_set` to differentiate between
+        these two root systems.
+        """
+        return self.n.cardinality()
+
+    def type(self):
+        """
+        Return the type of ``self``.
+
+        EXAMPLES::
+
+            sage: CartanType(['A', NN]).type()
+            'A'
+            sage: CartanType(['A', ZZ]).type()
+            'A'
+        """
+        return self.letter
+
+    def index_set(self):
+        r"""
+        Return the index set for the Cartan type ``self``.
+
+        The index set for all standard finite Cartan types is of the form
+        `\{1, \ldots, n\}`. (See :mod:`~sage.combinat.root_system.type_I`
+        for a slight abuse of this).
+
+        EXAMPLES::
+
+            sage: CartanType(['A', NN]).index_set()
+            Non negative integer semiring
+            sage: CartanType(['A', ZZ]).index_set()
+            Integer Ring
+        """
+        return self.n

sage/combinat/root_system/type_B.py

@@ -0,0 +1,347 @@
+# sage_setup: distribution = sagemath-modules
+"""
+Root system data for type B
+"""
+# ****************************************************************************
+#       Copyright (C) 2008-2009 Daniel Bump
+#       Copyright (C) 2008-2009 Justin Walker
+#       Copyright (C) 2008-2009 Nicolas M. Thiery <nthiery at users.sf.net>,
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from . import ambient_space
+
+
+class AmbientSpace(ambient_space.AmbientSpace):
+    def dimension(self):
+        """
+        EXAMPLES::
+
+            sage: e = RootSystem(['B',3]).ambient_space()
+            sage: e.dimension()
+            3
+        """
+        return self.root_system.cartan_type().rank()
+
+    def root(self, i, j):
+        """
+        Note that indexing starts at 0.
+
+        EXAMPLES::
+
+            sage: e = RootSystem(['B',3]).ambient_space()
+            sage: e.root(0,1)
+            (1, -1, 0)
+        """
+        return self.monomial(i) - self.monomial(j)
+
+    def simple_root(self, i):
+        """
+        EXAMPLES::
+
+            sage: e = RootSystem(['B',4]).ambient_space()
+            sage: e.simple_roots()
+            Finite family {1: (1, -1, 0, 0), 2: (0, 1, -1, 0), 3: (0, 0, 1, -1), 4: (0, 0, 0, 1)}
+            sage: e.positive_roots()
+            [(1, -1, 0, 0),
+            (1, 1, 0, 0),
+            (1, 0, -1, 0),
+            (1, 0, 1, 0),
+            (1, 0, 0, -1),
+            (1, 0, 0, 1),
+            (0, 1, -1, 0),
+            (0, 1, 1, 0),
+            (0, 1, 0, -1),
+            (0, 1, 0, 1),
+            (0, 0, 1, -1),
+            (0, 0, 1, 1),
+            (1, 0, 0, 0),
+            (0, 1, 0, 0),
+            (0, 0, 1, 0),
+            (0, 0, 0, 1)]
+            sage: e.fundamental_weights()
+            Finite family {1: (1, 0, 0, 0), 2: (1, 1, 0, 0), 3: (1, 1, 1, 0), 4: (1/2, 1/2, 1/2, 1/2)}
+        """
+        if i not in self.index_set():
+            raise ValueError("{} is not in the index set".format(i))
+        return self.root(i-1, i) if i < self.n else self.monomial(self.n-1)
+
+    def negative_roots(self):
+        """
+        EXAMPLES::
+
+            sage: RootSystem(['B',3]).ambient_space().negative_roots()
+            [(-1, 1, 0),
+             (-1, -1, 0),
+             (-1, 0, 1),
+             (-1, 0, -1),
+             (0, -1, 1),
+             (0, -1, -1),
+             (-1, 0, 0),
+             (0, -1, 0),
+             (0, 0, -1)]
+        """
+        return [-a for a in self.positive_roots()]
+
+    def positive_roots(self):
+        """
+        EXAMPLES::
+
+            sage: RootSystem(['B',3]).ambient_space().positive_roots()
+            [(1, -1, 0),
+             (1, 1, 0),
+             (1, 0, -1),
+             (1, 0, 1),
+             (0, 1, -1),
+             (0, 1, 1),
+             (1, 0, 0),
+             (0, 1, 0),
+             (0, 0, 1)]
+        """
+        res = []
+        for i in range(self.n-1):
+            for j in range(i + 1, self.n):
+                res.append(self.monomial(i) - self.monomial(j))
+                res.append(self.monomial(i) + self.monomial(j))
+        for i in range(self.n):
+            res.append(self.monomial(i))
+        return res
+
+    def fundamental_weight(self, i):
+        """
+        EXAMPLES::
+
+            sage: RootSystem(['B',3]).ambient_space().fundamental_weights()
+            Finite family {1: (1, 0, 0), 2: (1, 1, 0), 3: (1/2, 1/2, 1/2)}
+        """
+        if i not in self.index_set():
+            raise ValueError("{} is not in the index set".format(i))
+        n = self.dimension()
+        if i == n:
+            return self.sum(self.monomial(j) for j in range(n)) / 2
+        else:
+            return self.sum(self.monomial(j) for j in range(i))
+
+
+from .cartan_type import CartanType_standard_finite, CartanType_simple, CartanType_crystallographic, CartanType_simply_laced
+
+
+class CartanType(CartanType_standard_finite, CartanType_simple, CartanType_crystallographic):
+    def __init__(self, n):
+        """
+        EXAMPLES::
+
+            sage: ct = CartanType(['B',4])
+            sage: ct
+            ['B', 4]
+            sage: ct._repr_(compact = True)
+            'B4'
+
+            sage: ct.is_irreducible()
+            True
+            sage: ct.is_finite()
+            True
+            sage: ct.is_affine()
+            False
+            sage: ct.is_crystallographic()
+            True
+            sage: ct.is_simply_laced()
+            False
+            sage: ct.affine()
+            ['B', 4, 1]
+            sage: ct.dual()
+            ['C', 4]
+
+            sage: ct = CartanType(['B',1])
+            sage: ct.is_simply_laced()
+            True
+            sage: ct.affine()
+            ['B', 1, 1]
+
+        TESTS::
+
+            sage: TestSuite(ct).run()
+        """
+        assert n >= 1
+        CartanType_standard_finite.__init__(self, "B", n)
+        if n == 1:
+            self._add_abstract_superclass(CartanType_simply_laced)
+
+    def _latex_(self):
+        """
+        Return a latex representation of ``self``.
+
+        EXAMPLES::
+
+            sage: latex(CartanType(['B',4]))
+            B_{4}
+        """
+        return "B_{%s}" % self.n
+
+    AmbientSpace = AmbientSpace
+
+    def coxeter_number(self):
+        """
+        Return the Coxeter number associated with ``self``.
+
+        EXAMPLES::
+
+            sage: CartanType(['B',4]).coxeter_number()
+            8
+        """
+        return 2*self.n
+
+    def dual_coxeter_number(self):
+        """
+        Return the dual Coxeter number associated with ``self``.
+
+        EXAMPLES::
+
+            sage: CartanType(['B',4]).dual_coxeter_number()
+            7
+        """
+        return 2*self.n - 1
+
+    def dual(self):
+        """
+        Types B and C are in duality:
+
+        EXAMPLES::
+
+            sage: CartanType(["C", 3]).dual()
+            ['B', 3]
+        """
+        from . import cartan_type
+        return cartan_type.CartanType(["C", self.n])
+
+    def dynkin_diagram(self):
+        """
+        Return a Dynkin diagram for type B.
+
+        EXAMPLES::
+
+             sage: b = CartanType(['B',3]).dynkin_diagram(); b                          # needs sage.graphs
+             O---O=>=O
+             1   2   3
+             B3
+             sage: b.edges(sort=True)                                                   # needs sage.graphs
+             [(1, 2, 1), (2, 1, 1), (2, 3, 2), (3, 2, 1)]
+
+             sage: b = CartanType(['B',1]).dynkin_diagram(); b                          # needs sage.graphs
+             O
+             1
+             B1
+             sage: b.edges(sort=True)                                                   # needs sage.graphs
+             []
+        """
+        from .dynkin_diagram import DynkinDiagram_class
+        n = self.n
+        g = DynkinDiagram_class(self)
+        for i in range(1, n):
+            g.add_edge(i, i+1)
+        if n >= 2:
+            g.set_edge_label(n-1, n, 2)
+        return g
+
+    def ascii_art(self, label=None, node=None):
+        """
+        Return an ascii art representation of the Dynkin diagram.
+
+        EXAMPLES::
+
+            sage: print(CartanType(['B',1]).ascii_art())
+            O
+            1
+            sage: print(CartanType(['B',2]).ascii_art())
+            O=>=O
+            1   2
+            sage: print(CartanType(['B',5]).ascii_art(label = lambda x: x+2))
+            O---O---O---O=>=O
+            3   4   5   6   7
+        """
+        if label is None:
+            label = lambda i: i
+        if node is None:
+            node = self._ascii_art_node
+        n = self.n
+        if n == 1:
+            ret = node(label(1)) + "\n"
+        else:
+            ret = "---".join(node(label(i)) for i in range(1, n)) + "=>=" + node(label(n)) + '\n'
+        ret += "".join("{!s:4}".format(label(i)) for i in range(1, n + 1))
+        return ret
+
+    def _latex_dynkin_diagram(self, label=None, node=None, node_dist=2, dual=False):
+        r"""
+        Return a latex representation of the Dynkin diagram.
+
+        EXAMPLES::
+
+            sage: print(CartanType(['B',4])._latex_dynkin_diagram())
+            \draw (0 cm,0) -- (4 cm,0);
+            \draw (4 cm, 0.1 cm) -- +(2 cm,0);
+            \draw (4 cm, -0.1 cm) -- +(2 cm,0);
+            \draw[shift={(5.2, 0)}, rotate=0] (135 : 0.45cm) -- (0,0) -- (-135 : 0.45cm);
+            \draw[fill=white] (0 cm, 0 cm) circle (.25cm) node[below=4pt]{$1$};
+            \draw[fill=white] (2 cm, 0 cm) circle (.25cm) node[below=4pt]{$2$};
+            \draw[fill=white] (4 cm, 0 cm) circle (.25cm) node[below=4pt]{$3$};
+            \draw[fill=white] (6 cm, 0 cm) circle (.25cm) node[below=4pt]{$4$};
+            <BLANKLINE>
+
+        When ``dual=True``, the Dynkin diagram for the dual Cartan
+        type `C_n` is returned::
+
+            sage: print(CartanType(['B',4])._latex_dynkin_diagram(dual=True))
+            \draw (0 cm,0) -- (4 cm,0);
+            \draw (4 cm, 0.1 cm) -- +(2 cm,0);
+            \draw (4 cm, -0.1 cm) -- +(2 cm,0);
+            \draw[shift={(4.8, 0)}, rotate=180] (135 : 0.45cm) -- (0,0) -- (-135 : 0.45cm);
+            \draw[fill=white] (0 cm, 0 cm) circle (.25cm) node[below=4pt]{$1$};
+            \draw[fill=white] (2 cm, 0 cm) circle (.25cm) node[below=4pt]{$2$};
+            \draw[fill=white] (4 cm, 0 cm) circle (.25cm) node[below=4pt]{$3$};
+            \draw[fill=white] (6 cm, 0 cm) circle (.25cm) node[below=4pt]{$4$};
+            <BLANKLINE>
+
+        .. SEEALSO::
+
+            - :meth:`sage.combinat.root_system.type_C.CartanType._latex_dynkin_diagram`
+            - :meth:`sage.combinat.root_system.type_BC_affine.CartanType._latex_dynkin_diagram`
+        """
+        if label is None:
+            label = lambda i: i
+        if node is None:
+            node = self._latex_draw_node
+        if self.n == 1:
+            return node(0, 0, label(1))
+        n = self.n
+        ret = "\\draw (0 cm,0) -- (%s cm,0);\n" % ((n-2)*node_dist)
+        ret += "\\draw (%s cm, 0.1 cm) -- +(%s cm,0);\n" % ((n-2)*node_dist, node_dist)
+        ret += "\\draw (%s cm, -0.1 cm) -- +(%s cm,0);\n" % ((n-2)*node_dist, node_dist)
+        if dual:
+            ret += self._latex_draw_arrow_tip((n-1.5)*node_dist-0.2, 0, 180)
+        else:
+            ret += self._latex_draw_arrow_tip((n-1.5)*node_dist+0.2, 0, 0)
+        for i in range(self.n):
+            ret += node(i*node_dist, 0, label(i+1))
+        return ret
+
+    def _default_folded_cartan_type(self):
+        """
+        Return the default folded Cartan type.
+
+        EXAMPLES::
+
+            sage: CartanType(['B', 3])._default_folded_cartan_type()
+            ['B', 3] as a folding of ['D', 4]
+        """
+        from sage.combinat.root_system.type_folded import CartanTypeFolded
+        n = self.n
+        return CartanTypeFolded(self, ['D', n + 1],
+                                [[i] for i in range(1, n)] + [[n, n + 1]])
+
+
+# For unpickling backward compatibility (Sage <= 4.1)
+from sage.misc.persist import register_unpickle_override
+register_unpickle_override('sage.combinat.root_system.type_B',
+                           'ambient_space', AmbientSpace)