passagemath-modules 10.5.32__cp310-cp310-macosx_14_0_arm64.whl → 10.6.20__cp310-cp310-macosx_14_0_arm64.whl

sage/coding/guruswami_sudan/utils.py

@@ -9,7 +9,7 @@ AUTHORS:
 - David Lucas, ported the original implementation in Sage
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2015 David Lucas <david.lucas@inria.fr>
 #                     2015 Johan S. R. Nielsen <jsrn@jsrn.dk>
 #
@@ -17,12 +17,10 @@ AUTHORS:
 # 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/
-#*****************************************************************************
-
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.arith.misc import integer_floor as floor
-from sage.misc.lazy_import import lazy_import
 from sage.misc.functional import sqrt
 from sage.rings.integer_ring import ZZ
 from sage.rings.integer import Integer

sage/coding/kasami_codes.pyx

@@ -166,26 +166,25 @@ class KasamiCode(AbstractLinearCode):
             ValueError: The parameter t(=5) must be a power of 2
         """
         # Check validity of s and t
-        (p,i) = is_prime_power(t,get_data=True)
+        p, i = is_prime_power(t, get_data=True)
         if p != 2:
             raise ValueError(f"The parameter t(={t}) must be a power of 2")
 
-        if s != t*t:
+        if s != t * t:
             # then we must have s=q^{2j+1} and t = q^m
-            (p,k) = is_prime_power(s,get_data=True)
+            p, k = is_prime_power(s, get_data=True)
             if p != 2:
                 raise ValueError(f"The parameter s(={s}) must be a power of 2")
 
             # q= 2^l here l = gcd(k,i)
-            l = gcd(i,k)
-            q = 2**l
+            l = gcd(i, k)
             m = i // l
 
-            if (k//l) % 2 == 0:
+            if (k // l) % 2 == 0:
                 raise ValueError(
                     f"The parameter s(={s}) is invalid. Check the documentation")
 
-            j = ((k//l) - 1) // 2
+            j = ((k // l) - 1) // 2
 
             # gcd(m,2*j+1) = gcd( i/l, k/l) = 1
             if m > j:
@@ -220,7 +219,7 @@ class KasamiCode(AbstractLinearCode):
             sage: C.parameters()
             (8, 2)
         """
-        return (self._s,self._t)
+        return (self._s, self._t)
 
     def __eq__(self, other):
         r"""
@@ -240,10 +239,10 @@ class KasamiCode(AbstractLinearCode):
         # Check that s, t, extended values of both
         # objects are the same
         return isinstance(other, KasamiCode) \
-                and self.parameters() == other.parameters() \
-                and self._extended == other._extended
+            and self.parameters() == other.parameters() \
+            and self._extended == other._extended
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         Return a string representation of ``self``.
 
@@ -252,13 +251,12 @@ class KasamiCode(AbstractLinearCode):
             sage: codes.KasamiCode(4,2,extended=True)
             [4, 0] Extended (4, 2)-Kasami code
         """
-        ext = ""
-        if self._extended:
-            ext = " Extended"
-        return "[%s, %s]%s (%s, %s)-Kasami code"\
-                % (self.length(),self.dimension(), ext, self._s, self._t)
+        ext = " Extended" if self._extended else ""
+        return "[%s, %s]%s (%s, %s)-Kasami code" % (self.length(),
+                                                    self.dimension(), ext,
+                                                    self._s, self._t)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return a latex representation of ``self``.
 
@@ -268,11 +266,9 @@ class KasamiCode(AbstractLinearCode):
             sage: latex(C)
             [16, 9]\textnormal{ Extended} (16, 4)\textnormal{-Kasami code}
         """
-        ext = ""
-        if self._extended:
-            ext = " Extended"
+        ext = " Extended" if self._extended else ""
         return "[%s, %s]\\textnormal{%s} (%s, %s)\\textnormal{-Kasami code}"\
-                % (self.length(), self.dimension(), ext, self._s, self._t)
+            % (self.length(), self.dimension(), ext, self._s, self._t)
 
     def generator_matrix(self):
         r"""
@@ -330,11 +326,11 @@ class KasamiCode(AbstractLinearCode):
 
         def exp(row):
             return matrix(F,
-                          [x + [0]*(m - len(x)) for x in
-                            [a.polynomial().list() for a in row]]).transpose()
+                          [x + [0] * (m - len(x)) for x in
+                           [a.polynomial().list() for a in row]]).transpose()
 
         # Parity check matrix over GF(s)
