fix E251 in combinat/sf

src/sage/combinat/crystals/letters.pyx

@@ -104,7 +104,7 @@ def CrystalOfLetters(cartan_type, element_print_style=None, dual=None):
         else:
             return ClassicalCrystalOfLetters(ct,
                                              Crystal_of_letters_type_E6_element_dual,
-                                             element_print_style, dual = True)
+                                             element_print_style, dual=True)
     elif ct.letter == 'E' and ct.rank() == 7:
         return ClassicalCrystalOfLetters(ct, Crystal_of_letters_type_E7_element)
     elif ct.letter == 'E' and ct.rank() == 8 or ct.letter == 'F':
@@ -116,6 +116,7 @@ def CrystalOfLetters(cartan_type, element_print_style=None, dual=None):
     else:
         raise NotImplementedError
 
+
 class ClassicalCrystalOfLetters(UniqueRepresentation, Parent):
     r"""
     A generic class for classical crystals of letters.
@@ -136,7 +137,8 @@ class ClassicalCrystalOfLetters(UniqueRepresentation, Parent):
     time: ``list``, ``cmp``, (todo: ``phi``, ``epsilon``, ``e``, and
     ``f`` with caching)
     """
-    def __init__(self, cartan_type, element_class, element_print_style = None, dual = None):
+    def __init__(self, cartan_type, element_class,
+                 element_print_style=None, dual=None):
         """
         EXAMPLES::
 
@@ -146,7 +148,7 @@ class ClassicalCrystalOfLetters(UniqueRepresentation, Parent):
             sage: TestSuite(C).run()
         """
         self.Element = element_class
-        Parent.__init__(self, category = ClassicalCrystals())
+        Parent.__init__(self, category=ClassicalCrystals())
         self._cartan_type = CartanType(cartan_type)
         self.rename("The crystal of letters for type %s" % self._cartan_type)
         if cartan_type.type() == 'E':

src/sage/combinat/sf/dual.py

@@ -148,15 +148,14 @@ def __init__(self, dual_basis, scalar, scalar_name="", basis_name=None, prefix=N
             prefix = 'd_'+dual_basis.prefix()
 
         classical.SymmetricFunctionAlgebra_classical.__init__(self, self._sym,
-                                                              basis_name = basis_name,
-                                                              prefix = prefix)
+                                                              basis_name=basis_name,
+                                                              prefix=prefix)
 
         # temporary until Hom(GradedHopfAlgebrasWithBasis work better)
         category = sage.categories.all.ModulesWithBasis(self.base_ring())
-        self            .register_coercion(SetMorphism(Hom(self._dual_basis, self, category), self._dual_to_self))
+        self.register_coercion(SetMorphism(Hom(self._dual_basis, self, category), self._dual_to_self))
         self._dual_basis.register_coercion(SetMorphism(Hom(self, self._dual_basis, category), self._self_to_dual))
 
-
     def _dual_to_self(self, x):
         """
         Coerce an element of the dual of ``self`` canonically into ``self``.
@@ -193,7 +192,7 @@ def _dual_to_self(self, x):
             sage: h(m([2,1]) + 3*m[1,1,1])
             d_m[1, 1, 1] - d_m[2, 1]
         """
-        return self._element_class(self, dual = x)
+        return self._element_class(self, dual=x)
 
     def _self_to_dual(self, x):
         """

src/sage/combinat/sf/elementary.py

@@ -67,7 +67,7 @@ def _dual_basis_default(self):
             sage: e._dual_basis_default() is e.dual_basis()
             True
         """
-        return self.dual_basis(scalar = None, prefix="f", basis_name = "forgotten")
+        return self.dual_basis(scalar=None, prefix="f", basis_name="forgotten")
 
     def coproduct_on_generators(self, i):
         r"""

src/sage/combinat/sf/hall_littlewood.py

@@ -73,7 +73,7 @@ def __repr__(self):
         """
         return self._name + " over %s" % self._sym.base_ring()
 
-    def __init__(self, Sym, t = 't'):
+    def __init__(self, Sym, t='t'):
         """
         Initialize ``self``.
 
@@ -365,8 +365,8 @@ def __init__(self, hall_littlewood):
         s = self.__class__.__name__[15:].capitalize()
         sfa.SymmetricFunctionAlgebra_generic.__init__(
             self, hall_littlewood._sym,
-            basis_name = "Hall-Littlewood " + s + hall_littlewood._name_suffix,
-            prefix = "HL"+s)
+            basis_name="Hall-Littlewood " + s + hall_littlewood._name_suffix,
+            prefix="HL" +s)
         self.t = hall_littlewood.t
         self._sym = hall_littlewood._sym
         self._hall_littlewood = hall_littlewood
@@ -407,7 +407,8 @@ def _s_to_self(self, x):
             sage: P(s[2,1])
             6*HLP[1, 1, 1] + HLP[2, 1]
         """
