some details in posets

Author: fchapoton

src/sage/combinat/posets/poset_examples.py

@@ -727,7 +727,9 @@ def ProductOfChains(chain_lengths, facade=None):
             return LatticePoset(facade=facade)
         from sage.categories.cartesian_product import cartesian_product
         elements = cartesian_product([range(i) for i in l])
-        compare = lambda a, b: all(x <= y for x, y in zip(a, b))
+
+        def compare(a, b):
+            return all(x <= y for x, y in zip(a, b))
         return LatticePoset([elements, compare], facade=facade)
 
     @staticmethod
@@ -875,7 +877,7 @@ def RandomLattice(n, p, properties=None):
             covers = _random_lattice(n, p)
             covers_dict = {i: covers[i] for i in range(n)}
             D = DiGraph(covers_dict)
-            D.relabel([i-1 for i in Permutations(n).random_element()])
+            D.relabel([i - 1 for i in Permutations(n).random_element()])
             return LatticePoset(D, cover_relations=True)
 
         if isinstance(properties, str):
@@ -906,23 +908,23 @@ def RandomLattice(n, p, properties=None):
 
         if properties == set(['planar']):
             D = _random_planar_lattice(n)
-            D.relabel([i-1 for i in Permutations(n).random_element()])
+            D.relabel([i - 1 for i in Permutations(n).random_element()])
             return LatticePoset(D)
 
         if properties == set(['dismantlable']):
             D = _random_dismantlable_lattice(n)
-            D.relabel([i-1 for i in Permutations(n).random_element()])
+            D.relabel([i - 1 for i in Permutations(n).random_element()])
             return LatticePoset(D)
 
         if properties == set(['stone']):
             D = _random_stone_lattice(n)
-            D.relabel([i-1 for i in Permutations(n).random_element()])
+            D.relabel([i - 1 for i in Permutations(n).random_element()])
             return LatticePoset(D)
 
         if properties == set(['distributive']):
             tmp = Poset(_random_distributive_lattice(n)).order_ideals_lattice(as_ideals=False)
             D = copy(tmp._hasse_diagram)
-            D.relabel([i-1 for i in Permutations(n).random_element()])
+            D.relabel([i - 1 for i in Permutations(n).random_element()])
             return LatticePoset(D)
 
         raise AssertionError("bug in RandomLattice()")
@@ -948,7 +950,7 @@ def SetPartitions(n):
 
         def covers(x):
             for i, s in enumerate(x):
-                for j in range(i+1, len(x)):
+                for j in range(i + 1, len(x)):
                     L = list(x)
                     L[i] = s.union(x[j])
                     L.pop(j)
@@ -1051,8 +1053,8 @@ def StandardExample(n, facade=None):
             (False, False)
         """
         n = check_int(n, 2)
-        return Poset((range(2*n), [[i, j+n] for i in range(n)
-                                   for j in range(n) if i != j]),
+        return Poset((range(2 * n), [[i, j + n] for i in range(n)
+                                     for j in range(n) if i != j]),
                      facade=facade)
 
     @staticmethod
@@ -1548,20 +1550,20 @@ def YoungFibonacci(n):
 
         covers = []
         current_level = ['']
-        for i in range(1, n+1):
+        for i in range(1, n + 1):
             new_level = set()
             for low in current_level:
                 ind = low.find('1')
                 if ind != -1:  # = found a '1' -> change first '1' to '2'
-                    up = low[:ind]+'2'+low[ind+1:]
+                    up = low[:ind] + '2' + low[ind + 1:]
                     new_level.add(up)
                     covers.append((low, up))
                 else:  # no '1' in low
                     ind = len(low)
 
                 # add '1' to every position not after first existing '1'
-                for j in range(ind+1):
-                    up = '2'*j + '1' + low[j:len(low)]
+                for j in range(ind + 1):
+                    up = '2' * j + '1' + low[j:len(low)]
                     new_level.add(up)
                     covers.append((low, up))
 
@@ -1589,10 +1591,10 @@ def DoubleTailedDiamond(n):
         """
         n = check_int(n, 1)
 
-        edges = [(i, i+1) for i in range(1, n)]
-        edges.extend([(n, n+1), (n, n+2), (n+1, n+3), (n+2, n+3)])
-        edges.extend([(i, i+1) for i in range(n+3, 2*n+2)])
-        p = DiGraph([list(range(1, 2*n + 3)), edges])
+        edges = [(i, i + 1) for i in range(1, n)]
+        edges.extend([(n, n + 1), (n, n + 2), (n + 1, n + 3), (n + 2, n + 3)])
+        edges.extend([(i, i + 1) for i in range(n + 3, 2 * n + 2)])
+        p = DiGraph([list(range(1, 2 * n + 3)), edges])
         return DCompletePoset(p)
 
     @staticmethod
@@ -1694,7 +1696,7 @@ def PermutationPatternInterval(bottom, top):
                     # Try and remove the ith element from the permutation
                     lower = list(upper)
                     j = lower.pop(i)
-                    for k in range(len(top)-level-1):  # Standardize result
+                    for k in range(len(top) - level - 1):  # Standardize result
                         if lower[k] > j:
                             lower[k] = lower[k] - 1
                     lower_perm = P(lower)
@@ -1749,13 +1751,13 @@ def PermutationPatternOccurrenceInterval(bottom, top, pos):
         while len(top) - len(bottom) >= level + 1:
             elem.append([])  # Add a new empty level
             for upper in elem[level]:
-                for i in range(len(top)-level):
+                for i in range(len(top) - level):
                     # Try and remove the ith element from the permutation
                     if i in upper[1]:
                         continue
                     lower_perm = list(upper[0])
                     j = lower_perm.pop(i)
-                    for e in range(len(top)-level-1):
+                    for e in range(len(top) - level - 1):
                         if lower_perm[e] > j:
                             lower_perm[e] = lower_perm[e] - 1
                     lower_pos = list(upper[1])
@@ -1901,9 +1903,9 @@ def _random_lattice(n, p):
         # Look for an admissible lower cover for the next element i
         while True:
             # Generate a random antichain
-            lc_list = [i-1-floor(i*sqrt(random()))]
+            lc_list = [i - 1 - floor(i * sqrt(random()))]
             while random() < p and 0 not in lc_list:
-                new = i-1-floor(i*sqrt(random()))
+                new = i - 1 - floor(i * sqrt(random()))
                 if any(meets[new][lc] in [new, lc] for lc in lc_list):
                     continue
                 lc_list.append(new)

src/sage/combinat/posets/posets.py

@@ -6145,7 +6145,8 @@ def relabel(self, relabeling=None):
             True
         """
         from sage.combinat.posets.lattices import (FiniteLatticePoset,
-             FiniteMeetSemilattice, FiniteJoinSemilattice)
+                                                   FiniteMeetSemilattice,
+                                                   FiniteJoinSemilattice)
 
         if isinstance(self, FiniteLatticePoset):
             constructor = FiniteLatticePoset
@@ -6750,7 +6751,7 @@ def interval(self, x, y):
         """
         return [self._vertex_to_element(w)
                 for w in self._hasse_diagram.interval(
-                        self._element_to_vertex(x), self._element_to_vertex(y))]
+                    self._element_to_vertex(x), self._element_to_vertex(y))]
 
     def closed_interval(self, x, y):
         r"""
@@ -7191,7 +7192,7 @@ def chain_polytope(self):
         """
         from sage.geometry.polyhedron.constructor import Polyhedron
         ineqs = [[1] + [-ZZ(j in chain) for j in self]
-               for chain in self.maximal_chains_iterator()]
+                 for chain in self.maximal_chains_iterator()]
         for i in self:
             ineqs += [[0] + [ZZ(j == i) for j in self]]
         return Polyhedron(ieqs=ineqs, base_ring=ZZ)
@@ -7295,10 +7296,10 @@ def M_triangle(self):
         rk = hasse.rank_function()
         if rk is None:
             raise ValueError('the poset is not graded')
-        x, y = polygen(ZZ, 'x,y')
-        p = sum(hasse.moebius_function(a, b) * x**rk(a) * y**rk(b)
-                for a in hasse
-                for b in hasse.principal_order_filter(a))
+        ring = PolynomialRing(ZZ, 'x,y')
+        p = ring.sum(hasse.moebius_function(a, b) * ring.monomial(rk(a), rk(b))
+                     for a in hasse
+                     for b in hasse.principal_order_filter(a))
         return M_triangle(p)
 
     def f_polynomial(self):
@@ -7407,17 +7408,19 @@ def h_polynomial(self):
             :meth:`sage.topology.simplicial_complex.SimplicialComplex.h_vector`
         """
         q = polygen(ZZ, 'q')
+        ring = q.parent()
         hasse = self._hasse_diagram
         if len(hasse) == 1:
             return q.parent().one()
         maxi = hasse.top()
         mini = hasse.bottom()
         if (mini is None) or (maxi is None):
             raise ValueError("the poset is not bounded")
-        f = sum(q**(len(ch)) for ch in hasse.chains(exclude=[mini, maxi]))
+        f = ring.sum(ring.monomial(len(ch))
+                     for ch in hasse.chains(exclude=[mini, maxi]))
         d = f.degree()
         f = (1 - q)**d * q * f(q=q / (1 - q))
-        return q.parent(f)
+        return ring(f)
 
     def flag_f_polynomial(self):
         r"""
@@ -7607,15 +7610,16 @@ def characteristic_polynomial(self):
             sage: P.characteristic_polynomial()
             1
         """
-        hasse = self._hasse_diagram
-        rk = hasse.rank_function()
+        H = self._hasse_diagram
+        rk = H.rank_function()
         if not self.is_graded():
             raise ValueError("the poset is not graded")
         if not self.has_bottom():
             raise ValueError("the poset does not have a bottom element")
-        n = rk(hasse.maximal_elements()[0])
-        q = polygen(ZZ, 'q')
-        return sum(hasse.bottom_moebius_function(x) * q**(n - rk(x)) for x in hasse)
+        n = rk(H.maximal_elements()[0])
+        ring = PolynomialRing(ZZ, 'q')
+        return ring.sum(H.bottom_moebius_function(x) * ring.monomial(n - rk(x))
+                        for x in H)
 
     def chain_polynomial(self):
         """
@@ -8953,8 +8957,8 @@ def cardinality(self, from_iterator=False):
         # Obtained from The On-Line Encyclopedia of Integer Sequences;
         # this is sequence number A000112.
         known_values = [1, 1, 2, 5, 16, 63, 318, 2045, 16999, 183231,
-                2567284, 46749427, 1104891746, 33823827452, 1338193159771,
-                68275077901156, 4483130665195087]
+                        2567284, 46749427, 1104891746, 33823827452, 1338193159771,
+                        68275077901156, 4483130665195087]
         if not from_iterator and self._n < len(known_values):
             return Integer(known_values[self._n])
         else: