convert between two implementations of fin-dim algebras

This provides functionality for converting between two implementations of
finite-dimensional algebras:
- the modern one, implemented as MagmaticAlgebras.WithBasis.FiniteDimensional in
  sage.categories.magmatic_algebras (in the magmatic case) and as
  FiniteDimensionalAlgebrasWithBasis in
  sage.categories.finite_dimensional_algebras_with_basis
  (in the assocative case),
and
- the old one, implemented as FiniteDimensionalAlgebra in
  sage.algebras.finite_dimensional_algebras.finite_dimensional_algebra.
To be more precise, the latter now automatically inherits from the
former if the optional parameters assume_associative and
assume_unital are set to True, whereas the former can be
converted into the latter via the to_finite_dimensional_algebra method.
This way, the methods of one (e.g. ``center_basis`` on the modern
one or ``is_unitary`` on the old one) can be used on the other.

Fixing various other issues in both classes as well.

Author: darijgr

Diff for: src/sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra.py

@@ -9,7 +9,7 @@
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  as published by the Free Software Foundation; either version 2 of
 #  the License, or (at your option) any later version.
-#                  http:s//www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # ***************************************************************************
 
 from .finite_dimensional_algebra_element import FiniteDimensionalAlgebraElement
@@ -18,6 +18,7 @@
 from sage.rings.integer_ring import ZZ
 
 from sage.categories.magmatic_algebras import MagmaticAlgebras
+from sage.categories.algebras import Algebras
 from sage.matrix.constructor import matrix
 from sage.structure.element import Matrix
 from sage.structure.category_object import normalize_names
@@ -32,6 +33,9 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
     r"""
     Create a finite-dimensional `k`-algebra from a multiplication table.
 
+    This is a magmatic `k`-algebra, i.e., not necessarily
+    associative or unital.
+
     INPUT:
 
     - ``k`` -- a field
@@ -45,6 +49,10 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
       ``True``, then the category is set to ``category.Associative()``
       and methods requiring associativity assume this
 
+    - ``assume_unital`` -- boolean (default: ``False``); if
+      ``True``, then the category is set to ``category.Unital()``
+      and methods requiring unitality assume this
+
     - ``category`` -- (default:
       ``MagmaticAlgebras(k).FiniteDimensional().WithBasis()``)
       the category to which this algebra belongs
@@ -67,6 +75,49 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
         ....:                                   Matrix([[0,0,0], [0,0,0], [0,0,1]])])
         sage: B
         Finite-dimensional algebra of degree 3 over Rational Field
+        sage: B.one()
+        e0 + e2
+        sage: B.is_associative()
+        True
+
+    A more complicated example (the 3-rd descent algebra in
+    a slightly rescaled I-basis, see :class:`DescentAlgebra`)::
+
+        sage: Ma = Matrix([[6,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0]])
+        sage: Mb = Matrix([[0,0,0,0], [0,1,0,0], [0,1,0,0], [0,0,0,0]])
+        sage: Mc = Matrix([[0,0,0,0], [0,0,1,0], [0,0,1,0], [0,0,0,0]])
+        sage: Md = Matrix([[0,0,0,0], [0,1,-1,0], [0,-1,1,0], [0,0,0,2]])
+        sage: C = FiniteDimensionalAlgebra(QQ, [Ma, Mb, Mc, Md])
+        sage: C.one()
+        1/6*e0 + 1/2*e1 + 1/2*e2 + 1/2*e3
+        sage: C.is_associative()
+        True
+        sage: C.is_commutative()
+        False
+
+    If we set both ``is_associative`` and ``is_unital`` to
+    ``True``, then this is an associative unital algebra and
+    belongs to the category of
+    :class:`sage.categories.finite_dimensional_algebras_with_basis.FiniteDimensionalAlgebrasWithBasis`::
+
+        sage: C = FiniteDimensionalAlgebra(QQ, [Ma, Mb, Mc, Md],
+        ....:                              assume_associative=True,
+        ....:                              assume_unital=True)
+        sage: C.radical_basis()
+        (e1 - e2,)
+        sage: C.radical()
+        Radical of Finite-dimensional algebra of degree 4 over Rational Field
+        sage: C.center_basis()
+        (e0, e1 + e2 + e3)
+        sage: C.center()
+        Center of Finite-dimensional algebra of degree 4 over Rational Field
+        sage: C.center().is_commutative()
+        True
+        sage: e = C.basis()
+        sage: C.annihilator_basis([e[1]])
+        (e0, e1 - e2, e3)
+        sage: C.annihilator_basis([e[1]], side='left')
+        (e0, e1 - e2 - e3)
 
     TESTS::
 
@@ -82,7 +133,7 @@ class FiniteDimensionalAlgebra(UniqueRepresentation, Parent):
     """
     @staticmethod
     def __classcall_private__(cls, k, table, names='e', assume_associative=False,
-                              category=None):
+                              assume_unital=False, category=None):
         """
         Normalize input.
 
@@ -105,6 +156,26 @@ def __classcall_private__(cls, k, table, names='e', assume_associative=False,
             sage: A1 is A2
             True
 
+        Likewise for the ``assume_associative`` keyword::
+
+            sage: A3 = FiniteDimensionalAlgebra(GF(3), table,
+            ....:                               category=cat.Unital())
+            sage: A4 = FiniteDimensionalAlgebra(GF(3), table, assume_unital=True)
+            sage: A3 is A4
+            True
+
+        With both keywords on, the
+        :class:`sage.categories.algebras.Algebras` category
+        is used::
+
+            sage: cat_a = Algebras(GF(3)).FiniteDimensional().WithBasis()
+            sage: A5 = FiniteDimensionalAlgebra(GF(3), table,
+            ....:                               category=cat_a)
+            sage: A6 = FiniteDimensionalAlgebra(GF(3), table, assume_associative=True,
+            ....:                               assume_unital=True)
+            sage: A5 is A6
+            True
+
         Uniqueness depends on the category::
 
             sage: cat = Algebras(GF(3)).FiniteDimensional().WithBasis()
@@ -144,6 +215,12 @@ def __classcall_private__(cls, k, table, names='e', assume_associative=False,
         cat = cat.or_subcategory(category)
         if assume_associative:
             cat = cat.Associative()
+            if assume_unital:
+                # both unital and associative, so algebra in modern sense
+                cat = Algebras(k).FiniteDimensional().WithBasis()
+                cat = cat.or_subcategory(category)
+        elif assume_unital:
+            cat = cat.Unital()
 
         names = normalize_names(n, names)
 
@@ -610,10 +687,10 @@ def is_unitary(self):
         v = matrix(k, 1, n**2, (n - 1) * ([kone] + n * [kzero]) + [kone])
         try:
             sol1 = B1.solve_left(v)
-            sol2 = B2.solve_left(v)
         except ValueError:
             return False
-        assert sol1 == sol2
+        if sol1 * B2 != v:
+            return False
         self._one = sol1
         return True
 
@@ -931,7 +1008,8 @@ def maximal_ideals(self):
         """
         Return a list consisting of all maximal ideals of ``self``.
 
