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

sage/combinat/sf/hall_littlewood.py

@@ -5,7 +5,7 @@ Hall-Littlewood polynomials
 
 Notation used in the definitions follows mainly [Mac1995]_.
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -17,18 +17,20 @@ Notation used in the definitions follows mainly [Mac1995]_.
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 import sage.combinat.partition
+import sage.misc.persist
+
 from sage.categories.homset import Hom
+from sage.categories.modules_with_basis import ModulesWithBasis
 from sage.categories.morphism import SetMorphism
+from sage.combinat.sf import sfa
 from sage.misc.lazy_import import lazy_import
 from sage.rings.rational_field import QQ
 from sage.structure.unique_representation import UniqueRepresentation
 
-from . import sfa
-
 lazy_import('sage.libs.symmetrica.all', 'hall_littlewood')
 lazy_import('sage.matrix.constructor', 'matrix')
 
@@ -234,7 +236,7 @@ class HallLittlewood(UniqueRepresentation):
         Transitions between bases with the parameter `t` specialized::
 
             sage: Sym = SymmetricFunctions(FractionField(QQ['y','z']))
-            sage: (y,z) = Sym.base_ring().gens()
+            sage: y, z = Sym.base_ring().gens()
             sage: HLy = Sym.hall_littlewood(t=y)
             sage: HLz = Sym.hall_littlewood(t=z)
             sage: Qpy = HLy.Qp()
@@ -390,7 +392,7 @@ class HallLittlewood_generic(sfa.SymmetricFunctionAlgebra_generic):
         # common category BasesByOrthotriangularity (shared with Jack, HL, orthotriang, Mcdo)
         if hasattr(self, "_s_cache"):
             # temporary until Hom(GradedHopfAlgebrasWithBasis work better)
-            category = sage.categories.all.ModulesWithBasis(self._sym.base_ring())
+            category = ModulesWithBasis(self._sym.base_ring())
             self   .register_coercion(SetMorphism(Hom(self._s, self, category), self._s_to_self))
             self._s.register_coercion(SetMorphism(Hom(self, self._s, category), self._self_to_s))
 
@@ -862,7 +864,7 @@ class HallLittlewood_q(HallLittlewood_generic):
 
         self._P = self._hall_littlewood.P()
         # temporary until Hom(GradedHopfAlgebrasWithBasis work better)
-        category = sage.categories.all.ModulesWithBasis(self.base_ring())
+        category = ModulesWithBasis(self.base_ring())
 
         phi = self.module_morphism(diagonal=self._P._q_to_p_normalization,
                                    codomain=self._P, category=category)

sage/combinat/sf/homogeneous.py

@@ -6,7 +6,7 @@ Homogeneous symmetric functions
 By this we mean the basis formed of the complete homogeneous
 symmetric functions `h_\lambda`, not an arbitrary graded basis.
 """
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>
 #                     2012 Mike Zabrocki <mike.zabrocki@gmail.com>
 #
@@ -19,8 +19,8 @@ symmetric functions `h_\lambda`, not an arbitrary graded basis.
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 ####################################
 #                                  #
@@ -305,6 +305,9 @@ class SymmetricFunctionAlgebra_homogeneous(multiplicative.SymmetricFunctionAlgeb
                 sage: s = x.principal_specialization(3); s
                 0
             """
+            if n == 1:
+                return self.base_ring().sum(self.coefficients(sort=False))
+
             from sage.combinat.q_analogues import q_binomial
 
             def get_variable(ring, name):

sage/combinat/sf/jack.py

@@ -31,10 +31,10 @@ REFERENCES:
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
-import sage.categories.all
 from sage.arith.functions import lcm
 from sage.arith.misc import gcd
 from sage.categories.homset import End, Hom
+from sage.categories.modules_with_basis import ModulesWithBasis
 from sage.categories.morphism import SetMorphism
 from sage.misc.misc_c import prod
 from sage.rings.fraction_field import FractionField, FractionField_generic
@@ -202,7 +202,7 @@ class Jack(UniqueRepresentation):
         ::
 
             sage: Sym = SymmetricFunctions(QQ['a','b'].fraction_field())
