diff --git a/csp.py b/csp.py
index 6edb48004..ce3754914 100644
--- a/csp.py
+++ b/csp.py
@@ -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:
diff --git a/knowledge.py b/knowledge.py
index a33eac81a..2c00f22aa 100644
--- a/knowledge.py
+++ b/knowledge.py
@@ -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))
diff --git a/logic.py b/logic.py
index ae987edb4..bd0493043 100644
--- a/logic.py
+++ b/logic.py
@@ -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.
 
 
diff --git a/making_simple_decision4e.py b/making_simple_decision4e.py
index 775d5fe2a..25ba3e3b6 100644
--- a/making_simple_decision4e.py
+++ b/making_simple_decision4e.py
@@ -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
-
diff --git a/planning.py b/planning.py
index 3835e05df..f62c23e02 100644
--- a/planning.py
+++ b/planning.py
@@ -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:]
diff --git a/probability.py b/probability.py
index 183edfcf8..06a502547 100644
--- a/probability.py
+++ b/probability.py
@@ -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)
diff --git a/probability4e.py b/probability4e.py
index 7d464c62a..66d18dcf6 100644
--- a/probability4e.py
+++ b/probability4e.py
@@ -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()
diff --git a/search.py b/search.py
index 87f6b86e3..262f5a793 100644
--- a/search.py
+++ b/search.py
@@ -16,9 +16,6 @@
                    print_table, open_data, PriorityQueue, name, distance, vector_add, inf)
 
 
-# ______________________________________________________________________________
-
-
 class Problem:
     """The abstract class for a formal problem. You should subclass
     this and implement the methods actions and result, and possibly
@@ -59,12 +56,12 @@ def path_cost(self, c, state1, action, state2):
         """Return the cost of a solution path that arrives at state2 from
         state1 via action, assuming cost c to get up to state1. If the problem
         is such that the path doesn't matter, this function will only look at
-        state2.  If the path does matter, it will consider c and maybe state1
+        state2. If the path does matter, it will consider c and maybe state1
         and action. The default method costs 1 for every step in the path."""
         return c + 1
 
     def value(self, state):
-        """For optimization problems, each state has a value. Hill-climbing
+        """For optimization problems, each state has a value. Hill Climbing
         and related algorithms try to maximize this value."""
         raise NotImplementedError
 
@@ -76,8 +73,8 @@ class Node:
     """A node in a search tree. Contains a pointer to the parent (the node
     that this is a successor of) and to the actual state for this node. Note
     that if a state is arrived at by two paths, then there are two nodes with
-    the same state.  Also includes the action that got us to this state, and
-    the total path_cost (also known as g) to reach the node.  Other functions
+    the same state. Also includes the action that got us to this state, and
+    the total path_cost (also known as g) to reach the node. Other functions
     may add an f and h value; see best_first_graph_search and astar_search for
     an explanation of how the f and h values are handled. You will not need to
     subclass this class."""
@@ -137,7 +134,10 @@ def __hash__(self):
 
 
 class SimpleProblemSolvingAgentProgram:
-    """Abstract framework for a problem-solving agent. [Figure 3.1]"""
+    """
+    [Figure 3.1]
+    Abstract framework for a problem-solving agent.
+    """
 
     def __init__(self, initial_state=None):
         """State is an abstract representation of the state
@@ -176,10 +176,13 @@ def search(self, problem):
 
 
 def breadth_first_tree_search(problem):
-    """Search the shallowest nodes in the search tree first.
-        Search through the successors of a problem to find a goal.
-        The argument frontier should be an empty queue.
-        Repeats infinitely in case of loops. [Figure 3.7]"""
+    """
+    [Figure 3.7]
+    Search the shallowest nodes in the search tree first.
+    Search through the successors of a problem to find a goal.
+    The argument frontier should be an empty queue.
+    Repeats infinitely in case of loops.
+    """
 
     frontier = deque([Node(problem.initial)])  # FIFO queue
 
@@ -192,10 +195,13 @@ def breadth_first_tree_search(problem):
 
 
 def depth_first_tree_search(problem):
-    """Search the deepest nodes in the search tree first.
-        Search through the successors of a problem to find a goal.
-        The argument frontier should be an empty queue.
-        Repeats infinitely in case of loops. [Figure 3.7]"""
+    """
+    [Figure 3.7]
+    Search the deepest nodes in the search tree first.
+    Search through the successors of a problem to find a goal.
+    The argument frontier should be an empty queue.
+    Repeats infinitely in case of loops.
+    """
 
     frontier = [Node(problem.initial)]  # Stack
 
@@ -208,11 +214,14 @@ def depth_first_tree_search(problem):
 
 
 def depth_first_graph_search(problem):
-    """Search the deepest nodes in the search tree first.
-        Search through the successors of a problem to find a goal.
-        The argument frontier should be an empty queue.
-        Does not get trapped by loops.
-        If two paths reach a state, only use the first one. [Figure 3.7]"""
+    """
+    [Figure 3.7]
+    Search the deepest nodes in the search tree first.
+    Search through the successors of a problem to find a goal.
+    The argument frontier should be an empty queue.
+    Does not get trapped by loops.
+    If two paths reach a state, only use the first one.
+    """
     frontier = [(Node(problem.initial))]  # Stack
 
     explored = set()
@@ -417,9 +426,7 @@ class EightPuzzle(Problem):
 
     def __init__(self, initial, goal=(1, 2, 3, 4, 5, 6, 7, 8, 0)):
         """ Define goal state and initialize a problem """
-
-        self.goal = goal
-        Problem.__init__(self, initial, goal)
+        super().__init__(initial, goal)
 
     def find_blank_square(self, state):
         """Return the index of the blank square in a given state"""
@@ -490,11 +497,10 @@ class PlanRoute(Problem):
 
     def __init__(self, initial, goal, allowed, dimrow):
         """ Define goal state and initialize a problem """
-
+        super().__init__(initial, goal)
         self.dimrow = dimrow
         self.goal = goal
         self.allowed = allowed
-        Problem.__init__(self, initial, goal)
 
     def actions(self, state):
         """ Return the actions that can be executed in the given state.
@@ -623,8 +629,11 @@ def RBFS(problem, node, flimit):
 
 
 def hill_climbing(problem):
-    """From the initial node, keep choosing the neighbor with highest value,
-    stopping when no neighbor is better. [Figure 4.2]"""
+    """
+    [Figure 4.2]
+    From the initial node, keep choosing the neighbor with highest value,
+    stopping when no neighbor is better.
+    """
     current = Node(problem.initial)
     while True:
         neighbors = current.expand(problem)
@@ -725,7 +734,7 @@ class PeakFindingProblem(Problem):
 
     def __init__(self, initial, grid, defined_actions=directions4):
         """The grid is a 2 dimensional array/list whose state is specified by tuple of indices"""
-        Problem.__init__(self, initial)
+        super().__init__(initial)
         self.grid = grid
         self.defined_actions = defined_actions
         self.n = len(grid)
@@ -738,7 +747,7 @@ def actions(self, state):
         allowed_actions = []
         for action in self.defined_actions:
             next_state = vector_add(state, self.defined_actions[action])
-            if 0 <= next_state[0] <= self.n - 1 and next_state[1] >= 0 and next_state[1] <= self.m - 1:
+            if 0 <= next_state[0] <= self.n - 1 and 0 <= next_state[1] <= self.m - 1:
                 allowed_actions.append(action)
 
         return allowed_actions
@@ -756,10 +765,13 @@ def value(self, state):
 
 
 class OnlineDFSAgent:
-    """[Figure 4.21] The abstract class for an OnlineDFSAgent. Override
+    """
+    [Figure 4.21]
+    The abstract class for an OnlineDFSAgent. Override
     update_state method to convert percept to state. While initializing
     the subclass a problem needs to be provided which is an instance of
-    a subclass of the Problem class."""
+    a subclass of the Problem class.
+    """
 
     def __init__(self, problem):
         self.problem = problem
