aimacode
diff --git a/‎csp.py
+17-19 b/‎csp.py
+17-19
diff --git a/‎knowledge.py
+1-1 b/‎knowledge.py
+1-1
diff --git a/‎logic.py
+10-9 b/‎logic.py
+10-9
diff --git a/‎making_simple_decision4e.py
+9-11 b/‎making_simple_decision4e.py
+9-11
diff --git a/‎planning.py
+3-3 b/‎planning.py
+3-3
diff --git a/‎probability.py
+11-11 b/‎probability.py
+11-11
diff --git a/‎probability4e.py
+8-5 b/‎probability4e.py
+8-5
@@ -1,18 +1,17 @@
 """CSP (Constraint Satisfaction Problems) problems and solvers. (Chapter 6)"""
+
+import itertools
+import random
+import re
 import string
+from collections import defaultdict, Counter
+from functools import reduce
 from operator import eq, neg
 
 from sortedcontainers import SortedSet
 
-from utils import argmin_random_tie, count, first, extend
 import search
-
-from collections import defaultdict, Counter
-from functools import reduce
-
-import itertools
-import re
-import random
+from utils import argmin_random_tie, count, first, extend
 
 
 class CSP(search.Problem):
@@ -54,12 +53,12 @@ class CSP(search.Problem):
 
     def __init__(self, variables, domains, neighbors, constraints):
         """Construct a CSP problem. If variables is empty, it becomes domains.keys()."""
+        super().__init__(())
         variables = variables or list(domains.keys())
         self.variables = variables
         self.domains = domains
         self.neighbors = neighbors
         self.constraints = constraints
-        self.initial = ()
         self.curr_domains = None
         self.nassigns = 0
 
@@ -80,8 +79,7 @@ def nconflicts(self, var, val, assignment):
 
         # Subclasses may implement this more efficiently
         def conflict(var2):
-            return (var2 in assignment and
-                    not self.constraints(var, val, var2, assignment[var2]))
+            return var2 in assignment and not self.constraints(var, val, var2, assignment[var2])
 
         return count(conflict(v) for v in self.neighbors[var])
 
@@ -552,7 +550,7 @@ def assign_value(Xj, Xk, csp, assignment):
 
 
 # ______________________________________________________________________________
-# Map Coloring Problems
+# Map Coloring CSP Problems
 
 
 class UniversalDict:
@@ -585,7 +583,7 @@ def MapColoringCSP(colors, neighbors):
     return CSP(list(neighbors.keys()), UniversalDict(colors), neighbors, different_values_constraint)
 
 
-def parse_neighbors(neighbors, variables=None):
+def parse_neighbors(neighbors):
     """Convert a string of the form 'X: Y Z; Y: Z' into a dict mapping
     regions to neighbors. The syntax is a region name followed by a ':'
     followed by zero or more region names, followed by ';', repeated for
@@ -676,10 +674,10 @@ def nconflicts(self, var, val, assignment):
 
     def assign(self, var, val, assignment):
         """Assign var, and keep track of conflicts."""
-        oldval = assignment.get(var, None)
-        if val != oldval:
-            if oldval is not None:  # Remove old val if there was one
-                self.record_conflict(assignment, var, oldval, -1)
+        old_val = assignment.get(var, None)
+        if val != old_val:
+            if old_val is not None:  # Remove old val if there was one
+                self.record_conflict(assignment, var, old_val, -1)
             self.record_conflict(assignment, var, val, +1)
             CSP.assign(self, var, val, assignment)
 
@@ -776,7 +774,7 @@ class Sudoku(CSP):
     >>> h = Sudoku(harder1)
     >>> backtracking_search(h, select_unassigned_variable=mrv, inference=forward_checking) is not None
     True
-    """  # noqa
+    """
 
     R3 = _R3
     Cell = _CELL
@@ -831,7 +829,7 @@ def Zebra():
                 Spaniard: Dog; Kools: Yellow; Chesterfields: Fox;
                 Norwegian: Blue; Winston: Snails; LuckyStrike: OJ;
                 Ukranian: Tea; Japanese: Parliaments; Kools: Horse;
-                Coffee: Green; Green: Ivory""", variables)
+                Coffee: Green; Green: Ivory""")
     for type in [Colors, Pets, Drinks, Countries, Smokes]:
         for A in type:
             for B in type:
 
@@ -300,7 +300,7 @@ def extend_example(self, example, literal):
 
     def new_literals(self, clause):
         """Generate new literals based on known predicate symbols.
-        Generated literal must share atleast one variable with clause"""
+        Generated literal must share at least one variable with clause"""
         share_vars = variables(clause[0])
         for l in clause[1]:
             share_vars.update(variables(l))
 
@@ -46,13 +46,10 @@
                    issequence, Expr, expr, subexpressions, extend)
 
 