-            sage: (a,b) = Sym.base_ring().gens()
+            sage: a, b = Sym.base_ring().gens()
             sage: Jacka = Sym.jack(t=a)
             sage: Jackb = Sym.jack(t=b)
             sage: m = Sym.monomial()
@@ -526,13 +526,13 @@ class JackPolynomials_generic(sfa.SymmetricFunctionAlgebra_generic):
         # common category BasesByOrthotriangularity (shared with Jack, HL, orthotriang, Mcdo)
         if hasattr(self, "_m_cache"):
             # temporary until Hom(GradedHopfAlgebrasWithBasis work better)
-            category = sage.categories.all.ModulesWithBasis(self._sym.base_ring())
+            category = ModulesWithBasis(self._sym.base_ring())
             self._m = self._sym.monomial()
             self   .register_coercion(SetMorphism(Hom(self._m, self, category), self._m_to_self))
             self._m.register_coercion(SetMorphism(Hom(self, self._m, category), self._self_to_m))
         if hasattr(self, "_h_cache"):
             # temporary until Hom(GradedHopfAlgebrasWithBasis work better)
-            category = sage.categories.all.ModulesWithBasis(self._sym.base_ring())
+            category = ModulesWithBasis(self._sym.base_ring())
             self._h = self._sym.homogeneous()
             self   .register_coercion(SetMorphism(Hom(self._h, self, category), self._h_to_self))
             self._h.register_coercion(SetMorphism(Hom(self, self._h, category), self._self_to_h))
@@ -910,12 +910,14 @@ class JackPolynomials_p(JackPolynomials_generic):
              ([3],
               [([1, 1, 1], 3/(t^2 + 3/2*t + 1/2)), ([2, 1], 3/2/(t + 1/2)), ([3], 1)])]
         """
+        from sage.combinat.sf.sf import SymmetricFunctions
+
         if n in self._self_to_m_cache:
             return
         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()
+        monomial = SymmetricFunctions(QQt).monomial()
+        JP = 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,
@@ -1083,7 +1085,7 @@ class JackPolynomials_j(JackPolynomials_generic):
         # Should be shared with _q (and possibly other bases in Macdo/HL) as BasesByRenormalization
         self._P = self._jack.P()
         # temporary until Hom(GradedHopfAlgebrasWithBasis) works better
-        category = sage.categories.all.ModulesWithBasis(self.base_ring())
+        category = ModulesWithBasis(self.base_ring())
         phi = self.module_morphism(diagonal=self.c1,
                                    codomain=self._P, category=category)
         # should use module_morphism(on_coeffs = ...) once it exists
@@ -1120,7 +1122,7 @@ class JackPolynomials_q(JackPolynomials_generic):
         # Should be shared with _j (and possibly other bases in Macdo/HL) as BasesByRenormalization
         self._P = self._jack.P()
         # temporary until Hom(GradedHopfAlgebrasWithBasis) works better
-        category = sage.categories.all.ModulesWithBasis(self.base_ring())
+        category = 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)
@@ -1353,7 +1355,7 @@ class SymmetricFunctionAlgebra_zonal(sfa.SymmetricFunctionAlgebra_generic):
         #self._self_to_m_cache = {} and we don't need to compute it separately for zonals
         sfa.SymmetricFunctionAlgebra_generic.__init__(self, self._sym,
                                                       prefix='Z', basis_name='zonal')
-        category = sage.categories.all.ModulesWithBasis(self._sym.base_ring())
+        category = ModulesWithBasis(self._sym.base_ring())
         self   .register_coercion(SetMorphism(Hom(self._P, self, category), self.sum_of_terms))
         self._P.register_coercion(SetMorphism(Hom(self, self._P, category), self._P.sum_of_terms))
 

sage/combinat/sf/llt.py

@@ -33,15 +33,15 @@ REFERENCES:
 # ****************************************************************************
 import sage.combinat.skew_partition
 from sage.categories.homset import Hom
+from sage.categories.modules_with_basis import ModulesWithBasis
 from sage.categories.morphism import SetMorphism
 from sage.combinat import ribbon_tableau
 from sage.combinat.partition import Partition, Partitions, _Partitions
+from sage.combinat.sf import sfa
 from sage.rings.integer_ring import ZZ
 from sage.rings.rational_field import QQ
 from sage.structure.unique_representation import UniqueRepresentation
 
-from . import sfa
-
 # cache for H spin basis
 hsp_to_m_cache = {}
 m_to_hsp_cache = {}
@@ -75,7 +75,7 @@ class LLT_class(UniqueRepresentation):
 
         sage: # needs sage.symbolic
         sage: Symxt = SymmetricFunctions(QQ['x','t'].fraction_field())
-        sage: (x,t) = Symxt.base_ring().gens()
+        sage: x, t = Symxt.base_ring().gens()
         sage: LLT3x = Symxt.llt(3,t=x)
         sage: LLT3 = Symxt.llt(3)
         sage: HS3x = LLT3x.hspin()
@@ -411,7 +411,6 @@ class LLT_class(UniqueRepresentation):
              in the level 3 LLT spin basis
             sage: HSp3([1])^2
             HSp3[1, 1] + (-t+1)*HSp3[2]
-
             sage: s = Sym.schur()
             sage: HSp3(s([2]))
             HSp3[2]
@@ -463,7 +462,7 @@ class LLT_generic(sfa.SymmetricFunctionAlgebra_generic):
         sfa.SymmetricFunctionAlgebra_generic.__init__(self, self._sym, self._basis_name)
 
         # temporary until Hom(GradedHopfAlgebrasWithBasis work better)
-        category = sage.categories.all.ModulesWithBasis(self._sym.base_ring())
+        category = ModulesWithBasis(self._sym.base_ring())
         self._m = llt._sym.m()
         self   .register_coercion(SetMorphism(Hom(self._m, self, category), self._m_to_self))
         self._m.register_coercion(SetMorphism(Hom(self, self._m, category), self._self_to_m))

sage/combinat/sf/macdonald.py

@@ -34,7 +34,7 @@ REFERENCES:
    Journal of Algebra and Computation, Volume 23, Issue 4, (2013), pp. 833-852.
 """
 