@@ -811,8 +823,7 @@ class OnlineSearchProblem(Problem):
     Carried in a deterministic and a fully observable environment."""
 
     def __init__(self, initial, goal, graph):
-        self.initial = initial
-        self.goal = goal
+        super().__init__(initial, goal)
         self.graph = graph
 
     def actions(self, state):
@@ -893,7 +904,7 @@ def LRTA_cost(self, s, a, s1, H):
 # Genetic Algorithm
 
 
-def genetic_search(problem, fitness_fn, ngen=1000, pmut=0.1, n=20):
+def genetic_search(problem, ngen=1000, pmut=0.1, n=20):
     """Call genetic_algorithm on the appropriate parts of a problem.
     This requires the problem to have states that can mate and mutate,
     plus a value method that scores states."""
@@ -989,17 +1000,17 @@ def mutate(x, gene_pool, pmut):
 
 
 class Graph:
-    """A graph connects nodes (vertices) by edges (links).  Each edge can also
-    have a length associated with it.  The constructor call is something like:
+    """A graph connects nodes (vertices) by edges (links). Each edge can also
+    have a length associated with it. The constructor call is something like:
         g = Graph({'A': {'B': 1, 'C': 2})
     this makes a graph with 3 nodes, A, B, and C, with an edge of length 1 from
-    A to B,  and an edge of length 2 from A to C.  You can also do:
+    A to B,  and an edge of length 2 from A to C. You can also do:
         g = Graph({'A': {'B': 1, 'C': 2}, directed=False)
     This makes an undirected graph, so inverse links are also added. The graph
     stays undirected; if you add more links with g.connect('B', 'C', 3), then
-    inverse link is also added.  You can use g.nodes() to get a list of nodes,
+    inverse link is also added. You can use g.nodes() to get a list of nodes,
     g.get('A') to get a dict of links out of A, and g.get('A', 'B') to get the
-    length of the link from A to B.  'Lengths' can actually be any object at
+    length of the link from A to B. 'Lengths' can actually be any object at
     all, and nodes can be any hashable object."""
 
     def __init__(self, graph_dict=None, directed=True):
@@ -1165,7 +1176,7 @@ class GraphProblem(Problem):
     """The problem of searching a graph from one node to another."""
 
     def __init__(self, initial, goal, graph):
-        Problem.__init__(self, initial, goal)
+        super().__init__(initial, goal)
         self.graph = graph
 
     def actions(self, A):
@@ -1221,18 +1232,17 @@ def path_cost(self):
 
 class NQueensProblem(Problem):
     """The problem of placing N queens on an NxN board with none attacking
-    each other.  A state is represented as an N-element array, where
+    each other. A state is represented as an N-element array, where
     a value of r in the c-th entry means there is a queen at column c,
     row r, and a value of -1 means that the c-th column has not been
-    filled in yet.  We fill in columns left to right.
+    filled in yet. We fill in columns left to right.
     >>> depth_first_tree_search(NQueensProblem(8))
     <Node (7, 3, 0, 2, 5, 1, 6, 4)>
     """
 
     def __init__(self, N):
+        super().__init__(tuple([-1] * N))
         self.N = N
-        self.initial = tuple([-1] * N)
-        Problem.__init__(self, self.initial)
 
     def actions(self, state):
         """In the leftmost empty column, try all non-conflicting rows."""
diff --git a/tests/test_csp.py b/tests/test_csp.py
index 553880a40..a070cd531 100644
--- a/tests/test_csp.py
+++ b/tests/test_csp.py
@@ -402,7 +402,7 @@ def test_min_conflicts():
     assert min_conflicts(NQueensCSP(3), 1000) is None
 
 
-def test_nqueensCSP():
+def test_nqueens_csp():
     csp = NQueensCSP(8)
 
     assignment = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}
@@ -477,8 +477,7 @@ def test_topological_sort():
 
 
 def test_tree_csp_solver():
-    australia_small = MapColoringCSP(list('RB'),
-                                     'NT: WA Q; NSW: Q V')
+    australia_small = MapColoringCSP(list('RB'), 'NT: WA Q; NSW: Q V')
     tcs = tree_csp_solver(australia_small)
     assert (tcs['NT'] == 'R' and tcs['WA'] == 'B' and tcs['Q'] == 'B' and tcs['NSW'] == 'R' and tcs['V'] == 'B') or \
            (tcs['NT'] == 'B' and tcs['WA'] == 'R' and tcs['Q'] == 'R' and tcs['NSW'] == 'B' and tcs['V'] == 'R')
diff --git a/tests/test_knowledge.py b/tests/test_knowledge.py
index 556637652..d3829de02 100644
--- a/tests/test_knowledge.py
+++ b/tests/test_knowledge.py
@@ -33,9 +33,8 @@
 
 
 def r_example(Alt, Bar, Fri, Hun, Pat, Price, Rain, Res, Type, Est, GOAL):
