gh-40328: get rid of some "is_commutative" methods, via the category framework
    
Using the idea that, by default, a ring is not commutative unless it
belongs to the category of CommutativeRings.

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [ ] I have updated the documentation and checked the documentation
preview.
    
URL: #40328
Reported by: Frédéric Chapoton
Reviewer(s):

Author: Release Manager

src/sage/algebras/clifford_algebra.py

@@ -528,12 +528,28 @@ def __init__(self, Q, names, category=None):
             sage: ba = Cl.basis().keys()
             sage: all(FrozenBitset(format(i,'b')[::-1]) in ba for i in range(2**9))
             True
+
+        Check for the category::
+
+            sage: Q = QuadraticForm(ZZ, 3, [1,2,3,4,5,6])
+            sage: Cl.<x,y,z> = CliffordAlgebra(Q)
+            sage: Cl.is_commutative()
+            False
+            sage: Q = QuadraticForm(ZZ, 1, [1])
+            sage: Cl.<x> = CliffordAlgebra(Q)
+            sage: Cl.is_commutative()
+            True
         """
         self._quadratic_form = Q
         R = Q.base_ring()
         category = AlgebrasWithBasis(R.category()).Super().Filtered().FiniteDimensional().or_subcategory(category)
+
+        if self._quadratic_form.dim() < 2:
+            category = category.Commutative()
+
         indices = CliffordAlgebraIndices(Q.dim())
-        CombinatorialFreeModule.__init__(self, R, indices, category=category, sorting_key=tuple)
+        CombinatorialFreeModule.__init__(self, R, indices, category=category,
+                                         sorting_key=tuple)
         self._assign_names(names)
 
     def _repr_(self):
@@ -844,19 +860,6 @@ def one_basis(self):
         """
         return FrozenBitset()
 
-    def is_commutative(self) -> bool:
-        """
-        Check if ``self`` is a commutative algebra.
-
-        EXAMPLES::
-
-            sage: Q = QuadraticForm(ZZ, 3, [1,2,3,4,5,6])
-            sage: Cl.<x,y,z> = CliffordAlgebra(Q)
-            sage: Cl.is_commutative()
-            False
-        """
-        return self._quadratic_form.dim() < 2
-
     def quadratic_form(self):
         """
         Return the quadratic form of ``self``.

src/sage/algebras/iwahori_hecke_algebra.py

@@ -459,6 +459,15 @@ def __init__(self, W, q1, q2, base_ring):
             sage: R.<q1,q2> = QQ[]
             sage: H = IwahoriHeckeAlgebra("A2", q1, q2=q2, base_ring=Frac(R))
             sage: TestSuite(H).run()
+
+        TESTS::
+
+            sage: T = IwahoriHeckeAlgebra("B2", 1).T()
+            sage: T.is_commutative()
+            False
+            sage: T = IwahoriHeckeAlgebra("A1", 1).T()
+            sage: T.is_commutative()
+            True
         """
         self._W = W
         self._coxeter_type = W.coxeter_type()
@@ -499,7 +508,12 @@ def __init__(self, W, q1, q2, base_ring):
             self._category = FiniteDimensionalAlgebrasWithBasis(base_ring)
         else:
             self._category = AlgebrasWithBasis(base_ring)
-        Parent.__init__(self, base=base_ring, category=self._category.WithRealizations())
+
+        if base_ring.is_commutative() and W.is_commutative():
+            self._category = self._category.Commutative()
+
+        Parent.__init__(self, base=base_ring,
+                        category=self._category.WithRealizations())
 
         self._is_generic = False  # needed for initialisation of _KLHeckeBasis
 
@@ -767,19 +781,6 @@ def is_field(self, proof=True):
                 """
                 return False
 
-            def is_commutative(self) -> bool:
-                """
-                Return whether this Iwahori-Hecke algebra is commutative.
-
-                EXAMPLES::
-
-                    sage: T = IwahoriHeckeAlgebra("B2", 1).T()
-                    sage: T.is_commutative()
-                    False
-                """
-                return self.base_ring().is_commutative() \
-                    and self.realization_of().coxeter_group().is_commutative()
-
             @cached_method
             def one_basis(self):
                 r"""

src/sage/algebras/quatalg/quaternion_algebra.py

@@ -560,19 +560,6 @@ def inner_product_matrix(self):
         M.set_immutable()
         return M
 
-    def is_commutative(self) -> bool:
-        """
-        Return ``False`` always, since all quaternion algebras are
-        noncommutative.
-
-        EXAMPLES::
-
-            sage: Q.<i,j,k> = QuaternionAlgebra(QQ, -3,-7)
-            sage: Q.is_commutative()
-            False
-        """
-        return False
-
     def is_division_algebra(self) -> bool:
         """
         Check whether this quaternion algebra is a division algebra,
@@ -871,6 +858,12 @@ def __init__(self, base_ring, a, b, names='i,j,k'):
             Traceback (most recent call last):
             ...
             ValueError: 2 is not invertible in Integer Ring
+
+        Check for category::
+
+            sage: Q.<i,j,k> = QuaternionAlgebra(QQ, -3,-7)
+            sage: Q.is_commutative()
+            False
         """
         cat = Algebras(base_ring).Division().FiniteDimensional()
         Parent.__init__(self, base=base_ring, names=names, category=cat)

src/sage/combinat/chas/wqsym.py

@@ -471,8 +471,14 @@ def __init__(self, R):
 
             sage: A = algebras.WQSym(QQ)
             sage: TestSuite(A).run()  # long time
+
+            sage: M = algebras.WQSym(ZZ).M()
+            sage: M.is_commutative()
+            False
         """
         category = HopfAlgebras(R).Graded().Connected()
+        if R.is_zero():
+            category = category.Commutative()
         Parent.__init__(self, base=R, category=category.WithRealizations())
 
     def _repr_(self):
@@ -2041,18 +2047,6 @@ def is_field(self, proof=True):
             """
             return False
 
-        def is_commutative(self):
-            """
-            Return whether ``self`` is commutative.
-
-            EXAMPLES::
-
-                sage: M = algebras.WQSym(ZZ).M()
-                sage: M.is_commutative()
-                False
-            """
-            return self.base_ring().is_zero()
-
         def one_basis(self):
             """
             Return the index of the unit.

src/sage/combinat/fqsym.py

@@ -363,8 +363,14 @@ def __init__(self, R):
 
             sage: F = algebras.FQSym(QQ)
             sage: TestSuite(F).run() # long time (3s)
+
+            sage: F = algebras.FQSym(ZZ).F()
+            sage: F.is_commutative()
+            False
         """
         category = HopfAlgebras(R).Graded().Connected()
+        if R.is_zero():
+            category = category.Commutative()
         Parent.__init__(self, base=R, category=category.WithRealizations())
 
         # Bases
@@ -1350,18 +1356,6 @@ def is_field(self, proof=True):
             """
             return False
 
-        def is_commutative(self):
-            """
-            Return whether this `FQSym` is commutative.
-
-            EXAMPLES::
-
-                sage: F = algebras.FQSym(ZZ).F()
-                sage: F.is_commutative()
-                False
-            """
-            return self.base_ring().is_zero()
-
         def some_elements(self):
             """
             Return some elements of the free quasi-symmetric functions.