-        return self._from_cache(x, self._s_cache, self._s_to_self_cache, t = self.t)
+        return self._from_cache(x, self._s_cache, self._s_to_self_cache,
+                                t=self.t)
 
     def _self_to_s(self, x):
         r"""
@@ -435,7 +436,8 @@ def _self_to_s(self, x):
             sage: s(P[2,1])
             -6*s[1, 1, 1] + s[2, 1]
         """
-        return self._s._from_cache(x, self._s_cache, self._self_to_s_cache, t = self.t)
+        return self._s._from_cache(x, self._s_cache, self._self_to_s_cache,
+                                   t=self.t)
 
     def transition_matrix(self, basis, n):
         r"""
@@ -545,7 +547,7 @@ class Element(sfa.SymmetricFunctionAlgebra_generic.Element):
         Methods for elements of a Hall-Littlewood basis that are common to all bases.
         """
 
-        def expand(self, n, alphabet = 'x'):
+        def expand(self, n, alphabet='x'):
             r"""
             Expands the symmetric function as a symmetric polynomial in ``n`` variables.
 
@@ -577,7 +579,7 @@ def expand(self, n, alphabet = 'x'):
                 x^2
             """
             s = self.parent().realization_of().schur()
-            return s(self).expand(n, alphabet = alphabet)
+            return s(self).expand(n, alphabet=alphabet)
 
         def scalar(self, x, zee=None):
             r"""
@@ -618,7 +620,7 @@ def scalar(self, x, zee=None):
             s_x = s(x)
             return s_self.scalar(s_x, zee)
 
-        def scalar_hl(self, x, t = None):
+        def scalar_hl(self, x, t=None):
             r"""
             Returns the Hall-Littlewood (with parameter ``t``) scalar product
             of ``self`` and ``x``.
@@ -661,8 +663,9 @@ def scalar_hl(self, x, t = None):
             if t is None:
                 t = parent.t
             p = parent.realization_of().power()
-            f = lambda part1, part2: part1.centralizer_size(t = t)
-            return parent._apply_multi_module_morphism(p(self),p(x),f,orthogonal=True)
+            f = lambda part1, part2: part1.centralizer_size(t=t)
+            return parent._apply_multi_module_morphism(p(self), p(x), f,
+                                                       orthogonal=True)
 
 
 ###########
@@ -794,12 +797,11 @@ def _s_cache(self, n):
             sage: l(HLP._s_to_self_cache[2])
             [([1, 1], [([1, 1], 1)]), ([2], [([1, 1], t), ([2], 1)])]
         """
-        self._invert_morphism(n, QQt, self._self_to_s_cache, \
-                              self._s_to_self_cache, to_self_function = self._s_to_self_base, \
+        self._invert_morphism(n, QQt, self._self_to_s_cache,
+                              self._s_to_self_cache, to_self_function=self._s_to_self_base,
                               upper_triangular=True, ones_on_diagonal=True)
 
 
-
 ###########
 # Q basis #
 ###########
@@ -844,9 +846,10 @@ def __init__(self, hall_littlewood):
         # temporary until Hom(GradedHopfAlgebrasWithBasis work better)
         category = sage.categories.all.ModulesWithBasis(self.base_ring())
 
-        phi = self.module_morphism(diagonal = self._P._q_to_p_normalization, codomain = self._P, category = category)
+        phi = self.module_morphism(diagonal=self._P._q_to_p_normalization,
+                                   codomain=self._P, category=category)
         self._P.register_coercion(phi)
-        self   .register_coercion(~phi)
+        self.register_coercion(~phi)
 
     def _p_to_q_normalization(self, m):
         r"""