-# ______________________________________________________________________________
-
-
 class KB:
     """A knowledge base to which you can tell and ask sentences.
     To create a KB, first subclass this class and implement
-    tell, ask_generator, and retract.  Why ask_generator instead of ask?
+    tell, ask_generator, and retract. Why ask_generator instead of ask?
     The book is a bit vague on what ask means --
     For a Propositional Logic KB, ask(P & Q) returns True or False, but for an
     FOL KB, something like ask(Brother(x, y)) might return many substitutions
@@ -173,7 +170,7 @@ def variables(s):
 
 def is_definite_clause(s):
     """Returns True for exprs s of the form A & B & ... & C ==> D,
-    where all literals are positive.  In clause form, this is
+    where all literals are positive. In clause form, this is
     ~A | ~B | ... | ~C | D, where exactly one clause is positive.
     >>> is_definite_clause(expr('Farmer(Mac)'))
     True
@@ -602,7 +599,7 @@ def pl_fc_entails(kb, q):
 
 
 # ______________________________________________________________________________
-# DPLL-Satisfiable [Figure 7.17]
+# Heuristics for SAT Solvers
 
 
 def no_branching_heuristic(symbols, clauses):
@@ -707,6 +704,10 @@ def jw2(symbols, clauses):
     return P, True if scores[P] >= scores[~P] else False
 
 
+# ______________________________________________________________________________
+# DPLL-Satisfiable [Figure 7.17]
+
+
 def dpll_satisfiable(s, branching_heuristic=no_branching_heuristic):
     """Check satisfiability of a propositional sentence.
     This differs from the book code in two ways: (1) it returns a model
@@ -1114,7 +1115,7 @@ def sat_count(sym):
 
 
 # ______________________________________________________________________________
-# Map Coloring Problems
+# Map Coloring SAT Problems
 
 
 def MapColoringSAT(colors, neighbors):
@@ -1803,7 +1804,7 @@ def cascade_substitution(s):
     for x in s:
         s[x] = subst(s, s.get(x))
         if isinstance(s.get(x), Expr) and not is_variable(s.get(x)):
-            # Ensure Function Terms are correct updates by passing over them again.
+            # Ensure Function Terms are correct updates by passing over them again
             s[x] = subst(s, s.get(x))
 
 
@@ -2055,7 +2056,7 @@ def fol_bc_and(kb, goals, theta):
 # ______________________________________________________________________________
 
 # Example application (not in the book).
-# You can use the Expr class to do symbolic differentiation.  This used to be
+# You can use the Expr class to do symbolic differentiation. This used to be
 # a part of AI; now it is considered a separate field, Symbolic Algebra.
 
 
 
@@ -1,11 +1,9 @@
-from utils4e import (
-    argmax, element_wise_product, matrix_multiplication,
-    vector_to_diagonal, vector_add, scalar_vector_product, inverse_matrix,
-    weighted_sample_with_replacement, probability, normalize
-)
+import random
+
 from agents import Agent
 from probability import BayesNet
-import random
+from utils4e import argmax, vector_add, weighted_sample_with_replacement
+
 
 # Making Simple Decisions (Chapter 15)
 
@@ -108,6 +106,7 @@ def vpi(self, variable):
 class MCLmap:
     """Map which provides probability distributions and sensor readings.
     Consists of discrete cells which are either an obstacle or empty"""
+
     def __init__(self, m):
         self.m = m
         self.nrows = len(m)
@@ -131,7 +130,7 @@ def ray_cast(self, sensor_num, kin_state):
         #  0
         # 3R1
         #  2
-        delta = ((sensor_num % 2 == 0)*(sensor_num - 1), (sensor_num % 2 == 1)*(2 - sensor_num))
+        delta = ((sensor_num % 2 == 0) * (sensor_num - 1), (sensor_num % 2 == 1) * (2 - sensor_num))
         # sensor direction changes based on orientation
         for _ in range(orient):
             delta = (delta[1], -delta[0])
@@ -149,9 +148,9 @@ def ray_cast(sensor_num, kin_state, m):
         return m.ray_cast(sensor_num, kin_state)
 
     M = len(z)
-    W = [0]*N
-    S_ = [0]*N
-    W_ = [0]*N
+    W = [0] * N
+    S_ = [0] * N
+    W_ = [0] * N
     v = a['v']
     w = a['w']
 
@@ -167,4 +166,3 @@ def ray_cast(sensor_num, kin_state, m):
 
     S = weighted_sample_with_replacement(N, S_, W_)
     return S
-
@@ -1047,8 +1047,8 @@ def orderlevel(self, level, planning_problem):
     def execute(self):
         """Finds total-order solution for a planning graph"""
 
-        graphplan_solution = GraphPlan(self.planning_problem).execute()
-        filtered_solution = self.filter(graphplan_solution)
+        graphPlan_solution = GraphPlan(self.planning_problem).execute()
+        filtered_solution = self.filter(graphPlan_solution)
         ordered_solution = []
         planning_problem = self.planning_problem
         for level in filtered_solution:
@@ -1635,7 +1635,7 @@ def angelic_search(self, hierarchy, initial_plan):
                 if guaranteed and RealWorldPlanningProblem.making_progress(plan, initial_plan):
                     final_state = guaranteed[0]  # any element of guaranteed
                     return RealWorldPlanningProblem.decompose(hierarchy, final_state, pes_reachable_set)
-                # there should be at least one HLA/Angelic_HLA, otherwise plan would be primitive
+                # there should be at least one HLA/AngelicHLA, otherwise plan would be primitive
                 hla, index = RealWorldPlanningProblem.find_hla(plan, hierarchy)
                 prefix = plan.action[:index]
                 suffix = plan.action[index + 1:]
 
@@ -2,18 +2,16 @@
 Probability models. (Chapter 13-15)
 """
 