-#*****************************************************************************
+# ***************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -46,8 +46,8 @@ REFERENCES:
 #
 #  The full text of the GPL is available at:
 #
-#                  http://www.gnu.org/licenses/
-#*****************************************************************************
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
 
 import functools
 
@@ -273,7 +273,7 @@ class Macdonald(UniqueRepresentation):
         ::
 
             sage: Sym = SymmetricFunctions(QQ['x','y','z'].fraction_field())
-            sage: (x,y,z) = Sym.base_ring().gens()
+            sage: x, y, z = Sym.base_ring().gens()
             sage: Macxy = Sym.macdonald(q=x,t=y)
             sage: Macyz = Sym.macdonald(q=y,t=z)
             sage: Maczx = Sym.macdonald(q=z,t=x)
@@ -1292,7 +1292,7 @@ class MacdonaldPolynomials_h(MacdonaldPolynomials_generic):
             sage: s = Sym.s()
             sage: H(s[1,1])
             -(1/(q*t-1))*McdH[1, 1] + (t/(q*t-1))*McdH[2]
-            sage: (q,t) = Sym.base_ring().gens()
+            sage: q, t = Sym.base_ring().gens()
             sage: H(q*s[1, 1, 1] + (q*t+1)*s[2, 1] + t*s[3])
             McdH[2, 1]
             sage: H2 = Sym.macdonald(t=0).H()
@@ -1380,7 +1380,7 @@ class MacdonaldPolynomials_h(MacdonaldPolynomials_generic):
             sage: m = Sym.m()
             sage: H(m[1,1])
             -(1/(q*t-1))*McdH[1, 1] + (t/(q*t-1))*McdH[2]
-            sage: (q,t) = Sym.base_ring().gens()
+            sage: q, t = Sym.base_ring().gens()
             sage: H((2*q*t+q+t+2)*m[1, 1, 1] + (q*t+t+1)*m[2, 1] + t*m[3])
             McdH[2, 1]
 
@@ -1602,7 +1602,7 @@ class MacdonaldPolynomials_ht(MacdonaldPolynomials_generic):
             sage: m = Sym.m()
             sage: Ht(m[1,1])
             (1/(-q+t))*McdHt[1, 1] - (1/(-q+t))*McdHt[2]
