Trac #31140: use ⨂ for unicode of tensor symbol

URL: https://trac.sagemath.org/31140
Reported by: chapoton
Ticket author(s): Frédéric Chapoton
Reviewer(s): Travis Scrimshaw

Author: Release Manager

src/sage/categories/signed_tensor.py

@@ -1,19 +1,21 @@
+# -*- coding: utf-8 -*-
 """
 Signed Tensor Product Functorial Construction
 
 AUTHORS:
 
 - Travis Scrimshaw (2019-07): initial version
 """
-#*****************************************************************************
+# ****************************************************************************
 #  Copyright (C) 2019 Travis Scrimshaw <tcscrims at gamil.com>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
 #                  http://www.gnu.org/licenses/
-#*****************************************************************************
+# ****************************************************************************
 
 from sage.categories.covariant_functorial_construction import CovariantFunctorialConstruction, CovariantConstructionCategory
 
+
 class SignedTensorProductFunctor(CovariantFunctorialConstruction):
     """
     A singleton class for the signed tensor functor.
@@ -53,6 +55,7 @@ class SignedTensorProductFunctor(CovariantFunctorialConstruction):
     _functor_name = "tensor"
     _functor_category = "SignedTensorProducts"
     symbol = " # "
+    unicode_symbol = " ⨂ "
 
     def _repr_(self):
         """
@@ -66,8 +69,10 @@ def _repr_(self):
         #   default _repr_
         return "The signed tensor functorial construction"
 
+
 tensor_signed = SignedTensorProductFunctor()
 
+
 class SignedTensorProductsCategory(CovariantConstructionCategory):
     r"""
     An abstract base class for all SignedTensorProducts's categories.
@@ -112,4 +117,3 @@ def base(self):
             Integer Ring
         """
         return self.base_category().base()
-

src/sage/categories/tensor.py

@@ -1,19 +1,21 @@
+# -*- coding: utf-8 -*-
 """
 Tensor Product Functorial Construction
 
 AUTHORS:
 
- - Nicolas M. Thiery (2008-2010): initial revision and refactorization
+- Nicolas M. Thiéry (2008-2010): initial revision and refactorization
 """
-#*****************************************************************************
-#  Copyright (C) 2008-2010 Nicolas M. Thiery <nthiery at users.sf.net>
+# ****************************************************************************
+#  Copyright (C) 2008-2010 Nicolas M. Thiéry <nthiery at users.sf.net>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
 
 from sage.categories.covariant_functorial_construction import CovariantFunctorialConstruction, CovariantConstructionCategory
 
+
 class TensorProductFunctor(CovariantFunctorialConstruction):
     """
     A singleton class for the tensor functor.
@@ -48,8 +50,12 @@ class TensorProductFunctor(CovariantFunctorialConstruction):
     _functor_name = "tensor"
     _functor_category = "TensorProducts"
     symbol = " # "
+    unicode_symbol = " ⨂ "
+
 
 tensor = TensorProductFunctor()
+
+
 """
 The tensor product functorial construction
 
@@ -61,6 +67,7 @@ class TensorProductFunctor(CovariantFunctorialConstruction):
     The tensor functorial construction
 """
 
+
 class TensorProductsCategory(CovariantConstructionCategory):
     r"""
     An abstract base class for all TensorProducts's categories
@@ -102,4 +109,3 @@ def base(self):
             Integer Ring
         """
         return self.base_category().base()
-

src/sage/combinat/free_module.py

@@ -351,7 +351,7 @@ def element_class(self):
             'sage.combinat.free_module'
         """
         return self.__make_element_class__(self.Element,
-                                           name="%s.element_class"%self.__class__.__name__,
+                                           name="%s.element_class" % self.__class__.__name__,
                                            module=self.__class__.__module__,
                                            inherit=True)
 
@@ -669,7 +669,7 @@ def _element_constructor_(self, x):
             if x == 0:
                 return self.zero()
             else:
-                raise TypeError("do not know how to make x (= %s) an element of %s"%(x, self))
+                raise TypeError("do not know how to make x (= %s) an element of %s" % (x, self))
         #x is an element of the basis enumerated set;
         # This is a very ugly way of testing this
         elif ((hasattr(self._indices, 'element_class') and
@@ -685,7 +685,7 @@ def _element_constructor_(self, x):
                     return self._coerce_end(x)
                 except TypeError:
                     pass
-            raise TypeError("do not know how to make x (= %s) an element of self (=%s)"%(x,self))
+            raise TypeError("do not know how to make x (= %s) an element of self (=%s)" % (x, self))
 
     def _convert_map_from_(self, S):
         """
@@ -1297,21 +1297,20 @@ def __classcall_private__(cls, modules, **options):
                 options['category'] = options['category'].FiniteDimensional()
             return super(CombinatorialFreeModule.Tensor, cls).__classcall__(cls, modules, **options)
 
-
         def __init__(self, modules, **options):
             """
             TESTS::
 
                 sage: F = CombinatorialFreeModule(ZZ, [1,2]); F
                 F
             """
-            from sage.categories.tensor import tensor
             self._sets = modules
             indices = CartesianProduct_iters(*[module.basis().keys()
                                                for module in modules]).map(tuple)
             CombinatorialFreeModule.__init__(self, modules[0].base_ring(), indices, **options)
             # the following is not the best option, but it's better than nothing.
-            self._print_options['tensor_symbol'] = options.get('tensor_symbol', tensor.symbol)
+            if 'tensor_symbol' in options:
+                self._print_options['tensor_symbol'] = options['tensor_symbol']
 
         def _repr_(self):
             r"""
@@ -1381,7 +1380,7 @@ def _unicode_art_(self, term):
                 sage: R = NonCommutativeSymmetricFunctions(QQ).R()
                 sage: Partitions.options(diagram_str="#", convention="french")
                 sage: s = unicode_art(tensor((R[1,2], R[3,1,2]))); s
-                R    # R
+                R    ⨂ R
                  ┌┐     ┌┬┬┐
                  ├┼┐    └┴┼┤
                  └┴┘      ├┼┐
@@ -1395,9 +1394,9 @@ def _unicode_art_(self, term):
             if hasattr(self, "_print_options"):
                 symb = self._print_options['tensor_symbol']
                 if symb is None:
-                    symb = tensor.symbol
+                    symb = tensor.unicode_symbol
             else:
-                symb = tensor.symbol
+                symb = tensor.unicode_symbol
             return unicode_art(*(module._unicode_art_term(t)
                                  for module, t in zip(self._sets, term)),
                                sep=UnicodeArt([symb], breakpoints=[len(symb)]))
@@ -1495,10 +1494,11 @@ def tensor_constructor(self, modules):
             # a list l such that l[i] is True if modules[i] is readily a tensor product
             is_tensor = [isinstance(module, CombinatorialFreeModule_Tensor) for module in modules]
             # the tensor_constructor, on basis elements
-            result = self.monomial * CartesianProductWithFlattening(is_tensor) #.
+            result = self.monomial * CartesianProductWithFlattening(is_tensor)
             # TODO: make this into an element of Hom( A x B, C ) when those will exist
-            for i in range(0, len(modules)):
-                result = modules[i]._module_morphism(result, position = i, codomain = self)
+            for i in range(len(modules)):
+                result = modules[i]._module_morphism(result, position=i,
+                                                     codomain=self)
             return result
 
         def _tensor_of_elements(self, elements):
@@ -1593,6 +1593,7 @@ def _coerce_map_from_(self, R):
 
             return super(CombinatorialFreeModule_Tensor, self)._coerce_map_from_(R)
 
+
 class CartesianProductWithFlattening(object):
     """
     A class for Cartesian product constructor, with partial flattening
@@ -1754,7 +1755,7 @@ def cartesian_embedding(self, i):
         """
         assert i in self._sets_keys()
         return self._sets[i]._module_morphism(lambda t: self.monomial((i, t)),
-                                              codomain = self)
+                                              codomain=self)
 
     summand_embedding = cartesian_embedding
 
@@ -1785,7 +1786,7 @@ def cartesian_projection(self, i):
         """
         assert i in self._sets_keys()
         module = self._sets[i]
-        return self._module_morphism(lambda j_t: module.monomial(j_t[1]) if i == j_t[0] else module.zero(), codomain = module)
+        return self._module_morphism(lambda j_t: module.monomial(j_t[1]) if i == j_t[0] else module.zero(), codomain=module)
 
     summand_projection = cartesian_projection
 
@@ -1831,4 +1832,5 @@ def cartesian_factors(self):
     class Element(CombinatorialFreeModule.Element): # TODO: get rid of this inheritance
         pass
 
+
 CombinatorialFreeModule.CartesianProduct = CombinatorialFreeModule_CartesianProduct

src/sage/structure/indexed_generators.py

@@ -73,12 +73,13 @@ class IndexedGenerators(object):
 
     - ``tensor_symbol`` -- string or ``None`` (default: ``None``),
       string to use for tensor product in the print representation. If
-      ``None``, use  ``sage.categories.tensor.symbol``.
+      ``None``, use  ``sage.categories.tensor.symbol`` and
+      ``sage.categories.tensor.unicode_symbol``.
 
     - ``sorting_key`` -- a key function (default: ``lambda x: x``),
       to use for sorting elements in the output of elements
 
-    - ``sorting_reverse`` -- bool (default: ``False``), if ``True`` 
+    - ``sorting_reverse`` -- bool (default: ``False``), if ``True``
       sort elements in reverse order in the output of elements
 
     - ``string_quotes`` -- bool (default: ``True``), if ``True`` then