-        Hs = matrix(F, [[1]*self._s,
+        Hs = matrix(F, [[1] * self._s,
                         F.list(),
                         [a**(self._t + 1) for a in F]])
 

sage/coding/linear_code.py

@@ -99,10 +99,10 @@ Further references
 ------------------
 
 If you want to get started on Sage's linear codes library, see
-https://doc.sagemath.org/html/en/thematic_tutorials/coding_theory.html
+https://passagemath.org/docs/latest/html/en/thematic_tutorials/coding_theory.html
 
 If you want to learn more on the design of this library, see
-https://doc.sagemath.org/html/en/thematic_tutorials/structures_in_coding_theory.html
+https://passagemath.org/docs/latest/html/en/thematic_tutorials/structures_in_coding_theory.html
 
 REFERENCES:
 

sage/coding/linear_code_no_metric.py

@@ -375,18 +375,18 @@ class AbstractLinearCodeNoMetric(AbstractCode, Module):
         return self.dimension() / self.length()
 
     @cached_method
-    def gens(self) -> list:
+    def gens(self) -> tuple:
         r"""
-        Return the generators of this code as a list of vectors.
+        Return the generators of this code as a tuple of vectors.
 
         EXAMPLES::
 
             sage: C = codes.HammingCode(GF(2), 3)
             sage: C.gens()
-             [(1, 0, 0, 0, 0, 1, 1), (0, 1, 0, 0, 1, 0, 1),
-              (0, 0, 1, 0, 1, 1, 0), (0, 0, 0, 1, 1, 1, 1)]
+             ((1, 0, 0, 0, 0, 1, 1), (0, 1, 0, 0, 1, 0, 1),
+              (0, 0, 1, 0, 1, 1, 0), (0, 0, 0, 1, 1, 1, 1))
         """
-        return self.generator_matrix().rows()
+        return tuple(self.generator_matrix().rows())
 
     def basis(self):
         r"""

sage/coding/linear_rank_metric.py

@@ -92,6 +92,7 @@ Read more about
 AUTHORS:
 
 - Marketa Slukova (2019-08-16): initial version
+- Camille Garnier and Rubén Muñoz-\-Bertrand (2024-02-13): added rank_support_of_vector, and corrected the documentation
 
 TESTS::
 
@@ -147,9 +148,9 @@ def to_matrix_representation(v, sub_field=None, basis=None):
       specified, it is the prime subfield `\GF{p}` of `\GF{q^m}`
 
     - ``basis`` -- (default: ``None``) a basis of `\GF{q^m}` as a vector space over
-      ``sub_field``. If not specified, given that `q = p^s`, let
-      `1,\beta,\ldots,\beta^{sm}` be the power basis that SageMath uses to
-      represent `\GF{q^m}`. The default basis is then `1,\beta,\ldots,\beta^{m-1}`.
+      ``sub_field``. If not specified, the default basis is
+      `1,\beta,\ldots,\beta^{m-1}` where `\beta` is the generator of `\GF{q^m}`
+      given by SageMath.
 
     EXAMPLES::
 
@@ -199,9 +200,9 @@ def from_matrix_representation(w, base_field=None, basis=None):
       ``w``.
 
     - ``basis`` -- (default: ``None``) a basis of `\GF{q^m}` as a vector space over
-      `\GF{q}`. If not specified, given that `q = p^s`, let
-      `1,\beta,\ldots,\beta^{sm}` be the power basis that SageMath uses to
-      represent `\GF{q^m}`. The default basis is then `1,\beta,\ldots,\beta^{m-1}`.
+      `\GF{q}`. If not specified, the default basis is
+      `1,\beta,\ldots,\beta^{m-1}` where `\beta` is the generator
+      of `\GF{q^m}` given by SageMath.
 
     EXAMPLES::
 
@@ -231,7 +232,7 @@ def rank_weight(c, sub_field=None, basis=None):
     Return the rank of ``c`` as a matrix over ``sub_field``.
 
     If ``c`` is a vector over some field `\GF{q^m}`, the function converts it
-    into a matrix over `\GF{q}`.
+    into a matrix over ``sub_field```.
 
     INPUT:
 
@@ -241,9 +242,9 @@ def rank_weight(c, sub_field=None, basis=None):
       specified, it is the prime subfield `\GF{p}` of `\GF{q^m}`
 
     - ``basis`` -- (default: ``None``) a basis of `\GF{q^m}` as a vector space over
-      ``sub_field``. If not specified, given that `q = p^s`, let
-      `1,\beta,\ldots,\beta^{sm}` be the power basis that SageMath uses to
-      represent `\GF{q^m}`. The default basis is then `1,\beta,\ldots,\beta^{m-1}`.
+      ``sub_field``. If not specified, the default basis is
+      `1,\beta,\ldots,\beta^{m-1}` where `\beta` is the generator
+      of `\GF{q^m}` given by SageMath.
 
     EXAMPLES::
 
@@ -279,9 +280,9 @@ def rank_distance(a, b, sub_field=None, basis=None):
       specified, it is the prime subfield `\GF{p}` of `\GF{q^m}`
 
     - ``basis`` -- (default: ``None``) a basis of `\GF{q^m}` as a vector space over
-      ``sub_field``. If not specified, given that `q = p^s`, let
-      `1,\beta,\ldots,\beta^{sm}` be the power basis that SageMath uses to
-      represent `\GF{q^m}`. The default basis is then `1,\beta,\ldots,\beta^{m-1}`.
+      ``sub_field``. If not specified, the default basis is
+      `1,\beta,\ldots,\beta^{m-1}` where `\beta` is the generator
+      of `\GF{q^m}` given by SageMath.
 
     EXAMPLES::
 
@@ -380,9 +381,9 @@ class AbstractLinearRankMetricCode(AbstractLinearCodeNoMetric):
         - ``default_decoder_name`` -- the name of the default decoder of ``self``
 
         - ``basis`` -- (default: ``None``) a basis of `\GF{q^m}` as a vector space over
-          ``sub_field``. If not specified, given that `q = p^s`, let
-          `1,\beta,\ldots,\beta^{sm}` be the power basis that SageMath uses to
-          represent `\GF{q^m}`. The default basis is then `1,\beta,\ldots,\beta^{m-1}`.
+          ``sub_field``. If not specified, the default basis is
+          `1,\beta,\ldots,\beta^{m-1}` where `\beta` is the generator
+          of `\GF{q^m}` given by SageMath.
 
         EXAMPLES:
 
@@ -589,6 +590,67 @@ class AbstractLinearRankMetricCode(AbstractLinearCodeNoMetric):
         """
         return rank_weight(word, self.sub_field())
 
+    def rank_support_of_vector(self, word, sub_field=None, basis=None):
+        r"""
+        Return the rank support of ``word`` over ``sub_field``, i.e. the  vector space over
+        ``sub_field`` generated by its coefficients.
+
+        If ``word`` is a vector over some field `\GF{q^m}`, and ``sub_field`` is a subfield of
+        `\GF{q^m}`, the function converts it into a matrix over ``sub_field``, with
+        respect to the basis ``basis``.
+
+        INPUT:
+
+        - ``word`` -- a vector over the ``base_field`` of ``self``.
+
+        - ``sub_field`` -- (default: ``None``) a sub field of the
+          ``base_field`` of ``self``; if not specified, it is the prime
+          subfield of `\GF{p}` the ``base_field`` of ``self``.
+
+        - ``basis`` -- (default: ``None``) a basis of ``base_field`` of
+          ``self`` as a vector space over ``sub_field``. If not specified,
+          the default basis is `1,\beta,\ldots,\beta^{m-1}`, where `\beta` is
+          the generator of `\GF{q^m}` given by SageMath.
+
+        EXAMPLES::
+
+            sage: G = Matrix(GF(64), [[1,1,0], [0,0,1]])
+            sage: C = codes.LinearRankMetricCode(G, GF(4))
+            sage: a = GF(64).gen()
+            sage: c = vector([a^4 + a^3 + 1, a^4 + a^3 + 1, a^4 + a^3 + a^2 + 1])
+            sage: c in C
+            True
+            sage: C.rank_support_of_vector(c)
+            Vector space of degree 6 and dimension 2 over Finite Field of size 2
+            Basis matrix:
+            [1 0 0 1 1 0]
+            [0 0 1 0 0 0]
+
+        An example with a non canonical basis::
+
+            sage: K.<a> = GF(2^3)
+            sage: G = Matrix(K, [[1,1,0], [0,0,1]])
+            sage: C = codes.LinearRankMetricCode(G)
+            sage: c = vector([a^2, a^2, 0])
+            sage: basis = [a, a+1, a^2]
+            sage: C.rank_support_of_vector(c, basis=basis)
+            Vector space of degree 3 and dimension 1 over Finite Field of size 2
+            Basis matrix:
+            [0 0 1]
+
+        TESTS::
+
+            sage: C.rank_support_of_vector(c, GF(2^4))
+            Traceback (most recent call last):
+            ...
+            TypeError: the input subfield Finite Field in z4 of size 2^4 is not a subfield of Finite Field in a of size 2^3
+        """
+        word = self.ambient_space()(word)
+        if sub_field is not None:
+            if self.base_field().degree() % sub_field.degree() != 0:
+                raise TypeError(f"the input subfield {sub_field} is not a subfield of {self.base_field()}")
+        return to_matrix_representation(word, sub_field, basis).column_module()
+
     def matrix_form_of_vector(self, word):
         r"""
         Return the matrix representation of a word.
@@ -680,9 +742,9 @@ class LinearRankMetricCode(AbstractLinearRankMetricCode):
           specified, it is the prime field of ``base_field``
 
         - ``basis`` -- (default: ``None``) a basis of `\GF{q^m}` as a vector space over
-          ``sub_field``. If not specified, given that `q = p^s`, let
-          `1,\beta,\ldots,\beta^{sm}` be the power basis that SageMath uses to
-          represent `\GF{q^m}`. The default basis is then `1,\beta,\ldots,\beta^{m-1}`.
+          ``sub_field``. If not specified, the default basis is
+          `1,\beta,\ldots,\beta^{m-1}` where `\beta` is the generator `\GF{q^m}`
+          given by SageMath.
 
         EXAMPLES::
 

sage/combinat/cartesian_product.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-modules
 r"""
-Cartesian Products
+Cartesian products
 """
 # ****************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,

sage/combinat/free_module.py

@@ -1777,6 +1777,26 @@ class CombinatorialFreeModule_CartesianProduct(CombinatorialFreeModule):
         sage: S = cartesian_product([cartesian_product([F, G]), H])  # todo: not implemented
         F (+) G (+) H
     """
+    @staticmethod
+    def __classcall_private__(cls, modules, category, **options):
+        """
+        Dispatch to the appropriate class based on the input.
+
+        EXAMPLES::
+
+            sage: # needs sage.combinat sage.groups
+            sage: Q = RootSystem(['A',3]).root_space(GF(3))
+            sage: W = WeylGroup(['A',3], prefix='s')
+            sage: CP = cartesian_product([Q, W])
+            sage: type(CP)
+            <class 'sage.sets.cartesian_product.CartesianProduct_with_category'>
+        """
+        R = modules[0].base_ring()
+        Cat = ModulesWithBasis(R)
+        if any(module not in Cat for module in modules):
+            from sage.sets.cartesian_product import CartesianProduct
+            return CartesianProduct(modules, category, **options)
+        return super().__classcall__(cls, modules, category=category, **options)
 
     def __init__(self, modules, **options):
         r"""
@@ -1788,9 +1808,9 @@ class CombinatorialFreeModule_CartesianProduct(CombinatorialFreeModule):
             Free module generated by {2, 4, 5} over Integer Ring (+) Free module generated by {2, 4, 7} over Integer Ring
             sage: TestSuite(C).run()
         """
-        assert (len(modules))  # TODO: generalize to a family or tuple
+        assert len(modules)  # TODO: generalize to a family or tuple
         R = modules[0].base_ring()
-        assert (all(module in ModulesWithBasis(R)) for module in modules)
+        assert all(module in ModulesWithBasis(R) for module in modules)
         # should check the base ring
         self._sets = modules
         CombinatorialFreeModule.__init__(self, R,

sage/combinat/root_system/all.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-modules
 """
-Root Systems
+Root systems
 
 Quickref
 --------

sage/combinat/root_system/ambient_space.py

@@ -194,7 +194,7 @@ class AmbientSpace(CombinatorialFreeModule):
         # This adds coercion from a list
         if isinstance(v, (list, tuple)):
             K = self.base_ring()
-            return self._from_dict(dict((i,K(c)) for i,c in enumerate(v) if c))
+            return self._from_dict({i: K(c) for i, c in enumerate(v) if c})
         else:
             return CombinatorialFreeModule.__call__(self, v)
 

sage/combinat/root_system/associahedron.py

@@ -120,8 +120,8 @@ def Associahedron(cartan_type, backend='ppl'):
 
         sage: p1 = polytopes.associahedron(['A',4], backend='normaliz')   # optional - pynormaliz
         sage: TestSuite(p1).run(skip='_test_pickling')                    # optional - pynormaliz
-        sage: p2 = polytopes.associahedron(['A',4], backend='cdd')
-        sage: TestSuite(p2).run()
+        sage: p2 = polytopes.associahedron(['A',4], backend='cdd')        # needs cddexec_gmp
+        sage: TestSuite(p2).run()                                         # needs cddexec_gmp
         sage: p3 = polytopes.associahedron(['A',4], backend='field')
         sage: TestSuite(p3).run()
     """
@@ -141,7 +141,7 @@ class Associahedron_class_base:
 
         sage: Asso = polytopes.associahedron(['A',2]); Asso
         Generalized associahedron of type ['A', 2] with 5 vertices
-        sage: TestSuite(Asso).run()
+        sage: TestSuite(Asso).run()                                       # needs cddexec
     """
     def __new__(typ, parent=None, Vrep=None, Hrep=None, cartan_type=None, **kwds):
         r"""
@@ -181,7 +181,7 @@ class Associahedron_class_base:
             A 4-dimensional polyhedron in QQ^4 defined as the convex hull of 42 vertices
             sage: A.dilation(2)
             A 4-dimensional polyhedron in QQ^4 defined as the convex hull of 42 vertices
-            sage: A.dilation(2.0)
+            sage: A.dilation(2.0)                                         # needs cddexec
             A 4-dimensional polyhedron in RDF^4 defined as the convex hull of 42 vertices
             sage: A.convex_hull(A)
             A 4-dimensional polyhedron in QQ^4 defined as the convex hull of 42 vertices

sage/combinat/root_system/braid_move_calculator.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
-# sage.doctest: needs sage.libs.gap
+# sage.doctest: needs sage.graphs sage.libs.gap
 """
-Braid Move Calculator
+Braid move calculator
 
 AUTHORS:
 

sage/combinat/root_system/braid_orbit.pyx

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
 # cython: wraparound=False, boundscheck=False
 """
-Braid Orbit
+Braid orbit
 
 Cython function to compute the orbit of the braid moves on a reduced word.
 """

sage/combinat/root_system/branching_rules.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
-# sage.doctest: needs sage.libs.gap
+# sage.doctest: needs sage.graphs sage.libs.gap
 """
-Branching Rules
+Branching rules
 """
 # ****************************************************************************
 #  Copyright (C) 2014 Daniel Bump <bump at match.stanford.edu>
@@ -645,7 +645,7 @@ def branch_weyl_character(chi, R, S, rule='default'):
     These embeddings are described more completely (with references
     to the literature) in the thematic tutorial at:
 
-    https://doc.sagemath.org/html/en/thematic_tutorials/lie.html
+    https://passagemath.org/docs/latest/html/en/thematic_tutorials/lie.html
 
     EXAMPLES::
 

sage/combinat/root_system/cartan_type.py

@@ -1740,10 +1740,10 @@ class CartanType_crystallographic(CartanType_abstract):
         from sage.matrix.constructor import matrix, diagonal_matrix
         m = self.cartan_matrix()
         n = m.nrows()
-        M = matrix(ZZ, n, n*n, sparse=True)
-        for (i,j) in m.nonzero_positions():
-            M[i, n * i + j] = m[i,j]
-            M[j, n * i + j] -= m[j,i]
+        M = matrix(ZZ, n, n * n, sparse=True)
+        for i, j in m.nonzero_positions():
+            M[i, n * i + j] = m[i, j]
+            M[j, n * i + j] -= m[j, i]
         kern = M.integer_kernel()
         c = len(self.dynkin_diagram().connected_components(sort=False))
         if kern.dimension() < c:
@@ -1758,7 +1758,7 @@ class CartanType_crystallographic(CartanType_abstract):
         D = sum(kern.basis())
         assert diagonal_matrix(D) * m == m.transpose() * diagonal_matrix(D)
         I = self.index_set()
-        return Family( dict( (I[i], D[i]) for i in range(n) ) )
+        return Family({I[i]: D[i] for i in range(n)})
 
     def index_set_bipartition(self):
         r"""
@@ -2132,7 +2132,7 @@ class CartanType_affine(CartanType_simple, CartanType_crystallographic):
             raise ValueError("the kernel is not 1 dimensional")
         assert (all(coef > 0 for coef in annihilator_basis[0]))
 
-        return Family(dict((i,annihilator_basis[0][i])for i in self.index_set()))
+        return Family({i: annihilator_basis[0][i] for i in self.index_set()})
 
     acheck = row_annihilator
 
@@ -2206,8 +2206,8 @@ class CartanType_affine(CartanType_simple, CartanType_crystallographic):
         """
         a = self.a()
         acheck = self.acheck()
-        return Family(dict((i, max(ZZ(1), a[i] // acheck[i]))
-                           for i in self.index_set()))
+        return Family({i: max(ZZ.one(), a[i] // acheck[i])
+                       for i in self.index_set()})
 
     def translation_factors(self):
         r"""
@@ -2373,21 +2373,21 @@ class CartanType_affine(CartanType_simple, CartanType_crystallographic):
 
         REFERENCES:
 
-        .. [HST09] \F. Hivert, A. Schilling, and N. M. Thiery,
+        .. [HST09] \F. Hivert, A. Schilling, and N. M. Thiéry,
            *Hecke group algebras as quotients of affine Hecke
            algebras at level 0*, JCT A, Vol. 116, (2009) p. 844-863
            :arxiv:`0804.3781`
         """
         a = self.a()
         acheck = self.acheck()
-        if set([1/ZZ(2), 2]).issubset( set(a[i]/acheck[i] for i in self.index_set()) ):
+        s = set(a[i] / acheck[i] for i in self.index_set())
+        if ~ZZ(2) in s and 2 in s:
             # The test above and the formula below are rather meaningless
             # But they detect properly type BC or dual and return the correct value
-            return Family(dict((i, min(ZZ(1), a[i] / acheck[i]))
-                               for i in self.index_set()))
+            return Family({i: min(ZZ.one(), a[i] / acheck[i])
+                           for i in self.index_set()})
 
-        else:
-            return self.c()
+        return self.c()
 
     def _test_dual_classical(self, **options):
         r"""

sage/combinat/root_system/coxeter_group.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
 # sage.doctest: needs sage.graphs
 """
-Coxeter Groups
+Coxeter groups
 """
 # ***************************************************************************
 #       Copyright (C) 2010 Nicolas Thiery <nthiery at users.sf.net>
@@ -105,12 +105,12 @@ def CoxeterGroup(data, implementation='reflection', base_ring=None, index_set=No
 
     We use the different options for the "reflection" implementation::
 
-        sage: W = CoxeterGroup(["H",3], implementation='reflection', base_ring=RR); W   # needs sage.libs.gap
+        sage: W = CoxeterGroup(["H",3], implementation='reflection', base_ring=RR); W   # needs sage.libs.gap sage.symbolic
         Finite Coxeter group over Real Field with 53 bits of precision with Coxeter matrix:
         [1 3 2]
         [3 1 5]
         [2 5 1]
-        sage: W = CoxeterGroup([[1,10],[10,1]], implementation='reflection',            # needs sage.symbolics
+        sage: W = CoxeterGroup([[1,10],[10,1]], implementation='reflection',            # needs sage.symbolic
         ....:                  index_set=['a','b'], base_ring=SR); W
         Finite Coxeter group over Symbolic Ring with Coxeter matrix:
         [ 1 10]

sage/combinat/root_system/coxeter_matrix.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-modules
 # sage.doctest: needs sage.graphs
 """
-Coxeter Matrices
+Coxeter matrices
 """
 # ****************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,

sage/combinat/root_system/coxeter_type.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-modules
 """
-Coxeter Types
+Coxeter types
 """
 # ****************************************************************************
 #       Copyright (C) 2015 Travis Scrimshaw <tscrim at ucdavis.edu>,
@@ -397,6 +397,17 @@ class CoxeterType(SageObject, metaclass=ClasscallMetaclass):
                     return R((E(2*x) + ~E(2*x)).to_cyclotomic_field()) / R(-2)
                 else:
                     return R(x)
+        elif all(mat[i,j] in (1, 2, 3) or mat[i, j] <= -1 for i in range(n) for j in range(n)):
+            def val(x):
+                if x > -1:
+                    if x == 1:
+                        return R(1)
+                    elif x == 2:
+                        return R(0)
+                    elif x == 3:
+                        return R(1)/R(-2)
+                else:
+                    return R(x)
         else:
             from sage.functions.trig import cos
             from sage.symbolic.constants import pi