-            sage: (q,t) = Sym.base_ring().gens()
+            sage: q, t = Sym.base_ring().gens()
             sage: Ht((q*t+2*q+2*t+1)*m[1, 1, 1] + (q+t+1)*m[2, 1] + m[3])
             McdHt[2, 1]
 
@@ -1770,14 +1770,13 @@ class MacdonaldPolynomials_s(MacdonaldPolynomials_generic):
             (q*t - t^2 - q + t)/(-q^3 + q^2 + q - 1)
         """
         # Convert to the power sum
-        (q, t) = QQqt.gens()
+        q, t = QQqt.gens()
         p = self._sym.p()
         s = self._s
         p_x = p(s(part))
         f = lambda m, c: (m, c * prod([(1 - t**k) / (1 - q**k) for k in m]))
         res = s(p_x.map_item(f))
-        f = res.coefficient
-        return f
+        return res.coefficient
 
     def _s_cache(self, n):
         r"""
@@ -1835,7 +1834,7 @@ class MacdonaldPolynomials_s(MacdonaldPolynomials_generic):
                 sage: a._creation_by_determinant_helper(2,[1])
                 (q^3*t-q^2*t-q+1)*McdS[2, 1] + (q^3-q^2*t-q+t)*McdS[3]
             """
-            (q,t) = QQqt.gens()
+            q, t = QQqt.gens()
             from sage.combinat.sf.sf import SymmetricFunctions
             S = SymmetricFunctions(QQqt).macdonald().S()
 

sage/combinat/sf/monomial.py

@@ -403,6 +403,12 @@ class SymmetricFunctionAlgebra_monomial(classical.SymmetricFunctionAlgebra_class
                 sage: m.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 len(partition) <= 1)
+
             if q == 1:
                 if n == infinity:
                     raise ValueError("the stable principal specialization at q=1 is not defined")

sage/combinat/sf/ns_macdonald.py

@@ -61,7 +61,7 @@ class LatticeDiagram(CombinatorialObject):
 
     def leg(self, i, j):
         """
-        Return the leg of the box ``(i,j)`` in ``self``.
+        Return the leg of the box ``(i, j)`` in ``self``.
 
         EXAMPLES::
 
@@ -73,7 +73,7 @@ class LatticeDiagram(CombinatorialObject):
 
     def arm_left(self, i, j):
         """
-        Return the left arm of the box ``(i,j)`` in ``self``.
+        Return the left arm of the box ``(i, j)`` in ``self``.
 
         EXAMPLES::
 
@@ -85,7 +85,7 @@ class LatticeDiagram(CombinatorialObject):
 
     def arm_right(self, i, j):
         """
-        Return the right arm of the box ``(i,j)`` in ``self``.
+        Return the right arm of the box ``(i, j)`` in ``self``.
 
         EXAMPLES::
 
@@ -98,7 +98,7 @@ class LatticeDiagram(CombinatorialObject):
 
     def arm(self, i, j):
         """
-        Return the arm of the box ``(i,j)`` in ``self``.
+        Return the arm of the box ``(i, j)`` in ``self``.
 
         EXAMPLES::
 
@@ -122,7 +122,7 @@ class LatticeDiagram(CombinatorialObject):
 
     def a(self, i, j):
         """
-        Return the length of the arm of the box ``(i,j)`` in ``self``.
+        Return the length of the arm of the box ``(i, j)`` in ``self``.
 
         EXAMPLES::
 
@@ -145,9 +145,11 @@ class LatticeDiagram(CombinatorialObject):
         return sum(self._list)
 
     def flip(self):
-        """
-        Return the flip of ``self``, where flip is defined as follows. Let
-        ``r = max(self)``. Then ``self.flip()[i] = r - self[i]``.
+        r"""
+        Return the flip of ``self``.
+
+        The flip map is defined as follows. Let ``r = max(self)``.
+        Then ``self.flip()[i] = r - self[i]``.
 
         EXAMPLES::
 
@@ -244,24 +246,26 @@ class AugmentedLatticeDiagramFilling(CombinatorialObject):
                                for i in range(1, len(self) + 1)])
 
     def __contains__(self, ij):
