passagemath-graphs 10.5.34__cp312-cp312-musllinux_1_2_aarch64.whl → 10.6.1rc1__cp312-cp312-musllinux_1_2_aarch64.whl

sage/combinat/designs/MOLS_handbook_data.py

@@ -1,11 +1,11 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Known lower bounds on the number of Mutually Orthogonal Latin
-Squares (MOLS) of a given size.
+Bounds on the number of mutually orthogonal Latin squares
 
-This module consists (almost) entirely of an internal, constant tuple
-of python integers corresponding to Table 3.87 in the Handbook of
-Combinatorial Designs, 2nd edition, by Colbourn and Dinitz. One public
+This module contains known lower bounds on the number of mutually orthogonal
+Latin squares (MOLS) of a given size, and consists (almost) entirely of an
+internal, constant tuple of Python integers corresponding to Table 3.87 in the
+Handbook of Combinatorial Designs, 2nd edition, by Colbourn and Dinitz. One public
 function, :func:`lower_bound`, is provided to access it.
 
 Make sure we have all of the entries::

sage/combinat/designs/bibd.py

@@ -1,6 +1,6 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Balanced Incomplete Block Designs (BIBD)
+Balanced incomplete block designs (BIBD)
 
 This module gathers everything related to Balanced Incomplete Block Designs. One can build a
 BIBD (or check that it can be built) with :func:`balanced_incomplete_block_design`::

sage/combinat/designs/covering_array.py

@@ -1,13 +1,13 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-Covering Arrays (CA)
+Covering arrays
 
-A Covering Array, denoted `CA(N;t,k,v)`, is an `N` by `k` array with
+A covering array, denoted `CA(N;t,k,v)`, is an `N` by `k` array with
 entries from a set of `v` elements with the property that in every
 selection of `t` columns, every sequence of `t` elements appears in at
 least one row.
 
-An Orthogonal Array, denoted `OA(N;t,k,v)` is a covering array with the
+An orthogonal array, denoted `OA(N;t,k,v)` is a covering array with the
 property that every sequence of `t`-elements appears in exactly one row.
 (See :mod:`sage.combinat.designs.orthogonal_arrays`).
 

sage/combinat/designs/covering_design.py

@@ -49,13 +49,11 @@ Classes and methods
 from urllib.request import urlopen
 from ssl import create_default_context as default_context
 
-from sage.misc.sage_eval import sage_eval
 from sage.structure.sage_object import SageObject
 from sage.rings.rational import Rational
 from sage.arith.misc import binomial
 from sage.combinat.combination import Combinations
 from sage.combinat.designs.incidence_structures import IncidenceStructure
-from sage.cpython.string import bytes_to_str
 
 
 def schonheim(v, k, t):
@@ -513,6 +511,8 @@ def best_known_covering_design_www(v, k, t, verbose=False):
     A :exc:`ValueError` is raised if the ``(v, k, t)`` parameters are not
     found in the database.
     """
+    from sage.misc.sage_eval import sage_eval
+
     v = int(v)
     k = int(k)
     t = int(t)
@@ -521,11 +521,8 @@ def best_known_covering_design_www(v, k, t, verbose=False):
     if verbose:
         print("Looking up the bounds at %s" % url)
 
-    f = urlopen(url, context=default_context())
-    try:
-        s = bytes_to_str(f.read())
-    finally:
-        f.close()
+    with urlopen(url, context=default_context()) as f:
+        s = f.read().decode()
 
     if 'covering not in database' in s:  # not found
         str = "no (%d, %d, %d) covering design in database\n" % (v, k, t)

sage/combinat/designs/database.py

@@ -1111,7 +1111,8 @@ def OA_10_205():
 
     B = [0, 1, 22, 33, 83, 122, 135, 141, 145, 159, 175, 200, 226, 229, 231, 238, 246]
     pplane = [[(xx+i) % pplane_size for xx in B] for i in range(pplane_size)]
-    baer_subplane = set([i*pplane_size/baer_subplane_size for i in range(baer_subplane_size)])
+    baer_subplane = {i * pplane_size / baer_subplane_size
+                     for i in range(baer_subplane_size)}
 
     p = list(baer_subplane)[0]
 
@@ -1530,8 +1531,8 @@ def OA_17_560():
     # We remove all elements except those from F_{p^alpha} in the last three
     # columns
 
-    elements_of_subgroup = set([x for x in G_set if x.polynomial().degree() < beta])
-    relabel = {G_to_int[v]:i for i,v in enumerate(elements_of_subgroup)}
+    elements_of_subgroup = {x for x in G_set if x.polynomial().degree() < beta}
+    relabel = {G_to_int[v]: i for i, v in enumerate(elements_of_subgroup)}
     for x in range(p**alpha):
         if x not in relabel:
             relabel[x] = None
@@ -2376,11 +2377,11 @@ def QDM_35_7_1_1_7():
     M = [
         [None,None,None,None,None,None,None],
         [   0,   0,   0,   0,   0,   0,   0],
-        [  18, -18,  11, -11,   5,  -5,   4],
+        [  18, -18,  11, -11,   5, -5,   4],
         [  26, -26,  10, -10,  30, -30,  23],
-        [  20, -20,   3,  -3,  33, -33,  23],
-        [   5,  -5,  25, -25,  24, -24,   4],
-        [  17, -17,   4,  -4,  22, -22,   0]
+        [  20, -20,   3, -3,  33, -33,  23],
+        [   5, -5,  25, -25,  24, -24,   4],
+        [  17, -17,   4, -4,  22, -22,   0]
         ]
 
     from sage.rings.finite_rings.integer_mod_ring import IntegerModRing as AdditiveCyclic
@@ -2417,10 +2418,10 @@ def QDM_45_7_1_1_9():
     M = [
         [None,None,None,None,None,None,None,None,None],
         [   0,   0,   0,   0,   0,   0,   0,   0,   0],
-        [   1,  27,  16,   7,  -1, -27, -16,  -7,   3],
-        [  24,  40,   1,  35, -24, -40,  -1, -35,   7],
+        [   1,  27,  16,   7, -1, -27, -16, -7,   3],
+        [  24,  40,   1,  35, -24, -40, -1, -35,   7],
         [  10,  30,  22,  44, -10, -30, -22, -44,   7],
-        [   5,  18,  14,  33,  -5, -18, -14, -33,   3],
+        [   5,  18,  14,  33, -5, -18, -14, -33,   3],
         [  30,  16,  33,  27, -30, -16, -33, -27,   0],
         ]
 

sage/combinat/designs/designs_pyx.pyx

@@ -949,12 +949,12 @@ cpdef _OA_cache_set(int k, int n, truth_value):
         _OA_cache_size = new_cache_size
 
     if truth_value is True:
-        _OA_cache[n].max_true    = k if k>_OA_cache[n].max_true    else _OA_cache[n].max_true
+        _OA_cache[n].max_true = k if k>_OA_cache[n].max_true else _OA_cache[n].max_true
     elif truth_value is Unknown:
         _OA_cache[n].min_unknown = k if k<_OA_cache[n].min_unknown else _OA_cache[n].min_unknown
         _OA_cache[n].max_unknown = k if k>_OA_cache[n].max_unknown else _OA_cache[n].max_unknown
     else:
-        _OA_cache[n].min_false   = k if k<_OA_cache[n].min_false   else _OA_cache[n].min_false
+        _OA_cache[n].min_false = k if k<_OA_cache[n].min_false else _OA_cache[n].min_false
 
 cpdef _OA_cache_get(int k, int n):
     r"""

sage/combinat/designs/difference_matrices.py

@@ -1,7 +1,7 @@
 # sage_setup: distribution = sagemath-graphs
 # sage.doctest: needs sage.rings.finite_rings
 r"""
-Difference Matrices
+Difference matrices
 
 This module gathers code related to difference matrices. One can build those
 objects (or know if they can be built) with :func:`difference_matrix`::

sage/combinat/designs/evenly_distributed_sets.pyx

@@ -534,7 +534,7 @@ cdef class EvenlyDistributedSetsBacktracker:
                     x += 1
                 else:
                     kk += 1
-                    x += m - x%m
+                    x += m - x % m
             else:
                 x += 1
 
@@ -555,7 +555,7 @@ cdef class EvenlyDistributedSetsBacktracker:
                     if self.check:
                         self._check_cosets(kk)
                 elif self.cosets[x / m]:
-                    x += m - x%m
+                    x += m - x % m
                 elif kk == 2:
                     if self.min_orb[x] < x:
                         x += 1
@@ -650,12 +650,12 @@ cdef class EvenlyDistributedSetsBacktracker:
         c = 0
         for i in range(self.e):
             c += self.cosets[i]
-        if c != (kk * (kk-1)) / 2:
+        if 2 * c != (kk * (kk-1)):
             raise RuntimeError("the number of elements in cosets is wrong! Got {} instead of {}.".format(c, (kk*(kk-1))/2))
 
         for i in range(kk):
             for j in range(i):
                 if self.cosets[ self.diff[self.B[i]][self.B[j]] / m ] != 1:
-                    raise RuntimeError("self.cosets misses the difference B[{}]-B[{}]".format(i,j))
+                    raise RuntimeError("self.cosets misses the difference B[{}]-B[{}]".format(i, j))
 
         return 0

sage/combinat/designs/ext_rep.py

@@ -1,13 +1,13 @@
 # sage_setup: distribution = sagemath-graphs
 r"""
-External Representations of Block Designs
+External representations of block designs
 
-The "ext_rep" module is an API to the abstract tree represented by
+This module is an API to the abstract tree represented by
 an XML document containing the External Representation of a list of
 block designs. The module also provides the related I/O operations for
-reading/writing ext-rep files or data. The parsing is based on expat.
+reading/writing ``ext-rep`` files or data. The parsing is based on expat.
 
-This is a modified form of the module ext_rep.py (version 0.8)
+This is a modified form of the module ``ext_rep.py`` (version 0.8)
 written by Peter Dobcsanyi [Do2009]_ peter@designtheory.org.
 
 .. TODO::
@@ -16,12 +16,9 @@ written by Peter Dobcsanyi [Do2009]_ peter@designtheory.org.
     information about things like automorphism groups, transitivity, cycle type
     representatives, etc, but none of this data is made available through the
     current implementation.
-
-Functions
----------
 """
 
-###########################################################################
+# ***********************************************************************
 # This software is released under the terms of the GNU General Public
 # License, version 2 or above (your choice). For details on licensing,
 # see the accompanying documentation.
@@ -29,9 +26,9 @@ Functions
 # This is a modified form of the module ext_rep.py (version 0.8)
 # written by Peter Dobcsanyi peter@designtheory.org.
 #
-# Copyright 2004 by Peter Dobcsanyi peter@designtheory.org, and copyright
-# 2009 Carlo Hamalainen carlo.hamalainen@gmail.com
-###########################################################################
+# Copyright 2004 Peter Dobcsanyi peter@designtheory.org
+#           2009 Carlo Hamalainen carlo.hamalainen@gmail.com
+# ***********************************************************************
 
 import sys
 import xml.parsers.expat
@@ -598,7 +595,6 @@ def _encode_attribute(string):
         sage: _encode_attribute('E')
         'E'
     """
-
     if pattern_integer.match(string):
         return int(string)
     elif pattern_decimal.match(string):
@@ -611,8 +607,7 @@ class XTree:
     '''
     A lazy class to wrap a rooted tree representing an XML document.
     The tree's nodes are tuples of the structure:
-
-        (name, {dictionary of attributes}, [list of children])
+    (name, {dictionary of attributes}, [list of children])
 
     Methods and services of an XTree object ``t``:
 

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)::
@@ -127,6 +127,8 @@ from itertools import repeat
 from sage.rings.integer import Integer
 from sage.categories.sets_cat import EmptySetError
 from sage.misc.unknown import Unknown
+from sage.arith.misc import is_prime_power
+from sage.rings.finite_rings.finite_field_constructor import GF
 
 
 def are_mutually_orthogonal_latin_squares(l, verbose=False):
@@ -240,22 +242,22 @@ def mutually_orthogonal_latin_squares(k, n, partitions=False, check=True):
 
         sage: designs.mutually_orthogonal_latin_squares(4,5)                            # needs sage.schemes
         [
-        [0 2 4 1 3]  [0 3 1 4 2]  [0 4 3 2 1]  [0 1 2 3 4]
-        [4 1 3 0 2]  [3 1 4 2 0]  [2 1 0 4 3]  [4 0 1 2 3]
-        [3 0 2 4 1]  [1 4 2 0 3]  [4 3 2 1 0]  [3 4 0 1 2]
-        [2 4 1 3 0]  [4 2 0 3 1]  [1 0 4 3 2]  [2 3 4 0 1]
-        [1 3 0 2 4], [2 0 3 1 4], [3 2 1 0 4], [1 2 3 4 0]
+        [0 1 2 3 4]  [0 1 2 3 4]  [0 1 2 3 4]  [0 1 2 3 4]
+        [1 2 3 4 0]  [2 3 4 0 1]  [3 4 0 1 2]  [4 0 1 2 3]
+        [2 3 4 0 1]  [4 0 1 2 3]  [1 2 3 4 0]  [3 4 0 1 2]
+        [3 4 0 1 2]  [1 2 3 4 0]  [4 0 1 2 3]  [2 3 4 0 1]
+        [4 0 1 2 3], [3 4 0 1 2], [2 3 4 0 1], [1 2 3 4 0]
         ]
 
         sage: designs.mutually_orthogonal_latin_squares(3,7)                            # needs sage.schemes
         [
-        [0 2 4 6 1 3 5]  [0 3 6 2 5 1 4]  [0 4 1 5 2 6 3]
-        [6 1 3 5 0 2 4]  [5 1 4 0 3 6 2]  [4 1 5 2 6 3 0]
-        [5 0 2 4 6 1 3]  [3 6 2 5 1 4 0]  [1 5 2 6 3 0 4]
-        [4 6 1 3 5 0 2]  [1 4 0 3 6 2 5]  [5 2 6 3 0 4 1]
-        [3 5 0 2 4 6 1]  [6 2 5 1 4 0 3]  [2 6 3 0 4 1 5]
-        [2 4 6 1 3 5 0]  [4 0 3 6 2 5 1]  [6 3 0 4 1 5 2]
-        [1 3 5 0 2 4 6], [2 5 1 4 0 3 6], [3 0 4 1 5 2 6]
+        [0 1 2 3 4 5 6]  [0 1 2 3 4 5 6]  [0 1 2 3 4 5 6]
+        [1 2 3 4 5 6 0]  [2 3 4 5 6 0 1]  [3 4 5 6 0 1 2]
+        [2 3 4 5 6 0 1]  [4 5 6 0 1 2 3]  [6 0 1 2 3 4 5]
+        [3 4 5 6 0 1 2]  [6 0 1 2 3 4 5]  [2 3 4 5 6 0 1]
+        [4 5 6 0 1 2 3]  [1 2 3 4 5 6 0]  [5 6 0 1 2 3 4]
+        [5 6 0 1 2 3 4]  [3 4 5 6 0 1 2]  [1 2 3 4 5 6 0]
+        [6 0 1 2 3 4 5], [5 6 0 1 2 3 4], [4 5 6 0 1 2 3]
         ]
 
         sage: designs.mutually_orthogonal_latin_squares(2,5,partitions=True)            # needs sage.schemes
@@ -269,16 +271,16 @@ def mutually_orthogonal_latin_squares(k, n, partitions=False, check=True):
           [2, 7, 12, 17, 22],
           [3, 8, 13, 18, 23],
           [4, 9, 14, 19, 24]],
-         [[0, 8, 11, 19, 22],
-          [3, 6, 14, 17, 20],
-          [1, 9, 12, 15, 23],
-          [4, 7, 10, 18, 21],
-          [2, 5, 13, 16, 24]],
          [[0, 9, 13, 17, 21],
-          [2, 6, 10, 19, 23],
-          [4, 8, 12, 16, 20],
           [1, 5, 14, 18, 22],
-          [3, 7, 11, 15, 24]]]
+          [2, 6, 10, 19, 23],
+          [3, 7, 11, 15, 24],
+          [4, 8, 12, 16, 20]],
+         [[0, 8, 11, 19, 22],
+          [1, 9, 12, 15, 23],
+          [2, 5, 13, 16, 24],
+          [3, 6, 14, 17, 20],
+          [4, 7, 10, 18, 21]]]
 
     What is the maximum number of MOLS of size 8 that Sage knows how to build?::
 
@@ -342,6 +344,21 @@ def mutually_orthogonal_latin_squares(k, n, partitions=False, check=True):
         [3 4 5 6 7 1 2 0 8 9]  [5 6 7 1 2 3 4 0 9 8]
         [4 5 6 7 1 2 3 9 0 8], [7 1 2 3 4 5 6 9 8 0]
         ]
+
+    Verify the construction from [KD2015]_::
+
+        sage: designs.mutually_orthogonal_latin_squares(2, 9)
+        [
+        [0 1 2 3 4 5 6 7 8]  [0 1 2 3 4 5 6 7 8]
+        [2 3 6 4 1 8 0 5 7]  [3 8 4 7 5 2 1 0 6]
+        [3 8 4 7 5 2 1 0 6]  [4 7 1 5 8 6 3 2 0]
+        [4 7 1 5 8 6 3 2 0]  [5 0 8 2 6 1 7 4 3]
+        [5 0 8 2 6 1 7 4 3]  [6 4 0 1 3 7 2 8 5]
+        [6 4 0 1 3 7 2 8 5]  [7 6 5 0 2 4 8 3 1]
+        [7 6 5 0 2 4 8 3 1]  [8 2 7 6 0 3 5 1 4]
+        [8 2 7 6 0 3 5 1 4]  [1 5 3 8 7 0 4 6 2]
+        [1 5 3 8 7 0 4 6 2], [2 3 6 4 1 8 0 5 7]
+        ]
     """
     from sage.combinat.designs.orthogonal_arrays import orthogonal_array
     from sage.matrix.constructor import Matrix
@@ -367,6 +384,22 @@ def mutually_orthogonal_latin_squares(k, n, partitions=False, check=True):
 
         matrices = construction()[:k]
 
+    # Implements the construction from Theorem 5.2.4 of [KD2015]_ for prime powers.
+    # This was implemented to fix :issue:`26107`, which pointed out that this
+    # function was unacceptably slow when n was a large prime power
+    elif is_prime_power(n):
+        F = list(GF(n))
+
+        # We need the first element of the list to be 0
+        assert F[0] == 0
+
+        # This dictionary is used to convert from field elements to integers
+        conv = {F[i] : i for i in range(n)}
+
+        # Make the matrices
+        matrices = [Matrix([[conv[F[i] + F[r]*F[j]] for i in range(n)]
+                 for j in range(n)]) for r in range(1, k+1)]
+
     elif orthogonal_array(k + 2, n, existence=True) is not Unknown:
         # Forwarding non-existence results
         if orthogonal_array(k + 2, n, existence=True):

sage/combinat/designs/orthogonal_arrays.py

@@ -1724,7 +1724,8 @@ def OA_n_times_2_pow_c_from_matrix(k, c, G, A, Y, check=True):
         for i in range(len(B)):
             for j in range(i):
                 g_to_col_indices = {g: [] for g in G}
-                Hij = set([(Y[i] - Y[j]) * v for v in H])
+                YY = Y[i] - Y[j]
+                Hij = {YY * v for v in H}
                 for s in range(2 * G_card):
                     g_to_col_indices[B[i][s] - B[j][s]].append(s)
                 for s1, s2 in g_to_col_indices.values():

sage/combinat/designs/orthogonal_arrays_find_recursive.pyx

@@ -147,12 +147,13 @@ cpdef find_product_decomposition(int k, int n):
     """
     cdef int n1,n2
     for n1 in range(2, n):
-        n2 = n/n1  # n2 is decreasing along the loop
+        if n % n1:
+            # we want to iterate only through divisors of n1... it seems
+            # faster to use that rather than calling the divisors function
+            continue
+        n2 = n // n1  # n2 is decreasing along the loop
         if n2 < n1:
             break
-        if n%n1:  # we want to iterate only through divisors of n1... it seems
-                  # faster to use that rather than calling the divisors function
-            continue
         if is_available(k, n1) and is_available(k, n2):
             from sage.combinat.designs.orthogonal_arrays import wilson_construction
             return wilson_construction, (None,k,n1,n2,(),False)
@@ -188,11 +189,11 @@ cpdef find_wilson_decomposition_with_one_truncated_group(int k, int n):
     """
     cdef int r,u,m
     # If there exists a TD(k+1,t) then k+1 < t+2, i.e. k <= t
-    for r in range(max(1,k),n-1):
-        u = n%r
+    for r in range(max(1, k), n - 1):
+        u = n % r
         # We ensure that 1<=u, and that there can exists a TD(k,u), i.e k<u+2
         # (unless u == 1)
-        if u == 0 or (u>1 and k >= u+2):
+        if u == 0 or (u > 1 and k >= u + 2):
             continue
 
         m = n // r
@@ -292,9 +293,9 @@ cpdef find_construction_3_3(int k, int n):
         (11, 11, 16, 1)
         sage: find_construction_3_3(12,11)
     """
-    cdef int mm,nn,i
+    cdef int mm, nn, i
     for mm in range(k-1, n//2+1):
-        if not(is_available(k, mm) and is_available(k, mm + 1)):
+        if not (is_available(k, mm) and is_available(k, mm + 1)):
             continue
 
         for nn in range(2, n//mm+1):
@@ -392,10 +393,10 @@ cpdef find_construction_3_5(int k, int n):
             for s in range(min(i+1,nn)):
                 for r in range(max(0,i-nn-s), min(s+1,i-s+1,nn)):
                     t = i - r - s
-                    if ((nn-r-1)*(nn-s) < t         and
-                        (r==0 or is_available(k,r)) and
-                        (s==0 or is_available(k,s)) and
-                        (t==0 or is_available(k,t))):
+                    if ((nn-r-1)*(nn-s) < t and
+                        (r==0 or is_available(k, r)) and
+                        (s==0 or is_available(k, s)) and
+                        (t==0 or is_available(k, t))):
                         from sage.combinat.designs.orthogonal_arrays_build_recursive import construction_3_5
                         return construction_3_5, (k,nn,mm,r,s,t)
 
@@ -482,15 +483,15 @@ cpdef find_q_x(int k, int n):
         x = (n-q**2+q-2)/(2-q)
         if (x < q and
             0 < x and
-            n == (q-1)*(q-x)+x+2             and
-            is_available(k+1,q-x-1)          and
-            is_available(k+1,q-x+1)          and
+            n == (q-1)*(q-x)+x+2 and
+            is_available(k+1, q-x-1) and
+            is_available(k+1, q-x+1) and
             # The next is always True, because q is a prime power
             # is_available(k+1,q) and
-            is_available(k, x+2 )            and
+            is_available(k, x+2 ) and
             smallInteger(q).is_prime_power()):
             from sage.combinat.designs.orthogonal_arrays_build_recursive import construction_q_x
-            return construction_q_x, (k,q,x)
+            return construction_q_x, (k, q, x)
     return False
 
 cpdef find_thwart_lemma_3_5(int k, int N):
@@ -866,11 +867,11 @@ def int_as_sum(int value, list S, int k_max):
                 vv = v-i
                 if vv == 0:
                     return D[v] + (i,)
-                if (vv > 0            and   # The new integer i is too big
+                if (vv > 0 and              # The new integer i is too big
                     vv <= j*max_value and   # The new integer i is too small
-                    vv not in D       and   # We had it in D     already
+                    vv not in D and         # We had it in D     already
                     vv not in new_D):       # We had it in new_D already
-                    new_D[vv] = D[v]+(i,)
+                    new_D[vv] = D[v] + (i,)
         if not new_D:
             break
         D.update(new_D)