NUCS 2.3.0__tar.gz → 3.0.0__tar.gz

{nucs-2.3.0 → nucs-3.0.0/NUCS.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 2.3.0
+Version: 3.0.0
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs

{nucs-2.3.0/NUCS.egg-info → nucs-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: NUCS
-Version: 2.3.0
+Version: 3.0.0
 Summary: A Numpy and Numba based Python library for solving Constraint Satisfaction Problems over finite domains
 Author-email: Yan Georget <yan.georget@gmail.com>
 Project-URL: Homepage, https://github.com/yangeorget/nucs

{nucs-2.3.0 → nucs-3.0.0}/docs/source/conf.py

@@ -6,8 +6,8 @@ project = 'NUCS'
 copyright = '2024, Yan Georget'
 author = 'Yan Georget'
 
-release = '2.3.0'
-version = '2.3.0'
+release = '3.0.0'
+version = '3.0.0'
 
 # -- General configuration
 

{nucs-2.3.0 → nucs-3.0.0}/nucs/constants.py

@@ -29,8 +29,10 @@ PROBLEM_UNBOUND = 1  # returned when the filtering of a problem has been complet
 PROBLEM_BOUND = 2  # returned when a problem is solved
 
 SIGNATURE_COMPUTE_DOMAINS = int64(int32[:, :], int32[:])  # domains, parameters
-SIGNATURE_DOM_HEURISTIC = int64(int32[:], int32[:])  # shr_domain, shr_domain_copy
-SIGNATURE_VAR_HEURISTIC = int64(int32[:, :])  # shr_domains
+SIGNATURE_DOM_HEURISTIC = int64(
+    int32[:, :, :], uint16[:, :], uint8[:], int64  # shr_domains_stack  # dom_update_stack  # stacks_top  # dom_idx
+)
+SIGNATURE_VAR_HEURISTIC = int64(int32[:, :, :], uint8[:])  # shr_domains_stack, stacks_top
 SIGNATURE_CONSISTENCY_ALG = int64(
     int64[:],  # statistics
     uint8[:],  # algorithms
@@ -57,7 +59,7 @@ TYPE_CONSISTENCY_ALG = types.FunctionType(SIGNATURE_CONSISTENCY_ALG)
 
 NUMBA_DISABLE_JIT = os.getenv("NUMBA_DISABLE_JIT")
 
-LOG_FORMAT = "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+LOG_FORMAT = "%(asctime)s - %(processName)s - %(levelname)s - %(name)s - %(funcName)s - %(message)s"
 LOG_LEVEL_DEBUG = "DEBUG"
 LOG_LEVEL_INFO = "INFO"
 LOG_LEVEL_WARNING = "WARNING"

{nucs-2.3.0 → nucs-3.0.0}/nucs/examples/golomb/golomb_problem.py

@@ -127,7 +127,7 @@ def golomb_consistency_algorithm(
     shr_domains_stack: NDArray,
     not_entailed_propagators_stack: NDArray,
     dom_update_stack: NDArray,
-    stacks_height: NDArray,
+    stacks_top: NDArray,
     triggered_propagators: NDArray,
     compute_domains_addrs: NDArray,
 ) -> int:
@@ -139,7 +139,7 @@ def golomb_consistency_algorithm(
     """
     # first prune the search space
     mark_nb = (1 + int(math.sqrt(8 * len(dom_indices_arr) + 1))) // 2
-    ni_var_idx = first_not_instantiated_var_heuristic(shr_domains_stack[0])  # no domains shared between vars
+    ni_var_idx = first_not_instantiated_var_heuristic(shr_domains_stack, stacks_top)  # no domains shared between vars
     if 1 < ni_var_idx < mark_nb - 1:  # otherwise useless
         used_distance = np.zeros(sum_first(mark_nb - 2) + 1, dtype=np.bool)
         # a reusable array for storing the minimal sum of different integers:
@@ -148,7 +148,7 @@ def golomb_consistency_algorithm(
         # the following will mark at most sum(n-3) numbers as used
         # hence there will be at least n-2 unused numbers greater than 0
         for var_idx in range(index(mark_nb, ni_var_idx - 2, ni_var_idx - 1) + 1):
-            dist = shr_domains_stack[0, dom_indices_arr[var_idx], MIN]  # no offset
+            dist = shr_domains_stack[stacks_top[0], dom_indices_arr[var_idx], MIN]  # no offset
             if dist < len(used_distance):
                 used_distance[dist] = True
         # let's compute the sum of non-used numbers
@@ -161,9 +161,14 @@ def golomb_consistency_algorithm(
         for i in range(ni_var_idx - 1, mark_nb - 1):
             for j in range(i + 1, mark_nb):
                 dom_idx = dom_indices_arr[index(mark_nb, i, j)]
-                shr_domains_stack[0, dom_idx, MIN] = minimal_sum[j - i]  # no offset
+                shr_domains_stack[stacks_top[0], dom_idx, MIN] = minimal_sum[j - i]  # no offset
                 add_propagators(
-                    triggered_propagators, not_entailed_propagators_stack[0], shr_domains_propagators, dom_idx, MIN
+                    triggered_propagators,
+                    not_entailed_propagators_stack,
+                    stacks_top,
+                    shr_domains_propagators,
+                    dom_idx,
+                    MIN,
                 )
     return bound_consistency_algorithm(
         statistics,
@@ -179,7 +184,7 @@ def golomb_consistency_algorithm(
         shr_domains_stack,
         not_entailed_propagators_stack,
         dom_update_stack,
-        stacks_height,
+        stacks_top,
         triggered_propagators,
         compute_domains_addrs,
     )

{nucs-2.3.0 → nucs-3.0.0}/nucs/examples/queens/__main__.py

@@ -32,17 +32,27 @@ if __name__ == "__main__":
     parser.add_argument("--ff", type=bool, action=argparse.BooleanOptionalAction, default=False)
     args = parser.parse_args()
     problem = QueensProblem(args.n)
-    problems = problem.split(args.processors, 0)
-    solver = MultiprocessingSolver(
-        [
-            BacktrackSolver(
-                problem,
-                consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
-                var_heuristic_idx=VAR_HEURISTIC_SMALLEST_DOMAIN if args.ff else VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
-                log_level=args.log_level,
-            )
-            for problem in problems
-        ]
+    solver = (
+        MultiprocessingSolver(
+            [
+                BacktrackSolver(
+                    problem,
+                    consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
+                    var_heuristic_idx=(
+                        VAR_HEURISTIC_SMALLEST_DOMAIN if args.ff else VAR_HEURISTIC_FIRST_NOT_INSTANTIATED
+                    ),
+                    log_level=args.log_level,
+                )
+                for problem in problem.split(args.processors, 0)
+            ]
+        )
+        if args.processors > 1
+        else BacktrackSolver(
+            problem,
+            consistency_alg_idx=CONSISTENCY_ALG_SHAVING if args.shaving else CONSISTENCY_ALG_BC,
+            var_heuristic_idx=VAR_HEURISTIC_SMALLEST_DOMAIN if args.ff else VAR_HEURISTIC_FIRST_NOT_INSTANTIATED,
+            log_level=args.log_level,
+        )
     )
     solver.solve_all()
     print(solver.get_statistics())

{nucs-2.3.0 → nucs-3.0.0}/nucs/propagators/propagators.py

@@ -141,13 +141,15 @@ def pop_propagator(triggered_propagators: NDArray, previous_prop_idx: int) -> in
 @njit(cache=True)
 def add_propagators(
     triggered_propagators: NDArray,
-    not_entailed_propagators: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    stacks_top: NDArray,
     shr_domains_propagators: NDArray,
     dom_idx: int,
     bound: int,
 ) -> None:
+    cp_top_idx = stacks_top[0]
     for prop_idx in range(len(triggered_propagators)):
-        if shr_domains_propagators[dom_idx, bound, prop_idx] and not_entailed_propagators[prop_idx]:
+        if shr_domains_propagators[dom_idx, bound, prop_idx] and not_entailed_propagators_stack[cp_top_idx, prop_idx]:
             triggered_propagators[prop_idx] = True
     # np.logical_or(triggered_propagators, shr_domains_propagators[dom_idx, bound], triggered_propagators)
     # np.logical_and(triggered_propagators, not_entailed_propagators, triggered_propagators)

{nucs-2.3.0 → nucs-3.0.0}/nucs/solvers/backtrack_solver.py

@@ -19,7 +19,6 @@ from numba import njit  # type: ignore
 from numpy.typing import NDArray
 
 from nucs.constants import (
-    LOG_FORMAT,
     LOG_LEVEL_INFO,
     NUMBA_DISABLE_JIT,
     PROBLEM_BOUND,
@@ -96,10 +95,9 @@ class BacktrackSolver(Solver):
         :param var_heuristic_idx: the index of the heuristic for selecting a variable/domain
         :param dom_heuristic_idx: the index of the heuristic for reducing a domain
         :param stack_max_height: the maximal choice point stack height
+        :param log_level: the log level as a string
         """
-        logging.basicConfig(format=LOG_FORMAT, level=getattr(logging, log_level))
-        logger.debug("Initializing BacktrackSolver")
-        super().__init__(problem)
+        super().__init__(problem, log_level)
         logger.info(f"BacktrackSolver uses variable heuristic {var_heuristic_idx}")
         self.var_heuristic_idx = var_heuristic_idx
         logger.info(f"BacktrackSolver uses domain heuristic {dom_heuristic_idx}")
@@ -111,13 +109,13 @@ class BacktrackSolver(Solver):
         self.shr_domains_stack = np.empty((stack_max_height, self.problem.variable_nb, 2), dtype=np.int32)
         self.not_entailed_propagators_stack = np.empty((stack_max_height, self.problem.propagator_nb), dtype=np.bool)
         self.dom_update_stack = np.empty((stack_max_height, 2), dtype=np.uint16)
-        self.stacks_height = np.ones((1,), dtype=np.uint8)
+        self.stacks_top = np.ones((1,), dtype=np.uint8)
         logger.info(f"Choice points stack has a maximal height of {stack_max_height}")
         cp_init(
             self.shr_domains_stack,
             self.not_entailed_propagators_stack,
             self.dom_update_stack,
-            self.stacks_height,
+            self.stacks_top,
             np.array(problem.shr_domains_lst),
         )
         logger.debug("Choice points initialized")
@@ -168,6 +166,7 @@ class BacktrackSolver(Solver):
         :param update_domain_fct: the function to update the domain of the variable
         :return: the solution if it exists or None
         """
+        logger.debug(f"Optimizing variable {variable_idx}")
         compute_domains_addrs, var_heuristic_addrs, dom_heuristic_addrs, consistency_alg_addrs = (
             get_function_addresses()
         )
@@ -187,7 +186,7 @@ class BacktrackSolver(Solver):
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
                 self.dom_update_stack,
-                self.stacks_height,
+                self.stacks_top,
                 self.triggered_propagators,
                 self.consistency_alg_idx,
                 self.var_heuristic_idx,
@@ -205,11 +204,12 @@ class BacktrackSolver(Solver):
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
                 self.dom_update_stack,
-                self.stacks_height,
+                self.stacks_top,
                 self.triggered_propagators,
             )
             update_domain_fct(
-                self.shr_domains_stack[0],
+                self.shr_domains_stack,
+                self.stacks_top,
                 self.problem.dom_indices_arr,
                 self.problem.dom_offsets_arr,
                 variable_idx,
@@ -222,6 +222,7 @@ class BacktrackSolver(Solver):
         Returns an iterator over the solutions.
         :return: an iterator
         """
+        logger.info("Solving and iterating over the solutions")
         compute_domains_addrs, var_heuristic_addrs, dom_heuristic_addrs, consistency_alg_addrs = (
             get_function_addresses()
         )
@@ -240,7 +241,7 @@ class BacktrackSolver(Solver):
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
                 self.dom_update_stack,
-                self.stacks_height,
+                self.stacks_top,
                 self.triggered_propagators,
                 self.consistency_alg_idx,
                 self.var_heuristic_idx,
@@ -255,10 +256,9 @@ class BacktrackSolver(Solver):
             yield solution
             if not backtrack(
                 self.statistics,
-                self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
                 self.dom_update_stack,
-                self.stacks_height,
+                self.stacks_top,
                 self.triggered_propagators,
                 self.problem.shr_domains_propagators,
             ):
@@ -291,8 +291,10 @@ class BacktrackSolver(Solver):
         Enqueues the solution that optimizes a variable.
         :param variable_idx: the index of the variable
         :param update_domain_fct: the function to update the domain of the variable
+        :param processor_idx: the index of the processor
         :param solution_queue: the solution queue
         """
+        logger.debug(f"Optimizing variable {variable_idx} and queuing solutions found")
         compute_domains_addrs, var_heuristic_addrs, dom_heuristic_addrs, consistency_alg_addrs = (
             get_function_addresses()
         )
@@ -311,7 +313,7 @@ class BacktrackSolver(Solver):
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
                 self.dom_update_stack,
-                self.stacks_height,
+                self.stacks_top,
                 self.triggered_propagators,
                 self.consistency_alg_idx,
                 self.var_heuristic_idx,
@@ -330,11 +332,12 @@ class BacktrackSolver(Solver):
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
                 self.dom_update_stack,
-                self.stacks_height,
+                self.stacks_top,
                 self.triggered_propagators,
             )
             update_domain_fct(
-                self.shr_domains_stack[0],
+                self.shr_domains_stack,
+                self.stacks_top,
                 self.problem.dom_indices_arr,
                 self.problem.dom_offsets_arr,
                 variable_idx,
@@ -348,6 +351,7 @@ class BacktrackSolver(Solver):
         :param processor_idx: the index of the processor
         :param solution_queue: the solution queue
         """
+        logger.info("Solving and queuing solutions found")
         compute_domains_addrs, var_heuristic_addrs, dom_heuristic_addrs, consistency_alg_addrs = (
             get_function_addresses()
         )
@@ -366,7 +370,7 @@ class BacktrackSolver(Solver):
                 self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
                 self.dom_update_stack,
-                self.stacks_height,
+                self.stacks_top,
                 self.triggered_propagators,
                 self.consistency_alg_idx,
                 self.var_heuristic_idx,
@@ -381,10 +385,9 @@ class BacktrackSolver(Solver):
             solution_queue.put((processor_idx, solution, self.statistics))
             if not backtrack(
                 self.statistics,
-                self.shr_domains_stack,
                 self.not_entailed_propagators_stack,
                 self.dom_update_stack,
-                self.stacks_height,
+                self.stacks_top,
                 self.triggered_propagators,
                 self.problem.shr_domains_propagators,
             ):
@@ -397,7 +400,7 @@ def reset(
     shr_domains_stack: NDArray,
     not_entailed_propagators_stack: NDArray,
     dom_update_stack: NDArray,
-    stacks_height: NDArray,
+    stacks_top: NDArray,
     triggered_propagators: NDArray,
 ) -> None:
     """
@@ -405,14 +408,15 @@ def reset(
     :param problem: the problem
     :param shr_domains_stack: the stack of shared domains
     :param not_entailed_propagators_stack: the stack of not entailed propagators
-    :param stacks_height: the height of both stacks
+    :param dom_update_stack: the stack of domain updates
+    :param stacks_top: the index of the top of the stacks as a Numpy array
     :param triggered_propagators: the list of triggered propagators
     """
     cp_init(
         shr_domains_stack,
         not_entailed_propagators_stack,
         dom_update_stack,
-        stacks_height,
+        stacks_top,
         np.array(problem.shr_domains_lst),
     )
     triggered_propagators.fill(True)
@@ -433,7 +437,7 @@ def solve_one(
     shr_domains_stack: NDArray,
     not_entailed_propagators_stack: NDArray,
     dom_update_stack: NDArray,
-    stacks_height: NDArray,
+    stacks_top: NDArray,
     triggered_propagators: NDArray,
     consistency_alg_idx: int,
     var_heuristic_idx: int,
@@ -461,7 +465,8 @@ def solve_one(
     the first level correspond to the current shared domains, the rest correspond to the choice points
     :param not_entailed_propagators_stack: a stack not entailed propagators;
     the first level correspond to the propagators currently not entailed, the rest correspond to the choice points
-    :param stacks_height: the height of the stacks as a Numpy array
+    :param dom_update_stack: the stack of domain updates
+    :param stacks_top: the index of the top of the stacks as a Numpy array
     :param triggered_propagators: the Numpy array of triggered propagators
     :param consistency_alg_idx: the index of the consistency algorithm
     :param var_heuristic_idx: the index of the variable heuristic
@@ -495,35 +500,33 @@ def solve_one(
             shr_domains_stack,
             not_entailed_propagators_stack,
             dom_update_stack,
-            stacks_height,
+            stacks_top,
             triggered_propagators,
             compute_domains_addrs,
         )
         if status == PROBLEM_BOUND:
             statistics[STATS_IDX_SOLVER_SOLUTION_NB] += 1
-            return get_solution(shr_domains_stack[0], dom_indices_arr, dom_offsets_arr)
+            return get_solution(shr_domains_stack, stacks_top, dom_indices_arr, dom_offsets_arr)
         elif status == PROBLEM_UNBOUND:
-            dom_idx = var_heuristic_fct(shr_domains_stack[0])
-            cp_put(shr_domains_stack, not_entailed_propagators_stack, dom_update_stack, stacks_height, dom_idx)
-            cp_idx = stacks_height[0] - 1
-            event = dom_heuristic_fct(shr_domains_stack[0, dom_idx], shr_domains_stack[cp_idx, dom_idx])
-            dom_update_stack[cp_idx, 1] = event
+            dom_idx = var_heuristic_fct(shr_domains_stack, stacks_top)
+            cp_put(shr_domains_stack, not_entailed_propagators_stack, dom_update_stack, stacks_top, dom_idx)
+            event = dom_heuristic_fct(shr_domains_stack, dom_update_stack, stacks_top, dom_idx)
             add_propagators(
                 triggered_propagators,
-                not_entailed_propagators_stack[0],
+                not_entailed_propagators_stack,
+                stacks_top,
                 shr_domains_propagators,
                 dom_idx,
                 event,
             )
             statistics[STATS_IDX_SOLVER_CHOICE_NB] += 1
-            if stacks_height[0] - 1 > statistics[STATS_IDX_SOLVER_CHOICE_DEPTH]:
-                statistics[STATS_IDX_SOLVER_CHOICE_DEPTH] = stacks_height[0] - 1
+            if stacks_top[0] > statistics[STATS_IDX_SOLVER_CHOICE_DEPTH]:
+                statistics[STATS_IDX_SOLVER_CHOICE_DEPTH] = stacks_top[0]
         elif not backtrack(
             statistics,
-            shr_domains_stack,
             not_entailed_propagators_stack,
             dom_update_stack,
-            stacks_height,
+            stacks_top,
             triggered_propagators,
             shr_domains_propagators,
         ):

{nucs-2.3.0 → nucs-3.0.0}/nucs/solvers/bound_consistency_algorithm.py

@@ -10,7 +10,6 @@
 #
 # Copyright 2024 - Yan Georget
 ###############################################################################
-import numpy as np
 from numba import njit  # type: ignore
 from numpy.typing import NDArray
 
@@ -52,7 +51,7 @@ def bound_consistency_algorithm(
     shr_domains_stack: NDArray,
     not_entailed_propagators_stack: NDArray,
     dom_update_stack: NDArray,
-    stacks_height: NDArray,
+    stacks_top: NDArray,
     triggered_propagators: NDArray,
     compute_domains_addrs: NDArray,
 ) -> int:
@@ -74,7 +73,8 @@ def bound_consistency_algorithm(
     the first level correspond to the current shared domains, the rest correspond to the choice points
     :param not_entailed_propagators_stack: a stack not entailed propagators;
     the first level correspond to the propagators currently not entailed, the rest correspond to the choice points
-    :param stacks_height: the height of the stacks as a Numpy array
+    :param dom_update_stack: the stack of domain updates
+    :param stacks_top: the height of the stacks as a Numpy array
     :param triggered_propagators: the Numpy array of triggered propagators
     :param compute_domains_addrs: the addresses of the compute_domains functions
     :return: a status (consistency, inconsistency or entailment) as an integer
@@ -84,41 +84,41 @@ def bound_consistency_algorithm(
     while True:
         prop_idx = pop_propagator(triggered_propagators, prop_idx)
         if prop_idx == -1:
-            return PROBLEM_BOUND if is_solved(shr_domains_stack[0]) else PROBLEM_UNBOUND
+            return PROBLEM_BOUND if is_solved(shr_domains_stack, stacks_top) else PROBLEM_UNBOUND
         statistics[STATS_IDX_PROPAGATOR_FILTER_NB] += 1
         prop_var_start = var_bounds[prop_idx, START]
         prop_var_end = var_bounds[prop_idx, END]
         prop_indices = props_dom_indices[prop_var_start:prop_var_end]
         prop_offsets = props_dom_offsets[prop_var_start:prop_var_end]
-        prop_var_nb = prop_var_end - prop_var_start
-        prop_domains = np.empty((prop_var_nb, 2), dtype=np.int32)
-        np.add(shr_domains_stack[0, prop_indices], prop_offsets, prop_domains)
-        compute_domains_function = (
+        prop_domains = shr_domains_stack[stacks_top[0], prop_indices] + prop_offsets
+        compute_domains_fct = (
             COMPUTE_DOMAINS_FCTS[algorithms[prop_idx]]
             if NUMBA_DISABLE_JIT
             else function_from_address(TYPE_COMPUTE_DOMAINS, compute_domains_addrs[algorithms[prop_idx]])
         )
-        status = compute_domains_function(
+        status = compute_domains_fct(
             prop_domains, props_parameters[param_bounds[prop_idx, START] : param_bounds[prop_idx, END]]
         )
         if status == PROP_INCONSISTENCY:
             statistics[STATS_IDX_PROPAGATOR_INCONSISTENCY_NB] += 1
             return PROBLEM_INCONSISTENT
         if status == PROP_ENTAILMENT:
-            not_entailed_propagators_stack[0, prop_idx] = False
+            not_entailed_propagators_stack[stacks_top[0], prop_idx] = False
             statistics[STATS_IDX_PROPAGATOR_ENTAILMENT_NB] += 1
         shr_domains_changes = False
-        for var_idx in range(prop_var_nb):
+        top = stacks_top[0]
+        for var_idx in range(prop_var_end - prop_var_start):
             shr_domain_idx = prop_indices[var_idx]
             prop_offset = prop_offsets[var_idx, 0]  # because of vertical shape
             for bound in [MIN, MAX]:
                 shr_domain_bound = prop_domains[var_idx, bound] - prop_offset
-                if shr_domains_stack[0, shr_domain_idx, bound] != shr_domain_bound:
-                    shr_domains_stack[0, shr_domain_idx, bound] = shr_domain_bound
+                if shr_domains_stack[top, shr_domain_idx, bound] != shr_domain_bound:
+                    shr_domains_stack[top, shr_domain_idx, bound] = shr_domain_bound
                     shr_domains_changes = True
                     add_propagators(
                         triggered_propagators,
-                        not_entailed_propagators_stack[0],
+                        not_entailed_propagators_stack,
+                        stacks_top,
                         shr_domains_propagators,
                         shr_domain_idx,
                         bound,

nucs-3.0.0/nucs/solvers/choice_points.py

@@ -0,0 +1,88 @@
+from typing import Optional
+
+from numba import njit  # type: ignore
+from numpy.typing import NDArray
+
+from nucs.constants import STATS_IDX_SOLVER_BACKTRACK_NB
+from nucs.propagators.propagators import add_propagators
+
+
+@njit(cache=True)
+def cp_init(
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_top: NDArray,
+    shr_domains_arr: NDArray,
+) -> None:
+    """
+    Inits the choice points.
+    :param shr_domains_stack: the stack of shared domains
+    :param not_entailed_propagators_stack: the stack of not entailed propagators
+    :param stacks_top: the index of the top of the stacks as a Numpy array
+    :param shr_domains_arr: the shared domains
+    :return: a Numpy array
+    """
+    shr_domains_stack[0] = shr_domains_arr
+    not_entailed_propagators_stack[0] = True
+    dom_update_stack[0, :] = 0
+    stacks_top[0] = 0
+
+
+@njit(cache=True)
+def cp_put(
+    shr_domains_stack: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_top: NDArray,
+    dom_index: int,
+    bound: Optional[int] = 0,
+) -> None:
+    """
+    Adds a choice point to the stack of choice points.
+    :param shr_domains_stack: the stack of shared domains
+    :param not_entailed_propagators_stack: the stack of not entailed propagators
+    :param dom_update_stack: the stack of domain updates
+    :param stacks_top: the index of the top of the stacks as a Numpy array
+    :param dom_index: the index of the shared domain which is changed
+    :param bound: the bound (MIN or MAX) which is changed
+    """
+    dom_update_stack[stacks_top[0], 0] = dom_index
+    dom_update_stack[stacks_top[0], 1] = bound
+    shr_domains_stack[stacks_top[0] + 1, :, :] = shr_domains_stack[stacks_top[0], :, :]
+    not_entailed_propagators_stack[stacks_top[0] + 1, :] = not_entailed_propagators_stack[stacks_top[0], :]
+    stacks_top[0] += 1
+
+
+@njit(cache=True)
+def backtrack(
+    statistics: NDArray,
+    not_entailed_propagators_stack: NDArray,
+    dom_update_stack: NDArray,
+    stacks_top: NDArray,
+    triggered_propagators: NDArray,
+    shr_domains_propagators: NDArray,
+) -> bool:
+    """
+    Backtracks and updates the problem's domains.
+    :param statistics: the statistics array
+    :param not_entailed_propagators_stack: the stack of not entailed propagators
+    :param dom_update_stack: the stack of domain updates
+    :param stacks_top: the index of the top of the stacks as a Numpy array
+    :param triggered_propagators: the set propagators that are currently triggered as a Numpy array
+    :param shr_domains_propagators: a Numpy array indicating which propagators to trigger for a domain change
+    :return: true iff it is possible to backtrack
+    """
+    if stacks_top[0] == 0:
+        return False
+    stacks_top[0] -= 1
+    statistics[STATS_IDX_SOLVER_BACKTRACK_NB] += 1
+    add_propagators(
+        triggered_propagators,
+        not_entailed_propagators_stack,
+        stacks_top,
+        shr_domains_propagators,
+        dom_update_stack[stacks_top[0], 0],
+        1 - dom_update_stack[stacks_top[0], 1],
+    )
+    return True