-        """
-        Return ``True`` if the box ``(i,j) (= ij)`` is in ``self``. Note that this
-        does not include the basement row.
+        r"""
+        Return ``True`` if the box ``(i, j) (= ij)`` is in ``self``.
+
+        Note that this does not include the basement row.
 
         EXAMPLES::
 
             sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
-            sage: (1,1) in a
+            sage: (1, 1) in a
             True
-            sage: (1,0) in a
+            sage: (1, 0) in a
             False
         """
         i, j = ij
         return 0 < i <= len(self) and 0 < j <= len(self[i])
 
     def are_attacking(self, i, j, ii, jj):
-        """
-        Return ``True`` if the boxes ``(i,j)`` and ``(ii,jj)`` in ``self`` are attacking.
+        r"""
+        Return ``True`` if the boxes ``(i, j)`` and ``(ii, jj)`` in ``self``
+        are attacking.
 
         EXAMPLES::
 
@@ -353,10 +357,7 @@ class AugmentedLatticeDiagramFilling(CombinatorialObject):
             sage: a.is_non_attacking()
             True
         """
-        for a, b in self.attacking_boxes():
-            if self[a] == self[b]:
-                return False
-        return True
+        return all(self[a] != self[b] for a, b in self.attacking_boxes())
 
     def weight(self):
         """
@@ -480,24 +481,30 @@ class AugmentedLatticeDiagramFilling(CombinatorialObject):
         return res
 
     def _inv_aux(self):
-        """
+        r"""
         EXAMPLES::
 
             sage: a = AugmentedLatticeDiagramFilling([[1,6],[2],[3,4,2],[],[],[5,5]])
             sage: a._inv_aux()
             7
+
+            sage: data = [[1,6],[],[3,4,2],[5,5]]
+            sage: [AugmentedLatticeDiagramFilling(data, pi=pi)._inv_aux()
+            ....:  for pi in Permutations(4)]
+            [4, 4, 3, 3, 2, 2, 4, 4, 2, 2, 1, 1,
+             3, 3, 2, 2, 0, 0, 2, 2, 1, 1, 0, 0]
         """
         res = 0
         shape = self.shape()
         for i in range(1, len(self) + 1):
-            for j in range(i + 1, len(self) + 1):
-                if shape[i] <= shape[j]:
-                    res += 1
+            a = self._list[i-1][0]
+            res += sum(1 for j in range(i + 1, len(self) + 1)
+                       if shape[i] <= shape[j] and a < self._list[j-1][0])
         return res
 
     def inv(self):
-        """
-        Return ``self``'s inversion statistic.
+        r"""
+        Return the inversion statistic of ``self``.
 
         EXAMPLES::
 
@@ -512,7 +519,7 @@ class AugmentedLatticeDiagramFilling(CombinatorialObject):
 
     def coinv(self):
         """
-        Return ``self``'s co-inversion statistic.
+        Return the co-inversion statistic of ``self``.
 
         EXAMPLES::
 
@@ -524,10 +531,10 @@ class AugmentedLatticeDiagramFilling(CombinatorialObject):
         return sum(shape.a(i, j) for i, j in shape.boxes()) - self.inv()
 
     def coeff(self, q, t):
-        """
+        r"""
         Return the coefficient in front of ``self`` in the HHL formula for the
         expansion of the non-symmetric Macdonald polynomial
-        E(self.shape()).
+        ``E(self.shape())``.
 
         EXAMPLES::
 
@@ -536,19 +543,15 @@ class AugmentedLatticeDiagramFilling(CombinatorialObject):
             sage: a.coeff(q,t)                                                          # needs sage.symbolic
             (t - 1)^4/((q^2*t^3 - 1)^2*(q*t^2 - 1)^2)
         """
-        res = 1
         shape = self.shape()
-        for i, j in shape.boxes():
-            if self[i, j] != self[i, j - 1]:
-                res *= (1 - t) / (1 - q**(shape.l(i, j) + 1)
-                                  * t**(shape.a(i, j) + 1))
-        return res
+        return prod((1 - t) / (1 - q**(shape.l(i, j) + 1) * t**(shape.a(i, j) + 1))
+                    for i, j in shape.boxes() if self[i, j] != self[i, j - 1])
 
     def coeff_integral(self, q, t):
