passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/finite_dimensional_nilpotent_lie_algebras_with_basis.py

@@ -0,0 +1,167 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finite Dimensional Nilpotent Lie Algebras With Basis
+
+AUTHORS:
+
+- Eero Hakavuori (2018-08-16): initial version
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2018 Eero Hakavuori <eero.hakavuori@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.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.lie_algebras import LieAlgebras
+
+
+class FiniteDimensionalNilpotentLieAlgebrasWithBasis(CategoryWithAxiom_over_base_ring):
+    r"""
+    Category of finite dimensional nilpotent Lie algebras with basis.
+
+    TESTS::
+
+        sage: C1 = LieAlgebras(QQ).FiniteDimensional().WithBasis().Nilpotent()
+        sage: C2 = LieAlgebras(QQ).FiniteDimensional().Nilpotent().WithBasis()
+        sage: C3 = LieAlgebras(QQ).Nilpotent().FiniteDimensional().WithBasis()
+        sage: C4 = LieAlgebras(QQ).Nilpotent().WithBasis().FiniteDimensional()
+        sage: C5 = LieAlgebras(QQ).WithBasis().Nilpotent().FiniteDimensional()
+        sage: C6 = LieAlgebras(QQ).WithBasis().FiniteDimensional().Nilpotent()
+        sage: C1 is C2
+        True
+        sage: C2 is C3
+        True
+        sage: C3 is C4
+        True
+        sage: C4 is C5
+        True
+        sage: C5 is C6
+        True
+        sage: TestSuite(C1).run()
+    """
+    _base_category_class_and_axiom = (LieAlgebras.FiniteDimensional.WithBasis, "Nilpotent")
+
+    class ParentMethods:
+
+        def _test_nilpotency(self, **options):
+            r"""
+            Test that ``self`` is nilpotent and has the correct step.
+
+            INPUT:
+
+            - ``options`` -- any keyword arguments accepted by
+              :meth:`_tester`
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: L = LieAlgebra(QQ, {('X','Y'): {'Z': 1}}, nilpotent=True)
+                sage: L._test_nilpotency()
+                sage: L = LieAlgebra(QQ, {('X','Y'): {'Z': 1}},
+                ....:                nilpotent=True, step=3)
+                sage: L._test_nilpotency()
+                Traceback (most recent call last):
+                ...
+                AssertionError: claimed nilpotency step 3
+                does not match the actual nilpotency step 2
+                sage: L = LieAlgebra(QQ, {('X','Y'): {'X': 1}}, nilpotent=True)
+                sage: L._test_nilpotency()
+                Traceback (most recent call last):
+                ...
+                AssertionError: final term of lower central series is nonzero
+
+            See the documentation for :class:`TestSuite` for more information.
+            """
+            tester = self._tester(**options)
+
+            lcs = self.lower_central_series(submodule=True)
+            tester.assertEqual(lcs[-1].dimension(), 0,
+                msg="final term of lower central series is nonzero")
+
+            step = self.step()
+            tester.assertEqual(len(lcs) - 1, step,
+                msg="claimed nilpotency step %d does not match the "
+                "actual nilpotency step %d" % (step, len(lcs) - 1))
+
+        def lie_group(self, name='G', **kwds):
+            r"""
+            Return the Lie group associated to ``self``.
+
+            INPUT:
+
+            - ``name`` -- string (default: ``'G'``);
+              the name (symbol) given to the Lie group
+
+            EXAMPLES:
+
+            We define the Heisenberg group::
+
+                sage: L = lie_algebras.Heisenberg(QQ, 1)                                # needs sage.combinat sage.graphs sage.modules
+                sage: G = L.lie_group('G'); G                                           # needs sage.combinat sage.graphs sage.modules sage.symbolic
+                Lie group G of Heisenberg algebra of rank 1 over Rational Field
+
+            We test multiplying elements of the group::
+
+                sage: # needs sage.combinat sage.graphs sage.modules sage.symbolic
+                sage: p, q, z = L.basis()
+                sage: g = G.exp(p); g
+                exp(p1)
+                sage: h = G.exp(q); h
+                exp(q1)
+                sage: g * h
+                exp(p1 + q1 + 1/2*z)
+
+            We extend an element of the Lie algebra to a left-invariant
+            vector field::
+
+                sage: X = G.left_invariant_extension(2*p + 3*q, name='X'); X            # needs sage.combinat sage.graphs sage.modules sage.symbolic
+                Vector field X on the Lie group G of
+                 Heisenberg algebra of rank 1 over Rational Field
+                sage: X.at(G.one()).display()                                           # needs sage.combinat sage.graphs sage.modules sage.symbolic
+                X = 2 ∂/∂x_0 + 3 ∂/∂x_1
+                sage: X.display()                                                       # needs sage.combinat sage.graphs sage.modules sage.symbolic
+                X = 2 ∂/∂x_0 + 3 ∂/∂x_1 + (3/2*x_0 - x_1) ∂/∂x_2
+
+            .. SEEALSO::
+
+                :class:`~sage.groups.lie_gps.nilpotent_lie_group.NilpotentLieGroup`
+            """
+            from sage.groups.lie_gps.nilpotent_lie_group import NilpotentLieGroup
+            return NilpotentLieGroup(self, name, **kwds)
+
+        def step(self):
+            r"""
+            Return the nilpotency step of ``self``.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: L = LieAlgebra(QQ, {('X','Y'): {'Z': 1}}, nilpotent=True)
+                sage: L.step()
+                2
+                sage: sc = {('X','Y'): {'Z': 1}, ('X','Z'): {'W': 1}}
+                sage: LieAlgebra(QQ, sc, nilpotent=True).step()
+                3
+            """
+            if not hasattr(self, '_step'):
+                self._step = len(self.lower_central_series(submodule=True)) - 1
+            return self._step
+
+        def is_nilpotent(self):
+            r"""
+            Return ``True`` since ``self`` is nilpotent.
+
+            EXAMPLES::
+
+                sage: L = LieAlgebra(QQ, {('x','y'): {'z': 1}}, nilpotent=True)         # needs sage.combinat sage.modules
+                sage: L.is_nilpotent()                                                  # needs sage.combinat sage.modules
+                True
+            """
+            return True

