melatonin355
diff --git a/Collapse file
‎csp.py‎
Copy file name to clipboardExpand all lines: csp.py
+79-57Lines changed: 79 additions & 57 deletions b/Collapse file
‎csp.py‎
Copy file name to clipboardExpand all lines: csp.py
+79-57Lines changed: 79 additions & 57 deletions
@@ -1,12 +1,7 @@
-"""CSP (Constraint Satisfaction Problems) problems and solvers. (Chapter 5)."""
+"""CSP (Constraint Satisfaction Problems) problems and solvers. (Chapter 6)."""
 
-# (Written for the second edition of AIMA; expect some discrepanciecs
-# from the third edition until this gets reviewed.)
-
-from __future__ import generators
 from utils import *
 import search
-import types
 
 class CSP(search.Problem):
     """This class describes finite-domain Constraint Satisfaction Problems.
@@ -129,28 +124,57 @@ def choices(self, var):
         "Return all values for var that aren't currently ruled out."
         return (self.curr_domains or self.domains)[var]
 
-    def restore(self, removals):
-        "Undo all inferences from a supposition."
-        for B, b in removals:
-            self.curr_domains[B].append(b)
-
     def infer_assignment(self):
         "Return the partial assignment implied by the current inferences."
         self.support_pruning()
         return dict((v, self.curr_domains[v][0])
                     for v in self.vars if 1 == len(self.curr_domains[v]))
 
+    def restore(self, removals):
+        "Undo a supposition and all inferences from it."
+        for B, b in removals:
+            self.curr_domains[B].append(b)
+
     ## This is for min_conflicts search
 
     def conflicted_vars(self, current):
         "Return a list of variables in current assignment that are in conflict"
         return [var for var in self.vars
                 if self.nconflicts(var, current[var], current) > 0]
 
+#______________________________________________________________________________
+# Constraint Propagation with AC-3
+
+def AC3(csp, queue=None, removals=None):
+    """[Fig. 6.3]"""
+    if queue is None:
+        queue = [(Xi, Xk) for Xi in csp.vars for Xk in csp.neighbors[Xi]]
+    csp.support_pruning()
+    while queue:
+        (Xi, Xj) = queue.pop()
+        if revise(csp, Xi, Xj, removals):
+            if not csp.curr_domains[Xi]:
+                return False
+            for Xk in csp.neighbors[Xi]:
+                if Xk != Xi:
+                    queue.append((Xk, Xi))
+    return True
+
+def revise(csp, Xi, Xj, removals):
+    "Return true if we remove a value."
+    revised = False
+    for x in csp.curr_domains[Xi][:]:
+        # If Xi=x conflicts with Xj=y for every possible y, eliminate Xi=x
+        if every(lambda y: not csp.constraints(Xi, x, Xj, y),
+                 csp.curr_domains[Xj]):
+            csp.prune(Xi, x, removals)
+            revised = True
+    return revised
+
 #______________________________________________________________________________
 # CSP Backtracking Search
 
-## Variable ordering
+# Variable ordering
 
 def first_unassigned_variable(assignment, csp):
     "The default variable order."
@@ -169,7 +193,7 @@ def num_legal_values(csp, var, assignment):
         return count_if(lambda val: csp.nconflicts(var, val, assignment) == 0,
                         csp.domains[var])
 
-## Value ordering
+# Value ordering
 
 def unordered_domain_values(var, assignment, csp):
     "The default value order."
@@ -180,34 +204,33 @@ def lcv(var, assignment, csp):
     return sorted(csp.choices(var),
                   key=lambda val: csp.nconflicts(var, val, assignment))
 
-## Inference
+# Inference
 
-def no_inference(assignment, csp, var, value):
-    return []
+def no_inference(csp, var, value, assignment, removals):
+    return True
 
-def forward_checking(assignment, csp, var, value):
+def forward_checking(csp, var, value, assignment, removals):
     "Prune neighbor values inconsistent with var=value."
-    removals = csp.suppose(var, value)
     for B in csp.neighbors[var]:
         if B not in assignment:
             for b in csp.curr_domains[B][:]:
                 if not csp.constraints(var, value, B, b):
                     csp.prune(B, b, removals)
-    return removals
+            if not csp.curr_domains[B]:
+                return False
+    return True
 
-def mac(assignment, csp, var, value):
+def mac(csp, var, value, assignment, removals):
     "Maintain arc consistency."
-    removals = csp.suppose(var, value)
-    AC3(csp, [(X, var) for X in csp.neighbors[var]], removals)
-    return removals
+    return AC3(csp, [(X, var) for X in csp.neighbors[var]], removals)
 
-## The search, proper
+# The search, proper
 
 def backtracking_search(csp,
                         select_unassigned_variable = first_unassigned_variable,
                         order_domain_values = unordered_domain_values,
                         inference = no_inference):
-    """Fig. 6.5 (3rd edition)
+    """[Fig. 6.5]
     >>> backtracking_search(australia) is not None
     True
     >>> backtracking_search(australia, select_unassigned_variable=mrv) is not None
@@ -231,43 +254,19 @@ def backtrack(assignment):
         for value in order_domain_values(var, assignment, csp):
             if 0 == csp.nconflicts(var, value, assignment):
                 csp.assign(var, value, assignment)
-                removals = inference(assignment, csp, var, value)
-                result = backtrack(assignment)
-                if result is not None:
-                    return result
+                removals = csp.suppose(var, value)
+                if inference(csp, var, value, assignment, removals):
+                    result = backtrack(assignment)
+                    if result is not None:
+                        return result
                 csp.restore(removals)
-                csp.unassign(var, assignment)
+        csp.unassign(var, assignment)
         return None
 
     result = backtrack({})
     assert result is None or csp.goal_test(result)
     return result
 
-#______________________________________________________________________________
-# Constraint Propagation with AC-3
-
-def AC3(csp, queue=None, removals=None):
-    """[Fig. 5.7]"""
-    if queue is None:
-        queue = [(Xi, Xk) for Xi in csp.vars for Xk in csp.neighbors[Xi]]
-    csp.support_pruning()
-    while queue:
-        (Xi, Xj) = queue.pop()
-        if remove_inconsistent_values(csp, Xi, Xj, removals):
-            for Xk in csp.neighbors[Xi]:
-                queue.append((Xk, Xi))
-
-def remove_inconsistent_values(csp, Xi, Xj, removals):
-    "Return true if we remove a value."
-    removed = False
-    for x in csp.curr_domains[Xi][:]:
-        # If Xi=x conflicts with Xj=y for every possible y, eliminate Xi=x
-        if every(lambda y: not csp.constraints(Xi, x, Xj, y),
-                 csp.curr_domains[Xj]):
-            csp.prune(Xi, x, removals)
-            removed = True
-    return removed
-
 #______________________________________________________________________________
 # Min-conflicts hillclimbing search for CSPs
 
@@ -294,6 +293,29 @@ def min_conflicts_value(csp, var, current):
     return argmin_random_tie(csp.domains[var],
                              lambda val: csp.nconflicts(var, val, current))
 
+#______________________________________________________________________________
+
+def tree_csp_solver(csp):
+    "[Fig. 6.11]"
+    n = len(csp.vars)
+    assignment = {}
+    root = csp.vars[0]
+    X, parent = topological_sort(csp.vars, root)
+    for Xj in reversed(X):
+        if not make_arc_consistent(parent[Xj], Xj, csp):
+            return None
+    for Xi in X:
+        if not csp.curr_domains[Xi]:
+            return None
+        assignment[Xi] = csp.curr_domains[Xi][0]
+    return assignment
+
+def topological_sort(xs, x):
+    unimplemented()
+
+def make_arc_consistent(Xj, Xk, csp): 
+    unimplemented()
+
 #______________________________________________________________________________
 # Map-Coloring Problems
 
@@ -316,8 +338,7 @@ def MapColoringCSP(colors, neighbors):
     """Make a CSP for the problem of coloring a map with different colors
     for any two adjacent regions.  Arguments are a list of colors, and a
     dict of {region: [neighbor,...]} entries.  This dict may also be
-    specified as a string of the form defined by parse_neighbors"""
-
+    specified as a string of the form defined by parse_neighbors."""
     if isinstance(neighbors, str):
         neighbors = parse_neighbors(neighbors)
     return CSP(neighbors.keys(), UniversalDict(colors), neighbors,
@@ -475,6 +496,7 @@ class Sudoku(CSP):
     8 . . | 2 . 3 | . . 9
     . . 5 | . 1 . | 3 . .
     >>> AC3(e); e.display(e.infer_assignment())
+    True
     4 8 3 | 9 2 1 | 6 5 7
     9 6 7 | 3 4 5 | 8 2 1
     2 5 1 | 8 7 6 | 4 9 3