-        """
+        r"""
         Return the coefficient in front of ``self`` in the HHL formula for the
         expansion of the integral non-symmetric Macdonald polynomial
-        E(self.shape())
+        ``E(self.shape())``.
 
         EXAMPLES::
 
@@ -569,24 +572,26 @@ class AugmentedLatticeDiagramFilling(CombinatorialObject):
 
     def permuted_filling(self, sigma):
         """
+        Return the filling given by permuting the entries of ``self``
+        by ``sigma``.
+
         EXAMPLES::
 
-            sage: pi=Permutation([2,1,4,3]).to_permutation_group_element()
-            sage: fill=[[2],[1,2,3],[],[3,1]]
+            sage: pi = Permutation([2,1,4,3]).to_permutation_group_element()
+            sage: fill = [[2],[1,2,3],[],[3,1]]
             sage: AugmentedLatticeDiagramFilling(fill).permuted_filling(pi)
             [[2, 1], [1, 2, 1, 4], [4], [3, 4, 2]]
         """
         new_filling = []
         for col in self:
-            nc = [sigma(x) for x in col]
-            nc.pop(0)
+            nc = [sigma(x) for x in col[1:]]
             new_filling.append(nc)
         return AugmentedLatticeDiagramFilling(new_filling, sigma)
 
 
 def NonattackingFillings(shape, pi=None):
     """
-    Returning the finite set of nonattacking fillings of a
+    Return the finite set of nonattacking fillings of a
     given shape.
 
     EXAMPLES::
@@ -621,17 +626,16 @@ class NonattackingFillings_shape(Parent, UniqueRepresentation):
         """
         self.pi = pi
         self._shape = LatticeDiagram(shape)
-        self._name = "Nonattacking fillings of %s" % list(shape)
         Parent.__init__(self, category=FiniteEnumeratedSets())
 
-    def __repr__(self):
+    def _repr_(self):
         """
         EXAMPLES::
 
             sage: NonattackingFillings([0,1,2])
             Nonattacking fillings of [0, 1, 2]
         """
-        return self._name
+        return "Nonattacking fillings of %s" % list(self._shape)
 
     def flip(self):
         """
@@ -834,7 +838,7 @@ def _check_muqt(mu, q, t, pi=None):
 
 
 def E(mu, q=None, t=None, pi=None):
-    """
+    r"""
     Return the non-symmetric Macdonald polynomial in type A
     corresponding to a shape ``mu``, with basement permuted according to
     ``pi``.
@@ -876,9 +880,24 @@ def E(mu, q=None, t=None, pi=None):
         x0^2 + (q*t - q)/(q*t - 1)*x0*x1 + (q*t - q)/(q*t - 1)*x0*x2
         sage: E([0,2,0])
         (t - 1)/(q^2*t^2 - 1)*x0^2 + (q^2*t^3 - q^2*t^2 + q*t^2 - 2*q*t + q - t + 1)/(q^3*t^3 - q^2*t^2 - q*t + 1)*x0*x1 + x1^2 + (q*t^2 - 2*q*t + q)/(q^3*t^3 - q^2*t^2 - q*t + 1)*x0*x2 + (q*t - q)/(q*t - 1)*x1*x2
+
+        sage: [E([1,0,1], pi=pi) for pi in Permutations(3)]
+        [(t - 1)/(q*t^2 - 1)*x0*x1 + x0*x2,
+         x0*x1 + (q*t^2 - q*t)/(q*t^2 - 1)*x0*x2,
+         (t^2 - t)/(q*t^2 - 1)*x0*x1 + x1*x2,
+         x0*x1 + (q*t - q)/(q*t^2 - 1)*x1*x2,
+         (t - 1)/(q*t^2 - 1)*x0*x2 + x1*x2,
+         x0*x2 + (q*t^2 - q*t)/(q*t^2 - 1)*x1*x2]
+
+    TESTS::
+
+        sage: from sage.combinat.sf.ns_macdonald import E
+        sage: E([]).parent()
+        Multivariate Polynomial Ring in no variables over Fraction Field
+         of Multivariate Polynomial Ring in q, t over Rational Field
     """
     P, q, t, n, R, x = _check_muqt(mu, q, t, pi)