-        The algebra ``self`` has to be in the category of associative algebras.
+        The algebra ``self`` has to be in the category of
+        commutative, associative algebras.
 
         EXAMPLES::
 

Diff for: src/sage/algebras/finite_dimensional_algebras/finite_dimensional_algebra_element.pyx

@@ -334,6 +334,26 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
         from sage.misc.latex import latex
         return latex(self.matrix())
 
+    def __hash__(self):
+        """
+        Return the hash value for ``self``.
+
+        The result is cached.
+        (TODO: Not sure why, but caching does not work.)
+
+        EXAMPLES::
+
+            sage: A = FiniteDimensionalAlgebra(GF(3), [Matrix([[1,0], [0,1]]),
+            ....:                                      Matrix([[0,1], [0,0]])])
+            sage: a = A([1,2])
+            sage: b = A([2,3])
+            sage: hash(a) == hash(A([1,2]))
+            True
+            sage: hash(a) == hash(b)
+            False
+        """
+        return hash(tuple(self._vector.list()))
+
     def __getitem__(self, m):
         """
         Return the `m`-th coefficient of ``self``.
@@ -350,13 +370,18 @@ cdef class FiniteDimensionalAlgebraElement(AlgebraElement):
 
     def __len__(self):
         """
+        Return the number of coefficients of ``self``,
+        including the zero coefficients.
+
         EXAMPLES::
 
             sage: A = FiniteDimensionalAlgebra(QQ, [Matrix([[1,0,0], [0,1,0], [0,0,0]]),
             ....:                                   Matrix([[0,1,0], [0,0,0], [0,0,0]]),
             ....:                                   Matrix([[0,0,0], [0,0,0], [0,0,1]])])
             sage: len(A([2,1/4,3]))
             3
+            sage: len(A([2,0,3/4]))
+            3
         """
         return self._vector.ncols()