-    return {'Alt': Alt, 'Bar': Bar, 'Fri': Fri, 'Hun': Hun, 'Pat': Pat,
-            'Price': Price, 'Rain': Rain, 'Res': Res, 'Type': Type, 'Est': Est,
-            'GOAL': GOAL}
+    return {'Alt': Alt, 'Bar': Bar, 'Fri': Fri, 'Hun': Hun, 'Pat': Pat, 'Price': Price,
+            'Rain': Rain, 'Res': Res, 'Type': Type, 'Est': Est, 'GOAL': GOAL}
 
 
 restaurant = [
diff --git a/tests/test_logic.py b/tests/test_logic.py
index c05b29ec1..8d018bc40 100644
--- a/tests/test_logic.py
+++ b/tests/test_logic.py
@@ -292,11 +292,11 @@ def test_to_cnf():
             '((~P12 | B11) & (~P21 | B11) & (P12 | P21 | ~B11) & ~B11 & P12)')
     assert repr(to_cnf((P & Q) | (~P & ~Q))) == '((~P | P) & (~Q | P) & (~P | Q) & (~Q | Q))'
     assert repr(to_cnf('A <=> B')) == '((A | ~B) & (B | ~A))'
-    assert repr(to_cnf("B <=> (P1 | P2)")) == '((~P1 | B) & (~P2 | B) & (P1 | P2 | ~B))'
+    assert repr(to_cnf('B <=> (P1 | P2)')) == '((~P1 | B) & (~P2 | B) & (P1 | P2 | ~B))'
     assert repr(to_cnf('A <=> (B & C)')) == '((A | ~B | ~C) & (B | ~A) & (C | ~A))'
-    assert repr(to_cnf("a | (b & c) | d")) == '((b | a | d) & (c | a | d))'
-    assert repr(to_cnf("A & (B | (D & E))")) == '(A & (D | B) & (E | B))'
-    assert repr(to_cnf("A | (B | (C | (D & E)))")) == '((D | A | B | C) & (E | A | B | C))'
+    assert repr(to_cnf('a | (b & c) | d')) == '((b | a | d) & (c | a | d))'
+    assert repr(to_cnf('A & (B | (D & E))')) == '(A & (D | B) & (E | B))'
+    assert repr(to_cnf('A | (B | (C | (D & E)))')) == '((D | A | B | C) & (E | A | B | C))'
     assert repr(to_cnf(
         '(A <=> ~B) ==> (C | ~D)')) == '((B | ~A | C | ~D) & (A | ~A | C | ~D) & (B | ~B | C | ~D) & (A | ~B | C | ~D))'
 
diff --git a/tests/test_planning.py b/tests/test_planning.py
index 103402481..a39152adc 100644
--- a/tests/test_planning.py
+++ b/tests/test_planning.py
@@ -7,34 +7,34 @@
 from utils import expr
 from logic import FolKB, conjuncts
 
-random.seed("aima-python")
+random.seed('aima-python')
 
 
 def test_action():
     precond = 'At(c, a) & At(p, a) & Cargo(c) & Plane(p) & Airport(a)'
     effect = 'In(c, p) & ~At(c, a)'
     a = Action('Load(c, p, a)', precond, effect)
-    args = [expr("C1"), expr("P1"), expr("SFO")]
-    assert a.substitute(expr("Load(c, p, a)"), args) == expr("Load(C1, P1, SFO)")
+    args = [expr('C1'), expr('P1'), expr('SFO')]
+    assert a.substitute(expr('Load(c, p, a)'), args) == expr('Load(C1, P1, SFO)')
     test_kb = FolKB(conjuncts(expr('At(C1, SFO) & At(C2, JFK) & At(P1, SFO) & At(P2, JFK) & Cargo(C1) & Cargo(C2) & '
                                    'Plane(P1) & Plane(P2) & Airport(SFO) & Airport(JFK)')))
     assert a.check_precond(test_kb, args)
     a.act(test_kb, args)
-    assert test_kb.ask(expr("In(C1, P2)")) is False
-    assert test_kb.ask(expr("In(C1, P1)")) is not False
-    assert test_kb.ask(expr("Plane(P2)")) is not False
+    assert test_kb.ask(expr('In(C1, P2)')) is False
+    assert test_kb.ask(expr('In(C1, P1)')) is not False
+    assert test_kb.ask(expr('Plane(P2)')) is not False
     assert not a.check_precond(test_kb, args)
 
 
 def test_air_cargo_1():
     p = air_cargo()
     assert p.goal_test() is False
-    solution_1 = [expr("Load(C1 , P1, SFO)"),
-                  expr("Fly(P1, SFO, JFK)"),
-                  expr("Unload(C1, P1, JFK)"),
-                  expr("Load(C2, P2, JFK)"),
-                  expr("Fly(P2, JFK, SFO)"),
-                  expr("Unload(C2, P2, SFO)")]
+    solution_1 = [expr('Load(C1 , P1, SFO)'),
+                  expr('Fly(P1, SFO, JFK)'),
+                  expr('Unload(C1, P1, JFK)'),
+                  expr('Load(C2, P2, JFK)'),
+                  expr('Fly(P2, JFK, SFO)'),
+                  expr('Unload(C2, P2, SFO)')]
 
     for action in solution_1:
         p.act(action)