-from utils import (product, argmax, element_wise_product, matrix_multiplication, vector_to_diagonal, vector_add,
-                   scalar_vector_product, inverse_matrix, weighted_sample_with_replacement, isclose, probability,
-                   normalize, extend)
-from agents import Agent
-
 import random
 from collections import defaultdict
 from functools import reduce
-import numpy as np
 
+import numpy as np
 
-# ______________________________________________________________________________
+from agents import Agent
+from utils import (product, argmax, element_wise_product, matrix_multiplication, vector_to_diagonal, vector_add,
+                   scalar_vector_product, inverse_matrix, weighted_sample_with_replacement, isclose, probability,
+                   normalize, extend)
 
 
 def DTAgentProgram(belief_state):
@@ -106,7 +104,7 @@ def __getitem__(self, values):
         return ProbDist.__getitem__(self, values)
 
     def __setitem__(self, values, p):
-        """Set P(values) = p.  Values can be a tuple or a dict; it must
+        """Set P(values) = p. Values can be a tuple or a dict; it must
         have a value for each of the variables in the joint. Also keep track
         of the values we have seen so far for each variable."""
         values = event_values(values, self.variables)
@@ -307,7 +305,7 @@ class BayesNode:
 
     def __init__(self, X, parents, cpt):
         """X is a variable name, and parents a sequence of variable
-        names or a space-separated string.  cpt, the conditional
+        names or a space-separated string. cpt, the conditional
         probability table, takes one of these forms:
 
         * A number, the unconditional probability P(X=true). You can
@@ -541,8 +539,10 @@ def prior_sample(bn):
 
 
 def rejection_sampling(X, e, bn, N=10000):
-    """Estimate the probability distribution of variable X given
-    evidence e in BayesNet bn, using N samples.  [Figure 14.14]
+    """
+    [Figure 14.14]
+    Estimate the probability distribution of variable X given
+    evidence e in BayesNet bn, using N samples.
     Raises a ZeroDivisionError if all the N samples are rejected,
     i.e., inconsistent with e.
     >>> random.seed(47)
 
@@ -1,11 +1,12 @@
 """Probability models."""
 
-from utils4e import product, argmax, isclose, probability, extend
-from math import sqrt, pi, exp
 import copy
 import random
 from collections import defaultdict
 from functools import reduce
+from math import sqrt, pi, exp
+
+from utils4e import product, argmax, isclose, probability, extend
 
 
 # ______________________________________________________________________________
@@ -107,7 +108,7 @@ def __getitem__(self, values):
         return ProbDist.__getitem__(self, values)
 
     def __setitem__(self, values, p):
-        """Set P(values) = p.  Values can be a tuple or a dict; it must
+        """Set P(values) = p. Values can be a tuple or a dict; it must
         have a value for each of the variables in the joint. Also keep track
         of the values we have seen so far for each variable."""
         values = event_values(values, self.variables)
@@ -628,8 +629,9 @@ def prior_sample(bn):
 
 def rejection_sampling(X, e, bn, N=10000):
     """
+    [Figure 13.16]
     Estimate the probability distribution of variable X given
-    evidence e in BayesNet bn, using N samples.  [Figure 13.16]
+    evidence e in BayesNet bn, using N samples.
     Raises a ZeroDivisionError if all the N samples are rejected,
     i.e., inconsistent with e.
     >>> random.seed(47)
@@ -656,8 +658,9 @@ def consistent_with(event, evidence):
 
 def likelihood_weighting(X, e, bn, N=10000):
     """
+    [Figure 13.17]
     Estimate the probability distribution of variable X given
-    evidence e in BayesNet bn.  [Figure 13.17]
+    evidence e in BayesNet bn.
     >>> random.seed(1017)
     >>> likelihood_weighting('Burglary', dict(JohnCalls=T, MaryCalls=T),
     ...   burglary, 10000).show_approx()