gh-36853: various details in algebras (ruff mostly)
    
some details suggested by `ruff` about list and set comprehensions, also
about unicode

### 📝 Checklist

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
    
URL: #36853
Reported by: Frédéric Chapoton
Reviewer(s): Matthias Köppe

Author: Release Manager

src/sage/algebras/clifford_algebra.py

@@ -2783,15 +2783,15 @@ def __richcmp__(self, other, op):
         elif op == op_GT:
             return other.__richcmp__(self, op_LT)
 
-        s_gens = set(g for g in self.gens() if g)
-        o_gens = set(g for g in other.gens() if g)
+        s_gens = {g for g in self.gens() if g}
+        o_gens = {g for g in other.gens() if g}
 
         if self.side() != other.side():
             if other.side() == "right":
-                X = set(t * f for t in self.ring().basis() for f in s_gens)
+                X = {t * f for t in self.ring().basis() for f in s_gens}
                 s_gens.update(X)
             elif other.side() == "left":
-                X = set(f * t for t in self.ring().basis() for f in s_gens)
+                X = {f * t for t in self.ring().basis() for f in s_gens}
                 s_gens.update(X)
 
         if set(s_gens) == set(o_gens):
@@ -2805,10 +2805,10 @@ def __richcmp__(self, other, op):
 
         if self.side() != other.side():
             if self.side() == "right":
-                X = set(t * f for t in self.ring().basis() for f in o_gens)
+                X = {t * f for t in self.ring().basis() for f in o_gens}
                 s_gens.update(X)
             elif self.side() == "left":
-                X = set(f * t for t in self.ring().basis() for f in o_gens)
+                X = {f * t for t in self.ring().basis() for f in o_gens}
                 s_gens.update(X)
 
         contains = all(f in self for f in o_gens)

src/sage/algebras/cluster_algebra.py

@@ -1666,8 +1666,8 @@ def clear_computed_data(self):
             [(0, 1), (1, 0)]
         """
         I = identity_matrix(self._n)
-        self._path_dict = dict((v, []) for v in map(tuple, I.columns()))
-        self._F_poly_dict = dict((v, self._U(1)) for v in self._path_dict)
+        self._path_dict = {v: [] for v in map(tuple, I.columns())}
+        self._F_poly_dict = {v: self._U(1) for v in self._path_dict}
         self.reset_current_seed()
         self.reset_exploring_iterator()
 

src/sage/algebras/free_algebra.py

@@ -300,7 +300,7 @@ def create_key(self, base_ring, arg1=None, arg2=None,
             if order is None:
                 order = 'degrevlex' if degrees is None else 'deglex'
             args = [arg for arg in (arg1, arg2) if arg is not None]
-            kwds = dict(sparse=sparse, order=order, implementation="singular")
+            kwds = {'sparse': sparse, 'order': order, 'implementation': "singular"}
             if name is not None:
                 kwds["name"] = name
             if names is not None:

src/sage/algebras/fusion_rings/f_matrix.py

@@ -580,8 +580,8 @@ def findcases(self, output=False):
         """
         i = 0
         if output:
-            idx_map = dict()
-            ret = dict()
+            idx_map = {}
+            ret = {}
         id_anyon = self._FR.one()
         for (a, b, c, d) in product(self._FR.basis(), repeat=4):
             if a == id_anyon or b == id_anyon or c == id_anyon:
@@ -1053,7 +1053,7 @@ def load_fvars(self, filename):
             self._fvars, self._non_cyc_roots, self._coerce_map_from_cyc_field, self._qqbar_embedding = pickle.load(f)
         # Update state attributes
         self._chkpt_status = 7
-        self._solved = list(True for v in self._fvars)
+        self._solved = [True for v in self._fvars]
         self._field = self._qqbar_embedding.domain()
 
     def get_fr_str(self):
@@ -1675,9 +1675,9 @@ def equations_graph(self, eqns=None):
         for eq in eqns:
             # Eqns could be a list of poly objects or poly tuples stored in internal repn
             if isinstance(eq, tuple):
