NUCS 0.1__tar.gz

nucs-0.1/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Yan Georget
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nucs-0.1/NUCS.egg-info/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: NUCS
+Version: 0.1
+Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
+Author-email: Yan Georget <yan.georget@gmail.com>
+Project-URL: Homepage, https://github.com/yangeorget/nucs
+Project-URL: Issues, https://github.com/yangeorget/nucs
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numba==0.60.0
+Requires-Dist: numpy==2.0.1
+
+# NUCS
+
+## TLDR
+NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
+
+NUCS is powered by Numpy (https://numpy.org/) and Numba (https://numba.pydata.org/).
+
+NUCS is fast and easy to use.
+
+
+## How to use NUCS ?
+It is very simple to get started with NUCS.
+Either clone the Github repository or install the package.
+
+### Clone the NUCS Github repository
+Let's install NUCS from the source:
+```
+git clone https://github.com/yangeorget/nucs.git
+pip install -r requirements.txt
+```
+
+From there, you can launch some NUCS examples.
+Note that the second run will be much faster since the Python code will have been compiled.
+
+#### Run the NUCS tests
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. pytest tests/
+```
+
+#### Run some examples
+Find all solutions to the 12-queens problem:
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_queens.py -n 12
+```
+
+Find the optimal solution to the Golomb ruler problem with 10 marks:
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_golomb.py -n 10
+```
+
+### Install the NUCS package
+```
+pip install nucs
+````
+
+## Why Python ?
+NUCS is a Python library leveraging Numpy and Numba.
+
+Python is a powerful and flexible programing language that allows to express complex problems in a few lines of code.
+
+Numpy brings the computational power of languages like C and Fortran to Python, a language much easier to learn and use.
+
+Numba translates Python functions to optimized machine code at runtime using the industry-standard LLVM compiler library. 
+Numba-compiled numerical algorithms in Python can approach the speeds of C or FORTRAN.
+
+## Architecture
+
+## Speed matters
+
+## Other constraint solvers in Python
+- python-constraint 
+- CCPMpy
+- PyCSP

nucs-0.1/NUCS.egg-info/SOURCES.txt

@@ -0,0 +1,38 @@
+LICENSE.md
+README.md
+pyproject.toml
+NUCS.egg-info/PKG-INFO
+NUCS.egg-info/SOURCES.txt
+NUCS.egg-info/dependency_links.txt
+NUCS.egg-info/requires.txt
+NUCS.egg-info/top_level.txt
+nucs/__init__.py
+nucs/memory.py
+nucs/statistics.py
+nucs/heuristics/heuristic.py
+nucs/heuristics/variable_heuristic.py
+nucs/problems/__init__.py
+nucs/problems/alpha_problem.py
+nucs/problems/bibd_problem.py
+nucs/problems/golomb_problem.py
+nucs/problems/problem.py
+nucs/problems/queens_problem.py
+nucs/problems/schur_lemma_problem.py
+nucs/problems/sudoku_problem.py
+nucs/propagators/__init__.py
+nucs/propagators/affine_eq_propagator.py
+nucs/propagators/affine_geq_propagator.py
+nucs/propagators/affine_leq_propagator.py
+nucs/propagators/alldifferent_propagator.py
+nucs/propagators/count_eq_propagator.py
+nucs/propagators/dummy_propagator.py
+nucs/propagators/exactly_eq_propagator.py
+nucs/propagators/lexicographic_leq_propagator.py
+nucs/propagators/max_eq_propagator.py
+nucs/propagators/max_leq_propagator.py
+nucs/propagators/min_eq_propagator.py
+nucs/propagators/min_geq_propagator.py
+nucs/propagators/propagators.py
+nucs/solvers/__init__.py
+nucs/solvers/backtrack_solver.py
+nucs/solvers/solver.py

nucs-0.1/NUCS.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nucs-0.1/NUCS.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numba==0.60.0
+numpy==2.0.1

nucs-0.1/NUCS.egg-info/top_level.txt

@@ -0,0 +1 @@
+nucs

nucs-0.1/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.1
+Name: NUCS
+Version: 0.1
+Summary: A Numpy and Numba based Python library for solving Constraint Satifaction Problems
+Author-email: Yan Georget <yan.georget@gmail.com>
+Project-URL: Homepage, https://github.com/yangeorget/nucs
+Project-URL: Issues, https://github.com/yangeorget/nucs
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numba==0.60.0
+Requires-Dist: numpy==2.0.1
+
+# NUCS
+
+## TLDR
+NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
+
+NUCS is powered by Numpy (https://numpy.org/) and Numba (https://numba.pydata.org/).
+
+NUCS is fast and easy to use.
+
+
+## How to use NUCS ?
+It is very simple to get started with NUCS.
+Either clone the Github repository or install the package.
+
+### Clone the NUCS Github repository
+Let's install NUCS from the source:
+```
+git clone https://github.com/yangeorget/nucs.git
+pip install -r requirements.txt
+```
+
+From there, you can launch some NUCS examples.
+Note that the second run will be much faster since the Python code will have been compiled.
+
+#### Run the NUCS tests
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. pytest tests/
+```
+
+#### Run some examples
+Find all solutions to the 12-queens problem:
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_queens.py -n 12
+```
+
+Find the optimal solution to the Golomb ruler problem with 10 marks:
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_golomb.py -n 10
+```
+
+### Install the NUCS package
+```
+pip install nucs
+````
+
+## Why Python ?
+NUCS is a Python library leveraging Numpy and Numba.
+
+Python is a powerful and flexible programing language that allows to express complex problems in a few lines of code.
+
+Numpy brings the computational power of languages like C and Fortran to Python, a language much easier to learn and use.
+
+Numba translates Python functions to optimized machine code at runtime using the industry-standard LLVM compiler library. 
+Numba-compiled numerical algorithms in Python can approach the speeds of C or FORTRAN.
+
+## Architecture
+
+## Speed matters
+
+## Other constraint solvers in Python
+- python-constraint 
+- CCPMpy
+- PyCSP

nucs-0.1/README.md

@@ -0,0 +1,63 @@
+# NUCS
+
+## TLDR
+NUCS is a Python library for solving Constraint Satisfaction and Optimization Problems.
+
+NUCS is powered by Numpy (https://numpy.org/) and Numba (https://numba.pydata.org/).
+
+NUCS is fast and easy to use.
+
+
+## How to use NUCS ?
+It is very simple to get started with NUCS.
+Either clone the Github repository or install the package.
+
+### Clone the NUCS Github repository
+Let's install NUCS from the source:
+```
+git clone https://github.com/yangeorget/nucs.git
+pip install -r requirements.txt
+```
+
+From there, you can launch some NUCS examples.
+Note that the second run will be much faster since the Python code will have been compiled.
+
+#### Run the NUCS tests
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. pytest tests/
+```
+
+#### Run some examples
+Find all solutions to the 12-queens problem:
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_queens.py -n 12
+```
+
+Find the optimal solution to the Golomb ruler problem with 10 marks:
+```
+NUMBA_CACHE_DIR=.numba/cache PYTHONPATH=. python3 tests/examples/test_golomb.py -n 10
+```
+
+### Install the NUCS package
+```
+pip install nucs
+````
+
+## Why Python ?
+NUCS is a Python library leveraging Numpy and Numba.
+
+Python is a powerful and flexible programing language that allows to express complex problems in a few lines of code.
+
+Numpy brings the computational power of languages like C and Fortran to Python, a language much easier to learn and use.
+
+Numba translates Python functions to optimized machine code at runtime using the industry-standard LLVM compiler library. 
+Numba-compiled numerical algorithms in Python can approach the speeds of C or FORTRAN.
+
+## Architecture
+
+## Speed matters
+
+## Other constraint solvers in Python
+- python-constraint 
+- CCPMpy
+- PyCSP

nucs-0.1/nucs/heuristics/heuristic.py

@@ -0,0 +1,24 @@
+from abc import abstractmethod
+from typing import List
+
+from numpy.typing import NDArray
+
+
+class Heuristic:
+    """
+    Makes a choice.
+    A choice can be more complex than just instantiating a variable.
+    """
+
+    @abstractmethod
+    def choose(
+        self, choice_points: List[NDArray], shr_domains: NDArray, shr_domain_changes: NDArray, dom_indices: NDArray
+    ) -> None:
+        """
+        Makes a choice.
+        :param choice_points: the choice point stack
+        :param shr_domains: the shared domains of the problem
+        :param shr_domain_changes: an array of shared domain changes
+        :param dom_indices: the domain indices of the problem variables
+        """
+        pass

nucs-0.1/nucs/heuristics/variable_heuristic.py

@@ -0,0 +1,97 @@
+import sys
+from typing import Callable, List
+
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.heuristics.heuristic import Heuristic
+from nucs.memory import MAX, MIN
+
+
+class VariableHeuristic(Heuristic):
+    """
+    Chooses a variable and one or several values for this variable.
+    """
+
+    def __init__(self, variable_heuristic: Callable, domain_heuristic: Callable):
+        """
+        Inits the heuristic.
+        :param variable_heuristic: a function for choosing the variable
+        :param domain_heuristic: a function for choosing a new domain for this variable
+        """
+        self.variable_heuristic = variable_heuristic
+        self.domain_heuristic = domain_heuristic
+
+    def choose(
+        self, choice_points: List[NDArray], shr_domains: NDArray, shr_domain_changes: NDArray, dom_indices: NDArray
+    ) -> None:
+        var_idx = self.variable_heuristic(shr_domains, dom_indices)
+        shr_domains_copy = shr_domains.copy(order="F")
+        self.domain_heuristic(shr_domains, shr_domain_changes, shr_domains_copy, dom_indices[var_idx])
+        choice_points.append(shr_domains_copy)
+
+
+@njit("int16(int32[::1, :], uint16[:])", cache=True)
+def first_not_instantiated_var_heuristic(shr_domains: NDArray, dom_indices: NDArray) -> int:
+    """
+    Chooses the first non instantiated variable.
+    :param shr_domains: the shared domains of the problem
+    :param dom_indices: the domain indices of the problem variables
+    :return: the index of the variable
+    """
+    for var_idx, dom_index in enumerate(dom_indices):
+        if shr_domains[dom_index, MIN] < shr_domains[dom_index, MAX]:
+            return var_idx
+    return -1  # cannot happen
+
+
+@njit("int16(int32[::1, :], uint16[:])", cache=True)
+def smallest_domain_var_heuristic(shr_domains: NDArray, dom_indices: NDArray) -> int:
+    """
+    Chooses the variable with the smallest domain and which is not instantiated.
+    :param shr_domains: the shared domains of the problem
+    :param dom_indices: the domain indices of the problem variables
+    :return: the index of the variable
+    """
+    min_size = sys.maxsize
+    min_idx = -1
+    for var_idx, dom_index in enumerate(dom_indices):
+        size = shr_domains[dom_index, MAX] - shr_domains[dom_index, MIN]  # actually this is size - 1
+        if 0 < size < min_size:
+            min_idx = var_idx
+            min_size = size
+    return min_idx
+
+
+@njit("(int32[::1, :], boolean[::1, :], int32[::1, :], uint16)", cache=True)
+def min_value_dom_heuristic(
+    shr_domains: NDArray, shr_domain_changes: NDArray, shr_domains_copy: NDArray, domain_idx: int
+) -> None:
+    """
+    Chooses the first value of the domain
+    :param shr_domains: the shared domains of the problem
+    :param: shr_domain_changes: the changes to the shared domains
+    :param: shr_domains_copy: the shared domains to be added to the choice point
+    :param domain_idx: the index of the domain
+    """
+    value = shr_domains[domain_idx, MIN]
+    shr_domains_copy[domain_idx, MIN] = value + 1
+    shr_domains[domain_idx, MAX] = value
+    shr_domain_changes[domain_idx, MAX] = True
+
+
+@njit("(int32[::1, :], boolean[::1, :], int32[::1, :], uint16)", cache=True)
+def split_low_dom_heuristic(
+    shr_domains: NDArray, shr_domain_changes: NDArray, shr_domains_copy: NDArray, domain_idx: int
+) -> None:
+    """
+    Chooses the first half of the domain
+    :param shr_domains: the shared domains of the problem
+    :param: shr_domain_changes: the changes to the shared domains
+    :param: shr_domains_copy: the shared domains to be added to the choice point
+    :param domain_idx: the index of the domain
+    """
+    value = (shr_domains[domain_idx, MIN] + shr_domains[domain_idx, MAX]) // 2
+    shr_domains_copy[domain_idx, MIN] = value + 1
+    shr_domains[domain_idx, MAX] = value
+    shr_domain_changes[domain_idx, MAX] = True

nucs-0.1/nucs/memory.py

@@ -0,0 +1,73 @@
+from typing import List, Tuple, Union
+
+import numpy as np
+from numpy.typing import NDArray
+
+START = 0
+END = 1
+
+MIN = 0
+MAX = 1
+
+PROP_INCONSISTENCY = 0
+PROP_CONSISTENCY = 1
+PROP_ENTAILMENT = 2
+
+
+def new_domains_by_values(domains: List[Union[int, Tuple[int, int]]]) -> NDArray:
+    return np.array(
+        [(domain, domain) if isinstance(domain, int) else domain for domain in domains],
+        dtype=np.int32,
+        order="F",
+    )
+
+
+def new_indices_by_values(dom_indices: List[int]) -> NDArray:
+    return np.array(dom_indices, dtype=np.uint16, order="C")
+
+
+def new_indices(n: int) -> NDArray:
+    return np.empty(n, dtype=np.uint16, order="C")
+
+
+def new_domain_offsets_by_values(dom_offsets: List[int]) -> NDArray:
+    return np.array(dom_offsets, dtype=np.int32, order="C")
+
+
+def new_offsets(n: int) -> NDArray:
+    return np.empty(n, dtype=np.int32, order="C")
+
+
+def new_data_by_values(data: List[int]) -> NDArray:
+    return np.array(data, dtype=np.int32, order="C")
+
+
+def new_data(n: int) -> NDArray:
+    return np.empty(n, dtype=np.int32, order="C")
+
+
+def new_domain_changes(n: int) -> NDArray:
+    return np.ones((n, 2), dtype=bool, order="F")
+
+
+def new_triggers(n: int, init_value: bool) -> NDArray:
+    if init_value:
+        return np.ones((n, 2), dtype=bool, order="F")
+    else:
+        return np.zeros((n, 2), dtype=bool, order="F")
+
+
+def new_triggered_propagators(n: int) -> NDArray:
+    return np.empty(n, dtype=bool, order="C")
+
+
+def new_entailed_propagators(n: int) -> NDArray:
+    return np.zeros(n, dtype=bool, order="C")
+
+
+def new_algorithms(n: int) -> NDArray:
+    return np.empty(n, dtype=np.int8, order="C")
+
+
+def new_bounds(n: int) -> NDArray:
+    return np.empty((n, 2), dtype=np.uint16)

nucs-0.1/nucs/problems/alpha_problem.py

@@ -0,0 +1,107 @@
+from typing import List
+
+from nucs.problems.problem import Problem
+from nucs.propagators.propagators import ALG_AFFINE_EQ, ALG_ALLDIFFERENT
+
+A = 0
+B = 1
+C = 2
+D = 3
+E = 4
+F = 5
+G = 6
+H = 7
+I = 8
+J = 9
+K = 10
+L = 11
+M = 12
+N = 13
+O = 14
+P = 15
+Q = 16
+R = 17
+S = 18
+T = 19
+U = 20
+V = 21
+W = 22
+X = 23
+Y = 24
+Z = 25
+
+
+class AlphaProblem(Problem):
+    """
+    This problem comes from the newsgroup rec.puzzle.
+    The numbers from 1 to 26 are assigned to the letters of the alphabet.
+    The numbers beside each word are the total of the values assigned to the letters in the word
+    (e.g for LYRE: L,Y,R,E might be to equal 5,9,20 and 13 or any other combination that add up to 47).
+
+    Find the value of each letter under the equations:
+    BALLET  45     GLEE  66     POLKA      59     SONG     61
+    CELLO   43     JAZZ  58     QUARTET    50     SOPRANO  82
+    CONCERT 74     LYRE  47     SAXOPHONE 134     THEME    72
+    FLUTE   30     OBOE  53     SCALE      51     VIOLIN  100
+    FUGUE   50     OPERA 65     SOLO       37     WALTZ    34
+    """
+
+    def __init__(self) -> None:
+        super().__init__(shr_domains=[(1, 26)] * 26, dom_indices=list(range(26)), dom_offsets=[0] * 26)
+        self.set_propagators(
+            [
+                ([A, B, E, T, L], ALG_AFFINE_EQ, [1, 1, 1, 1, 2, 45]),
+                ([C, E, O, L], ALG_AFFINE_EQ, [1, 1, 1, 2, 43]),
+                ([E, O, N, R, T, C], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 2, 74]),
+                ([E, F, L, U, T], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 30]),
+                ([E, F, G, U], ALG_AFFINE_EQ, [1, 1, 1, 2, 50]),
+                ([G, L, E], ALG_AFFINE_EQ, [1, 1, 2, 66]),
+                ([A, J, Z], ALG_AFFINE_EQ, [1, 1, 2, 58]),
+                ([E, L, R, Y], ALG_AFFINE_EQ, [1, 1, 1, 1, 47]),
+                ([E, B, O], ALG_AFFINE_EQ, [1, 1, 2, 53]),
+                ([A, E, P, O, R], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 65]),
+                ([A, K, L, O, P], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 59]),
+                ([A, E, Q, R, U, T], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 2, 50]),
+                ([A, E, H, N, P, S, X, O], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 1, 1, 2, 134]),
+                ([A, C, E, L, S], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 51]),
+                ([L, S, O], ALG_AFFINE_EQ, [1, 1, 2, 37]),
+                ([G, N, O, S], ALG_AFFINE_EQ, [1, 1, 1, 1, 61]),
+                ([A, N, P, R, S, O], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 2, 82]),
+                ([H, M, T, E], ALG_AFFINE_EQ, [1, 1, 1, 2, 72]),
+                ([L, N, O, V, I], ALG_AFFINE_EQ, [1, 1, 1, 1, 2, 100]),
+                ([A, L, T, W, Z], ALG_AFFINE_EQ, [1, 1, 1, 1, 1, 34]),
+                ([A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z], ALG_ALLDIFFERENT, []),
+            ]
+        )
+
+    def pretty_print_solution(self, solution: List[int]) -> None:
+        print(
+            {
+                "A": solution[A],
+                "B": solution[B],
+                "C": solution[C],
+                "D": solution[D],
+                "E": solution[E],
+                "F": solution[F],
+                "G": solution[G],
+                "H": solution[H],
+                "I": solution[I],
+                "J": solution[J],
+                "K": solution[K],
+                "L": solution[L],
+                "M": solution[M],
+                "N": solution[N],
+                "O": solution[O],
+                "P": solution[P],
+                "Q": solution[Q],
+                "R": solution[R],
+                "S": solution[S],
+                "T": solution[T],
+                "U": solution[U],
+                "V": solution[V],
+                "W": solution[W],
+                "X": solution[X],
+                "Y": solution[Y],
+                "Z": solution[Z],
+            }
+        )

nucs-0.1/nucs/problems/bibd_problem.py

@@ -0,0 +1,49 @@
+from nucs.problems.problem import Problem
+from nucs.propagators.propagators import (
+    ALG_EXACTLY_EQ,
+    ALG_LEXICOGRAPHIC_LEQ,
+    ALG_MIN_EQ,
+)
+
+
+class BIBDProblem(Problem):
+    """
+    A simple model for the BIBD problem.
+    See https://www.csplib.org/Problems/prob028/ for a complete description of the problem.
+    """
+
+    def __init__(self, v: int, b: int, r: int, k: int, l: int):
+        s = (v * (v - 1)) // 2
+        n = (v + s) * b
+        super().__init__(
+            shr_domains=[(0, 1)] * n,
+            dom_indices=list(range(n)),
+            dom_offsets=[0] * n,
+        )
+        propagators = []
+        # rows: counts
+        for i in range(0, v):
+            propagators.append((list(range(i * b, (i + 1) * b)), ALG_EXACTLY_EQ, [1, r]))
+        # columns: counts
+        for j in range(0, b):
+            propagators.append((list(range(j, v * b, b)), ALG_EXACTLY_EQ, [1, k]))
+        # scalar products: conjunctions and counts
+        conj_idx = v * b
+        for i1 in range(0, v - 1):
+            for i2 in range(i1 + 1, v):
+                conj_vars = []
+                for j in range(0, b):
+                    propagators.append(
+                        ([(i1 * b + j), (i2 * b + j), conj_idx], ALG_MIN_EQ, [])
+                    )  # TODO: replace by AND ?
+                    conj_vars.append(conj_idx)
+                    conj_idx += 1
+                propagators.append((conj_vars, ALG_EXACTLY_EQ, [1, l]))
+        # remove symmetries
+        # lexleq on rows
+        for i in range(0, v - 1):
+            propagators.append((list(range(i * b, (i + 2) * b)), ALG_LEXICOGRAPHIC_LEQ, []))
+        # lexleq on columns
+        for j in range(0, b - 1):
+            propagators.append((list(range(j, v * b, b)) + list(range(j + 1, v * b, b)), ALG_LEXICOGRAPHIC_LEQ, []))
+        self.set_propagators(propagators)