@@ -45,12 +45,12 @@ def test_air_cargo_1():
 def test_air_cargo_2():
     p = air_cargo()
     assert p.goal_test() is False
-    solution_2 = [expr("Load(C1 , P1, SFO)"),
-                  expr("Fly(P1, SFO, JFK)"),
-                  expr("Unload(C1, P1, JFK)"),
-                  expr("Load(C2, P1, JFK)"),
-                  expr("Fly(P1, JFK, SFO)"),
-                  expr("Unload(C2, P1, SFO)")]
+    solution_2 = [expr('Load(C1 , P1, SFO)'),
+                  expr('Fly(P1, SFO, JFK)'),
+                  expr('Unload(C1, P1, JFK)'),
+                  expr('Load(C2, P1, JFK)'),
+                  expr('Fly(P1, JFK, SFO)'),
+                  expr('Unload(C2, P1, SFO)')]
 
     for action in solution_2:
         p.act(action)
@@ -61,12 +61,12 @@ def test_air_cargo_2():
 def test_air_cargo_3():
     p = air_cargo()
     assert p.goal_test() is False
-    solution_3 = [expr("Load(C2, P2, JFK)"),
-                  expr("Fly(P2, JFK, SFO)"),
-                  expr("Unload(C2, P2, SFO)"),
-                  expr("Load(C1 , P1, SFO)"),
-                  expr("Fly(P1, SFO, JFK)"),
-                  expr("Unload(C1, P1, JFK)")]
+    solution_3 = [expr('Load(C2, P2, JFK)'),
+                  expr('Fly(P2, JFK, SFO)'),
+                  expr('Unload(C2, P2, SFO)'),
+                  expr('Load(C1 , P1, SFO)'),
+                  expr('Fly(P1, SFO, JFK)'),
+                  expr('Unload(C1, P1, JFK)')]
 
     for action in solution_3:
         p.act(action)
@@ -77,12 +77,12 @@ def test_air_cargo_3():
 def test_air_cargo_4():
     p = air_cargo()
     assert p.goal_test() is False
-    solution_4 = [expr("Load(C2, P2, JFK)"),
-                  expr("Fly(P2, JFK, SFO)"),
-                  expr("Unload(C2, P2, SFO)"),
-                  expr("Load(C1, P2, SFO)"),
-                  expr("Fly(P2, SFO, JFK)"),
-                  expr("Unload(C1, P2, JFK)")]
+    solution_4 = [expr('Load(C2, P2, JFK)'),
+                  expr('Fly(P2, JFK, SFO)'),
+                  expr('Unload(C2, P2, SFO)'),
+                  expr('Load(C1, P2, SFO)'),
+                  expr('Fly(P2, SFO, JFK)'),
+                  expr('Unload(C1, P2, JFK)')]
 
     for action in solution_4:
         p.act(action)
@@ -93,9 +93,9 @@ def test_air_cargo_4():
 def test_spare_tire_1():
     p = spare_tire()
     assert p.goal_test() is False
-    solution_1 = [expr("Remove(Flat, Axle)"),
-                  expr("Remove(Spare, Trunk)"),
-                  expr("PutOn(Spare, Axle)")]
+    solution_1 = [expr('Remove(Flat, Axle)'),
+                  expr('Remove(Spare, Trunk)'),
+                  expr('PutOn(Spare, Axle)')]
 
     for action in solution_1:
         p.act(action)
@@ -119,9 +119,9 @@ def test_spare_tire_2():
 def test_three_block_tower():
     p = three_block_tower()
     assert p.goal_test() is False
-    solution = [expr("MoveToTable(C, A)"),
-                expr("Move(B, Table, C)"),
-                expr("Move(A, Table, B)")]
+    solution = [expr('MoveToTable(C, A)'),
+                expr('Move(B, Table, C)'),
+                expr('Move(A, Table, B)')]
 
     for action in solution:
         p.act(action)
@@ -145,8 +145,8 @@ def test_simple_blocks_world():
 def test_have_cake_and_eat_cake_too():
     p = have_cake_and_eat_cake_too()
     assert p.goal_test() is False
