passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/algebras_with_basis.py

@@ -0,0 +1,377 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Algebras With Basis
+"""
+# ****************************************************************************
+#  Copyright (C) 2008      Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#                2008-2013 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 sage.categories.cartesian_product import CartesianProductsCategory
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.tensor import TensorProductsCategory, tensor
+from sage.categories.unital_algebras import UnitalAlgebras
+from sage.misc.cachefunc import cached_method
+from sage.misc.lazy_attribute import lazy_attribute
+from sage.misc.lazy_import import LazyImport
+
+
+class AlgebrasWithBasis(CategoryWithAxiom_over_base_ring):
+    """
+    The category of algebras with a distinguished basis.
+
+    EXAMPLES::
+
+        sage: C = AlgebrasWithBasis(QQ); C
+        Category of algebras with basis over Rational Field
+        sage: sorted(C.super_categories(), key=str)
+        [Category of algebras over Rational Field,
+         Category of unital algebras with basis over Rational Field]
+
+    We construct a typical parent in this category, and do some
+    computations with it::
+
+        sage: # needs sage.combinat sage.modules
+        sage: A = C.example(); A
+        An example of an algebra with basis:
+         the free algebra on the generators ('a', 'b', 'c') over Rational Field
+        sage: A.category()
+        Category of algebras with basis over Rational Field
+        sage: A.one_basis()
+        word:
+        sage: A.one()
+        B[word: ]
+        sage: A.base_ring()
+        Rational Field
+        sage: A.basis().keys()
+        Finite words over {'a', 'b', 'c'}
+        sage: (a,b,c) = A.algebra_generators()
+        sage: a^3, b^2
+        (B[word: aaa], B[word: bb])
+        sage: a * c * b
+        B[word: acb]
+        sage: A.product
+        <bound method MagmaticAlgebras.WithBasis.ParentMethods._product_from_product_on_basis_multiply of
+         An example of an algebra with basis:
+          the free algebra on the generators ('a', 'b', 'c') over Rational Field>
+        sage: A.product(a * b, b)
+        B[word: abb]
+        sage: TestSuite(A).run(verbose=True)
+        running ._test_additive_associativity() . . . pass
+        running ._test_an_element() . . . pass
+        running ._test_associativity() . . . pass
+        running ._test_cardinality() . . . pass
+        running ._test_category() . . . pass
+        running ._test_characteristic() . . . pass
+        running ._test_construction() . . . pass
+        running ._test_distributivity() . . . pass
+        running ._test_elements() . . .
+          Running the test suite of self.an_element()
+          running ._test_category() . . . pass
+          running ._test_eq() . . . pass
+          running ._test_monomial_coefficients() . . . 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_eq() . . . pass
+        running ._test_new() . . . pass
+        running ._test_not_implemented_methods() . . . pass
+        running ._test_one() . . . pass
+        running ._test_pickling() . . . pass
+        running ._test_prod() . . . pass
+        running ._test_some_elements() . . . pass
+        running ._test_zero() . . . pass
+        sage: A.__class__
+        <class 'sage.categories.examples.algebras_with_basis.FreeAlgebra_with_category'>
+        sage: A.element_class
+        <class 'sage.categories.examples.algebras_with_basis.FreeAlgebra_with_category.element_class'>
+
+    Please see the source code of `A` (with ``A??``) for how to
+    implement other algebras with basis.
+
+    TESTS::
+
+        sage: TestSuite(AlgebrasWithBasis(QQ)).run()
+    """
+
+    def example(self, alphabet=('a', 'b', 'c')):
+        """
+        Return an example of algebra with basis.
+
+        EXAMPLES::
+
+            sage: AlgebrasWithBasis(QQ).example()                                       # needs sage.combinat sage.modules
+            An example of an algebra with basis:
+             the free algebra on the generators ('a', 'b', 'c') over Rational Field
+
+        An other set of generators can be specified as optional argument::
+
+            sage: AlgebrasWithBasis(QQ).example((1,2,3))                                # needs sage.combinat sage.modules
+            An example of an algebra with basis:
+             the free algebra on the generators (1, 2, 3) over Rational Field
+        """
+        from sage.categories.examples.algebras_with_basis import Example
+        return Example(self.base_ring(), alphabet)
+
+    Filtered = LazyImport('sage.categories.filtered_algebras_with_basis', 'FilteredAlgebrasWithBasis')
+    FiniteDimensional = LazyImport('sage.categories.finite_dimensional_algebras_with_basis', 'FiniteDimensionalAlgebrasWithBasis', at_startup=True)
+    Graded = LazyImport('sage.categories.graded_algebras_with_basis', 'GradedAlgebrasWithBasis')
+    Super = LazyImport('sage.categories.super_algebras_with_basis', 'SuperAlgebrasWithBasis')
+
+    class ParentMethods:
+
+        # For backward compatibility
+        one = UnitalAlgebras.WithBasis.ParentMethods.one
+
+        def hochschild_complex(self, M):
+            """
+            Return the Hochschild complex of ``self`` with coefficients
+            in ``M``.
+
+            .. SEEALSO::
+
+                :class:`~sage.homology.hochschild_complex.HochschildComplex`
+
+            EXAMPLES::
+
+                sage: R.<x> = QQ[]
+                sage: A = algebras.DifferentialWeyl(R)                                  # needs sage.modules
+                sage: H = A.hochschild_complex(A)                                       # needs sage.modules
+
+                sage: # needs sage.combinat sage.groups sage.modules
+                sage: SGA = SymmetricGroupAlgebra(QQ, 3)
+                sage: T = SGA.trivial_representation()
+                sage: H = SGA.hochschild_complex(T)
+            """
+            from sage.homology.hochschild_complex import HochschildComplex
+            return HochschildComplex(self, M)
+
+    class ElementMethods:
+
+        def __invert__(self):
+            """
+            Return the inverse of ``self`` if ``self`` is a multiple of one,
+            and one is in the basis of this algebra. Otherwise throws
+            an error.
+
+            Caveat: this generic implementation is not complete; there
+            may be invertible elements in the algebra that can't be
+            inversed this way. It is correct though for graded
+            connected algebras with basis.
+
+            .. WARNING::
+
+                This might produce a result which does not belong to
+                the parent of ``self``, yet believes to do so. For
+                instance, inverting 2 times the unity will produce 1/2
+                times the unity, even if 1/2 is not in the base ring.
+                Handle with care.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.modules
+                sage: C = AlgebrasWithBasis(QQ).example()
+                sage: x = C(2); x
+                2*B[word: ]
+                sage: ~x
+                1/2*B[word: ]
+                sage: a = C.algebra_generators().first(); a
+                B[word: a]
+                sage: ~a
+                Traceback (most recent call last):
+                ...
+                ValueError: cannot invert self (= B[word: a])
+            """
+            # FIXME: make this generic
+            mcs = self.monomial_coefficients(copy=False)
+            one = self.parent().one_basis()
+            if len(mcs) == 1 and one in mcs:
+                return self.parent().term(one, ~mcs[one])
+            else:
+                raise ValueError("cannot invert self (= %s)" % self)
+
+    class CartesianProducts(CartesianProductsCategory):
+        """
+        The category of algebras with basis, constructed as Cartesian
+        products of algebras with basis.
+
+        Note: this construction give the direct products of algebras with basis.
+        See comment in :class:`Algebras.CartesianProducts
+        <sage.categories.algebras.Algebras.CartesianProducts>`
+        """
+
+        def extra_super_categories(self):
+            """
+            A Cartesian product of algebras with basis is endowed with
+            a natural algebra with basis structure.
+
+            EXAMPLES::
+
+                sage: AlgebrasWithBasis(QQ).CartesianProducts().extra_super_categories()
+                [Category of algebras with basis over Rational Field]
+                sage: AlgebrasWithBasis(QQ).CartesianProducts().super_categories()
+                [Category of algebras with basis over Rational Field,
+                 Category of Cartesian products of algebras over Rational Field,
+                 Category of Cartesian products of vector spaces with basis over Rational Field]
+            """
+            return [self.base_category()]
+
+        class ParentMethods:
+            @cached_method
+            def one_from_cartesian_product_of_one_basis(self):
+                """
+                Return the one of this Cartesian product of algebras, as per
+                ``Monoids.ParentMethods.one``
+
+                It is constructed as the Cartesian product of the ones of the
+                summands, using their :meth:`~AlgebrasWithBasis.ParentMethods.one_basis` methods.
+
+                This implementation does not require multiplication by
+                scalars nor calling cartesian_product. This might help keeping
+                things as lazy as possible upon initialization.
+
+                EXAMPLES::
+
+                    sage: # needs sage.combinat sage.modules
+                    sage: A = AlgebrasWithBasis(QQ).example(); A
+                    An example of an algebra with basis: the free algebra
+                     on the generators ('a', 'b', 'c') over Rational Field
+                    sage: A.one_basis()
+                    word:
+                    sage: B = cartesian_product((A, A, A))
+                    sage: B.one_from_cartesian_product_of_one_basis()
+                    B[(0, word: )] + B[(1, word: )] + B[(2, word: )]
+                    sage: B.one()
+                    B[(0, word: )] + B[(1, word: )] + B[(2, word: )]
+
+                    sage: cartesian_product([SymmetricGroupAlgebra(QQ, 3),              # needs sage.combinat sage.groups sage.modules
+                    ....:                    SymmetricGroupAlgebra(QQ, 4)]).one()
+                    B[(0, [1, 2, 3])] + B[(1, [1, 2, 3, 4])]
+                """
+                return self.sum_of_monomials(zip(self._sets_keys(), (set.one_basis() for set in self._sets)))
+
+            @lazy_attribute
+            def one(self):
+                """
+                TESTS::
+
+                    sage: A = AlgebrasWithBasis(QQ).example(); A                        # needs sage.combinat sage.modules
+                    An example of an algebra with basis: the free algebra
+                     on the generators ('a', 'b', 'c') over Rational Field
+                    sage: B = cartesian_product((A, A, A))                              # needs sage.combinat sage.modules
+                    sage: B.one()                                                       # needs sage.combinat sage.modules
+                    B[(0, word: )] + B[(1, word: )] + B[(2, word: )]
+                """
+                if all(hasattr(module, "one_basis") and module.one_basis is not NotImplemented for module in self._sets):
+                    return self.one_from_cartesian_product_of_one_basis
+                return self._one_generic
+
+            _one_generic = UnitalAlgebras.CartesianProducts.ParentMethods.one
+
+            # def product_on_basis(self, t1, t2):
+            # would be easy to implement, but without a special
+            # version of module morphism, this would not take
+            # advantage of the block structure
+
+    class TensorProducts(TensorProductsCategory):
+        """
+        The category of algebras with basis constructed by tensor product of algebras with basis
+        """
+
+        @cached_method
+        def extra_super_categories(self):
+            """
+            EXAMPLES::
+
+                sage: AlgebrasWithBasis(QQ).TensorProducts().extra_super_categories()
+                [Category of algebras with basis over Rational Field]
+                sage: AlgebrasWithBasis(QQ).TensorProducts().super_categories()
+                [Category of algebras with basis over Rational Field,
+                 Category of tensor products of algebras over Rational Field,
+                 Category of tensor products of vector spaces with basis over Rational Field]
+            """
+            return [self.base_category()]
+
+        class ParentMethods:
+            """
+            implements operations on tensor products of algebras with basis
+            """
+
+            @cached_method
+            def one_basis(self):
+                """
+                Return the index of the one of this tensor product of
+                algebras, as per ``AlgebrasWithBasis.ParentMethods.one_basis``
+
+                It is the tuple whose operands are the indices of the
+                ones of the operands, as returned by their
+                :meth:`.one_basis` methods.
+
+                EXAMPLES::
+
+                    sage: # needs sage.combinat sage.modules
+                    sage: A = AlgebrasWithBasis(QQ).example(); A
+                    An example of an algebra with basis: the free algebra
+                     on the generators ('a', 'b', 'c') over Rational Field
+                    sage: A.one_basis()
+                    word:
+                    sage: B = tensor((A, A, A))
+                    sage: B.one_basis()
+                    (word: , word: , word: )
+                    sage: B.one()
+                    B[word: ] # B[word: ] # B[word: ]
+                """
+                # FIXME: this method should be conditionally defined,
+                # so that B.one_basis returns NotImplemented if not
+                # all modules provide one_basis
+                if all(hasattr(module, "one_basis") for module in self._sets):
+                    return tuple(module.one_basis() for module in self._sets)
+                else:
+                    raise NotImplementedError
+
+            def product_on_basis(self, t1, t2):
+                """
+                The product of the algebra on the basis, as per
+                ``AlgebrasWithBasis.ParentMethods.product_on_basis``.
+
+                EXAMPLES::
+
+                    sage: # needs sage.combinat sage.modules
+                    sage: A = AlgebrasWithBasis(QQ).example(); A
+                    An example of an algebra with basis: the free algebra
+                     on the generators ('a', 'b', 'c') over Rational Field
+                    sage: (a,b,c) = A.algebra_generators()
+                    sage: x = tensor((a, b, c)); x
+                    B[word: a] # B[word: b] # B[word: c]
+                    sage: y = tensor((c, b, a)); y
+                    B[word: c] # B[word: b] # B[word: a]
+                    sage: x * y
+                    B[word: ac] # B[word: bb] # B[word: ca]
+                    sage: x = tensor(((a + 2*b), c)); x
+                    B[word: a] # B[word: c] + 2*B[word: b] # B[word: c]
+                    sage: y = tensor((c, a)) + 1; y
+                    B[word: ] # B[word: ] + B[word: c] # B[word: a]
+                    sage: x * y
+                    B[word: a] # B[word: c] + B[word: ac] # B[word: ca]
+                     + 2*B[word: b] # B[word: c] + 2*B[word: bc] # B[word: ca]
+
+
+                TODO: optimize this implementation!
+                """
+                return tensor(module.monomial(x1) * module.monomial(x2)
+                              for module, x1, x2 in zip(self._sets, t1, t2))
+
+        class ElementMethods:
+            """
+            Implement operations on elements of tensor products of algebras with basis
+            """
+            pass

sage/categories/all.py

@@ -0,0 +1,160 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Sage categories quickref
+
+- ``sage.categories.primer?``                      a primer on Elements, Parents, and Categories
+- ``sage.categories.tutorial?``                    a tutorial on Elements, Parents, and Categories
+- ``Category?``                                    technical background on categories
+- ``Sets()``, ``Semigroups()``, ``Algebras(QQ)``   some categories
+- ``SemiGroups().example()??``                     sample implementation of a semigroup
+- ``Hom(A, B)``, ``End(A, Algebras())``            homomorphisms sets
+- ``tensor``, ``cartesian_product``                functorial constructions
+
+Module layout:
+
+- :mod:`sage.categories.basic`                the basic categories
+- :mod:`sage.categories.all`                  all categories
+- :mod:`sage.categories.semigroups`           the ``Semigroups()`` category
+- :mod:`sage.categories.examples.semigroups`  the example of ``Semigroups()``
+- :mod:`sage.categories.homset`               morphisms, ...
+- :mod:`sage.categories.map`
+- :mod:`sage.categories.morphism`
+- :mod:`sage.categories.functors`
+- :mod:`sage.categories.cartesian_product`    functorial constructions
+- :mod:`sage.categories.tensor`
+- :mod:`sage.categories.dual`
+"""
+# install the docstring of this module to the containing package
+from sage.misc.namespace_package import install_doc
+install_doc(__package__, __doc__)
+
+from sage.categories import primer
+
+from sage.misc.lazy_import import lazy_import
+
+from sage.categories.all__sagemath_objects import *
+
+from sage.categories.basic import *
+
+from sage.categories.chain_complexes import ChainComplexes, HomologyFunctor
+
+from sage.categories.simplicial_complexes import SimplicialComplexes
+
+from sage.categories.tensor import tensor
+from sage.categories.signed_tensor import tensor_signed
+
+from sage.categories.g_sets import GSets
+from sage.categories.pointed_sets import PointedSets
+
+from sage.categories.sets_with_grading import SetsWithGrading
+
+from sage.categories.groupoid import Groupoid
+from sage.categories.permutation_groups import PermutationGroups
+
+# enumerated sets
+from sage.categories.finite_sets import FiniteSets
+from sage.categories.enumerated_sets import EnumeratedSets
+from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
+from sage.categories.infinite_enumerated_sets import InfiniteEnumeratedSets
+
+# posets
+from sage.categories.posets import Posets
+from sage.categories.finite_posets import FinitePosets
+from sage.categories.lattice_posets import LatticePosets
+from sage.categories.finite_lattice_posets import FiniteLatticePosets
+
+# finite groups/...
+from sage.categories.finite_semigroups import FiniteSemigroups
+from sage.categories.finite_monoids import FiniteMonoids
+from sage.categories.finite_groups import FiniteGroups
+from sage.categories.finite_permutation_groups import FinitePermutationGroups
+
+# fields
+from sage.categories.number_fields import NumberFields
+from sage.categories.function_fields import FunctionFields
+
+# modules
+from sage.categories.left_modules import LeftModules
+from sage.categories.right_modules import RightModules
+from sage.categories.bimodules import Bimodules
+
+from sage.categories.modules import Modules
+RingModules = Modules
+from sage.categories.vector_spaces import VectorSpaces
+
+# (Hopf) algebra structures
+from sage.categories.algebras import Algebras
+from sage.categories.commutative_algebras import CommutativeAlgebras
+from sage.categories.coalgebras import Coalgebras
+from sage.categories.bialgebras import Bialgebras
+from sage.categories.hopf_algebras import HopfAlgebras
+from sage.categories.lie_algebras import LieAlgebras
+
+# specific algebras
+from sage.categories.monoid_algebras import MonoidAlgebras
+from sage.categories.group_algebras import GroupAlgebras
+from sage.categories.matrix_algebras import MatrixAlgebras
+
+# ideals
+from sage.categories.ring_ideals import RingIdeals
+Ideals = RingIdeals
+from sage.categories.commutative_ring_ideals import CommutativeRingIdeals
+from sage.categories.algebra_modules import AlgebraModules
+from sage.categories.algebra_ideals import AlgebraIdeals
+from sage.categories.commutative_algebra_ideals import CommutativeAlgebraIdeals
+
+# schemes and varieties
+from sage.categories.modular_abelian_varieties import ModularAbelianVarieties
+from sage.categories.schemes import Schemes, AbelianVarieties, Jacobians
+
+# * with basis
+from sage.categories.modules_with_basis import ModulesWithBasis
+FreeModules = ModulesWithBasis
+from sage.categories.hecke_modules import HeckeModules
+from sage.categories.algebras_with_basis import AlgebrasWithBasis
+from sage.categories.coalgebras_with_basis import CoalgebrasWithBasis
+from sage.categories.bialgebras_with_basis import BialgebrasWithBasis
+from sage.categories.hopf_algebras_with_basis import HopfAlgebrasWithBasis
+
+# finite dimensional * with basis
+from sage.categories.finite_dimensional_modules_with_basis import FiniteDimensionalModulesWithBasis
+from sage.categories.finite_dimensional_algebras_with_basis import FiniteDimensionalAlgebrasWithBasis
+from sage.categories.finite_dimensional_coalgebras_with_basis import FiniteDimensionalCoalgebrasWithBasis
+from sage.categories.finite_dimensional_bialgebras_with_basis import FiniteDimensionalBialgebrasWithBasis
+from sage.categories.finite_dimensional_hopf_algebras_with_basis import FiniteDimensionalHopfAlgebrasWithBasis
+
+# graded *
+from sage.categories.graded_modules import GradedModules
+from sage.categories.graded_algebras import GradedAlgebras
+from sage.categories.graded_coalgebras import GradedCoalgebras
+from sage.categories.graded_bialgebras import GradedBialgebras
+from sage.categories.graded_hopf_algebras import GradedHopfAlgebras
+
+# graded * with basis
+from sage.categories.graded_modules_with_basis import GradedModulesWithBasis
+from sage.categories.graded_algebras_with_basis import GradedAlgebrasWithBasis
+from sage.categories.graded_coalgebras_with_basis import GradedCoalgebrasWithBasis
+from sage.categories.graded_bialgebras_with_basis import GradedBialgebrasWithBasis
+from sage.categories.graded_hopf_algebras_with_basis import GradedHopfAlgebrasWithBasis
+
+# Coxeter groups
+from sage.categories.coxeter_groups import CoxeterGroups
+lazy_import('sage.categories.finite_coxeter_groups', 'FiniteCoxeterGroups')
+from sage.categories.weyl_groups import WeylGroups
+from sage.categories.finite_weyl_groups import FiniteWeylGroups
+from sage.categories.affine_weyl_groups import AffineWeylGroups
+
+# crystal bases
+from sage.categories.crystals import Crystals
+from sage.categories.highest_weight_crystals import HighestWeightCrystals
+from sage.categories.regular_crystals import RegularCrystals
+from sage.categories.finite_crystals import FiniteCrystals
+from sage.categories.classical_crystals import ClassicalCrystals
+
+# polyhedra
+lazy_import('sage.categories.polyhedra', 'PolyhedralSets')
+
+# lie conformal algebras
+lazy_import('sage.categories.lie_conformal_algebras', 'LieConformalAlgebras')
+del lazy_import
+del install_doc

sage/categories/aperiodic_semigroups.py

@@ -0,0 +1,29 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Aperiodic semigroups
+"""
+#*****************************************************************************
+#  Copyright (C) 2016 Nicolas M. Thiéry <nthiery at users.sf.net>
+#
+# 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
+from sage.categories.semigroups import Semigroups
+
+
+class AperiodicSemigroups(CategoryWithAxiom):
+    def extra_super_categories(self):
+        r"""
+        Implement the fact that an aperiodic semigroup is `H`-trivial.
+
+        EXAMPLES::
+
+            sage: Semigroups().Aperiodic().extra_super_categories()
+            [Category of h trivial semigroups]
+        """
+        return [Semigroups().HTrivial()]

sage/categories/associative_algebras.py

@@ -0,0 +1,47 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Associative algebras
+"""
+# ****************************************************************************
+#  Copyright (C) 2011 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 sage.misc.lazy_import import LazyImport
+from sage.categories.category_with_axiom import CategoryWithAxiom_over_base_ring
+from sage.categories.magmatic_algebras import MagmaticAlgebras
+
+
+class AssociativeAlgebras(CategoryWithAxiom_over_base_ring):
+    r"""
+    The category of associative algebras over a given base ring.
+
+    An associative algebra over a ring `R` is a module over `R` which
+    is also a not necessarily unital ring.
+
+    .. WARNING::
+
+        Until :issue:`15043` is implemented, :class:`Algebras` is the
+        category of associative unital algebras; thus, unlike the name
+        suggests, :class:`AssociativeAlgebras` is not a subcategory of
+        :class:`Algebras` but of
+        :class:`~.magmatic_algebras.MagmaticAlgebras`.
+
+    EXAMPLES::
+
+        sage: from sage.categories.associative_algebras import AssociativeAlgebras
+        sage: C = AssociativeAlgebras(ZZ); C
+        Category of associative algebras over Integer Ring
+
+    TESTS::
+
+        sage: from sage.categories.magmatic_algebras import MagmaticAlgebras
+        sage: C is MagmaticAlgebras(ZZ).Associative()
+        True
+        sage: TestSuite(C).run()
+    """
+    _base_category_class_and_axiom = (MagmaticAlgebras, "Associative")
+
+    Unital = LazyImport('sage.categories.algebras', 'Algebras', at_startup=True)