@@ -996,10 +999,12 @@ def _s_cache(self, n):
             sage: l(HLQp._self_to_s_cache[2])
             [([1, 1], [([1, 1], 1), ([2], t)]), ([2], [([2], 1)])]
         """
-        self._invert_morphism(n, QQt, self._self_to_s_cache, \
-                              self._s_to_self_cache, to_other_function = self._to_s, \
+        self._invert_morphism(n, QQt, self._self_to_s_cache,
+                              self._s_to_self_cache,
+                              to_other_function=self._to_s,
                               lower_triangular=True, ones_on_diagonal=True)
 
+
 # Unpickling backward compatibility
 sage.misc.persist.register_unpickle_override('sage.combinat.sf.hall_littlewood', 'HallLittlewoodElement_p', HallLittlewood_p.Element)
 sage.misc.persist.register_unpickle_override('sage.combinat.sf.hall_littlewood', 'HallLittlewoodElement_q', HallLittlewood_q.Element)

src/sage/combinat/sf/jack.py

@@ -503,8 +503,8 @@ def __init__(self, jack):
         s = self.__class__.__name__[16:].capitalize()
         sfa.SymmetricFunctionAlgebra_generic.__init__(
             self, jack._sym,
-            basis_name = "Jack " + s + jack._name_suffix,
-            prefix = "Jack"+s)
+            basis_name="Jack " + s + jack._name_suffix,
+            prefix="Jack" + s)
         self.t = jack.t
         self._sym = jack._sym
         self._jack = jack
@@ -550,7 +550,8 @@ def _m_to_self(self, x):
             sage: JP(m[2,1])
             -3/2*JackP[1, 1, 1] + JackP[2, 1]
         """
-        return self._from_cache(x, self._m_cache, self._m_to_self_cache, t = self.t)
+        return self._from_cache(x, self._m_cache, self._m_to_self_cache,
+                                t=self.t)
 
     def _self_to_m(self, x):
         r"""
@@ -578,7 +579,8 @@ def _self_to_m(self, x):
             sage: m(JP[2,1])
             3/2*m[1, 1, 1] + m[2, 1]
         """
-        return self._m._from_cache(x, self._m_cache, self._self_to_m_cache, t = self.t)
+        return self._m._from_cache(x, self._m_cache, self._self_to_m_cache,
+                                   t=self.t)
 
     def c1(self, part):
         r"""
@@ -897,15 +899,14 @@ def _m_cache(self, n):
         """
         if n in self._self_to_m_cache:
             return
-        else:
-            self._self_to_m_cache[n] = {}
+        self._self_to_m_cache[n] = {}
         t = QQt.gen()
         monomial = sage.combinat.sf.sf.SymmetricFunctions(QQt).monomial()
         JP = sage.combinat.sf.sf.SymmetricFunctions(QQt).jack().P()
-        JP._gram_schmidt(n, monomial, lambda p: part_scalar_jack(p,p,t), \
-                           self._self_to_m_cache[n], upper_triangular=True)
-        JP._invert_morphism(n, QQt, self._self_to_m_cache, \
-                              self._m_to_self_cache, to_other_function = self._to_m)
+        JP._gram_schmidt(n, monomial, lambda p: part_scalar_jack(p, p, t),
+                         self._self_to_m_cache[n], upper_triangular=True)
+        JP._invert_morphism(n, QQt, self._self_to_m_cache,
+                            self._m_to_self_cache, to_other_function=self._to_m)
 
     def _to_m(self, part):
         r"""
@@ -1071,7 +1072,8 @@ def __init__(self, jack):
         self._P = self._jack.P()
         # temporary until Hom(GradedHopfAlgebrasWithBasis) works better
         category = sage.categories.all.ModulesWithBasis(self.base_ring())
-        phi = self.module_morphism(diagonal = self.c1, codomain = self._P, category = category)
+        phi = self.module_morphism(diagonal=self.c1,
+                                   codomain=self._P, category=category)
         # should use module_morphism(on_coeffs = ...) once it exists
         self._P.register_coercion(self._P._normalize_morphism(category) * phi)
         self   .register_coercion(self   ._normalize_morphism(category) *~phi)
@@ -1107,15 +1109,19 @@ def __init__(self, jack):
         self._P = self._jack.P()
         # temporary until Hom(GradedHopfAlgebrasWithBasis) works better
         category = sage.categories.all.ModulesWithBasis(self.base_ring())
-        phi = self._P.module_morphism(diagonal = self._P.scalar_jack_basis, codomain = self, category = category)
-        self   .register_coercion(self   ._normalize_morphism(category) *  phi)
+        phi = self._P.module_morphism(diagonal=self._P.scalar_jack_basis,
+                                      codomain=self, category=category)
+        self.register_coercion(self._normalize_morphism(category) * phi)
         self._P.register_coercion(self._P._normalize_morphism(category) * ~phi)
 
     class Element(JackPolynomials_generic.Element):
         pass
 
+
 qp_to_h_cache = {}
 h_to_qp_cache = {}
+
+
 class JackPolynomials_qp(JackPolynomials_generic):
     def __init__(self, jack):
         r"""
