def _constraint_sudoku_problem_from_name_to_var_map(name_to_var_map: Dict[Tuple[int, int], csp.Variable]) \ -> csp.ConstraintProblem: grid_len = int(sqrt(len(name_to_var_map.keys()))) constraints = set() rows_indices = _get_rows_indices(grid_len) for row in rows_indices: row_vars = (name_to_var_map[(i, j)] for i, j in name_to_var_map.keys() if (i, j) in row) constraints.add( csp.Constraint(row_vars, csp.all_diff_constraint_evaluator)) column_indices = _get_columns_indices(grid_len) for column in column_indices: column_vars = (name_to_var_map[(i, j)] for i, j in name_to_var_map.keys() if (i, j) in column) constraints.add( csp.Constraint(column_vars, csp.all_diff_constraint_evaluator)) block_indices = _get_block_indices(grid_len) for block in block_indices: block_vars = (name_to_var_map[(i, j)] for i, j in name_to_var_map.keys() if (i, j) in block) constraints.add( csp.Constraint(block_vars, csp.all_diff_constraint_evaluator)) return csp.ConstraintProblem(constraints, name_to_var_map)
def setUp(self): colors = ["red", "green", "blue"] names = {"wa", "nt", "q", "nsw", "v", "sa", "t"} variables = csp.Variable.from_names_to_equal_domain(names, colors) self.variables = variables const1 = csp.Constraint([variables["sa"], variables["wa"]], csp.all_diff_constraint_evaluator) const2 = csp.Constraint([variables["sa"], variables["nt"]], csp.all_diff_constraint_evaluator) const3 = csp.Constraint([variables["sa"], variables["q"]], csp.all_diff_constraint_evaluator) const4 = csp.Constraint([variables["sa"], variables["nsw"]], csp.all_diff_constraint_evaluator) const5 = csp.Constraint([variables["sa"], variables["v"]], csp.all_diff_constraint_evaluator) const6 = csp.Constraint([variables["wa"], variables["nt"]], csp.all_diff_constraint_evaluator) const7 = csp.Constraint([variables["nt"], variables["q"]], csp.all_diff_constraint_evaluator) const8 = csp.Constraint([variables["q"], variables["nsw"]], csp.all_diff_constraint_evaluator) const9 = csp.Constraint([variables["nsw"], variables["v"]], csp.all_diff_constraint_evaluator) const10 = csp.Constraint([variables["t"]], csp.always_satisfied) self.constraints = [ const1, const2, const3, const4, const5, const6, const7, const8, const9, const10 ] self.const_problem = csp.ConstraintProblem(frozenset(self.constraints), variables)
def test_UncontainedVariableError(self): var1 = csp.Variable([i for i in range(5)], 4) var2 = csp.Variable([i for i in range(5, 10)], 6) var3 = csp.Variable([i for i in range(11, 20)]) variables = [var1, var2] const = csp.Constraint(variables, csp.MaxSum(28)) self.assertRaises(csp.UncontainedVariableError, const.get_consistent_domain_values, var3)
def test_get_consistent_domain(self): var1 = csp.Variable([i for i in range(5)], 4) var2 = csp.Variable([i for i in range(5, 10)], 6) var3 = csp.Variable([i for i in range(15, 26)]) variables = [var1, var2, var3] const = csp.Constraint(variables, csp.MaxSum(28)) consistent_domain = const.get_consistent_domain_values(var3) const_domain = frozenset({15, 16, 17}) self.assertTrue(consistent_domain, const_domain)
def test_is_consistent(self): var1 = csp.Variable([i for i in range(5)], 4) var2 = csp.Variable([i for i in range(5, 10)], 6) var3 = csp.Variable([i for i in range(11, 20)]) variables = [var1, var2, var3] const = csp.Constraint(variables, csp.MaxSum(28)) self.assertTrue(const.is_consistent()) self.assertFalse(const) var3.assign(17) self.assertTrue(const)
def test_bool_operator(self): var1 = csp.Variable([i for i in range(10)]) var2 = csp.Variable([i for i in range(10, 20)]) variables = {var1, var2} const = csp.Constraint(variables, csp.ExactSum(28)) self.assertFalse(const) var1.assign(7) var2.assign(13) self.assertFalse(const) var1.unassign() var1.assign(9) var2.unassign() var2.assign(19) self.assertTrue(const)
return row1 != row2 and abs(row1 - row2) != columns_difference return not_attacking_constraint not_attacking_constraints = dict() for i in range(1, n): not_attacking_constraints[i] = get_not_attacking_constraint(i) constraints = set() for col1 in range(n): for col2 in range(n): if col1 < col2: constraints.add( csp.Constraint( (name_to_variable_map[col1], name_to_variable_map[col2]), not_attacking_constraints[abs(col1 - col2)])) n_queens_problem = csp.ConstraintProblem(constraints) # /////////////////////////////////////////////// USAGE EXAMPLE /////////////////////////////////////////////// # csp.heuristic_backtracking_search(n_queens_problem) # for name in name_to_variable_map: # print(name, ":", name_to_variable_map[name].value) # # 0 : 3 # 1 : 6 # 2 : 2 # 3 : 7 # 4 : 1 # 5 : 4
def setUp(self): colors = ["red", "green", "blue"] names = {"wa", "nt", "q", "nsw", "v", "sa", "t"} self.name_to_variable_map = csp.Variable.from_names_to_equal_domain( names, colors) const1 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["wa"]], csp.all_diff_constraint_evaluator) const2 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["nt"]], csp.all_diff_constraint_evaluator) const3 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["q"]], csp.all_diff_constraint_evaluator) const4 = csp.Constraint([ self.name_to_variable_map["sa"], self.name_to_variable_map["nsw"] ], csp.all_diff_constraint_evaluator) const5 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["v"]], csp.all_diff_constraint_evaluator) const6 = csp.Constraint( [self.name_to_variable_map["wa"], self.name_to_variable_map["nt"]], csp.all_diff_constraint_evaluator) const7 = csp.Constraint( [self.name_to_variable_map["nt"], self.name_to_variable_map["q"]], csp.all_diff_constraint_evaluator) const8 = csp.Constraint( [self.name_to_variable_map["q"], self.name_to_variable_map["nsw"]], csp.all_diff_constraint_evaluator) const9 = csp.Constraint( [self.name_to_variable_map["nsw"], self.name_to_variable_map["v"]], csp.all_diff_constraint_evaluator) const10 = csp.Constraint([self.name_to_variable_map["t"]], csp.always_satisfied) constraints1 = [ const1, const2, const3, const4, const5, const6, const7, const8, const9, const10 ] self.const_problem1 = csp.ConstraintProblem(constraints1) const11 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["wa"]], csp.all_diff_constraint_evaluator) const12 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["nt"]], csp.all_diff_constraint_evaluator) const13 = csp.Constraint([ self.name_to_variable_map["sa"], self.name_to_variable_map["nsw"] ], csp.all_diff_constraint_evaluator) const14 = csp.Constraint( [self.name_to_variable_map["nsw"], self.name_to_variable_map["q"]], csp.all_diff_constraint_evaluator) const15 = csp.Constraint( [self.name_to_variable_map["nsw"], self.name_to_variable_map["v"]], csp.all_diff_constraint_evaluator) constraints2 = [const11, const12, const13, const14, const15] self.const_problem2 = csp.ConstraintProblem(constraints2) const21 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["wa"]], csp.all_diff_constraint_evaluator) const22 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["q"]], csp.all_diff_constraint_evaluator) const23 = csp.Constraint( [self.name_to_variable_map["wa"], self.name_to_variable_map["nt"]], csp.all_diff_constraint_evaluator) const24 = csp.Constraint( [self.name_to_variable_map["nt"], self.name_to_variable_map["q"]], csp.all_diff_constraint_evaluator) const25 = csp.Constraint( [self.name_to_variable_map["q"], self.name_to_variable_map["v"]], csp.all_diff_constraint_evaluator) constraints3 = [const21, const22, const23, const24, const25] self.const_problem3 = csp.ConstraintProblem(constraints3)
name_to_domain_map["w"] = range(10) name_to_domain_map["r"] = range(10) name_to_domain_map["u"] = range(10) name_to_domain_map["t"] = range(1, 10) name_to_domain_map["f"] = range(1, 10) # carry digits name_to_domain_map["c_10"] = (0, 1) name_to_domain_map["c_100"] = (0, 1) name_to_domain_map["c_1000"] = (0, 1) name_to_variable_map = csp.Variable.from_names_to_domains(name_to_domain_map) all_diff_const = csp.Constraint((name_to_variable_map[name] for name in name_to_variable_map if name not in ["c_10", "c_100", "c_1000"]), csp.all_diff_constraint_evaluator) def units_digit(values: tuple) -> bool: if len(values) < 3: return True o, r, c_10 = values return o + o == r + 10 * c_10 units_digit_const = csp.Constraint( (name_to_variable_map["o"], name_to_variable_map["r"], name_to_variable_map["c_10"]), units_digit)
self.__delay_time = delay_time def __call__(self, values: tuple) -> bool: if len(values) < 2: return True first_task, second_task = values return first_task + self.__delay_time <= second_task ten_delayer = TimeDelayer(10) one_delayer = TimeDelayer(1) two_delayer = TimeDelayer(2) three_delayer = TimeDelayer(3) const1 = csp.Constraint( (name_to_variable_map["axel_f"], name_to_variable_map["wheel_rf"]), ten_delayer) const2 = csp.Constraint( (name_to_variable_map["axel_b"], name_to_variable_map["wheel_rb"]), ten_delayer) const3 = csp.Constraint( (name_to_variable_map["axel_f"], name_to_variable_map["wheel_lf"]), ten_delayer) const4 = csp.Constraint( (name_to_variable_map["axel_b"], name_to_variable_map["wheel_lb"]), ten_delayer) const5 = csp.Constraint( (name_to_variable_map["wheel_rf"], name_to_variable_map["nuts_rf"]), one_delayer) const6 = csp.Constraint(
# Solving the States and Territories of Australia map-coloring problem: (see problem construction for edges) # |Northern Territory| # |Queensland| # |Western Australia| # |South Australia| # |New South Wales| # |Victoria| # # # |Tasmania| colors = ["red", "green", "blue"] names = {"wa", "nt", "q", "nsw", "v", "sa", "t"} name_to_variable_map = csp.Variable.from_names_to_equal_domain(names, colors) const1 = csp.Constraint( [name_to_variable_map["sa"], name_to_variable_map["wa"]], csp.all_diff_constraint_evaluator) const2 = csp.Constraint( [name_to_variable_map["sa"], name_to_variable_map["nt"]], csp.all_diff_constraint_evaluator) const3 = csp.Constraint( [name_to_variable_map["sa"], name_to_variable_map["q"]], csp.all_diff_constraint_evaluator) const4 = csp.Constraint( [name_to_variable_map["sa"], name_to_variable_map["nsw"]], csp.all_diff_constraint_evaluator) const5 = csp.Constraint( [name_to_variable_map["sa"], name_to_variable_map["v"]], csp.all_diff_constraint_evaluator) const6 = csp.Constraint( [name_to_variable_map["wa"], name_to_variable_map["nt"]],
def setUp(self): colors = {"red", "green"} names = {"wa", "nt", "q", "nsw", "v", "sa", "t"} self.name_to_variable_map = csp.Variable.from_names_to_equal_domain( names, colors) const1 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["wa"]], csp.all_diff_constraint_evaluator) const2 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["nt"]], csp.all_diff_constraint_evaluator) const3 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["q"]], csp.all_diff_constraint_evaluator) const4 = csp.Constraint([ self.name_to_variable_map["sa"], self.name_to_variable_map["nsw"] ], csp.all_diff_constraint_evaluator) const5 = csp.Constraint( [self.name_to_variable_map["sa"], self.name_to_variable_map["v"]], csp.all_diff_constraint_evaluator) const6 = csp.Constraint( [self.name_to_variable_map["wa"], self.name_to_variable_map["nt"]], csp.all_diff_constraint_evaluator) const7 = csp.Constraint( [self.name_to_variable_map["nt"], self.name_to_variable_map["q"]], csp.all_diff_constraint_evaluator) const8 = csp.Constraint( [self.name_to_variable_map["q"], self.name_to_variable_map["nsw"]], csp.all_diff_constraint_evaluator) const9 = csp.Constraint( [self.name_to_variable_map["nsw"], self.name_to_variable_map["v"]], csp.all_diff_constraint_evaluator) const10 = csp.Constraint([self.name_to_variable_map["t"]], csp.always_satisfied) constraints = [ const1, const2, const3, const4, const5, const6, const7, const8, const9, const10 ] self.const_problem1 = csp.ConstraintProblem(constraints) x = csp.Variable((2, 5)) y = csp.Variable((2, 4)) z = csp.Variable((2, 5)) def is_divisor(values: tuple) -> bool: if len(values) < 2: return True result = values[0] / values[1] return result == int(result) const1 = csp.Constraint((x, z), is_divisor) const2 = csp.Constraint((y, z), is_divisor) self.const_problem2 = csp.ConstraintProblem((const1, const2)) x = csp.Variable((1, 2, 3)) y = csp.Variable((1, 2, 3)) def less_than(values: tuple) -> bool: if len(values) < 2: return True return values[0] < values[1] const = csp.Constraint((x, y), less_than) self.const_problem3 = csp.ConstraintProblem((const, ))
color_vars = dict() nationality_vars = dict() drink_vars = dict() smoke_vars = dict() pets_vars = dict() for i in range(1, 6): color_vars[i] = csp.Variable(colors) nationality_vars[i] = csp.Variable(nationalities) drink_vars[i] = csp.Variable(drinks) smoke_vars[i] = csp.Variable(smokes) pets_vars[i] = csp.Variable(pets) constraints = set() constraints.add( csp.Constraint(color_vars.values(), csp.all_diff_constraint_evaluator)) constraints.add( csp.Constraint(nationality_vars.values(), csp.all_diff_constraint_evaluator)) constraints.add( csp.Constraint(drink_vars.values(), csp.all_diff_constraint_evaluator)) constraints.add( csp.Constraint(smoke_vars.values(), csp.all_diff_constraint_evaluator)) constraints.add( csp.Constraint(pets_vars.values(), csp.all_diff_constraint_evaluator)) def hint_one(values: tuple) -> bool: if len(values) < 2: return True nationality, color = values
def test_get_variables(self): var1 = csp.Variable([i for i in range(10)]) var2 = csp.Variable([i for i in range(10, 20)]) variables = (var1, var2) const = csp.Constraint(variables, csp.ExactSum(28)) self.assertEqual(const.variables, variables)
def test_unary_constraint(self): var = csp.Variable([i for i in range(10)]) const = csp.Constraint({var}, csp.MinSum(5)) var_from_const, *_ = const.variables self.assertEqual(frozenset(var_from_const.domain), frozenset(i for i in range(6, 10)))
# domain of each variable: 1, ..., n x n # constraints: # 1. global all different. # 2. the values of all rows sum up to magic sum. # 3. the values of all columns sum up to magic sum. # 4. the values of both diagonals sum up to magic sum. n = 3 order = n**2 magic_sum = n * int((order + 1) / 2) name_to_variable_map = {square: csp.Variable(range(1, order + 1)) for square in range(1, order + 1)} constraints = set() constraints.add(csp.Constraint(name_to_variable_map.values(), csp.all_diff_constraint_evaluator)) exact_magic_sum = csp.ExactLengthExactSum(n, magic_sum) for row in range(1, order + 1, n): constraints.add(csp.Constraint((name_to_variable_map[i] for i in range(row, row + n)), exact_magic_sum)) for column in range(1, n + 1): constraints.add(csp.Constraint((name_to_variable_map[i] for i in range(column, order + 1, n)), exact_magic_sum)) constraints.add(csp.Constraint((name_to_variable_map[diag] for diag in range(1, order + 1, n + 1)), exact_magic_sum)) constraints.add(csp.Constraint((name_to_variable_map[diag] for diag in range(n, order, n - 1)), exact_magic_sum))