-    res = 0
+    res = R.zero()
     for a in n:
         weight = a.weight()
         res += q**a.maj() * t**a.coinv() * a.coeff(q, t) * prod(x[i]**weight[i] for i in range(len(weight)))
@@ -886,11 +905,11 @@ def E(mu, q=None, t=None, pi=None):
 
 
 def E_integral(mu, q=None, t=None, pi=None):
-    """
+    r"""
     Return the integral form for the non-symmetric Macdonald
     polynomial in type A corresponding to a shape mu.
 
-    Note that if both q and t are specified, then they must have the
+    Note that if both `q` and `t` are specified, then they must have the
     same parent.
 
     REFERENCE:
@@ -920,9 +939,24 @@ def E_integral(mu, q=None, t=None, pi=None):
         (t^2 - 2*t + 1)*x0^2 + (q^2*t^2 - q^2*t - q*t + q)*x0*x1 + (q^2*t^2 - q^2*t - q*t + q)*x0*x2
         sage: E_integral([0,2,0])
         (q^2*t^3 - q^2*t^2 - t + 1)*x0^2 + (q^4*t^3 - q^3*t^2 - q^2*t + q*t^2 - q*t + q - t + 1)*x0*x1 + (t^2 - 2*t + 1)*x1^2 + (q^4*t^3 - q^3*t^2 - q^2*t + q)*x0*x2 + (q^2*t^2 - q^2*t - q*t + q)*x1*x2
+
+        sage: [E_integral([1,0,1], pi=pi) for pi in Permutations(3)]
+        [(q*t^3 - q*t^2 - t + 1)*x0*x1 + (t^2 - 2*t + 1)*x0*x2,
+         (t^2 - 2*t + 1)*x0*x1 + (q^2*t^4 - q^2*t^3 - q*t^2 + q*t)*x0*x2,
+         (q*t^4 - q*t^3 - t^2 + t)*x0*x1 + (t^2 - 2*t + 1)*x1*x2,
+         (t^2 - 2*t + 1)*x0*x1 + (q^2*t^3 - q^2*t^2 - q*t + q)*x1*x2,
+         (q*t^3 - q*t^2 - t + 1)*x0*x2 + (t^2 - 2*t + 1)*x1*x2,
+         (t^2 - 2*t + 1)*x0*x2 + (q^2*t^4 - q^2*t^3 - q*t^2 + q*t)*x1*x2]
+
+    TESTS::
+
+        sage: from sage.combinat.sf.ns_macdonald import E_integral
+        sage: E_integral([]).parent()
+        Multivariate Polynomial Ring in no variables over Fraction Field
+         of Multivariate Polynomial Ring in q, t over Rational Field
     """
     P, q, t, n, R, x = _check_muqt(mu, q, t, pi)
-    res = 0
+    res = R.zero()
     for a in n:
         weight = a.weight()
         res += q**a.maj() * t**a.coinv() * a.coeff_integral(q, t) * prod(x[i]**weight[i] for i in range(len(weight)))
@@ -930,7 +964,7 @@ def E_integral(mu, q=None, t=None, pi=None):
 
 
 def Ht(mu, q=None, t=None, pi=None):
-    """
+    r"""
     Return the symmetric Macdonald polynomial using the Haiman,
     Haglund, and Loehr formula.
 
@@ -955,9 +989,16 @@ def Ht(mu, q=None, t=None, pi=None):
         x0^2 + (q + 1)*x0*x1 + x1^2 + (q + 1)*x0*x2 + (q + 1)*x1*x2 + x2^2
         sage: HHt([2]).expand(3)
         x0^2 + (q + 1)*x0*x1 + x1^2 + (q + 1)*x0*x2 + (q + 1)*x1*x2 + x2^2
+
+    TESTS::
+
+        sage: from sage.combinat.sf.ns_macdonald import Ht
+        sage: Ht([]).parent()
+        Multivariate Polynomial Ring in no variables over Fraction Field
+         of Multivariate Polynomial Ring in q, t over Rational Field
     """
     P, q, t, n, R, x = _check_muqt(mu, q, t, pi)
-    res = 0
+    res = R.zero()
     for a in n:
         weight = a.weight()
         res += q**a.maj() * t**a.inv() * prod(x[i]**weight[i] for i in range(len(weight)))