@@ -1247,9 +1253,10 @@ def _self_to_h( self, x ):
             sage: h(JQp[2,1])
             h[2, 1] - 3/5*h[3]
         """
-        return self._h._from_cache(x, self._h_cache, self._self_to_h_cache, t = self.t)
+        return self._h._from_cache(x, self._h_cache, self._self_to_h_cache,
+                                   t=self.t)
 
-    def _h_to_self( self, x ):
+    def _h_to_self(self, x):
         r"""
         Isomorphism from the homogeneous basis into ``self``
 
@@ -1275,9 +1282,10 @@ def _h_to_self( self, x ):
             sage: JQp(h[2,1])
             JackQp[2, 1] + 3/5*JackQp[3]
         """
-        return self._from_cache(x, self._h_cache, self._h_to_self_cache, t = self.t)
+        return self._from_cache(x, self._h_cache, self._h_to_self_cache,
+                                t=self.t)
 
-    def coproduct_by_coercion( self, elt ):
+    def coproduct_by_coercion(self, elt):
         r"""
         Returns the coproduct of the element ``elt`` by coercion to the Schur basis.
 

src/sage/combinat/sf/k_dual.py

@@ -131,7 +131,7 @@ def __init__(self, Sym, k, t='t'):
             self._quotient_basis = Sym.m()
         else:
             self._quotient_basis = Sym.hall_littlewood(t=self.t).P()
-        Parent.__init__(self, category = GradedHopfAlgebras(R).Quotients().WithRealizations())
+        Parent.__init__(self, category=GradedHopfAlgebras(R).Quotients().WithRealizations())
         self.indices = ConstantFunction(Partitions_all_bounded(k))
 
     def ambient(self):
@@ -282,11 +282,11 @@ def _G_to_km_on_basis_single_level(self, w, m):
         if m < w.length():
             return 0
         ans = self.zero()
-        for la in Partitions(m, max_part = self.k):
-            ans += g.homogeneous_basis_noncommutative_variables_zero_Hecke((la)).coefficient(w)*mon(la)
+        for la in Partitions(m, max_part=self.k):
+            ans += g.homogeneous_basis_noncommutative_variables_zero_Hecke((la)).coefficient(w) * mon(la)
         return ans
 
-    def _AffineGrothendieck(self, w,m):
+    def _AffineGrothendieck(self, w, m):
         r"""
         Returns the affine Grothendieck polynomial indexed by the affine permutation
         ``w``.  Because this belongs to the completion of the algebra, and hence is an

src/sage/combinat/sf/llt.py

@@ -432,8 +432,8 @@ def __init__(self, llt, prefix):
         s = self.__class__.__name__[4:]
         sfa.SymmetricFunctionAlgebra_generic.__init__(
             self, llt._sym,
-            basis_name = "level %s LLT "%llt.level() + s + llt._name_suffix,
-            prefix = prefix)
+            basis_name="level %s LLT " % llt.level() + s + llt._name_suffix,
+            prefix=prefix)
 
         self.t = llt.t
         self._sym = llt._sym
@@ -474,7 +474,8 @@ def _m_to_self(self, x):
             sage: HSp3(m[2,1])
             -2*HSp3[1, 1, 1] + (2*t^2+2*t+1)*HSp3[2, 1] + (-2*t^2-t)*HSp3[3]
         """
-        return self._from_cache(x, self._m_cache, self._m_to_self_cache, t = self.t)
+        return self._from_cache(x, self._m_cache, self._m_to_self_cache,
+                                t=self.t)
 
     def _self_to_m(self, x):
         r"""
@@ -502,8 +503,8 @@ def _self_to_m(self, x):
             sage: m(HSp3[2,1])
             (t+2)*m[1, 1, 1] + (t+1)*m[2, 1] + t*m[3]
         """
-        return self._m._from_cache(x, self._m_cache, self._self_to_m_cache, t = self.t)
-
+        return self._m._from_cache(x, self._m_cache, self._self_to_m_cache,
+                                   t=self.t)
 
     def level(self):
         r"""
@@ -598,8 +599,9 @@ def _m_cache(self, n):
             [([1, 1], [([1, 1], 1/t), ([2], -1/t)]),
              ([2], [([1, 1], -1/t), ([2], (t + 1)/t)])]
         """
-        self._invert_morphism(n, QQt, self._self_to_m_cache, \
-                              self._m_to_self_cache, to_other_function = self._to_m)
+        self._invert_morphism(n, QQt, self._self_to_m_cache,
+                              self._m_to_self_cache,
+                              to_other_function=self._to_m)
 
     class Element(sfa.SymmetricFunctionAlgebra_generic.Element):
         pass