passagemath-graphs 10.5.10__cp39-cp39-macosx_14_0_arm64.whl → 10.5.43__cp39-cp39-macosx_14_0_arm64.whl

sage/combinat/designs/group_divisible_designs.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.rings.finite_rings
 r"""
-Group-Divisible Designs (GDD)
+Group-divisible designs (GDD)
 
 This module gathers everything related to Group-Divisible Designs. The
 constructions defined here can be accessed through ``designs.<tab>``::

sage/combinat/designs/incidence_structures.py

@@ -365,11 +365,11 @@ class IncidenceStructure:
             True
             sage: ["Am", "I", "finally", "done ?"] in IS
             False
-            sage: IS = designs.ProjectiveGeometryDesign(3, 1, GF(2),                    # needs sage.combinat
+            sage: IS = designs.ProjectiveGeometryDesign(3, 1, GF(2),                    # needs sage.combinat sage.modules
             ....:                                       point_coordinates=False)
-            sage: [3,8,7] in IS                                                         # needs sage.combinat
+            sage: [3,8,7] in IS                                                         # needs sage.combinat sage.modules
             True
-            sage: [3,8,9] in IS                                                         # needs sage.combinat
+            sage: [3,8,9] in IS                                                         # needs sage.combinat sage.modules
             False
         """
         try:
@@ -1508,10 +1508,10 @@ class IncidenceStructure:
             sage: BD.is_t_design(0,6,3,7) or BD.is_t_design(0,7,4,7) or BD.is_t_design(0,7,3,8)
             False
 
-            sage: BD = designs.AffineGeometryDesign(3, 1, GF(2))                        # needs sage.combinat
-            sage: BD.is_t_design(1)                                                     # needs sage.combinat
+            sage: BD = designs.AffineGeometryDesign(3, 1, GF(2))                        # needs sage.combinat sage.modules
+            sage: BD.is_t_design(1)                                                     # needs sage.combinat sage.modules
             True
-            sage: BD.is_t_design(2)                                                     # needs sage.combinat
+            sage: BD.is_t_design(2)                                                     # needs sage.combinat sage.modules
             True
 
         Steiner triple and quadruple systems are other names for `2-(v,3,1)` and
@@ -1924,8 +1924,8 @@ class IncidenceStructure:
             sage: TD.is_resolvable()
             True
 
-            sage: AG = designs.AffineGeometryDesign(3,1,GF(2))                          # needs sage.combinat
-            sage: AG.is_resolvable()                                                    # needs sage.combinat
+            sage: AG = designs.AffineGeometryDesign(3,1,GF(2))                          # needs sage.combinat sage.modules
+            sage: AG.is_resolvable()                                                    # needs sage.combinat sage.modules
             True
 
         Their classes::

sage/combinat/designs/latin_squares.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.modules
 r"""
-Mutually Orthogonal Latin Squares (MOLS)
+Mutually orthogonal Latin squares (MOLS)
 
 The main function of this module is :func:`mutually_orthogonal_latin_squares`
 and can be can be used to generate MOLS (or check that they exist)::

sage/combinat/designs/orthogonal_arrays_build_recursive.py

@@ -257,7 +257,7 @@ def construction_3_5(k, n, m, r, s, t, explain_construction=False):
     group_k_3 = [B[-1] for B in master_design if B[-3] not in group_k_1 and B[-2] not in group_k_2]
     group_k_3 = list(set(group_k_3))
     assert len(group_k_3) <= t
-    group_k_3.extend([x for x in range(q) if x not in group_k_3])
+    group_k_3.extend(x for x in range(q) if x not in group_k_3)
     group_k_3 = group_k_3[:t]
 
     # Relabelling the OA
@@ -546,7 +546,7 @@ def construction_q_x(k, q, x, check=True, explain_construction=False):
     # delete points.
     #
     # TD.extend([range(i*q,(i+1)*q) for i in range(x)])
-    TD.extend([list(range(i*q,(i+1)*q))+[p2] for i in range(x,q)])
+    TD.extend(list(range(i*q,(i+1)*q))+[p2] for i in range(x,q))
 
     points_to_delete = set([i*q+j for i in range(x) for j in range(1,q)]+[i*q for i in range(x,q)])
     points_to_keep = set(range(q**2+2))-points_to_delete
@@ -838,14 +838,14 @@ def thwart_lemma_4_1(k, n, m, explain_construction=False):
     # - (1+t,t,1+t), (1,1,1), (1+t,t,t), (1,1,2), (0,0,1), (1,0,1), (0,1,1+t),
     #   (0,1,1), (1,0,-t)
     points = [(1+t,t,1+t), (1,1,1), (1+t,t,t), (1,1,2), (0,0,1), (1,0,1), (0,1,1+t), (0,1,1), (1,0,-t)]
-    points = [[K(_) for _ in t] for t in points] # triples of K^3
+    points = [[K(c) for c in t] for t in points] # triples of K^3
     AG_2_3 = []
     for x,y,z in points:
         if z != 0:
-            x,y,z = x/z,y/z,z/z
+            x, y, z = x / z, y / z, K.one()
             AG_2_3.append(relabel[x]+n*relabel[y])
         elif y != 0:
-            x,y,z = x/y,y/y,z
+            x, y = x / y, K.one()
             AG_2_3.append(q**2+relabel[x])
         else:
             AG_2_3.append(q**2+q)
@@ -1003,7 +1003,7 @@ def three_factor_product(k, n1, n2, n3, check=False, explain_construction=False)
       Rolf S. Rees,
       Journal of Combinatorial Designs 1.1 (1993): 15-26.
     """
