gh-36095: Implementing a generic one method for unital algebras
    
<!-- ^^^^^
Please provide a concise, informative and self-explanatory title.
Don't put issue numbers in there, do this in the PR body below.
For example, instead of "Fixes #1234" use "Introduce new method to
calculate 1+1"
-->
<!-- Describe your changes here in detail -->

We implement a generic `one()` method for unital algebras in order to
fix the following:
```python
sage: S2 = simplicial_complexes.Sphere(2)
sage: H = S2.cohomology_ring(QQ)
sage: C = cartesian_product([H, H])
sage: C.one()  # this raises an error currently
B[(0, (0, 0))] + B[(1, (0, 0))]
```

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->
<!-- If your change requires a documentation PR, please link it
appropriately -->
<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
<!-- Feel free to remove irrelevant items. -->

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #36095
Reported by: Travis Scrimshaw
Reviewer(s): Frédéric Chapoton

Author: Release Manager

src/sage/categories/algebras.py

@@ -216,9 +216,8 @@ def extra_super_categories(self):
                 sage: C.extra_super_categories()
                 [Category of algebras over Rational Field]
                 sage: sorted(C.super_categories(), key=str)
-                [Category of Cartesian products of distributive magmas and additive magmas,
-                 Category of Cartesian products of monoids,
-                 Category of Cartesian products of vector spaces over Rational Field,
+                [Category of Cartesian products of monoids,
+                 Category of Cartesian products of unital algebras over Rational Field,
                  Category of algebras over Rational Field]
             """
             return [self.base_category()]

src/sage/categories/algebras_with_basis.py

@@ -231,7 +231,8 @@ class ParentMethods:
             @cached_method
             def one_from_cartesian_product_of_one_basis(self):
                 """
-                Returns the one of this Cartesian product of algebras, as per ``Monoids.ParentMethods.one``
+                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.
@@ -272,10 +273,11 @@ def one(self):
                     sage: B.one()                                                       # needs sage.combinat sage.modules
                     B[(0, word: )] + B[(1, word: )] + B[(2, word: )]
                 """
-                if all(hasattr(module, "one_basis") for module in self._sets):
+                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
-                else:
-                    return NotImplemented
+                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

src/sage/categories/unital_algebras.py

@@ -18,14 +18,15 @@
 from sage.categories.homset import Hom
 from sage.categories.rings import Rings
 from sage.categories.magmatic_algebras import MagmaticAlgebras
+from sage.categories.cartesian_product import CartesianProductsCategory
 
 
 class UnitalAlgebras(CategoryWithAxiom_over_base_ring):
     """
     The category of non-associative algebras over a given base ring.
 
     A non-associative algebra over a ring `R` is a module over `R`
-    which s also a unital magma.
+    which is also a unital magma.
 
     .. WARNING::
 
@@ -382,3 +383,55 @@ def from_base_ring_from_one_basis(self, r):
                     3*B[word: ]
                 """
                 return self.term(self.one_basis(), r)
+
+    class CartesianProducts(CartesianProductsCategory):
+        r"""
+        The category of unital algebras constructed as Cartesian products
+        of unital algebras.
+
+        This construction gives the direct product of algebras. See
+        discussion on:
+
+         - http://groups.google.fr/group/sage-devel/browse_thread/thread/35a72b1d0a2fc77a/348f42ae77a66d16#348f42ae77a66d16
+         - :wikipedia:`Direct_product`
+        """
+        def extra_super_categories(self):
+            """
+            A Cartesian product of algebras is endowed with a natural
+            unital algebra structure.
+
+            EXAMPLES::
+
+                sage: from sage.categories.unital_algebras import UnitalAlgebras
+                sage: C = UnitalAlgebras(QQ).CartesianProducts()
+                sage: C.extra_super_categories()
+                [Category of unital algebras over Rational Field]
+                sage: sorted(C.super_categories(), key=str)
+                [Category of Cartesian products of distributive magmas and additive magmas,
+                 Category of Cartesian products of unital magmas,
+                 Category of Cartesian products of vector spaces over Rational Field,
+                 Category of unital algebras over Rational Field]
+            """
+            return [self.base_category()]
+
+        class ParentMethods:
+            @cached_method
+            def one(self):
+                r"""
+                Return the multiplicative unit element.
+
+                EXAMPLES::
+
+                    sage: S2 = simplicial_complexes.Sphere(2)
+                    sage: H = S2.cohomology_ring(QQ)
+                    sage: C = cartesian_product([H, H])
+                    sage: one = C.one()
+                    sage: one
+                    B[(0, (0, 0))] + B[(1, (0, 0))]
+                    sage: one == one * one
+                    True
+                    sage: all(b == b * one for b in C.basis())
+                    True
+                """
+                data = enumerate(self.cartesian_factors())
+                return self._cartesian_product_of_elements([C.one() for i, C in data])