-    solution = [expr("Eat(Cake)"),
-                expr("Bake(Cake)")]
+    solution = [expr('Eat(Cake)'),
+                expr('Bake(Cake)')]
 
     for action in solution:
         p.act(action)
@@ -514,9 +514,9 @@ def test_double_tennis():
     p = double_tennis_problem()
     assert not goal_test(p.goals, p.initial)
 
-    solution = [expr("Go(A, RightBaseLine, LeftBaseLine)"),
-                expr("Hit(A, Ball, RightBaseLine)"),
-                expr("Go(A, LeftNet, RightBaseLine)")]
+    solution = [expr('Go(A, RightBaseLine, LeftBaseLine)'),
+                expr('Hit(A, Ball, RightBaseLine)'),
+                expr('Go(A, LeftNet, RightBaseLine)')]
 
     for action in solution:
         p.act(action)
diff --git a/utils.py b/utils.py
index 68694532e..9576108cf 100644
--- a/utils.py
+++ b/utils.py
@@ -715,13 +715,10 @@ def __call__(self, *args):
     # Equality and repr
     def __eq__(self, other):
         """x == y' evaluates to True or False; does not build an Expr."""
-        return (isinstance(other, Expr)
-                and self.op == other.op
-                and self.args == other.args)
+        return isinstance(other, Expr) and self.op == other.op and self.args == other.args
 
     def __lt__(self, other):
-        return (isinstance(other, Expr)
-                and str(self) < str(other))
+        return isinstance(other, Expr) and str(self) < str(other)
 
     def __hash__(self):
         return hash(self.op) ^ hash(self.args)
diff --git a/utils4e.py b/utils4e.py
index 3dfd6c100..d23d168e5 100644
--- a/utils4e.py
+++ b/utils4e.py
@@ -203,8 +203,7 @@ def histogram(values, mode=0, bin_function=None):
         bins[val] = bins.get(val, 0) + 1
 
     if mode:
-        return sorted(list(bins.items()), key=lambda x: (x[1], x[0]),
-                      reverse=True)
+        return sorted(list(bins.items()), key=lambda x: (x[1], x[0]), reverse=True)
     else:
         return sorted(bins.items())
 
@@ -495,25 +494,16 @@ def f(self, x):
         return max(0, x)
 
     def derivative(self, value):
-        if value > 0:
-            return 1
-        else:
-            return 0
+        return 1 if value > 0 else 0
 
 
 class elu(Activation):
 
     def f(self, x, alpha=0.01):
-        if x > 0:
-            return x
-        else:
-            return alpha * (math.exp(x) - 1)
+        return x if x > 0 else alpha * (math.exp(x) - 1)
 
     def derivative(self, value, alpha=0.01):
-        if value > 0:
-            return 1
-        else:
-            return alpha * math.exp(value)
+        return 1 if value > 0 else alpha * math.exp(value)
 
 
 class tanh(Activation):
@@ -522,22 +512,16 @@ def f(self, x):
         return np.tanh(x)
 
     def derivative(self, value):
-        return (1 - (value ** 2))
+        return 1 - (value ** 2)
 
 
 class leaky_relu(Activation):
 
     def f(self, x, alpha=0.01):
-        if x > 0:
-            return x
-        else:
-            return alpha * x
+        return x if x > 0 else alpha * x
 
     def derivative(self, value, alpha=0.01):
-        if value > 0:
-            return 1
-        else:
-            return alpha
+        return 1 if value > 0 else alpha
 
 
 def step(x):
@@ -815,7 +799,7 @@ def __rmatmul__(self, lhs):
         return Expr('@', lhs, self)
 
     def __call__(self, *args):
-        "Call: if 'f' is a Symbol, then f(0) == Expr('f', 0)."
+        """Call: if 'f' is a Symbol, then f(0) == Expr('f', 0)."""
         if self.args:
             raise ValueError('can only do a call for a Symbol, not an Expr')
         else:
@@ -823,10 +807,11 @@ def __call__(self, *args):
 
     # Equality and repr
     def __eq__(self, other):
-        "'x == y' evaluates to True or False; does not build an Expr."
-        return (isinstance(other, Expr)
-                and self.op == other.op
-                and self.args == other.args)
+        """'x == y' evaluates to True or False; does not build an Expr."""
+        return isinstance(other, Expr) and self.op == other.op and self.args == other.args
+
+    def __lt__(self, other):
+        return isinstance(other, Expr) and str(self) < str(other)
 
     def __hash__(self):
         return hash(self.op) ^ hash(self.args)