-                s = [v for v in variables(eq)]
+                s = list(variables(eq))
             else:
-                s = [v for v in eq.variables()]
+                s = list(eq.variables())
             for x in s:
                 for y in s:
                     if y != x:
@@ -1765,8 +1765,8 @@ def _par_graph_gb(self, eqns=None, term_order="degrevlex", largest_comp=45, verb
         """
         if eqns is None:
             eqns = self.ideal_basis
-        small_comps = list()
-        temp_eqns = list()
+        small_comps = []
+        temp_eqns = []
         for comp, comp_eqns in self._partition_eqns(eqns=eqns, verbose=verbose).items():
             # Check if component is too large to process
             if len(comp) > largest_comp:
@@ -1924,8 +1924,8 @@ def _get_explicit_solution(self, eqns=None, verbose=True):
 
         F = self._field
         R = F['x']
-        numeric_fvars = dict()
-        non_cyclotomic_roots = list()
+        numeric_fvars = {}
+        non_cyclotomic_roots = []
         must_change_base_field = False
         phi = F.hom([F.gen()], F)
         for comp, part in eqns_partition.items():
@@ -2270,7 +2270,7 @@ def _update_equations(self):
             {fx3}
         """
         special_values = {known: self._fvars[self._var_to_sextuple[known]] for known in self._solved if known}
-        self.ideal_basis = set(eq.subs(special_values) for eq in self.ideal_basis)
+        self.ideal_basis = {eq.subs(special_values) for eq in self.ideal_basis}
         self.ideal_basis.discard(0)
 
     def find_cyclotomic_solution(self, equations=None, algorithm="", verbose=True, output=False):

src/sage/algebras/fusion_rings/fusion_double.py

@@ -187,7 +187,7 @@ def __init__(self, G, prefix="s"):
         self._fusion_labels = None
         self._field = None
         cat = AlgebrasWithBasis(ZZ)
-        CombinatorialFreeModule.__init__(self, ZZ, [k for k in self._names],
+        CombinatorialFreeModule.__init__(self, ZZ, list(self._names),
                                          prefix=prefix, bracket=False, category=cat)
 
     def _repr_(self):
@@ -433,7 +433,7 @@ def Nk_ij(self, i, j, k, use_characters=False):
         G = self._G
         I = G.conjugacy_class(i.g())
         J = G.conjugacy_class(j.g())
-        IJ = set(I_elem * J_elem for I_elem in I for J_elem in J)
+        IJ = {I_elem * J_elem for I_elem in I for J_elem in J}
         if k.g() not in IJ:
             return ZZ.zero()
 

src/sage/algebras/fusion_rings/fusion_ring.py

@@ -1175,13 +1175,13 @@ def _get_trees(fr, top_row, root):
                 return [[]] if fr.Nk_ij(m1, m2, root) else []
             else:
                 m1, m2 = top_row[:2]
-                return [tuple([l, *b]) for l in fr.basis() for b in _get_trees(fr, [l]+top_row[2:], root) if fr.Nk_ij(m1, m2, l)]
+                return [(l, *b) for l in fr.basis() for b in _get_trees(fr, [l]+top_row[2:], root) if fr.Nk_ij(m1, m2, l)]
 
-        comp_basis = list()
+        comp_basis = []
         for top in product((a*a).monomials(), repeat=n_strands//2):
             # If the n_strands is odd, we must extend the top row by a fusing anyon
             top_row = list(top)+[a]*(n_strands % 2)
-            comp_basis.extend(tuple([*top, *levels]) for levels in _get_trees(self, top_row, b))
+            comp_basis.extend((*top, *levels) for levels in _get_trees(self, top_row, b))
         return comp_basis
 
     def get_fmatrix(self, *args, **kwargs):
@@ -1248,7 +1248,7 @@ def _emap(self, mapper, input_args, worker_pool=None):
         no_mp = worker_pool is None
         # Map phase
         input_iter = zip_longest([], input_iter, fillvalue=(mapper, id(self)))
-        results = list()
+        results = []
         if no_mp:
             mapped = map(executor, input_iter)
         else:

src/sage/algebras/hecke_algebras/cubic_hecke_algebra.py

@@ -2405,7 +2405,7 @@ def _reduce_gen_power(self, k):
             result = result_ele.to_vector()
 
         elif abs(k) == 1:
-            result_ele = self._tietze_to_finite_sub_basis_monomial(tuple([k]))
+            result_ele = self._tietze_to_finite_sub_basis_monomial((k,))
             result = result_ele.to_vector()
 
         else:
@@ -2874,7 +2874,7 @@ def garside_involution(self, element):
             True
         """
         braid_group = self.braid_group()
-        reverse_gens = [g for g in braid_group.gens()]
+        reverse_gens = list(braid_group.gens())
         reverse_gens.reverse()
         brgrp_garside_involution = braid_group.hom(reverse_gens, check=False)
         return self._extend_braid_automorphism(element, brgrp_garside_involution)
@@ -3446,7 +3446,7 @@ def schur_elements(self, generic=False):
         GER = self.extension_ring(generic=True)
         generic_result = [GER(s) for s in gap3_result]
         if generic:
-            return [s for s in generic_result]
+            return list(generic_result)
         else:
             ER = self.extension_ring()
             return [ER(s) for s in generic_result]

src/sage/algebras/hecke_algebras/cubic_hecke_matrix_rep.py

@@ -968,7 +968,7 @@ def _image_on_basis(self, basis_element):
                 for gen_ind in ele_Tietze:
                     gen_matrix_list = self._image_on_gen(gen_ind)
                     if matrix_list is None:
-                        matrix_list = [m for m in gen_matrix_list]
+                        matrix_list = list(gen_matrix_list)
                     else:
                         for i in range(len(matrix_list)):
                             matrix_list[i] *= gen_matrix_list[i]

src/sage/algebras/lie_algebras/affine_lie_algebra.py

@@ -789,12 +789,12 @@ def build_root(O):
         for r in list(self._root_mapping.keys()):
             self._root_mapping[-r] = [-s for s in self._root_mapping[r]]
         if self._cartan_type.type() == 'BC':
-            assert set(r for r in self._root_mapping if len(self._root_mapping[r]) > 1) == set(Q.roots())
+            assert {r for r in self._root_mapping if len(self._root_mapping[r]) > 1} == set(Q.roots())
             if self._cartan_type.rank() == 2:
                 # Special case since sl_2 has only 1 root length
-                assert set(r / 2 for r in self._root_mapping if len(self._root_mapping[r]) == 1) == set(Q.roots())
+                assert {r / 2 for r in self._root_mapping if len(self._root_mapping[r]) == 1} == set(Q.roots())
             else:
-                assert set(r / 2 for r in self._root_mapping if len(self._root_mapping[r]) == 1) == set(Q.short_roots())
+                assert {r / 2 for r in self._root_mapping if len(self._root_mapping[r]) == 1} == set(Q.short_roots())
             from sage.combinat.free_module import CombinatorialFreeModule
             X = sorted(self._root_mapping, key=str)
             self._g1 = CombinatorialFreeModule(R, X, prefix='E')
@@ -845,7 +845,7 @@ def _test_classical_subalgebra(self, **options):
             if r + s in roots:
                 tester.assertEqual(list(ret.support()), [(r+s, 0)], f"obtained [{r}, {s}] == {ret}")
             elif r == -s:
-                supp = set((ac, 0) for ac in r.associated_coroot().monomials())
+                supp = {(ac, 0) for ac in r.associated_coroot().monomials()}
                 tester.assertEqual(set(ret.support()), supp, f"obtained [{r}, {s}] == {ret}")
             else:
                 tester.assertEqual(ret, self.zero(), f"nonzero for [{r}, {s}]")

src/sage/algebras/lie_algebras/classical_lie_algebra.py

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """
 Classical Lie Algebras