passagemath-graphs 10.5.43__cp312-cp312-macosx_14_0_arm64.whl → 10.6.1rc2__cp312-cp312-macosx_14_0_arm64.whl

sage/combinat/designs/subhypergraph_search.pyx

@@ -115,7 +115,7 @@ Methods
 #  Distributed under the terms of the GNU General Public License (GPL)
 #  as published by the Free Software Foundation; either version 2 of
 #  the License, or (at your option) any later version.
-#                  http://www.gnu.org/licenses/
+#                  https://www.gnu.org/licenses/
 # ****************************************************************************
 
 from libc.stdlib cimport qsort
@@ -134,7 +134,7 @@ cdef inline int bs_get(uint64_t * bitset, int index) noexcept:
     r"""
     Return a bit of a bitset
     """
-    return (bitset[index//64]>>(index%64))&1
+    return (bitset[index // 64] >> (index % 64)) & 1
 
 cdef inline void bs_set(uint64_t * bitset, int index, int bit) noexcept:
     r"""
@@ -143,8 +143,8 @@ cdef inline void bs_set(uint64_t * bitset, int index, int bit) noexcept:
     "bit" *MUST* be equal to either 0 or to 1. The code does not involve any
     "if".
     """
-    bitset[index//64] &= ~((<uint64_t> 1)<<index%64)
-    bitset[index//64] |= (<uint64_t> bit)<<index%64
+    bitset[index // 64] &= ~((<uint64_t> 1) << index % 64)
+    bitset[index // 64] |= (<uint64_t> bit) << index % 64
 
 cdef inline int bs_issubset64(uint64_t * b1, uint64_t b2, int limbs) noexcept:
     r"""

sage/combinat/designs/twographs.py

@@ -244,13 +244,13 @@ def is_twograph(T) -> bool:
         for x in B:
             v_to_blocks[x].add(B)
 
-    def has_triple(x_y_z):
+    def has_triple(x_y_z) -> bool:
         x, y, z = x_y_z
         return bool(v_to_blocks[x] & v_to_blocks[y] & v_to_blocks[z])
 
     # Check that every quadruple contains an even number of triples
     for quad in combinations(range(T.num_points()), 4):
-        if sum(map(has_triple, combinations(quad, 3))) % 2 == 1:
+        if sum(map(has_triple, combinations(quad, 3))) % 2:
             return False
 
     return True

sage/combinat/finite_state_machine.py

@@ -5416,7 +5416,7 @@ class FiniteStateMachine(SageObject):
     # properties (state and transitions)
     # ************************************************************************
 
-    def has_state(self, state):
+    def has_state(self, state) -> bool:
         """
         Return whether ``state`` is one of the states of the finite
         state machine.
@@ -5438,7 +5438,7 @@ class FiniteStateMachine(SageObject):
         except LookupError:
             return False
 
-    def has_transition(self, transition):
+    def has_transition(self, transition) -> bool:
         """
         Return whether ``transition`` is one of the transitions of
         the finite state machine.
@@ -5464,7 +5464,7 @@ class FiniteStateMachine(SageObject):
             return transition in self.iter_transitions()
         raise TypeError("Transition is not an instance of FSMTransition.")
 
-    def has_initial_state(self, state):
+    def has_initial_state(self, state) -> bool:
         """
         Return whether ``state`` is one of the initial states of the
         finite state machine.
@@ -5486,7 +5486,7 @@ class FiniteStateMachine(SageObject):
         except LookupError:
             return False
 
-    def has_initial_states(self):
+    def has_initial_states(self) -> bool:
         """
         Return whether the finite state machine has an initial state.
 
@@ -5499,7 +5499,7 @@ class FiniteStateMachine(SageObject):
         """
         return bool(self.initial_states())
 
-    def has_final_state(self, state):
+    def has_final_state(self, state) -> bool:
         """
         Return whether ``state`` is one of the final states of the
         finite state machine.
@@ -5520,7 +5520,7 @@ class FiniteStateMachine(SageObject):
         except LookupError:
             return False
 
-    def has_final_states(self):
+    def has_final_states(self) -> bool:
         """
         Return whether the finite state machine has a final state.
 

sage/combinat/posets/bubble_shuffle.py

@@ -0,0 +1,247 @@
+# sage_setup: distribution = sagemath-graphs
+# sage.doctest: needs sage.combinat sage.modules
+r"""
+Bubble and Shuffle lattices
+
+Shuffle lattices were defined by Greene in [Gre1988]_.
+
+Bubble lattices were introduced by McConville and Mühle in [MacCM2022]_.
+
+The Bubble lattice `B_{m,n}` and the Shuffle lattice `S_{m,n}` share
+the same underlying set, namely all shuffles of two subwords of the
+two words `X = (x_1,x_2,\ldots,x_{m})` and `Y = (y_1,y_2,\ldots,y_n)`.
+
+.. NOTE::
+
+    In the implementation here, the underlying set is the set of all shuffles
+    of subsets of `\{-m,\ldots,-1\}` with subsets of `\{1,\ldots,n\}`.
+"""
+from typing import Iterator
+
+from sage.combinat.posets.lattices import LatticePoset
+from sage.combinat.subset import subsets
+from sage.graphs.digraph import DiGraph
+from sage.graphs.graph import Graph
+from sage.misc.lazy_import import lazy_import
+from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
+
+lazy_import('sage.combinat.shuffle', 'ShuffleProduct')
+
+
+def bubble_cardinality(m, n) -> Integer:
+    r"""
+    Return the cardinality of the Bubble lattice `B_{m,n}`.
+
+    We have
+
+    .. MATH::
+
+        |B_{m,n}| = \sum_{i=0}^m \sum_{j=0}^n \binom{i+j}{j} \binom{m}{i} \binom{n}{j}.
+
+    This is also the cardinality of the Shuffle lattice `S_{m,n}`.
+
+    INPUT:
+
+    - ``m`` -- integer
+    - ``n`` -- integer
+
+    EXAMPLES::
+
+        sage: from sage.combinat.posets.bubble_shuffle import bubble_cardinality
+        sage: bubble_cardinality(2,1)
+        12
+    """
+    return ZZ.sum(ZZ(i + j).binomial(j) * ZZ(m).binomial(i) * ZZ(n).binomial(j)
+                  for i in range(m + 1) for j in range(n + 1))
+
+
+def bubble_set(m, n) -> Iterator[tuple[int, ...]]:
+    r"""
+    Return the underlying set of the Bubble lattice `B_{m,n}`.
+
+    This is the set of all shuffles of subsets of `\{-m,\ldots,-1\}`
+    with subsets of `\{1,\ldots,n\}`.
+
+    This is also the underlying set of the Shuffle lattice `S_{m,n}`.
+
+    INPUT:
+
+    - ``m`` -- integer
+    - ``n`` -- integer
+
+    EXAMPLES::
+
+        sage: from sage.combinat.posets.bubble_shuffle import bubble_set
+        sage: list(bubble_set(2,1))
+        [(),
+         (1,),
+         (-1,),
+         (-1, 1),
+         (1, -1),
+         (-2,),
+         (-2, 1),
+         (1, -2),
+         (-1, -2),
+         (-1, -2, 1),
+         (1, -1, -2),
+         (-1, 1, -2)]
+    """
+    X = [-i for i in range(1, m + 1)]
+    Y = list(range(1, n + 1))
+    for subX in subsets(X):
+        wX = tuple(subX)
+        for subY in subsets(Y):
+            for shu in ShuffleProduct(wX, tuple(subY)):
+                yield tuple(shu)
+
+
+def bubble_coverings(m, n, mot, transpose=True) -> Iterator[tuple[int, ...]]:
+    """
+    Return generating relations of the Bubble lattice `B_{m,n}`.
+
+    Note that these relations include the cover relations, but not only them.
+
+    This can also produce covers in the Shuffle lattice `S_{m,n}`.
+
+    INPUT:
+
+    - ``m`` -- integer
+    - ``n`` -- integer
+    - ``mot`` -- element of `B_{m,n}` as a tuple
+    - ``transpose`` -- boolean (default: ``True``) whether to return covers
+      in the Bubble lattice or in the Shuffle lattice
+
+    EXAMPLES::
+
+        sage: from sage.combinat.posets.bubble_shuffle import bubble_coverings
+        sage: list(bubble_coverings(2, 1, (-2, 1)))
+        [(1,), (1, -2)]
+        sage: list(bubble_coverings(2, 1, (-2, 1), False))
+        [(1,)]
+    """
+    # removal of one x
+    for j, letter in enumerate(mot):
+        if letter < 0:
+            yield tuple(mot[:j] + mot[j + 1:])
+
+    # insertion of one y
+    for j in range(len(mot) + 1):
+        debut, fin = tuple(mot[:j]), tuple(mot[j:])
+        yavant = max((letter for letter in debut if letter > 0), default=0)
+        yapres = min((letter for letter in fin if letter > 0), default=n + 1)
+        for y in range(yavant + 1, yapres):
+            yield debut + (y,) + fin
+
+    if not transpose:
+        return
+
+    # exchange from xy to yx
+    for j in range(len(mot) - 1):
+        if mot[j] < 0 and mot[j + 1] > 0:
+            mot2 = list(mot)
+            mot2[j] = mot[j + 1]
+            mot2[j + 1] = mot[j]
+            yield tuple(mot2)
+
+
+def BubblePoset(m, n) -> LatticePoset:
+    r"""
+    Return the Bubble lattice `B_{m,n}`.
+
+    Bubble lattices were introduced by McConville and Mühle in [MacCM2022]_.
+
+    The Bubble lattice `B_{m,n}` and the Shuffle lattice `S_{m,n}` share
+    the same underlying set, namely all shuffles of two subwords of the
+    two words `X = (x_1,x_2,\ldots,x_{m})` and `Y = (y_1,y_2,\ldots,y_n)`.
+
+    The Bubble poset is an extension of the Shuffle poset, by adding the
+    exchange of adjacent letters from `X` and `Y`, from `xy` to `yx`.
+
+    .. SEEALSO::
+
+        :func:`ShufflePoset`, :func:`noncrossing_bipartite_complex`
+
+    EXAMPLES::
+
+        sage: P = posets.BubblePoset(2,1); P
+        Finite lattice containing 12 elements
+        sage: P.zeta_polynomial()
+        1/40*q^5 + 7/24*q^4 + 23/24*q^3 - 7/24*q^2 + 1/60*q
+    """
+    bubbles = list(bubble_set(m, n))
+
+    dg = DiGraph([(x, y) for x in bubbles for y in bubble_coverings(m, n, x)])
+    # here we have more than just the cover relations
+    return LatticePoset(dg)
+
+
+def ShufflePoset(m, n) -> LatticePoset:
+    r"""
+    Return the Shuffle lattice `S_{m,n}`.
+
+    Shuffle lattices were defined by Greene in [Gre1988]_.
+
+    The Bubble lattice `B_{m,n}` and the Shuffle lattice `S_{m,n}` share
+    the same underlying set, namely all shuffles of two subwords of the
+    two words `X = (x_1,x_2,\ldots,x_{m})` and `Y = (y_1,y_2,\ldots,y_n)`.
+
+    The partial order in the Shuffle poset is defined by either inserting a
+    letter from `Y` or deleting a letter from `X`.
+
+    .. SEEALSO:: :func:`BubblePoset`
+
+    EXAMPLES::
+
+        sage: P = posets.ShufflePoset(2,1); P
+        Finite lattice containing 12 elements
+        sage: P.zeta_polynomial()
+        2*q^3 - q^2
+    """
+    bubbles = list(bubble_set(m, n))
+
+    dg = DiGraph([(x, y) for x in bubbles
+                  for y in bubble_coverings(m, n, x, transpose=False)])
+    # here we just have the cover relations
+    return LatticePoset(dg, cover_relations=True)
+
+
+def noncrossing_bipartite_complex(m, n):
+    """
+    Return a simplicial complex related to the Bubble lattice `B_{m,n}`.
+
+    This is a pure spherical simplicial complex, whose flip graph
+    is isomorphic to the Hasse diagram of `B_{m,n}`.
+
+    .. SEEALSO:: :func:`BubblePoset`
+
+    EXAMPLES::
+
+        sage: C = simplicial_complexes.NoncrossingBipartiteComplex(2,1)
+        sage: H = C.flip_graph()
+        sage: P = posets.BubblePoset(2,1)
+        sage: H.is_isomorphic(P.hasse_diagram().to_undirected())
+        True
+    """
+    vertices: list[tuple] = [("x", i) for i in range(1, m + 1)]
+    vertices.extend(("y", i) for i in range(1, n + 1))
+    vertices.extend(("xy", i, j) for i in range(m + 1) for j in range(n + 1)
+                    if i or j)
+
+    def compatible(v: tuple, w: tuple) -> bool:
+        if v == w:
+            return False
+        if v[0] != "xy" and w[0] != "xy":
+            return True
+        if v[0] == "xy" and w[0] == "xy":
+            return not ((w[1] < v[1] and w[2] > v[2])
+                        or (v[1] < w[1] and v[2] > w[2]))
+        if v[0] == "xy":
+            if w[0] == "x":
+                return v[1] != w[1]
+            return v[2] != w[1]
+        if v[0] == "x":
+            return w[1] != v[1]
+        return w[2] != v[1]
+
+    return Graph([vertices, compatible]).clique_complex()

sage/combinat/posets/d_complete.py

@@ -127,8 +127,8 @@ class DCompletePoset(FiniteJoinSemilattice):
                     queue.append(c)
                     enqueued.add(c)
 
-        poset_hooks = {self._vertex_to_element(key): ZZ(value) for (key, value) in hooks.items()}
-        return poset_hooks
+        return {self._vertex_to_element(key): ZZ(value)
+                for (key, value) in hooks.items()}
 
     def get_hook(self, elmt):
         r"""
@@ -143,7 +143,7 @@ class DCompletePoset(FiniteJoinSemilattice):
         """
         return self._hooks[elmt]
 
-    def get_hooks(self):
+    def get_hooks(self) -> dict:
         r"""
         Return all the hook lengths as a dictionary.
 

sage/combinat/posets/elements.py

@@ -54,7 +54,7 @@ class PosetElement(Element):
             self.element = element
         self.vertex = vertex
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         r"""
         TESTS::
 
@@ -65,7 +65,7 @@ class PosetElement(Element):
         """
         return hash(self.element)
 
-    def _repr_(self):
+    def _repr_(self) -> str:
         """
         TESTS::
 
@@ -74,7 +74,7 @@ class PosetElement(Element):
         """
         return "%s" % str(self.element)
 
-    def _latex_(self):
+    def _latex_(self) -> str:
         r"""
         Return the latex code of the poset element.
 

sage/combinat/posets/hasse_cython.pyx

@@ -117,7 +117,7 @@ class IncreasingChains(RecursivelyEnumeratedSet_forest):
             return True
         if self._conversion is not None:
             tup = [self._from_poset[elt] for elt in tup]
-        if any(not(0 <= i < self._n) for i in tup):
+        if not all(0 <= i < self._n for i in tup):
             return False
         y = tup[0]
         for k in range(1, len(tup)):

sage/combinat/posets/hasse_diagram.py

@@ -92,7 +92,7 @@ class HasseDiagram(DiGraph):
         Hasse diagram of a poset containing 4 elements
         sage: TestSuite(H).run()
     """
-    def _repr_(self):
+    def _repr_(self) -> str:
         r"""
         TESTS::
 
@@ -260,9 +260,9 @@ class HasseDiagram(DiGraph):
         """
         if lin_ext is None or lin_ext == list(range(len(self))):
             return all(x < y for x, y in self.cover_relations_iterator())
-        else:
-            return all(lin_ext.index(x) < lin_ext.index(y)
-                       for x, y in self.cover_relations_iterator())
+        indices = {x: lin_ext.index(x) for x in self}
+        return all(indices[x] < indices[y]
+                   for x, y in self.cover_relations_iterator())
 
     def cover_relations_iterator(self):
         r"""
@@ -604,7 +604,7 @@ class HasseDiagram(DiGraph):
         self._intervals = [[sorted(up.intersection(down)) for down in v_down]
                            for up in v_up]
 
-    def interval(self, x, y):
+    def interval(self, x, y) -> list:
         r"""
         Return a list of the elements `z` of ``self`` such that
         `x \leq z \leq y`.
@@ -674,7 +674,7 @@ class HasseDiagram(DiGraph):
 
     closed_interval = interval
 
-    def open_interval(self, x, y):
+    def open_interval(self, x, y) -> list:
         """
         Return a list of the elements `z` of ``self`` such that `x < z < y`.
 
@@ -694,8 +694,7 @@ class HasseDiagram(DiGraph):
         ci = self.interval(x, y)
         if not ci:
             return []
-        else:
-            return ci[1:-1]
+        return ci[1:-1]
 
     def rank_function(self):
         r"""
@@ -842,8 +841,7 @@ class HasseDiagram(DiGraph):
         """
         if element is None:
             return len(self.level_sets()) - 1
-        else:
-            return self.rank_function()(element)
+        return self.rank_function()(element)
 
     def is_ranked(self) -> bool:
         r"""
@@ -1185,10 +1183,9 @@ class HasseDiagram(DiGraph):
         """
         if algorithm == 'matrix':
             return - self.lequal_matrix() * self.moebius_function_matrix().transpose()
-        elif algorithm == 'cython':
+        if algorithm == 'cython':
             return coxeter_matrix_fast(self._leq_storage)  # noqa: F821
-        else:
-            raise ValueError("unknown algorithm")
+        raise ValueError("unknown algorithm")
 
     def order_filter(self, elements):
         r"""
@@ -1404,8 +1401,7 @@ class HasseDiagram(DiGraph):
         """
         if boolean:
             return self._leq_matrix_boolean
-        else:
-            return self._leq_matrix
+        return self._leq_matrix
 
     def _alternate_is_lequal(self, i, j):
         r"""
@@ -1894,8 +1890,7 @@ class HasseDiagram(DiGraph):
         if n < 3:
             if return_list:
                 return []
-            else:
-                return None
+            return None
         result = []  # Never take the bottom element to list.
         m = 0
         for i in range(n - 1):
@@ -1905,8 +1900,7 @@ class HasseDiagram(DiGraph):
                 if not return_list:
                     if m < n - 1:
                         return m
-                    else:
-                        return None
+                    return None
                 result.append(m)
         result.pop()  # Remove the top element.
         return result
@@ -2946,7 +2940,7 @@ class HasseDiagram(DiGraph):
 
         return True
 
-    def neutral_elements(self):
+    def neutral_elements(self) -> set:
         """
         Return the list of neutral elements of the lattice.
 
@@ -2994,7 +2988,7 @@ class HasseDiagram(DiGraph):
         mt = self.meet_matrix()
         jn = self.join_matrix()
 
-        def is_neutral(a):
+        def is_neutral(a) -> bool:
             noncomp = all_elements.difference(self.depth_first_search(a))
             noncomp.difference_update(self.depth_first_search(a, neighbors=self.neighbor_in_iterator))
 
@@ -3086,7 +3080,7 @@ class HasseDiagram(DiGraph):
                 result = e
         return result
 
-    def atoms_of_congruence_lattice(self):
+    def atoms_of_congruence_lattice(self) -> list:
         r"""
         Return atoms of the congruence lattice.
 

sage/combinat/posets/hochschild_lattice.py

@@ -0,0 +1,158 @@
+# sage_setup: distribution = sagemath-graphs
+# sage.doctest: needs sage.modules
+r"""
+Hochschild lattices
+
+Hochschild lattices were defined in [Cha2020]_ as posets and
+shown to be congruence uniform lattices in [Com2021]_.
+
+The name comes from the Hochschild polytopes introduced by Sanebdlidze
+in [San2009]_ for the study of free loop spaces in algebraic topology.
+The Hasse diagram of the Hochschild lattice is an orientation of the
+1-skeleton of the Hochschild polytope.
+
+For `n \geq 1`, the cardinality of the Hochschild lattice `H_n` is
+`2^{n - 2} \times (n + 3)`, starting with
+`2, 5, 12, 28, 64, 144, 320, 704, 1536, 3328, 7168, 15360, \ldots`.
+
+The underlying set of `H_n` consists of some words in the alphabet
+`(0,1,2)`, whose precise description can be found in [Com2021]_.
+"""
+from typing import Iterator
+
+from sage.combinat.posets.lattices import LatticePoset
+from sage.topology.simplicial_complex import SimplicialComplex
+
+
+def hochschild_lattice(n) -> LatticePoset:
+    r"""
+    Return the Hochschild lattice `H_n`.
+
+    INPUT:
+
+    - `n \geq 1` -- an integer
+
+    The cardinality of `H_n` is `2^{n - 2} \times (n + 3)`.
+
+    .. SEEALSO:: :func:`hochschild_simplicial_complex`, :func:`hochschild_fan`
+
+    EXAMPLES::
+
+        sage: P = posets.HochschildLattice(5); P
+        Finite lattice containing 64 elements
+        sage: P.degree_polynomial()
+        x^5 + 9*x^4*y + 22*x^3*y^2 + 22*x^2*y^3 + 9*x*y^4 + y^5
+
+    TESTS::
+
+        sage: posets.HochschildLattice(0)
+        Traceback (most recent call last):
+        ...
+        ValueError: this requires n >= 1
+    """
+    if n <= 0:
+        raise ValueError("this requires n >= 1")
+
+    def iterator_True(n) -> Iterator[tuple[int, ...]]:
+        """
+        Iterator over part of the underlying set.
+        """
+        if n == 0:
+            yield ()
+            return
+        for w in iterator_True(n - 1):
+            yield (0,) + w
+            yield (2,) + w
+
+    def iterator_False(n) -> Iterator[tuple[int, ...]]:
+        """
+        Iterator over rest of the underlying set.
+        """
+        if n == 0:
+            yield ()
+            return
+        for w in iterator_True(n - 1):
+            yield (0,) + w
+        for w in iterator_False(n - 1):
+            yield (1,) + w
+            yield (2,) + w
+
+    def sommets(n) -> Iterator[tuple[int, ...]]:
+        """
+        Iterator over the full underlying set.
+        """
+        for w in iterator_True(n - 1):
+            yield (0,) + w
+        for w in iterator_False(n - 1):
+            yield (1,) + w
+
+    verts = list(sommets(n))
+
+    def compare(a, b) -> bool:
+        return all(ai <= bi for ai, bi in zip(a, b))
+
+    return LatticePoset([verts, compare])
+
+
+def hochschild_fan(n):
+    """
+    Return Saneblidze's fan for the Hochschild polytope.
+
+    The dual polytope is obtained from a standard simplex
+    by a sequence of truncations.
+
+    .. SEEALSO::
+
+        :func:`hochschild_simplicial_complex`, :func:`hochschild_lattice`
+
+    EXAMPLES::
+
+        sage: # needs sage.geometry.polyhedron
+        sage: from sage.combinat.posets.hochschild_lattice import hochschild_fan
+        sage: F = hochschild_fan(4); F
+        Rational polyhedral fan in 4-d lattice N
+        sage: F.f_vector()
+        (1, 11, 39, 56, 28)
+    """
+    from sage.geometry.cone import Cone
+    from sage.geometry.fan import Fan
+    from sage.modules.free_module_element import vector
+
+    rays = [vector([1] * n)]
+    rays.extend(vector([0 if j != i else -1 for j in range(n)])
+                for i in range(n))
+
+    cones = [Cone([rays[j] for j in range(n + 1) if j != i])
+             for i in range(n + 1)]
+
+    # standard fan of projective space Pn
+    F = Fan(cones, check=False)
+
+    # double sequence of blowups
+    subdiv = [sum(r for r in rays[k + 1:]) for k in range(n - 1)]
+    subdiv.extend(sum(r for r in rays[:n - k]) for k in range(n - 1))
+
+    return F.subdivide(subdiv)
+
+
+def hochschild_simplicial_complex(n) -> SimplicialComplex:
+    """
+    Return a simplicial complex related to the Hochschild lattice `H_n`.
+
+    This is a pure spherical simplicial complex, whose flip graph
+    is isomorphic to the Hasse diagram of `H_n`.
+
+    .. SEEALSO:: :func:`hochschild_fan`, :func:`hochschild_lattice`
+
+    EXAMPLES::
+
+        sage: # needs sage.geometry.polyhedron
+        sage: C = simplicial_complexes.HochschildSphere(3); C
+        Simplicial complex with 8 vertices and 12 facets
+        sage: H = C.flip_graph()
+        sage: P = posets.HochschildLattice(3)
+        sage: H.is_isomorphic(P.hasse_diagram().to_undirected())
+        True
+    """
+    F = hochschild_fan(n)
+    return SimplicialComplex([C.rays() for C in F.cones(n)])