passagemath-combinat 10.6.1__cp312-cp312-musllinux_1_2_aarch64.whl → 10.8.1a1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/combinat/partition_tuple.py

@@ -943,7 +943,7 @@ class PartitionTuple(CombinatorialElement):
             sage: PartitionTuple([[2,1],[1],[1,1,1]]).cells()
             [(0, 0, 0), (0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 0, 0), (2, 1, 0), (2, 2, 0)]
         """
-        return [(c,a,b) for c in range(len(self)) for (a,b) in self[c].cells()]
+        return [(c, a, b) for c in range(len(self)) for a, b in self[c].cells()]
 
     def content(self, k, r, c, multicharge):
         r"""
@@ -1177,9 +1177,9 @@ class PartitionTuple(CombinatorialElement):
             - :meth:`top_garnir_tableau`
         """
         try:
-            (comp, row,col) = cell
+            comp, row, col = cell
         except ValueError:
-            (comp, row,col) = cell[0]
+            comp, row, col = cell[0]
 
         if comp >= len(self) or row+1 >= len(self[comp]) or col >= self[comp][row+1]:
             raise ValueError('(comp, row+1, col) must be inside the diagram')
@@ -1246,7 +1246,7 @@ class PartitionTuple(CombinatorialElement):
 
             - :meth:`~sage.combinat.partition.Partition_tuple.garnir_tableau`
         """
-        (comp,row,col) = cell
+        comp, row, col = cell
         if comp >= len(self) or row+1 >= len(self[comp]) or col >= self[comp][row+1]:
             raise ValueError('(comp, row+1, col) must be inside the diagram')
 
@@ -1393,7 +1393,8 @@ class PartitionTuple(CombinatorialElement):
             sage: PartitionTuple([[1,1],[4,3],[2,1,1]]).removable_cells()
             [(0, 1, 0), (1, 0, 3), (1, 1, 2), (2, 0, 1), (2, 2, 0)]
         """
-        return [(k,r,c) for k in range(len(self)) for (r,c) in self[k].removable_cells()]
+        return [(k, r, c) for k in range(len(self))
+                for r, c in self[k].removable_cells()]
 
     corners = removable_cells  # for compatibility with partitions
 
@@ -1411,7 +1412,8 @@ class PartitionTuple(CombinatorialElement):
             sage: PartitionTuple([[1,1],[4,3],[2,1,1]]).addable_cells()
             [(0, 0, 1), (0, 2, 0), (1, 0, 4), (1, 1, 3), (1, 2, 0), (2, 0, 2), (2, 1, 1), (2, 3, 0)]
         """
-        return [(k,r,c) for k in range(len(self)) for (r,c) in self[k].addable_cells()]
+        return [(k, r, c) for k in range(len(self))
+                for r, c in self[k].addable_cells()]
 
     outside_corners = addable_cells  # for compatibility with partitions
 
@@ -1537,9 +1539,9 @@ class PartitionTuple(CombinatorialElement):
             deg = sum(mu._initial_degree(e) for mu in self)
         I = IntegerModRing(e)
         multires = [I(k) for k in multicharge]
-        for (k,r,c) in self.cells():
-            res = I(multicharge[k]-r+c)
-            for l in range(k+1, self.level()):
+        for k, r, c in self.cells():
+            res = I(multicharge[k] - r + c)
+            for l in range(k + 1, self.level()):
                 if res == multires[l]:
                     deg += 1
         return deg
@@ -1696,7 +1698,7 @@ class PartitionTuple(CombinatorialElement):
         """
         block = {}
         Ie = IntegerModRing(e)
-        for (k,r,c) in self.cells():
+        for k, r, c in self.cells():
             i = Ie(multicharge[k] + c - r)
             block[i] = block.get(i, 0) + 1
         return block

sage/combinat/plane_partition.py

@@ -26,8 +26,7 @@ AUTHORS:
 # ****************************************************************************
 
 from __future__ import annotations
-from typing import NewType
-from collections.abc import Iterator
+from typing import NewType, TYPE_CHECKING
 
 from sage.structure.richcmp import richcmp, richcmp_method
 from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
@@ -45,6 +44,9 @@ from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
 from sage.sets.family import Family
 from sage.sets.non_negative_integers import NonNegativeIntegers
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 lazy_import('sage.modules.free_module_element', 'vector')
 
 
@@ -140,7 +142,7 @@ class PlanePartition(ClonableArray,
                 self._max_y = 0
                 self._max_z = 0
         else:
-            (self._max_x, self._max_y, self._max_z) = self.parent()._box
+            self._max_x, self._max_y, self._max_z = self.parent()._box
 
     def __richcmp__(self, other, op):
         r"""
@@ -913,9 +915,7 @@ class PlanePartition(ClonableArray,
             sage: PlanePartition([]).is_CSPP()
             True
         """
-        if self.z_tableau() == self.y_tableau():
-            return True
-        return False
+        return self.z_tableau() == self.y_tableau()
 
     def is_TSPP(self) -> bool:
         r"""
@@ -1101,17 +1101,14 @@ class PlanePartition(ClonableArray,
             [(0, 0, 0), (0, 0, 1), (0, 1, 0), (1, 0, 0), (2, 0, 0)]
         """
         from sage.combinat.posets.poset_examples import posets
-        (a, b, c) = (self._max_x, self._max_y, self._max_z)
-        Q = posets.ProductOfChains([a, b, c])
-        count = 0
+        abc = [self._max_x, self._max_y, self._max_z]
+        Q = posets.ProductOfChains(abc)
         generate = []
         for i, row in enumerate(self):
             for j, val in enumerate(row):
                 if val > 0:
-                    generate.append((i, j, val-1))
-            count += 1
-        oi = Q.order_ideal(generate)
-        return oi
+                    generate.append((i, j, val - 1))
+        return Q.order_ideal(generate)
 
     def maximal_boxes(self) -> list:
         r"""

sage/combinat/positive_integer_semigroup_test.py

@@ -0,0 +1,17 @@
+# sage_setup: distribution = sagemath-combinat
+import pytest
+
+
+def test_positive_integer_semigroup():
+    r"""
+    Run the ``TestSuite()`` for ``PositiveIntegerSemigroup``
+    (this can take quite a long time).
+    """
+    from sage.misc.sage_unittest import TestSuite
+    from sage.combinat.backtrack import PositiveIntegerSemigroup
+    PP = PositiveIntegerSemigroup()
+
+    # fewer max_runs since these are kind of slow
+    TestSuite(PP).run(verbose=True,
+                      raise_on_failure=True,
+                      max_runs=256)

sage/combinat/quickref.py

@@ -30,7 +30,7 @@ Combinatorial objects::
 
 Constructions and Species::
 
-    sage: for (p, s) in cartesian_product([P,S]): print((p, s)) # not tested
+    sage: for ps in cartesian_product([P,S]): print(ps) # not tested
     sage: def IV_3(n):
     ....:     return IntegerVectors(n, 3)
     sage: DisjointUnionEnumeratedSets(Family(IV_3, NonNegativeIntegers))  # not tested
@@ -49,7 +49,7 @@ Polytopes::
 
     sage: points = random_matrix(ZZ, 6, 3, x=7).rows()                                  # needs sage.modules
     sage: L = LatticePolytope(points)                                                   # needs sage.geometry.polyhedron sage.modules
-    sage: L.npoints(); L.plot3d()                           # random                    # needs palp sage.geometry.polyhedron sage.modules sage.plot
+    sage: L.n_points(); L.plot3d()                           # random                   # needs palp sage.geometry.polyhedron sage.modules sage.plot
 
 :ref:`Root systems, Coxeter and Weyl groups <sage.combinat.root_system.all>`::
 

sage/combinat/recognizable_series.py

@@ -1843,8 +1843,8 @@ class RecognizableSeriesSpace(UniqueRepresentation, Parent):
         z = self.coefficient_ring().zero()
         o = self.coefficient_ring().one()
         e = self.coefficient_ring().an_element()
-        return self(list(Matrix([[o, z], [i * o, o]])
-                         for i, _ in enumerate(self.alphabet())),
+        return self([Matrix([[o, z], [i * o, o]])
+                     for i, _ in enumerate(self.alphabet())],
                     vector([z, e]), right=vector([e, z]))
 
     def some_elements(self, **kwds):

sage/combinat/regular_sequence.py

@@ -333,7 +333,7 @@ class RegularSequence(RecognizableSeries):
         return iter(self[n] for n in count())
 
     @cached_method
-    def is_degenerated(self):
+    def is_degenerated(self) -> bool:
         r"""
         Return whether this `k`-regular sequence is degenerated,
         i.e., whether this `k`-regular sequence does not satisfy
@@ -364,7 +364,7 @@ class RegularSequence(RecognizableSeries):
             False
         """
         from sage.rings.integer_ring import ZZ
-        return (self.mu[ZZ(0)] * self.right) != self.right
+        return (self.mu[ZZ.zero()] * self.right) != self.right
 
     def _error_if_degenerated_(self):
         r"""
@@ -1101,10 +1101,10 @@ class RegularSequence(RecognizableSeries):
             Z = zero_matrix(C[0].dimensions()[0])
 
             def blocks(r):
-                upper = list([C[s], D[s], Z]
-                             for s in reversed(srange(max(0, r-2), r+1)))
-                lower = list([Z, C[s], D[s]]
-                             for s in reversed(srange(k-3+len(upper), k)))
+                upper = [[C[s], D[s], Z]
+                         for s in reversed(srange(max(0, r-2), r+1))]
+                lower = [[Z, C[s], D[s]]
+                         for s in reversed(srange(k-3+len(upper), k))]
                 return upper + lower
 
             return {r: Matrix.block(blocks(r)) for r in P.alphabet()}
@@ -1281,7 +1281,7 @@ class RegularSequence(RecognizableSeries):
         return result
 
     @cached_method
-    def is_bounded(self):
+    def is_bounded(self) -> bool:
         r"""
         Return whether this `k`-regular sequence is bounded.
 

sage/combinat/regular_sequence_bounded.py

@@ -28,15 +28,15 @@ ACKNOWLEDGEMENT:
 - Gabriel Lipnik is supported by the
   Austrian Science Fund (FWF): P 24644-N26.
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2017 Gabriel Lipnik <devel@gabriellipnik.at>
 #
 # This program is free software: You can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 
 def multiply_reduce(A, B):
@@ -77,7 +77,7 @@ def multiply_reduce(A, B):
         [ -8 -14 -20]
         [  2   2   2]
     """
-    return (A*B).apply_map(lambda m: min(m, 2))
+    return (A * B).apply_map(lambda m: min(m, 2))
 
 
 def construct_phi(matrices):
@@ -146,7 +146,6 @@ def construct_phi(matrices):
         [2 2 2], [0 2 0], [0 2 2], [1 1 2], [2 0 0], [2 2 2], [1 2 2]
         ]
     """
-    from sage.arith.srange import srange
     length = len(matrices)
 
     def get_immutable(M):
@@ -163,7 +162,7 @@ def construct_phi(matrices):
     raise RuntimeError('Phi too large.')
 
 
-def is_integer_valued(matrices):
+def is_integer_valued(matrices) -> bool:
     r"""
     Return whether every matrix in ``matrices`` is integer-valued.
 
@@ -206,7 +205,7 @@ def is_integer_valued(matrices):
     return all(mat in M for mat in matrices)
 
 
-def is_non_negative(matrices):
+def is_non_negative(matrices) -> bool:
     r"""
     Return whether every matrix in ``matrices`` is non-negative.
 
@@ -237,10 +236,10 @@ def is_non_negative(matrices):
         sage: is_non_negative(matrices)
         True
     """
-    return all(min(mat.list()) >= 0 for mat in matrices)
+    return all(v >= 0 for mat in matrices for v in mat.list())
 
 
-def is_bounded_via_mandel_simon_algorithm(matrices):
+def is_bounded_via_mandel_simon_algorithm(matrices) -> bool:
     r"""
     Return whether the semigroup generated whether the semigroup of all
     possible products of ``matrices`` is finite/bounded.
@@ -290,10 +289,10 @@ def is_bounded_via_mandel_simon_algorithm(matrices):
         sage: is_bounded_via_mandel_simon_algorithm(N)
         Traceback (most recent call last):
         ...
-        ValueError: Not all matrices are integer-valued.
+        ValueError: not all matrices are integer-valued
     """
     if not is_integer_valued(matrices):
-        raise ValueError('Not all matrices are integer-valued.')
+        raise ValueError('not all matrices are integer-valued')
 
     phi = construct_phi(matrices)
     return not any(multiply_reduce(M, M) == M and not M**2 == M**3
@@ -391,17 +390,15 @@ def make_positive(matrices) -> list:
         ...
         ValueError: There is a matrix which is neither non-negative nor non-positive.
     """
-    from sage.arith.srange import srange
 
     def do(mat):
         if is_non_negative(mat):
             return mat
-        elif is_non_negative(-mat):
+        if is_non_negative(-mat):
             return -mat
-        else:
-            raise ValueError('There is a matrix which is neither non-negative nor non-positive.')
+        raise ValueError('There is a matrix which is neither non-negative nor non-positive.')
 
-    return list(do(mat) for mat in matrices)
+    return [do(mat) for mat in matrices]
 
 
 def regular_sequence_is_bounded(S):
@@ -515,10 +512,7 @@ def regular_sequence_is_bounded(S):
         sage: regular_sequence_is_bounded(S)                                            # needs sage.rings.number_field
         True
     """
-    from sage.arith.srange import srange
-
     matrices = list(S.mu)
-    length = len(matrices)
     try:
         return is_bounded_via_mandel_simon_algorithm(make_positive(matrices))
     except ValueError:
@@ -528,8 +522,8 @@ def regular_sequence_is_bounded(S):
     if not has_bounded_matrix_powers(matrices):
         return False
 
-    matricesProd = list(ell*em for ell in matrices for em in matrices
-                        if ell != em)
+    matricesProd = [ell * em for ell in matrices for em in matrices
+                    if ell != em]
     if not has_bounded_matrix_powers(matricesProd):
         return False
 

sage/combinat/restricted_growth.py

@@ -4,7 +4,7 @@ Restricted growth arrays
 
 These combinatorial objects are in bijection with set partitions.
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2008 Mike Hansen <mhansen@gmail.com>,
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -16,8 +16,8 @@ These combinatorial objects are in bijection with set partitions.
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 from sage.combinat.combinat import bell_number
 from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
 from sage.structure.parent import Parent

sage/combinat/ribbon.py

@@ -2,7 +2,7 @@
 r"""
 Ribbons
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -14,7 +14,7 @@ Ribbons
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from .ribbon_shaped_tableau import RibbonShapedTableau, StandardRibbonShapedTableaux

sage/combinat/rigged_configurations/bijection.py

@@ -13,7 +13,7 @@ AUTHORS:
 - Travis Scrimshaw (2014-09-10): Added type `D_4^{(3)}`
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2011-2015 Travis Scrimshaw <tscrim@ucdavis.edu>
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -25,8 +25,8 @@ AUTHORS:
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 from sage.combinat.rigged_configurations.bij_type_A import KRTToRCBijectionTypeA
 from sage.combinat.rigged_configurations.bij_type_A import RCToKRTBijectionTypeA

sage/combinat/rsk.py

@@ -2591,6 +2591,8 @@ class RuleStar(Rule):
         sage: FC_tabs = [T for shape in shapes
         ....:                  for T in SemistandardTableaux(shape, max_entry=4)
         ....:                      if fc(row_reading(T.conjugate()))]
+        sage: from random import sample
+        sage: FC_tabs = sample(FC_tabs, 25)  # verify only a random subset
         sage: Checks = []
         sage: for T in FC_tabs:  # long time
         ....:    shape = T.shape().conjugate()

sage/combinat/schubert_polynomial.py

@@ -77,7 +77,6 @@ We can also check the properties listed in :wikipedia:`Schubert_polynomial`::
 
 from sage.categories.graded_algebras_with_basis import GradedAlgebrasWithBasis
 from sage.combinat.free_module import CombinatorialFreeModule
-from sage.combinat.key_polynomial import KeyPolynomial
 from sage.combinat.permutation import Permutations, Permutation
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_import import lazy_import
@@ -87,6 +86,7 @@ from sage.rings.polynomial.infinite_polynomial_element import InfinitePolynomial
 from sage.rings.polynomial.multi_polynomial import MPolynomial
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 
+lazy_import('sage.combinat.key_polynomial', 'OperatorPolynomial')
 lazy_import('sage.libs.symmetrica', 'all', as_='symmetrica')
 
 
@@ -459,6 +459,15 @@ class SchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             sage: for _ in range(50):
             ....:     P = next(it)
             ....:     assert X(k(X(P))) == X(P), P
+
+        Check the round trip from atom polynomials::
+
+            sage: a = AtomPolynomials(ZZ)
+            sage: X = SchubertPolynomialRing(ZZ)
+            sage: it = iter(Permutations())
+            sage: for _ in range(50):
+            ....:     P = next(it)
+            ....:     assert X(a(X(P))) == X(P), P
         """
         if isinstance(x, list):
             # checking the input to avoid symmetrica crashing Sage, see trac 12924
@@ -477,7 +486,7 @@ class SchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             S = PolynomialRing(R.base_ring(),
                                names=list(map(repr, reversed(R.gens()))))
             return symmetrica.t_POLYNOM_SCHUBERT(S(x.polynomial()))
-        elif isinstance(x, KeyPolynomial):
+        elif isinstance(x, OperatorPolynomial):
             return self(x.expand())
         else:
             raise TypeError

sage/combinat/set_partition.py

@@ -2097,11 +2097,7 @@ class SetPartitions(UniqueRepresentation, Parent):
             return False
 
         # Check to make sure each element of x is a set
-        for s in x:
-            if not isinstance(s, (set, frozenset, Set_generic)):
-                return False
-
-        return True
+        return all(isinstance(s, (set, frozenset, Set_generic)) for s in x)
 
     def _element_constructor_(self, s, check=True):
         """
@@ -2506,7 +2502,7 @@ class SetPartitions(UniqueRepresentation, Parent):
         # Yip draws the diagram as an upper triangular matrix, thus
         # we refer to the cell in row i and column j with (i, j)
         P = []
-        rooks_by_column = {j: i for (i, j) in rooks}
+        rooks_by_column = {j: i for i, j in rooks}
         for c in range(1, n + 1):
             # determine the weight of column c
             try:
@@ -2515,7 +2511,7 @@ class SetPartitions(UniqueRepresentation, Parent):
                 ne = r - 1 + sum(1 for i, j in rooks if i > r and j < c)
             except KeyError:
                 n_rooks = 0
-                ne = sum(1 for i, j in rooks if j < c)
+                ne = sum(1 for _, j in rooks if j < c)
 
             b = c - n_rooks - ne
             if len(P) == b - 1:

sage/combinat/set_partition_iterator.pyx

@@ -1,5 +1,4 @@
 # sage_setup: distribution = sagemath-combinat
-# cython: binding=True
 r"""
 Fast set partition iterators
 """

sage/combinat/set_partition_ordered.py

@@ -454,7 +454,7 @@ class OrderedSetPartition(ClonableArray,
         return FiniteEnumeratedSet([par(sum((list(i) for i in C), []))
                                     for C in product(*[OrderedSetPartitions(X) for X in self])])
 
-    def is_finer(self, co2):
+    def is_finer(self, co2) -> bool:
         """
         Return ``True`` if the ordered set partition ``self`` is finer
         than the ordered set partition ``co2``; otherwise, return ``False``.
@@ -673,7 +673,7 @@ class OrderedSetPartition(ClonableArray,
         return FiniteEnumeratedSet([par(sum((list(P) for P in C), []))
                                     for C in product(*[[buo(X, comp) for comp in Compositions(len(X))] for X in self])])
 
-    def is_strongly_finer(self, co2):
+    def is_strongly_finer(self, co2) -> bool:
         r"""
         Return ``True`` if the ordered set partition ``self`` is strongly
         finer than the ordered set partition ``co2``; otherwise, return

sage/combinat/sf/classical.py

@@ -44,7 +44,7 @@ def init():
         sage: sage.combinat.sf.classical.conversion_functions = {}
         sage: init()
         sage: sage.combinat.sf.classical.conversion_functions[('Schur', 'powersum')]
-        <built-in function t_SCHUR_POWSYM_symmetrica>
+        <cyfunction t_SCHUR_POWSYM_symmetrica at ...>
 
     The following checks if the bug described in :issue:`15312` is fixed. ::
 

sage/combinat/sf/dual.py

@@ -21,6 +21,7 @@ Generic dual bases symmetric functions
 import sage.combinat.partition
 import sage.data_structures.blas_dict as blas
 from sage.categories.homset import Hom
+from sage.categories.modules_with_basis import ModulesWithBasis
 from sage.categories.morphism import SetMorphism
 from sage.matrix.constructor import matrix
 
@@ -168,7 +169,7 @@ class SymmetricFunctionAlgebra_dual(classical.SymmetricFunctionAlgebra_classical
                                                               prefix=prefix)
 
         # temporary until Hom(GradedHopfAlgebrasWithBasis work better)
-        category = sage.categories.all.ModulesWithBasis(self.base_ring())
+        category = ModulesWithBasis(self.base_ring())
         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))
 
@@ -394,16 +395,14 @@ class SymmetricFunctionAlgebra_dual(classical.SymmetricFunctionAlgebra_classical
 
             # For every partition p of size n, compute self(p) in
             # terms of the dual basis using the scalar product.
-            i = 0
-            for s_part in partitions_n:
+            for i, s_part in enumerate(partitions_n):
                 # s_part corresponds to self(dual_basis(part))
                 # s_mcs  corresponds to self(dual_basis(part))._monomial_coefficients
                 s_mcs = {}
 
                 # We need to compute the scalar product of d[s_part] and
                 # all of the d[p_part]'s
-                j = 0
-                for p_part in partitions_n:
+                for j, p_part in enumerate(partitions_n):
                     # Compute the scalar product of d[s_part] and d[p_part]
                     sp = zero
                     for ds_part in d[s_part]:
@@ -413,10 +412,7 @@ class SymmetricFunctionAlgebra_dual(classical.SymmetricFunctionAlgebra_classical
                         s_mcs[p_part] = sp
                         transition_matrix_n[i,j] = sp
 
-                    j += 1
-
                 self._to_self_cache[ s_part ] = s_mcs
-                i += 1
 
         else:
             # Now the other case. Note that just being in this case doesn't

sage/combinat/sf/elementary.py

@@ -3,7 +3,7 @@
 """
 Elementary symmetric functions
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>
 #                     2012 Mike Zabrocki <mike.zabrocki@gmail.com>
 #                     2012 Anne Schilling <anne@math.ucdavis.edu>
@@ -17,8 +17,8 @@ Elementary symmetric functions
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 from sage.arith.misc import binomial, factorial
 from sage.combinat.partition import Partition
 from sage.combinat.sf import classical, multiplicative
@@ -96,7 +96,7 @@ class SymmetricFunctionAlgebra_elementary(multiplicative.SymmetricFunctionAlgebr
         def P(i):
             return Partition([i]) if i else Partition([])
         T = self.tensor_square()
-        return T.sum_of_monomials( (P(j), P(i-j)) for j in range(i+1) )
+        return T.sum_of_monomials((P(j), P(i - j)) for j in range(i + 1))
 
     def _magma_init_(self, magma):
         """
@@ -169,7 +169,7 @@ class SymmetricFunctionAlgebra_elementary(multiplicative.SymmetricFunctionAlgebr
             """
             e = self.parent()
             h = e.realization_of().h()
-            return e( h._from_element(self) )
+            return e(h._from_element(self))
 
         omega_involution = omega
 
@@ -282,7 +282,7 @@ class SymmetricFunctionAlgebra_elementary(multiplicative.SymmetricFunctionAlgebr
             dct = {Partition([i // n for i in lam]):
                    (-1) ** (sum(lam) - (sum(lam) // n)) * coeff
                    for (lam, coeff) in e_coords_of_self
-                   if all( i % n == 0 for i in lam )}
+                   if all(not i % n for i in lam)}
             result_in_e_basis = parent._from_dict(dct)
             return parent(result_in_e_basis)
 
@@ -395,6 +395,12 @@ class SymmetricFunctionAlgebra_elementary(multiplicative.SymmetricFunctionAlgebr
                 sage: e.zero().principal_specialization(3)
                 0
             """
+            if n == 1:
+                R = self.base_ring()
+                mc = self.monomial_coefficients(copy=False).items()
+                return R.sum(c for partition, c in mc
+                             if not partition or partition[0] == 1)
+
             from sage.combinat.q_analogues import q_binomial
 
             def get_variable(ring, name):
@@ -417,7 +423,7 @@ class SymmetricFunctionAlgebra_elementary(multiplicative.SymmetricFunctionAlgebr
                 f = lambda partition: prod(binomial(n, part) for part in partition)
             elif n == infinity:
                 f = lambda partition: prod(q**binomial(part, 2)/prod((1-q**i)
-                                                                     for i in range(1,part+1))
+                                                                     for i in range(1, part+1))
                                            for part in partition)
             else:
                 f = lambda partition: prod(q**binomial(part, 2)*q_binomial(n, part, q=q)