sage/categories/finite_dimensional_semisimple_algebras_with_basis.py

@@ -0,0 +1,270 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finite dimensional semisimple algebras with basis
+"""
+#*****************************************************************************
+#  Copyright (C) 2011-2015 Nicolas M. Thiery <nthiery at users.sf.net>
+#                2014-2015 Aladin Virmaux <aladin.virmaux at u-psud.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.categories.algebras import Algebras
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.semisimple_algebras import SemisimpleAlgebras
+from sage.misc.cachefunc import cached_method
+
+
+class FiniteDimensionalSemisimpleAlgebrasWithBasis(CategoryWithAxiom_over_base_ring):
+    """
+    The category of finite dimensional semisimple algebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: from sage.categories.finite_dimensional_semisimple_algebras_with_basis import FiniteDimensionalSemisimpleAlgebrasWithBasis
+        sage: C = FiniteDimensionalSemisimpleAlgebrasWithBasis(QQ); C
+        Category of finite dimensional semisimple algebras with basis over Rational Field
+
+    This category is best constructed as::
+
+        sage: D = Algebras(QQ).Semisimple().FiniteDimensional().WithBasis(); D
+        Category of finite dimensional semisimple algebras with basis over Rational Field
+        sage: D is C
+        True
+
+    TESTS::
+
+        sage: TestSuite(C).run()
+    """
+    _base_category_class_and_axiom = (SemisimpleAlgebras.FiniteDimensional, "WithBasis")
+
+    class ParentMethods:
+        # This is needed to override the one in finite_dimensional_algebras_with_basis
+        def radical_basis(self, **keywords):
+            r"""
+            Return a basis of the Jacobson radical of this algebra.
+
+            - ``keywords`` -- for compatibility; ignored
+
+            OUTPUT: the empty list since this algebra is semisimple
+
+            EXAMPLES::
+
+                sage: A = SymmetricGroup(4).algebra(QQ)                                 # needs sage.combinat sage.groups sage.modules
+                sage: A.radical_basis()                                                 # needs sage.combinat sage.groups sage.modules
+                ()
+
+            TESTS::
+
+                sage: A.radical_basis.__module__                                        # needs sage.combinat sage.groups sage.modules
+                'sage.categories.finite_dimensional_semisimple_algebras_with_basis'
+            """
+            return ()
+
+        @cached_method
+        def central_orthogonal_idempotents(self):
+            r"""
+            Return a maximal list of central orthogonal
+            idempotents of ``self``.
+
+            .. TODO::
+
+                The implementation assumes that the algebra
+                is split over its base field.
+
+            *Central orthogonal idempotents* of an algebra `A`
+            are idempotents `(e_1, \ldots, e_n)` in the center
+            of `A` such that `e_i e_j = 0` whenever `i \neq j`.
+
+            With the maximality condition, they sum up to `1`
+            and are uniquely determined (up to order).
+
+            EXAMPLES:
+
+            For the algebra of the (abelian) alternating group `A_3`,
+            we recover three idempotents corresponding to the three
+            one-dimensional representations `V_i` on which `(1,2,3)`
+            acts on `V_i` as multiplication by the `i`-th power of a
+            cube root of unity::
+
+                sage: # needs sage.groups sage.rings.number_field
+                sage: R = CyclotomicField(3)
+                sage: A3 = AlternatingGroup(3).algebra(R)
+                sage: idempotents = A3.central_orthogonal_idempotents()
+                sage: idempotents
+                (1/3*() + 1/3*(1,2,3) + 1/3*(1,3,2),
+                 1/3*() - (1/3*zeta3+1/3)*(1,2,3) - (-1/3*zeta3)*(1,3,2),
+                 1/3*() - (-1/3*zeta3)*(1,2,3) - (1/3*zeta3+1/3)*(1,3,2))
+                sage: A3.is_identity_decomposition_into_orthogonal_idempotents(idempotents)
+                True
+
+            For the semisimple quotient of a quiver algebra,
+            we recover the vertices of the quiver::
+
+                sage: # needs sage.graphs sage.modules sage.rings.number_field
+                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: Aquo = A.semisimple_quotient()
+                sage: Aquo.central_orthogonal_idempotents()
+                (B['x'], B['y'])
+            """
+            return tuple([x.lift()
+                          for x in self.center().central_orthogonal_idempotents()])
+
+    class Commutative(CategoryWithAxiom_over_base_ring):
+
+        class ParentMethods:
+
+            @cached_method
+            def _orthogonal_decomposition(self, generators=None):
+                r"""
+                Return a maximal list of orthogonal quasi-idempotents of
+                this finite dimensional semisimple commutative algebra.
+
+                INPUT:
+
+                - ``generators`` -- list of generators of
+                  ``self`` (default: the basis of ``self``)
+
+                OUTPUT: list of quasi-idempotent elements of ``self``
+
+                Each quasi-idempotent `e` spans a one
+                dimensional (non unital) subalgebra of
+                ``self``, and cannot be decomposed as a sum
+                `e=e_1+e_2` of quasi-idempotents elements.
+                All together, they form a basis of ``self``.
+
+                Up to the order and scalar factors, the result
+                is unique. In particular it does not depend on
+                the provided generators which are only used
+                for improved efficiency.
+
+                ALGORITHM:
+
+                Thanks to Schur's Lemma, a commutative
+                semisimple algebra `A` is a direct sum of
+                dimension 1 subalgebras. The algorithm is
+                recursive and proceeds as follows:
+
+                0. If `A` is of dimension 1, return a nonzero
+                   element.
+
+                1. Otherwise: find one of the generators such
+                   that the morphism `x \mapsto ax` has at
+                   least two (right) eigenspaces.
+
+                2. Decompose both eigenspaces recursively.
+
+                EXAMPLES:
+
+                We compute an orthogonal decomposition of the
+                center of the algebra of the symmetric group
+                `S_4`::
+
+                    sage: Z4 = SymmetricGroup(4).algebra(QQ).center()                   # needs sage.combinat sage.groups sage.modules
+                    sage: Z4._orthogonal_decomposition()                                # needs sage.combinat sage.groups sage.modules
+                    (B[0] + B[1] + B[2] + B[3] + B[4],
+                     B[0] + 1/3*B[1] - 1/3*B[2] - 1/3*B[4],
+                     B[0] + B[2] - 1/2*B[3],
+                     B[0] - 1/3*B[1] - 1/3*B[2] + 1/3*B[4],
+                     B[0] - B[1] + B[2] + B[3] - B[4])
+
+                .. TODO::
+
+                    Improve speed by using matrix operations
+                    only, or even better delegating to a
+                    multivariate polynomial solver.
+                """
+                if self.dimension() == 1:
+                    return self.basis().list()
+
+                category = Algebras(self.base_ring()).Semisimple().WithBasis().FiniteDimensional().Commutative().Subobjects()
+
+                if generators is None:
+                    generators = self.basis().list()
+
+                # Searching for a good generator ...
+                for gen in generators:
+                    # Computing the eigenspaces of the
+                    # linear map x -> gen*x
+                    phi = self.module_morphism(
+                        on_basis=lambda i:
+                        gen*self.term(i),
+                        codomain=self)
+                    eigenspaces = phi.matrix().eigenspaces_right()
+
+                    if len(eigenspaces) >= 2:
+                        # Gotcha! Let's split the algebra according to the eigenspaces
+                        subalgebras = [
+                            self.submodule(map(self.from_vector, eigenspace.basis()),
+                                           category=category)
+                            for eigenvalue, eigenspace in eigenspaces]
+
+                        # Decompose recursively each eigenspace
+                        return tuple([idempotent.lift()
+                                      for subalgebra in subalgebras
+                                      for idempotent in subalgebra._orthogonal_decomposition()])
+                # TODO: Should this be an assertion check?
+                raise Exception("Unable to fully decompose %s!" % self)
+
+            @cached_method
+            def central_orthogonal_idempotents(self):
+                r"""
+                Return the central orthogonal idempotents of
+                this semisimple commutative algebra.
+
+                Those idempotents form a maximal decomposition
+                of the identity into primitive orthogonal
+                idempotents.
+
+                .. TODO::
+
+                    The implementation assumes that the algebra
+                    is split over its base field.
+
+                OUTPUT: list of orthogonal idempotents of ``self``
+
+                EXAMPLES::
+
+                    sage: # needs sage.combinat sage.groups sage.modules
+                    sage: A4 = SymmetricGroup(4).algebra(QQ)
+                    sage: Z4 = A4.center()
+                    sage: idempotents = Z4.central_orthogonal_idempotents()
+                    sage: idempotents
+                    (1/24*B[0] + 1/24*B[1] + 1/24*B[2] + 1/24*B[3] + 1/24*B[4],
+                     3/8*B[0] + 1/8*B[1] - 1/8*B[2] - 1/8*B[4],
+                     1/6*B[0] + 1/6*B[2] - 1/12*B[3],
+                     3/8*B[0] - 1/8*B[1] - 1/8*B[2] + 1/8*B[4],
+                     1/24*B[0] - 1/24*B[1] + 1/24*B[2] + 1/24*B[3] - 1/24*B[4])
+
+                Lifting those idempotents from the center, we
+                recognize among them the sum and alternating
+                sum of all permutations::
+
+                    sage: [e.lift() for e in idempotents]                               # needs sage.combinat sage.groups sage.modules
+                    [1/24*() + 1/24*(3,4) + 1/24*(2,3) + 1/24*(2,3,4) + 1/24*(2,4,3)
+                     + 1/24*(2,4) + 1/24*(1,2) + 1/24*(1,2)(3,4) + 1/24*(1,2,3)
+                     + 1/24*(1,2,3,4) + 1/24*(1,2,4,3) + 1/24*(1,2,4) + 1/24*(1,3,2)
+                     + 1/24*(1,3,4,2) + 1/24*(1,3) + 1/24*(1,3,4) + 1/24*(1,3)(2,4)
+                     + 1/24*(1,3,2,4) + 1/24*(1,4,3,2) + 1/24*(1,4,2) + 1/24*(1,4,3)
+                     + 1/24*(1,4) + 1/24*(1,4,2,3) + 1/24*(1,4)(2,3),
+                     ...,
+                     1/24*() - 1/24*(3,4) - 1/24*(2,3) + 1/24*(2,3,4) + 1/24*(2,4,3)
+                     - 1/24*(2,4) - 1/24*(1,2) + 1/24*(1,2)(3,4) + 1/24*(1,2,3)
+                     - 1/24*(1,2,3,4) - 1/24*(1,2,4,3) + 1/24*(1,2,4) + 1/24*(1,3,2)
+                     - 1/24*(1,3,4,2) - 1/24*(1,3) + 1/24*(1,3,4) + 1/24*(1,3)(2,4)
+                     - 1/24*(1,3,2,4) - 1/24*(1,4,3,2) + 1/24*(1,4,2) + 1/24*(1,4,3)
+                     - 1/24*(1,4) - 1/24*(1,4,2,3) + 1/24*(1,4)(2,3)]
+
+                We check that they indeed form a decomposition
+                of the identity of `Z_4` into orthogonal idempotents::
+
+                    sage: # needs sage.combinat sage.groups sage.modules
+                    sage: Z4.is_identity_decomposition_into_orthogonal_idempotents(idempotents)
+                    True
+                """
+                return tuple([(e.leading_coefficient()/(e*e).leading_coefficient())*e
+                              for e in self._orthogonal_decomposition()])