-    assert n1 <= n2 and n2 <= n3
+    assert n1 <= n2 <= n3
 
     if explain_construction:
         return ("Three-factor product with n={}.{}.{} from:\n" +
@@ -1569,7 +1569,8 @@ def brouwer_separable_design(k, t, q, x, check=False, verbose=False, explain_con
         blocks_of_size_q_plus_t = _reorder_matrix(blocks_of_size_q_plus_t)
 
         for i,classs in enumerate(OA_tq1_classes):
-            OA.extend([R[xx] if xx < t+q else N-i-1 for xx in B] for R in blocks_of_size_q_plus_t for B in classs)
+            OA.extend([R[xx] if xx < t+q else N-i-1 for xx in B]
+                      for R in blocks_of_size_q_plus_t for B in classs)
 
         # The set of size x
         OA.extend([N-1-xx for xx in R] for R in orthogonal_array(k,x))

sage/combinat/designs/resolvable_bibd.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.rings.finite_rings
 r"""
-Resolvable Balanced Incomplete Block Design (RBIBD)
+Resolvable balanced incomplete block design (RBIBD)
 
 This module contains everything related to resolvable Balanced Incomplete Block
 Designs. The constructions implemented here can be obtained through the

sage/combinat/designs/steiner_quadruple_systems.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Steiner Quadruple Systems
+Steiner quadruple systems
 
 A Steiner Quadruple System on `n` points is a family `SQS_n \subset \binom {[n]}
 4` of `4`-sets, such that any set `S\subset [n]` of size three is a subset of

sage/combinat/designs/subhypergraph_search.pyx

@@ -179,21 +179,21 @@ cdef hypergraph h_init(int n, list H) noexcept:
     """
     cdef int x,i
     cdef hypergraph h
-    h.n          = n
-    h.m          = len(H)
-    h.limbs      = (n+63) // 64  # =ceil(n/64)
-    h.names      = <int *>  sig_malloc(sizeof(int)*n)
-    h.sets       = <uint64_t **> sig_malloc(h.m*sizeof(uint64_t *))
-    h.set_space  = <uint64_t *>  sig_calloc(h.m*(h.limbs+1),sizeof(uint64_t))
+    h.n = n
+    h.m = len(H)
+    h.limbs = (n+63) // 64  # =ceil(n/64)
+    h.names = <int *> sig_malloc(sizeof(int)*n)
+    h.sets = <uint64_t **> sig_malloc(h.m*sizeof(uint64_t *))
+    h.set_space = <uint64_t *> sig_calloc(h.m*(h.limbs+1),sizeof(uint64_t))
 
     # Consistency check
     for S in H:
         for x in S:
-            if x<0 or x>=n:
+            if x < 0 or x >= n:
                 h.n = -1
 
-    if (h.names     == NULL or
-        h.sets      == NULL or
+    if (h.names == NULL or
+        h.sets == NULL or
         h.set_space == NULL or
         h.n == -1):
         h.n = -1

sage/combinat/finite_state_machine_generators.py

@@ -1,9 +1,9 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.graphs sage.modules
 r"""
-Common Automata and Transducers (Finite State Machines Generators)
+Common automata and transducers (finite state machines generators)
 
-Automata and Transducers in Sage can be built through the
+Automata and transducers in Sage can be built through the
 :class:`automata <AutomatonGenerators>`
 and :class:`transducers <TransducerGenerators>` objects, respectively.
 It contains generators for

sage/combinat/graph_path.py

@@ -1,8 +1,8 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Paths in Directed Acyclic Graphs
+Paths in directed acyclic graphs
 """
-#*****************************************************************************
+# ****************************************************************************
 #       Copyright (C) 2007 Mike Hansen <mhansen@gmail.com>,
 #
 #  Distributed under the terms of the GNU General Public License (GPL)
@@ -15,7 +15,7 @@ Paths in Directed Acyclic Graphs
 #  The full text of the GPL is available at:
 #
 #                  http://www.gnu.org/licenses/
-#*****************************************************************************
+# ****************************************************************************
 
 from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
 from sage.structure.parent import Parent

sage/combinat/interval_posets.py

@@ -48,6 +48,7 @@ from sage.misc.latex import latex
 from sage.misc.lazy_attribute import lazy_attribute
 from sage.misc.lazy_import import lazy_import
 from sage.rings.integer import Integer
+from sage.rings.integer_ring import ZZ
 from sage.rings.semirings.non_negative_integer_semiring import NN
 from sage.sets.non_negative_integers import NonNegativeIntegers
 from sage.sets.disjoint_union_enumerated_sets import DisjointUnionEnumeratedSets
@@ -593,8 +594,8 @@ class TamariIntervalPoset(Element,
         n = self._size
         m = other.size()
         relations = self._poset.cover_relations()
-        relations.extend([(i + n, j + n)
-                          for i, j in other._poset.cover_relations_iterator()])
+        relations.extend((i + n, j + n)
+                         for i, j in other._poset.cover_relations_iterator())
         P = FinitePoset(DiGraph([list(range(1, n + m + 1)), relations],
                                 format='vertices_and_edges'))  # type:ignore
         return TamariIntervalPoset(P, check=False)  # type:ignore
@@ -1981,9 +1982,9 @@ class TamariIntervalPoset(Element,
         relations = [(i - start + 1, j - start + 1)
                      for (i, j) in self.increasing_cover_relations()
                      if i >= start and j < end]
-        relations.extend([(j - start + 1, i - start + 1)
-                          for (j, i) in self.decreasing_cover_relations()
-                          if i >= start and j < end])
+        relations.extend((j - start + 1, i - start + 1)
+                         for (j, i) in self.decreasing_cover_relations()
+                         if i >= start and j < end)
         return TamariIntervalPoset(end - start, relations, check=False)
 
     sub_poset = subposet
@@ -3111,7 +3112,7 @@ class TamariIntervalPosets(UniqueRepresentation, Parent):
             rroots, rrelations, rindex = get_relations(bt[1], start=index + 1)
             roots.append(index)
             relations.extend(rrelations)
-            relations.extend([(j, index) for j in rroots])
+            relations.extend((j, index) for j in rroots)
             return roots, relations, rindex
 
         _, relations, index = get_relations(binary_tree)
@@ -3225,7 +3226,7 @@ class TamariIntervalPosets(UniqueRepresentation, Parent):
             roots, relations, rindex = get_relations(bt[1], start=index + 1)
             roots.append(index)
             relations.extend(lrelations)
-            relations.extend([(j, index) for j in lroots])
+            relations.extend((j, index) for j in lroots)
             return roots, relations, rindex
 
         _, relations, index = get_relations(binary_tree)
@@ -3758,11 +3759,10 @@ class TamariIntervalPosets_size(TamariIntervalPosets):
             sage: [TamariIntervalPosets(i).cardinality() for i in range(6)]
             [1, 1, 3, 13, 68, 399]
         """
-        from sage.arith.misc import binomial
         n = self._size
         if n == 0:
-            return Integer(1)
-        return (2 * binomial(4 * n + 1, n - 1)) // (n * (n + 1))
+            return ZZ.one()
+        return (2 * Integer(4 * n + 1).binomial(n - 1)) // (n * (n + 1))
         # return Integer(2 * factorial(4*n+1)/(factorial(n+1)*factorial(3*n+2)))
 
     def __iter__(self) -> Iterator[TIP]:

sage/combinat/ordered_tree.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-graphs
 """
-Ordered Rooted Trees
+Ordered rooted trees
 
 AUTHORS:
 

sage/combinat/posets/cartesian_product.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-graphs
 """
-Cartesian products of Posets
+Cartesian products of posets
 
 AUTHORS:
 

sage/combinat/posets/d_complete.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.combinat sage.modules
 r"""
-D-Complete Posets
+D-complete posets
 
 AUTHORS:
 

sage/combinat/posets/forest.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Forest Posets
+Forest posets
 
 AUTHORS:
 

sage/combinat/posets/hasse_diagram.py

@@ -2102,14 +2102,16 @@ class HasseDiagram(DiGraph):
             for e in orbit:
                 orbit_number[e] = ind
 
-        comps = [None] * n
         mt = self.meet_matrix()
         jn = self.join_matrix()
-        for e in range(n):
-            # Fix following after issue #20727
-            comps[e] = [x for x in range(n) if
-                        mt[e, x] == 0 and jn[e, x] == n - 1 and
-                        x in orbits[orbit_number[dual_isomorphism[e]]]]
+
+        items = ((e, dual_isomorphism[e]) for e in range(n))
+
+        # Fix following after issue #20727
+        comps = [[x for x in range(n)
+                  if mt[e, x] == 0 and jn[e, x] == n - 1 and
+                  x in orbits[orbit_number[dual_e]]]
+                 for e, dual_e in items]
 
         # Fitting is done by this recursive function:
         def recursive_fit(orthocomplements, unbinded):

sage/combinat/posets/incidence_algebras.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.modules
 r"""
-Incidence Algebras
+Incidence algebras
 """
 # ****************************************************************************
 #       Copyright (C) 2014 Travis Scrimshaw <tscrim at ucdavis.edu>
@@ -12,6 +12,8 @@ Incidence Algebras
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
+from copy import copy
+from typing import Any
 
 from sage.misc.cachefunc import cached_method
 from sage.misc.lazy_attribute import lazy_attribute
@@ -20,8 +22,6 @@ from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets
 from sage.combinat.free_module import CombinatorialFreeModule
 from sage.matrix.matrix_space import MatrixSpace
 
-from copy import copy
-
 
 class IncidenceAlgebra(CombinatorialFreeModule):
     r"""
@@ -450,22 +450,22 @@ class ReducedIncidenceAlgebra(CombinatorialFreeModule):
             sage: TestSuite(R).run()  # long time
         """
         self._ambient = I
-        EC = {}
+        EC: dict[Any, list] = {}
         P = self._ambient._poset
         if not P.is_finite():
             raise NotImplementedError("only implemented for finite posets")
         for i in self._ambient.basis().keys():
             S = P.subposet(P.interval(*i))
             added = False
-            for k in EC:
+            for k, ECk in EC.items():
                 if S._hasse_diagram.is_isomorphic(k._hasse_diagram):
-                    EC[k].append(i)
+                    ECk.append(i)
                     added = True
                     break
             if not added:
                 EC[S] = [i]
-        self._equiv_classes = map(sorted, EC.values())
-        self._equiv_classes = {cls[0]: cls for cls in self._equiv_classes}
+        equiv_classes = map(sorted, EC.values())
+        self._equiv_classes = {cls[0]: cls for cls in equiv_classes}
         cat = Algebras(I.base_ring()).FiniteDimensional().WithBasis()
         CombinatorialFreeModule.__init__(self, I.base_ring(),
                                          sorted(self._equiv_classes.keys()),

sage/combinat/posets/lattices.py

@@ -1293,7 +1293,8 @@ class FiniteLatticePoset(FiniteMeetSemilattice, FiniteJoinSemilattice):
 
             - Weaker properties: :meth:`is_join_semidistributive`,
               :meth:`is_meet_semidistributive`
-            - Stronger properties: :meth:`is_distributive`
+            - Stronger properties: :meth:`is_distributive`,
+              :meth:`is_congruence_uniform`
 
         TESTS::
 
@@ -3553,7 +3554,7 @@ class FiniteLatticePoset(FiniteMeetSemilattice, FiniteJoinSemilattice):
             True
         """
         # Rationale for naming of elements: a lattice can have
-        # elements 1, (1, 1), (1, (1, 1)) and so on. We can't just
+        # elements 1, (1, 1), (1, (1, 1)) and so on. We cannot just
         # make a copy of S with elements (s, 1).
 
         # The construction could be defined for any convex
@@ -3958,7 +3959,7 @@ class FiniteLatticePoset(FiniteMeetSemilattice, FiniteJoinSemilattice):
 
             Add a certificate-option.
         """
-        # Todo: This can be made much faster, if we don't regenerate meet- and
+        # Todo: This can be made much faster, if we do not regenerate meet- and
         # join-matrices every time, but instead remove some rows and columns
         # from them.
 
@@ -4274,7 +4275,7 @@ class FiniteLatticePoset(FiniteMeetSemilattice, FiniteJoinSemilattice):
 
         The congruence lattice of this lattice has maximal chains satisfying the needed
         property, but also maximal chains not satisfying that; this shows that the code
-        can't be optimized to test just some maximal chain::
+        cannot be optimized to test just some maximal chain::
 
             sage: L = LatticePoset(DiGraph('QSO?I?_?_GBG??_??a???@?K??A??B???C??s??G??I??@??A??@???'))
             sage: L.is_constructible_by_doublings('convex')                             # needs sage.combinat
@@ -4347,6 +4348,29 @@ class FiniteLatticePoset(FiniteMeetSemilattice, FiniteJoinSemilattice):
                     todo.append(e_up)
         return False
 
+    def is_congruence_uniform(self) -> bool:
+        """
+        Return whether ``self`` is congruence uniform.
+
+        This is equivalent to being constructible by doubling intervals.
+
+        .. SEEALSO:: :meth:`is_constructible_by_doublings`
+
+        EXAMPLES::
+
+            sage: P = posets.PentagonPoset()
+            sage: P.is_congruence_uniform()
+            True
+            sage: P = posets.DiamondPoset(5)
+            sage: P.is_congruence_uniform()
+            False
+
+        REFERENCES:
+
+        - [Day1979]_
+        """
+        return self.is_constructible_by_doublings(type="interval")
+
     def is_isoform(self, certificate=False):
         """
         Return ``True`` if the lattice is isoform and ``False`` otherwise.

sage/combinat/posets/linear_extension_iterator.pyx

@@ -160,6 +160,8 @@ def _linear_extension_gen(_D, list _le, list _a, list _b, list _is_plus, Py_ssiz
     if i == -1:
         return
 
+    import sage.matrix  # otherwise there will be a lot of "Exception ignored in: 'linear_extension_iterator._linear_extension_right_b'"
+
     for e in _linear_extension_gen(_D, _le, _a, _b, _is_plus, i-1):
         yield e
     mrb = 0

sage/combinat/posets/linear_extensions.py

@@ -1,16 +1,6 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Linear Extensions of Posets
-
-This module defines two classes:
-
-- :class:`LinearExtensionOfPoset`
-- :class:`LinearExtensionsOfPoset`
-- :class:`LinearExtensionsOfPosetWithHooks`
-- :class:`LinearExtensionsOfForest`
-
-Classes and methods
--------------------
+Linear extensions of posets
 """
 # ****************************************************************************
 #       Copyright (C) 2012 Anne Schilling <anne at math.ucdavis.edu>
@@ -532,7 +522,7 @@ class LinearExtensionsOfPoset(UniqueRepresentation, Parent):
             True
             sage: L._poset is P
             True
-            sage: TestSuite(L).run()
+            sage: TestSuite(L).run()                                                    # needs sage.modules
 
             sage: P = Poset((divisors(15), attrcall("divides")))
             sage: L = P.linear_extensions()
@@ -628,12 +618,12 @@ class LinearExtensionsOfPoset(UniqueRepresentation, Parent):
         for x in range(n):
             # Use the existing Jup table to compute all covering
             # relations in J(P) for things that are above loc(x).
-            K = [[loc[x]]]
+            K0 = [[loc[x]]]
             j = 0
-            while K[j]:
-                K.append([b for a in K[j] for b in Jup[a]])
+            while K0[j]:
+                K0.append([b for a in K0[j] for b in Jup[a]])
                 j += 1
-            K = sorted({item for sublist in K for item in sublist})
+            K = sorted({item for sublist in K0 for item in sublist})
             for j in range(len(K)):
                 i = m + j + 1
                 Jup[i] = [m + K.index(a) + 1 for a in Jup[K[j]]]
@@ -732,6 +722,7 @@ class LinearExtensionsOfPoset(UniqueRepresentation, Parent):
 
         EXAMPLES::
 
+            sage: # needs sage.modules
             sage: P = Poset(([1,2,3,4], [[1,3],[1,4],[2,3]]), linear_extension=True)
             sage: L = P.linear_extensions()
             sage: G = L.markov_chain_digraph(); G

sage/combinat/posets/moebius_algebra.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.modules
 r"""
-Möbius Algebras
+Möbius algebras
 """
 # ****************************************************************************
 #       Copyright (C) 2014 Travis Scrimshaw <tscrim at ucdavis.edu>,

sage/combinat/posets/poset_examples.py

@@ -1591,7 +1591,7 @@ class Posets(metaclass=ClasscallMetaclass):
 
         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)])
+        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)