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))