From 4f591486ee976e05fcf4f5b5f37278dfcf7f69cc Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Tue, 6 Mar 2018 22:11:52 -0500
Subject: [PATCH 1/9] Updating submodule

---
 search.ipynb | 56 ++++++++++++++++++++--------------------------------
 search.py    | 31 +++++++++++++++++------------
 2 files changed, 39 insertions(+), 48 deletions(-)

diff --git a/search.ipynb b/search.ipynb
index edcdf592f..dd4059ddd 100644
--- a/search.ipynb
+++ b/search.ipynb
@@ -15,6 +15,7 @@
    "cell_type": "code",
    "execution_count": 134,
    "metadata": {
+    "collapsed": true,
     "scrolled": true
    },
    "outputs": [],
@@ -635,7 +636,9 @@
   {
    "cell_type": "code",
    "execution_count": 138,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "romania_map = UndirectedGraph(dict(\n",
@@ -680,7 +683,9 @@
   {
    "cell_type": "code",
    "execution_count": 139,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)"
@@ -730,7 +735,9 @@
   {
    "cell_type": "code",
    "execution_count": 141,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
@@ -754,7 +761,9 @@
   {
    "cell_type": "code",
    "execution_count": 142,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "# initialise a graph\n",
@@ -805,36 +814,11 @@
   {
    "cell_type": "code",
    "execution_count": 143,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
-   "source": [
-    "def show_map(node_colors):\n",
-    "    # set the size of the plot\n",
-    "    plt.figure(figsize=(18,13))\n",
-    "    # draw the graph (both nodes and edges) with locations from romania_locations\n",
-    "    nx.draw(G, pos = romania_locations, node_color = [node_colors[node] for node in G.nodes()])\n",
-    "\n",
-    "    # draw labels for nodes\n",
-    "    node_label_handles = nx.draw_networkx_labels(G, pos = node_label_pos, labels = node_labels, font_size = 14)\n",
-    "    # add a white bounding box behind the node labels\n",
-    "    [label.set_bbox(dict(facecolor='white', edgecolor='none')) for label in node_label_handles.values()]\n",
-    "\n",
-    "    # add edge lables to the graph\n",
-    "    nx.draw_networkx_edge_labels(G, pos = romania_locations, edge_labels=edge_labels, font_size = 14)\n",
-    "    \n",
-    "    # add a legend\n",
-    "    white_circle = lines.Line2D([], [], color=\"white\", marker='o', markersize=15, markerfacecolor=\"white\")\n",
-    "    orange_circle = lines.Line2D([], [], color=\"orange\", marker='o', markersize=15, markerfacecolor=\"orange\")\n",
-    "    red_circle = lines.Line2D([], [], color=\"red\", marker='o', markersize=15, markerfacecolor=\"red\")\n",
-    "    gray_circle = lines.Line2D([], [], color=\"gray\", marker='o', markersize=15, markerfacecolor=\"gray\")\n",
-    "    green_circle = lines.Line2D([], [], color=\"green\", marker='o', markersize=15, markerfacecolor=\"green\")\n",
-    "    plt.legend((white_circle, orange_circle, red_circle, gray_circle, green_circle),\n",
-    "               ('Un-explored', 'Frontier', 'Currently Exploring', 'Explored', 'Final Solution'),\n",
-    "               numpoints=1,prop={'size':16}, loc=(.8,.75))\n",
-    "    \n",
-    "    # show the plot. No need to use in notebooks. nx.draw will show the graph itself.\n",
-    "    plt.show()"
-   ]
+   "source": []
   },
   {
    "cell_type": "markdown",
@@ -1056,7 +1040,9 @@
   {
    "cell_type": "code",
    "execution_count": 146,
-   "metadata": {},
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [],
    "source": [
     "class vacuumAgent(SimpleProblemSolvingAgentProgram):\n",
@@ -3915,7 +3901,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.6.3"
   }
  },
  "nbformat": 4,
diff --git a/search.py b/search.py
index ac834d80c..9d3906aec 100644
--- a/search.py
+++ b/search.py
@@ -154,7 +154,7 @@ def __init__(self, initial_state=None):
     def __call__(self, percept):
         """[Figure 3.1] Formulate a goal and problem, then
         search for a sequence of actions to solve it."""
-        self.state = self.update_state(self.state, percept)
+        self.state = self.update_state(percept)
         if not self.seq:
             goal = self.formulate_goal(self.state)
             problem = self.formulate_problem(self.state, goal)
@@ -182,7 +182,7 @@ def search(self, problem):
 def tree_search(problem, frontier):
     """Search through the successors of a problem to find a goal.
     The argument frontier should be an empty queue.
-    Don't worry about repeated paths to a state. [Figure 3.7]"""
+    Repeats infinites in case of loops. [Figure 3.7]"""
     frontier.append(Node(problem.initial))
     while frontier:
         node = frontier.pop()
@@ -195,6 +195,7 @@ def tree_search(problem, frontier):
 def graph_search(problem, frontier):
     """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]"""
     frontier.append(Node(problem.initial))
     explored = set()
@@ -225,7 +226,11 @@ def depth_first_graph_search(problem):
 
 
 def breadth_first_search(problem):
-    """[Figure 3.11]"""
+    """[Figure 3.11]
+	Note that this function can be implemented in a 
+	single line as below:
+	return graph_search(problem, FIFOQueue())
+    """
     node = Node(problem.initial)
     if problem.goal_test(node.state):
         return node
@@ -730,10 +735,10 @@ def __init__(self, initial, goal, graph):
         self.graph = graph
 
     def actions(self, state):
-        return self.graph.dict[state].keys()
+        return self.graph.graph_dict[state].keys()
 
     def output(self, state, action):
-        return self.graph.dict[state][action]
+        return self.graph.graph_dict[state][action]
 
     def h(self, state):
         """Returns least possible cost to reach a goal for the given state."""
@@ -920,16 +925,16 @@ class Graph:
     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, dict=None, directed=True):
-        self.dict = dict or {}
+    def __init__(self, graph_dict=None, directed=True):
+        self.graph_dict = graph_dict or {}
         self.directed = directed
         if not directed:
             self.make_undirected()
 
     def make_undirected(self):
         """Make a digraph into an undirected graph by adding symmetric edges."""
-        for a in list(self.dict.keys()):
-            for (b, dist) in self.dict[a].items():
+        for a in list(self.graph_dict.keys()):
+            for (b, dist) in self.graph_dict[a].items():
                 self.connect1(b, a, dist)
 
     def connect(self, A, B, distance=1):
@@ -941,13 +946,13 @@ def connect(self, A, B, distance=1):
 
     def connect1(self, A, B, distance):
         """Add a link from A to B of given distance, in one direction only."""
-        self.dict.setdefault(A, {})[B] = distance
+        self.graph_dict.setdefault(A, {})[B] = distance
 
     def get(self, a, b=None):
         """Return a link distance or a dict of {node: distance} entries.
         .get(a,b) returns the distance or None;
         .get(a) returns a dict of {node: distance} entries, possibly {}."""
-        links = self.dict.setdefault(a, {})
+        links = self.graph_dict.setdefault(a, {})
         if b is None:
             return links
         else:
@@ -955,7 +960,7 @@ def get(self, a, b=None):
 
     def nodes(self):
         """Return a list of nodes in the graph."""
-        return list(self.dict.keys())
+        return list(self.graph_dict.keys())
 
 
 def UndirectedGraph(dict=None):
@@ -1097,7 +1102,7 @@ def path_cost(self, cost_so_far, A, action, B):
     def find_min_edge(self):
         """Find minimum value of edges."""
         m = infinity
-        for d in self.graph.dict.values():
+        for d in self.graph.graph_dict.values():
             local_min = min(d.values())
             m = min(m, local_min)
 

From a1171a3993e45cdb91ad808ae2c0159cc3240863 Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Wed, 7 Mar 2018 02:10:31 -0500
Subject: [PATCH 2/9] Moved viz code to notebook.py + changes

---
 notebook.py  | 155 ++++++++++++
 search.ipynb | 658 +++++++++++++++++++--------------------------------
 search.py    |  13 +-
 3 files changed, 404 insertions(+), 422 deletions(-)

diff --git a/notebook.py b/notebook.py
index 6e1a0fbfc..fdd7b9a7c 100644
--- a/notebook.py
+++ b/notebook.py
@@ -886,3 +886,158 @@ def draw_table(self):
         self.fill(0, 0, 0)
         self.text_n(self.table[self.context[0]][self.context[1]] if self.context else "Click for text", 0.025, 0.975)
         self.update()
+
+############################################################################################################
+
+#####################           Functions to assist plotting in search.ipynb            ####################
+
+############################################################################################################
+import networkx as nx
+import matplotlib.pyplot as plt
+from matplotlib import lines
+
+from ipywidgets import interact
+import ipywidgets as widgets
+from IPython.display import display
+import time
+
+def show_map(graph_data, node_colors = None):
+    G = nx.Graph(graph_data['graph_dict'])
+    node_colors = node_colors or graph_data['node_colors']
+    node_positions = graph_data['node_positions']
+    node_label_pos = graph_data['node_label_positions']
+    edge_weights= graph_data['edge_weights']
+    
+    # set the size of the plot
+    plt.figure(figsize=(18,13))
+    # draw the graph (both nodes and edges) with locations from romania_locations
+    nx.draw(G, pos = {k : node_positions[k] for k in G.nodes()},
+                node_color = [node_colors[node] for node in G.nodes()], linewidths = 0.3, edgecolors = 'k')
+
+    # draw labels for nodes
+    node_label_handles = nx.draw_networkx_labels(G, pos = node_label_pos, font_size = 14)
+    
+    # add a white bounding box behind the node labels
+    [label.set_bbox(dict(facecolor='white', edgecolor='none')) for label in node_label_handles.values()]
+
+    # add edge lables to the graph
+    nx.draw_networkx_edge_labels(G, pos = node_positions, edge_labels = edge_weights, font_size = 14)
+    
+    # add a legend
+    white_circle = lines.Line2D([], [], color="white", marker='o', markersize=15, markerfacecolor="white")
+    orange_circle = lines.Line2D([], [], color="orange", marker='o', markersize=15, markerfacecolor="orange")
+    red_circle = lines.Line2D([], [], color="red", marker='o', markersize=15, markerfacecolor="red")
+    gray_circle = lines.Line2D([], [], color="gray", marker='o', markersize=15, markerfacecolor="gray")
+    green_circle = lines.Line2D([], [], color="green", marker='o', markersize=15, markerfacecolor="green")
+    plt.legend((white_circle, orange_circle, red_circle, gray_circle, green_circle),
+               ('Un-explored', 'Frontier', 'Currently Exploring', 'Explored', 'Final Solution'),
+               numpoints=1,prop={'size':16}, loc=(.8,.75))
+    
+    # show the plot. No need to use in notebooks. nx.draw will show the graph itself.
+    plt.show()
+    
+## helper functions for visualisations
+   
+def final_path_colors(initial_node_colors, problem, solution):
+    "returns a node_colors dict of the final path provided the problem and solution"
+    
+    # get initial node colors
+    final_colors = dict(initial_node_colors)
+    # color all the nodes in solution and starting node to green
+    final_colors[problem.initial] = "green"
+    for node in solution:
+        final_colors[node] = "green"  
+    return final_colors
+
+def display_visual(graph_data, user_input, algorithm=None, problem=None):
+    initial_node_colors = graph_data['node_colors']
+    if user_input == False:
+        def slider_callback(iteration):
+            # don't show graph for the first time running the cell calling this function
+            try:
+                show_map(graph_data, node_colors = all_node_colors[iteration])
+            except:
+                pass
+        def visualize_callback(Visualize):
+            if Visualize is True:
+                button.value = False
+                
+                global all_node_colors
+                
+                iterations, all_node_colors, node = algorithm(problem)
+                solution = node.solution()
+                all_node_colors.append(final_path_colors(all_node_colors[0], problem, solution))
+                
+                slider.max = len(all_node_colors) - 1
+                
+                for i in range(slider.max + 1):
+                    slider.value = i
+                     #time.sleep(.5)
+        
+        slider = widgets.IntSlider(min=0, max=1, step=1, value=0)
+        slider_visual = widgets.interactive(slider_callback, iteration = slider)
+        display(slider_visual)
+
+        button = widgets.ToggleButton(value = False)
+        button_visual = widgets.interactive(visualize_callback, Visualize = button)
+        display(button_visual)
+    
+    if user_input == True:
+        node_colors = dict(initial_node_colors)
+        if algorithm == None:
+            algorithms = {"Breadth First Tree Search": breadth_first_tree_search,
+                          "Depth First Tree Search": depth_first_tree_search,
+                          "Breadth First Search": breadth_first_search,
+                          "Depth First Graph Search": depth_first_graph_search,
+                          "Uniform Cost Search": uniform_cost_search,
+                          "A-star Search": astar_search}
+            algo_dropdown = widgets.Dropdown(description = "Search algorithm: ",
+                                             options = sorted(list(algorithms.keys())),
+                                             value = "Breadth First Tree Search")
+            display(algo_dropdown)
+        
+        def slider_callback(iteration):
+            # don't show graph for the first time running the cell calling this function
+            try:
+                show_map(graph_data, node_colors = all_node_colors[iteration])
+            except:
+                pass
+            
+        def visualize_callback(Visualize):
+            if Visualize is True:
+                button.value = False
+                
+                problem = GraphProblem(start_dropdown.value, end_dropdown.value, romania_map)
+                global all_node_colors
+                
+                if algorithm == None:
+                    user_algorithm = algorithms[algo_dropdown.value]
+                
+#                 print(user_algorithm)
+#                 print(problem)
+                
+                iterations, all_node_colors, node = user_algorithm(problem)
+                solution = node.solution()
+                all_node_colors.append(final_path_colors(all_node_colors[0], problem, solution))
+
+                slider.max = len(all_node_colors) - 1
+                
+                for i in range(slider.max + 1):
+                    slider.value = i
+#                     time.sleep(.5)
+                         
+        start_dropdown = widgets.Dropdown(description = "Start city: ",
+                                          options = sorted(list(node_colors.keys())), value = "Arad")
+        display(start_dropdown)
+
+        end_dropdown = widgets.Dropdown(description = "Goal city: ",
+                                        options = sorted(list(node_colors.keys())), value = "Fagaras")
+        display(end_dropdown)
+        
+        button = widgets.ToggleButton(value = False)
+        button_visual = widgets.interactive(visualize_callback, Visualize = button)
+        display(button_visual)
+        
+        slider = widgets.IntSlider(min=0, max=1, step=1, value=0)
+        slider_visual = widgets.interactive(slider_callback, iteration = slider)
+        display(slider_visual)
\ No newline at end of file
diff --git a/search.ipynb b/search.ipynb
index dd4059ddd..5027257a9 100644
--- a/search.ipynb
+++ b/search.ipynb
@@ -13,7 +13,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 134,
+   "execution_count": 1,
    "metadata": {
     "collapsed": true,
     "scrolled": true
@@ -21,7 +21,7 @@
    "outputs": [],
    "source": [
     "from search import *\n",
-    "from notebook import psource\n",
+    "from notebook import psource, show_map, final_path_colors, display_visual\n",
     "\n",
     "# Needed to hide warnings in the matplotlib sections\n",
     "import warnings\n",
@@ -74,6 +74,32 @@
     "*Don't miss the visualisations of these algorithms solving the route-finding problem defined on Romania map at the end of this notebook.*"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For visualisations, we use networkx and matplotlib to show the map in the notebook and we use ipywidgets to interact with the map to see how the searching algorithm works. These are imported as required in `notebook.py`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "import networkx as nx\n",
+    "import matplotlib.pyplot as plt\n",
+    "from matplotlib import lines\n",
+    "\n",
+    "from ipywidgets import interact\n",
+    "import ipywidgets as widgets\n",
+    "from IPython.display import display\n",
+    "import time"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -85,7 +111,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 135,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -277,7 +303,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 136,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -480,7 +506,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 137,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -594,7 +620,7 @@
        "    <span class=\"k\">def</span> <span class=\"nf\">find_min_edge</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
        "        <span class=\"sd\">&quot;&quot;&quot;Find minimum value of edges.&quot;&quot;&quot;</span>\n",
        "        <span class=\"n\">m</span> <span class=\"o\">=</span> <span class=\"n\">infinity</span>\n",
-       "        <span class=\"k\">for</span> <span class=\"n\">d</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">graph</span><span class=\"o\">.</span><span class=\"n\">dict</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">():</span>\n",
+       "        <span class=\"k\">for</span> <span class=\"n\">d</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">graph</span><span class=\"o\">.</span><span class=\"n\">graph_dict</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">():</span>\n",
        "            <span class=\"n\">local_min</span> <span class=\"o\">=</span> <span class=\"nb\">min</span><span class=\"p\">(</span><span class=\"n\">d</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">())</span>\n",
        "            <span class=\"n\">m</span> <span class=\"o\">=</span> <span class=\"nb\">min</span><span class=\"p\">(</span><span class=\"n\">m</span><span class=\"p\">,</span> <span class=\"n\">local_min</span><span class=\"p\">)</span>\n",
        "\n",
@@ -635,7 +661,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 138,
+   "execution_count": 6,
    "metadata": {
     "collapsed": true
    },
@@ -682,7 +708,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 139,
+   "execution_count": 7,
    "metadata": {
     "collapsed": true
    },
@@ -709,7 +735,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 140,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -725,32 +751,6 @@
     "print(romania_locations)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's start the visualisations by importing necessary modules. We use networkx and matplotlib to show the map in the notebook and we use ipywidgets to interact with the map to see how the searching algorithm works."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 141,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "%matplotlib inline\n",
-    "import networkx as nx\n",
-    "import matplotlib.pyplot as plt\n",
-    "from matplotlib import lines\n",
-    "\n",
-    "from ipywidgets import interact\n",
-    "import ipywidgets as widgets\n",
-    "from IPython.display import display\n",
-    "import time"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -760,48 +760,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 142,
+   "execution_count": 9,
    "metadata": {
     "collapsed": true
    },
    "outputs": [],
    "source": [
-    "# initialise a graph\n",
-    "G = nx.Graph()\n",
-    "\n",
-    "# use this while labeling nodes in the map\n",
-    "node_labels = dict()\n",
-    "# use this to modify colors of nodes while exploring the graph.\n",
-    "# This is the only dict we send to `show_map(node_colors)` while drawing the map\n",
-    "node_colors = dict()\n",
-    "\n",
-    "for n, p in romania_locations.items():\n",
-    "    # add nodes from romania_locations\n",
-    "    G.add_node(n)\n",
-    "    # add nodes to node_labels\n",
-    "    node_labels[n] = n\n",
-    "    # node_colors to color nodes while exploring romania map\n",
-    "    node_colors[n] = \"white\"\n",
-    "\n",
-    "# we'll save the initial node colors to a dict to use later\n",
-    "initial_node_colors = dict(node_colors)\n",
-    "    \n",
-    "# positions for node labels\n",
-    "node_label_pos = { k:[v[0],v[1]-10]  for k,v in romania_locations.items() }\n",
-    "\n",
-    "# use this while labeling edges\n",
-    "edge_labels = dict()\n",
-    "\n",
-    "# add edges between cities in romania map - UndirectedGraph defined in search.py\n",
-    "for node in romania_map.nodes():\n",
-    "    connections = romania_map.get(node)\n",
-    "    for connection in connections.keys():\n",
-    "        distance = connections[connection]\n",
+    "# node colors, node positions and node label positions\n",
+    "node_colors = {node: 'white' for node in romania_map.locations.keys()}\n",
+    "node_positions = romania_map.locations\n",
+    "node_label_pos = { k:[v[0],v[1]-10]  for k,v in romania_map.locations.items() }\n",
+    "edge_weights = {(k, k2) : v2 for k, v in romania_map.graph_dict.items() for k2, v2 in v.items()}\n",
     "\n",
-    "        # add edges to the graph\n",
-    "        G.add_edge(node, connection)\n",
-    "        # add distances to edge_labels\n",
-    "        edge_labels[(node, connection)] = distance"
+    "romania_graph_data = {  'graph_dict' : romania_map.graph_dict,\n",
+    "                        'node_colors': node_colors,\n",
+    "                        'node_positions': node_positions,\n",
+    "                        'node_label_positions': node_label_pos,\n",
+    "                         'edge_weights': edge_weights\n",
+    "                     }"
    ]
   },
   {
@@ -811,15 +787,6 @@
     "We have completed building our graph based on romania_map and its locations. It's time to display it here in the notebook. This function `show_map(node_colors)` helps us do that. We will be calling this function later on to display the map at each and every interval step while searching, using variety of algorithms from the book."
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 143,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -829,16 +796,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 144,
+   "execution_count": 10,
    "metadata": {
     "scrolled": true
    },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABTsAAAPKCAYAAABbVI7QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n",
       "text/plain": [
-       "<matplotlib.figure.Figure at 0xe87fe50>"
+       "<matplotlib.figure.Figure at 0x7faa59a8af28>"
       ]
      },
      "metadata": {},
@@ -846,7 +813,7 @@
     }
    ],
    "source": [
-    "show_map(node_colors)"
+    "show_map(romania_graph_data)"
    ]
   },
   {
@@ -867,7 +834,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 145,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -982,7 +949,7 @@
        "                <span class=\"k\">return</span> <span class=\"bp\">None</span>\n",
        "        <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">seq</span><span class=\"o\">.</span><span class=\"n\">pop</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">)</span>\n",
        "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">update_state</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">percept</span><span class=\"p\">):</span>\n",
+       "    <span class=\"k\">def</span> <span class=\"nf\">update_state</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">percept</span><span class=\"p\">):</span>\n",
        "        <span class=\"k\">raise</span> <span class=\"ne\">NotImplementedError</span>\n",
        "\n",
        "    <span class=\"k\">def</span> <span class=\"nf\">formulate_goal</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">):</span>\n",
@@ -1039,7 +1006,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 146,
+   "execution_count": 12,
    "metadata": {
     "collapsed": true
    },
@@ -1082,7 +1049,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -1096,20 +1063,20 @@
     }
    ],
    "source": [
-    "    state1 = [(0, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Dirty\"]]]\n",
-    "    state2 = [(1, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Dirty\"]]]\n",
-    "    state3 = [(0, 0), [(0, 0), \"Clean\"], [(1, 0), [\"Dirty\"]]]\n",
-    "    state4 = [(1, 0), [(0, 0), \"Clean\"], [(1, 0), [\"Dirty\"]]]\n",
-    "    state5 = [(0, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Clean\"]]]\n",
-    "    state6 = [(1, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Clean\"]]]\n",
-    "    state7 = [(0, 0), [(0, 0), \"Clean\"], [(1, 0), [\"Clean\"]]]\n",
-    "    state8 = [(1, 0), [(0, 0), \"Clean\"], [(1, 0), [\"Clean\"]]]\n",
+    "state1 = [(0, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Dirty\"]]]\n",
+    "state2 = [(1, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Dirty\"]]]\n",
+    "state3 = [(0, 0), [(0, 0), \"Clean\"], [(1, 0), [\"Dirty\"]]]\n",
+    "state4 = [(1, 0), [(0, 0), \"Clean\"], [(1, 0), [\"Dirty\"]]]\n",
+    "state5 = [(0, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Clean\"]]]\n",
+    "state6 = [(1, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Clean\"]]]\n",
+    "state7 = [(0, 0), [(0, 0), \"Clean\"], [(1, 0), [\"Clean\"]]]\n",
+    "state8 = [(1, 0), [(0, 0), \"Clean\"], [(1, 0), [\"Clean\"]]]\n",
     "\n",
-    "    a = vacuumAgent(state1)\n",
+    "a = vacuumAgent(state1)\n",
     "\n",
-    "    print(a(state6)) \n",
-    "    print(a(state1))\n",
-    "    print(a(state3))"
+    "print(a(state6)) \n",
+    "print(a(state1))\n",
+    "print(a(state3))"
    ]
   },
   {
@@ -1120,151 +1087,36 @@
     "\n",
     "In this section, we have visualizations of the following searching algorithms:\n",
     "\n",
-    "1. Breadth First Tree Search - Implemented\n",
-    "2. Depth First Tree Search - Implemented\n",
-    "3. Depth First Graph Search - Implemented\n",
-    "4. Breadth First Search - Implemented\n",
-    "5. Best First Graph Search - Implemented\n",
-    "6. Uniform Cost Search - Implemented\n",
+    "1. Breadth First Tree Search\n",
+    "2. Depth First Tree Search\n",
+    "3. Breadth First Search\n",
+    "4. Depth First Graph Search\n",
+    "5. Best First Graph Search\n",
+    "6. Uniform Cost Search\n",
     "7. Depth Limited Search\n",
     "8. Iterative Deepening Search\n",
-    "9. A\\*-Search - Implemented\n",
+    "9. A\\*-Search\n",
     "10. Recursive Best First Search\n",
     "\n",
     "We add the colors to the nodes to have a nice visualisation when displaying. So, these are the different colors we are using in these visuals:\n",
     "* Un-explored nodes - <font color='black'>white</font>\n",
     "* Frontier nodes - <font color='orange'>orange</font>\n",
     "* Currently exploring node - <font color='red'>red</font>\n",
-    "* Already explored nodes - <font color='gray'>gray</font>\n",
-    "\n",
-    "Now, we will define some helper methods to display interactive buttons and sliders when visualising search algorithms."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "collapsed": true
-   },
-   "outputs": [],
-   "source": [
-    "def final_path_colors(problem, solution):\n",
-    "    \"returns a node_colors dict of the final path provided the problem and solution\"\n",
-    "    \n",
-    "    # get initial node colors\n",
-    "    final_colors = dict(initial_node_colors)\n",
-    "    # color all the nodes in solution and starting node to green\n",
-    "    final_colors[problem.initial] = \"green\"\n",
-    "    for node in solution:\n",
-    "        final_colors[node] = \"green\"  \n",
-    "    return final_colors\n",
-    "\n",
-    "\n",
-    "def display_visual(user_input, algorithm=None, problem=None):\n",
-    "    if user_input == False:\n",
-    "        def slider_callback(iteration):\n",
-    "            # don't show graph for the first time running the cell calling this function\n",
-    "            try:\n",
-    "                show_map(all_node_colors[iteration])\n",
-    "            except:\n",
-    "                pass\n",
-    "        def visualize_callback(Visualize):\n",
-    "            if Visualize is True:\n",
-    "                button.value = False\n",
-    "                \n",
-    "                global all_node_colors\n",
-    "                \n",
-    "                iterations, all_node_colors, node = algorithm(problem)\n",
-    "                solution = node.solution()\n",
-    "                all_node_colors.append(final_path_colors(problem, solution))\n",
-    "                \n",
-    "                slider.max = len(all_node_colors) - 1\n",
-    "                \n",
-    "                for i in range(slider.max + 1):\n",
-    "                    slider.value = i\n",
-    "                     #time.sleep(.5)\n",
-    "        \n",
-    "        slider = widgets.IntSlider(min=0, max=1, step=1, value=0)\n",
-    "        slider_visual = widgets.interactive(slider_callback, iteration = slider)\n",
-    "        display(slider_visual)\n",
-    "\n",
-    "        button = widgets.ToggleButton(value = False)\n",
-    "        button_visual = widgets.interactive(visualize_callback, Visualize = button)\n",
-    "        display(button_visual)\n",
-    "    \n",
-    "    if user_input == True:\n",
-    "        node_colors = dict(initial_node_colors)\n",
-    "        if algorithm == None:\n",
-    "            algorithms = {\"Breadth First Tree Search\": breadth_first_tree_search,\n",
-    "                          \"Depth First Tree Search\": depth_first_tree_search,\n",
-    "                          \"Breadth First Search\": breadth_first_search,\n",
-    "                          \"Depth First Graph Search\": depth_first_graph_search,\n",
-    "                          \"Uniform Cost Search\": uniform_cost_search,\n",
-    "                          \"A-star Search\": astar_search}\n",
-    "            algo_dropdown = widgets.Dropdown(description = \"Search algorithm: \",\n",
-    "                                             options = sorted(list(algorithms.keys())),\n",
-    "                                             value = \"Breadth First Tree Search\")\n",
-    "            display(algo_dropdown)\n",
-    "        \n",
-    "        def slider_callback(iteration):\n",
-    "            # don't show graph for the first time running the cell calling this function\n",
-    "            try:\n",
-    "                show_map(all_node_colors[iteration])\n",
-    "            except:\n",
-    "                pass\n",
-    "            \n",
-    "        def visualize_callback(Visualize):\n",
-    "            if Visualize is True:\n",
-    "                button.value = False\n",
-    "                \n",
-    "                problem = GraphProblem(start_dropdown.value, end_dropdown.value, romania_map)\n",
-    "                global all_node_colors\n",
-    "                \n",
-    "                if algorithm == None:\n",
-    "                    user_algorithm = algorithms[algo_dropdown.value]\n",
-    "                \n",
-    "#                 print(user_algorithm)\n",
-    "#                 print(problem)\n",
-    "                \n",
-    "                iterations, all_node_colors, node = user_algorithm(problem)\n",
-    "                solution = node.solution()\n",
-    "                all_node_colors.append(final_path_colors(problem, solution))\n",
-    "\n",
-    "                slider.max = len(all_node_colors) - 1\n",
-    "                \n",
-    "                for i in range(slider.max + 1):\n",
-    "                    slider.value = i\n",
-    "#                     time.sleep(.5)\n",
-    "                         \n",
-    "        start_dropdown = widgets.Dropdown(description = \"Start city: \",\n",
-    "                                          options = sorted(list(node_colors.keys())), value = \"Arad\")\n",
-    "        display(start_dropdown)\n",
-    "\n",
-    "        end_dropdown = widgets.Dropdown(description = \"Goal city: \",\n",
-    "                                        options = sorted(list(node_colors.keys())), value = \"Fagaras\")\n",
-    "        display(end_dropdown)\n",
-    "        \n",
-    "        button = widgets.ToggleButton(value = False)\n",
-    "        button_visual = widgets.interactive(visualize_callback, Visualize = button)\n",
-    "        display(button_visual)\n",
-    "        \n",
-    "        slider = widgets.IntSlider(min=0, max=1, step=1, value=0)\n",
-    "        slider_visual = widgets.interactive(slider_callback, iteration = slider)\n",
-    "        display(slider_visual)"
+    "* Already explored nodes - <font color='gray'>gray</font>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## BREADTH-FIRST TREE SEARCH\n",
+    "## 1. BREADTH-FIRST TREE SEARCH\n",
     "\n",
     "We have a working implementation in search module. But as we want to interact with the graph while it is searching, we need to modify the implementation. Here's the modified breadth first tree search."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 23,
    "metadata": {
     "collapsed": true
    },
@@ -1278,7 +1130,7 @@
     "    # we use these two variables at the time of visualisations\n",
     "    iterations = 0\n",
     "    all_node_colors = []\n",
-    "    node_colors = dict(initial_node_colors)\n",
+    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
     "    \n",
     "    #Adding first node to the queue\n",
     "    frontier.append(Node(problem.initial))\n",
@@ -1332,14 +1184,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 24,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d55324f7343a4c71a9a2d4da6d037037"
-      }
+       "model_id": "be89c3400c414da5910ee3add884779b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1347,8 +1204,13 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "b07a3813dd724c51a9b37f646cf2be25"
-      }
+       "model_id": "a8a6b81612074acfaa93c65f4f136006",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1357,20 +1219,21 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Fagaras', romania_map)\n",
-    "display_visual(user_input = False, algorithm = breadth_first_tree_search, problem = romania_problem)"
+    "a, b, c = breadth_first_tree_search(romania_problem)\n",
+    "display_visual(romania_graph_data, user_input = False, algorithm = breadth_first_tree_search, problem = romania_problem)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Depth-First Tree Search:\n",
+    "## 2. Depth-First Tree Search:\n",
     "Now let's discuss another searching algorithm, Depth-First Tree Search."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "metadata": {
     "collapsed": true
    },
@@ -1386,14 +1249,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "523b10cf84e54798a044ee714b864b52"
-      }
+       "model_id": "f15901b690cb4d07a25cb398a88eead7",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1401,8 +1269,13 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "aecea953f6a448c192ac8e173cf46e35"
-      }
+       "model_id": "e9919397595f4f0899f988ec83c55b2e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1411,7 +1284,7 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Oradea', romania_map)\n",
-    "display_visual(user_input = False, algorithm = depth_first_tree_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, algorithm = depth_first_tree_search, problem = romania_problem)"
    ]
   },
   {
@@ -1420,14 +1293,14 @@
     "collapsed": true
    },
    "source": [
-    "## BREADTH-FIRST SEARCH\n",
+    "## 3. BREADTH-FIRST GRAPH SEARCH\n",
     "\n",
     "Let's change all the `node_colors` to starting position and define a different problem statement."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "metadata": {
     "collapsed": true
    },
@@ -1439,7 +1312,7 @@
     "    # we use these two variables at the time of visualisations\n",
     "    iterations = 0\n",
     "    all_node_colors = []\n",
-    "    node_colors = dict(initial_node_colors)\n",
+    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
     "    \n",
     "    node = Node(problem.initial)\n",
     "    \n",
@@ -1491,14 +1364,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "735a3dea191a42b6bd97fdfd337ea3e7"
-      }
+       "model_id": "433e357d16f24df4915558c55d1acfce",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1506,8 +1384,13 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ef445770d70a4b7c9d1544b98a55ca4d"
-      }
+       "model_id": "57422ca786e3497d8032df57589e7539",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1516,20 +1399,20 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(user_input = False, algorithm = breadth_first_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, algorithm = breadth_first_search, problem = romania_problem)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Depth-First Graph Search:  \n",
+    "## 4. Depth-First Graph Search:  \n",
     "Although we have a working implementation in search module, we have to make a few changes in the algorithm to make it suitable for visualization."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 20,
    "metadata": {
     "collapsed": true
    },
@@ -1542,7 +1425,7 @@
     "    # we use these two variables at the time of visualisations\n",
     "    iterations = 0\n",
     "    all_node_colors = []\n",
-    "    node_colors = dict(initial_node_colors)\n",
+    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
     "    \n",
     "    frontier.append(Node(problem.initial))\n",
     "    explored = set()\n",
@@ -1595,14 +1478,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "61149ffbc02846af97170f8975d4f11d"
-      }
+       "model_id": "8e8f4f8ac5e840c68daac1d0f25b8786",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1610,8 +1498,13 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "90b1f8f77fdb4207a3570fbe88a0bdf6"
-      }
+       "model_id": "3a3b877f596c42a4a5e822d0cfb43557",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1620,21 +1513,21 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(user_input = False, algorithm = depth_first_graph_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, algorithm = depth_first_graph_search, problem = romania_problem)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## BEST FIRST SEARCH\n",
+    "## 5. BEST FIRST SEARCH\n",
     "\n",
     "Let's change all the `node_colors` to starting position and define a different problem statement."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 25,
    "metadata": {
     "collapsed": true
    },
@@ -1652,7 +1545,7 @@
     "    # we use these two variables at the time of visualisations\n",
     "    iterations = 0\n",
     "    all_node_colors = []\n",
-    "    node_colors = dict(initial_node_colors)\n",
+    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
     "    \n",
     "    f = memoize(f, 'f')\n",
     "    node = Node(problem.initial)\n",
@@ -1714,14 +1607,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## UNIFORM COST SEARCH\n",
+    "## 6. UNIFORM COST SEARCH\n",
     "\n",
     "Let's change all the `node_colors` to starting position and define a different problem statement."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 28,
    "metadata": {
     "collapsed": true
    },
@@ -1731,19 +1624,24 @@
     "    \"[Figure 3.14]\"\n",
     "    #Uniform Cost Search uses Best First Search algorithm with f(n) = g(n)\n",
     "    iterations, all_node_colors, node = best_first_graph_search(problem, lambda node: node.path_cost)\n",
-    "    return(iterations, all_node_colors, node)"
+    "    return(iterations, all_node_colors, node)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "46b8200b4a8f47e7b18145234a8469da"
-      }
+       "model_id": "4d163c43d0de4cbba511203ce70ff42c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1751,8 +1649,13 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "ca9b2d01bbd5458bb037585c719d73fc"
-      }
+       "model_id": "4124f2b065a042fd9f22c24752efac62",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1761,7 +1664,7 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(user_input = False, algorithm = uniform_cost_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, algorithm = uniform_cost_search, problem = romania_problem)"
    ]
   },
   {
@@ -1774,7 +1677,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 30,
    "metadata": {
     "collapsed": true
    },
@@ -1786,19 +1689,24 @@
     "    else in your Problem subclass.\"\"\"\n",
     "    h = memoize(h or problem.h, 'h')\n",
     "    iterations, all_node_colors, node = best_first_graph_search(problem, lambda n: h(n))\n",
-    "    return(iterations, all_node_colors, node)"
+    "    return(iterations, all_node_colors, node)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 31,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e3ddd0260d7d4a8aa62d610976b9568a"
-      }
+       "model_id": "d8e3ac7446a140278648c03c1e73cccd",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1806,8 +1714,13 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "dae485b1f4224c34a88de42d252da76c"
-      }
+       "model_id": "12f2a6e525e2411c858e3aef3bfe48eb",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1816,21 +1729,21 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(user_input = False, algorithm = greedy_best_first_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, algorithm = greedy_best_first_search, problem = romania_problem)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## A\\* SEARCH\n",
+    "## 9. A\\* SEARCH\n",
     "\n",
     "Let's change all the `node_colors` to starting position and define a different problem statement."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 34,
    "metadata": {
     "collapsed": true
    },
@@ -1842,19 +1755,24 @@
     "    else in your Problem subclass.\"\"\"\n",
     "    h = memoize(h or problem.h, 'h')\n",
     "    iterations, all_node_colors, node = best_first_graph_search(problem, lambda n: n.path_cost + h(n))\n",
-    "    return(iterations, all_node_colors, node)"
+    "    return(iterations, all_node_colors, node)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "15a78d815f0c4ea589cdd5ad40bc8794"
-      }
+       "model_id": "c53e9003385741398e11639b52bdf53a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1862,8 +1780,13 @@
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "10450687dd574be2a380e9e40403fa83"
-      }
+       "model_id": "f8a00ed468174908b387f6f2b74e46a5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "A Jupyter Widget"
+      ]
      },
      "metadata": {},
      "output_type": "display_data"
@@ -1872,66 +1795,33 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(user_input = False, algorithm = astar_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, algorithm = astar_search, problem = romania_problem)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 36,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
     {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "9019790cf8324d73966373bb3f5373a8"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "b8a3195598da472d996e4e8b81595cb7"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "aabe167a0d6440f0a020df8a85a9206c"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "25d146d187004f4f9db6a7dccdbc7e93"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "68d532810a9e46309415fd353c474a4d"
-      }
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "ename": "NameError",
+     "evalue": "name 'breadth_first_tree_search' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-36-2ce59a236ac3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mall_node_colors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# display_visual(romania_graph_data, user_input = True, algorithm = breadth_first_tree_search)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mdisplay_visual\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mromania_graph_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muser_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m~/Documents/dev/aima-python/notebook.py\u001b[0m in \u001b[0;36mdisplay_visual\u001b[0;34m(graph_data, user_input, algorithm, problem)\u001b[0m\n\u001b[1;32m    986\u001b[0m         \u001b[0mnode_colors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minitial_node_colors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    987\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0malgorithm\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 988\u001b[0;31m             algorithms = {\"Breadth First Tree Search\": breadth_first_tree_search,\n\u001b[0m\u001b[1;32m    989\u001b[0m                           \u001b[0;34m\"Depth First Tree Search\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdepth_first_tree_search\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    990\u001b[0m                           \u001b[0;34m\"Breadth First Search\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbreadth_first_search\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'breadth_first_tree_search' is not defined"
+     ]
     }
    ],
    "source": [
     "all_node_colors = []\n",
-    "# display_visual(user_input = True, algorithm = breadth_first_tree_search)\n",
-    "display_visual(user_input = True)"
+    "# display_visual(romania_graph_data, user_input = True, algorithm = breadth_first_tree_search)\n",
+    "display_visual(romania_graph_data, user_input = True)"
    ]
   },
   {
@@ -1968,7 +1858,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 37,
    "metadata": {
     "collapsed": true
    },
@@ -2021,54 +1911,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "True\n",
-      "Number of explored nodes by the following heuristic are:  145\n",
-      "[2, 4, 3, 1, 5, 6, 7, 8, 0]\n",
-      "[2, 4, 3, 1, 5, 6, 7, 0, 8]\n",
-      "[2, 4, 3, 1, 0, 6, 7, 5, 8]\n",
-      "[2, 0, 3, 1, 4, 6, 7, 5, 8]\n",
-      "[0, 2, 3, 1, 4, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 0, 4, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 4, 0, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 4, 5, 6, 7, 0, 8]\n",
-      "[1, 2, 3, 4, 5, 6, 7, 8, 0]\n",
-      "Number of explored nodes by the following heuristic are:  153\n",
-      "[2, 4, 3, 1, 5, 6, 7, 8, 0]\n",
-      "[2, 4, 3, 1, 5, 6, 7, 0, 8]\n",
-      "[2, 4, 3, 1, 0, 6, 7, 5, 8]\n",
-      "[2, 0, 3, 1, 4, 6, 7, 5, 8]\n",
-      "[0, 2, 3, 1, 4, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 0, 4, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 4, 0, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 4, 5, 6, 7, 0, 8]\n",
-      "[1, 2, 3, 4, 5, 6, 7, 8, 0]\n",
-      "Number of explored nodes by the following heuristic are:  145\n",
-      "[2, 4, 3, 1, 5, 6, 7, 8, 0]\n",
-      "[2, 4, 3, 1, 5, 6, 7, 0, 8]\n",
-      "[2, 4, 3, 1, 0, 6, 7, 5, 8]\n",
-      "[2, 0, 3, 1, 4, 6, 7, 5, 8]\n",
-      "[0, 2, 3, 1, 4, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 0, 4, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 4, 0, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 4, 5, 6, 7, 0, 8]\n",
-      "[1, 2, 3, 4, 5, 6, 7, 8, 0]\n",
-      "Number of explored nodes by the following heuristic are:  169\n",
-      "[2, 4, 3, 1, 5, 6, 7, 8, 0]\n",
-      "[2, 4, 3, 1, 5, 6, 7, 0, 8]\n",
-      "[2, 4, 3, 1, 0, 6, 7, 5, 8]\n",
-      "[2, 0, 3, 1, 4, 6, 7, 5, 8]\n",
-      "[0, 2, 3, 1, 4, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 0, 4, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 4, 0, 6, 7, 5, 8]\n",
-      "[1, 2, 3, 4, 5, 6, 7, 0, 8]\n",
-      "[1, 2, 3, 4, 5, 6, 7, 8, 0]\n"
+     "ename": "TypeError",
+     "evalue": "__init__() missing 1 required positional argument: 'initial'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-38-7c2caf95bba3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Solving the puzzle\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mpuzzle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEightPuzzle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mpuzzle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheckSolvability\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# checks whether the initialized configuration is solvable or not\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mpuzzle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_heuristic\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Max_heuristic\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mpuzzle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Linear\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'initial'"
      ]
     }
    ],
@@ -2103,7 +1957,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
@@ -2238,7 +2092,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 40,
    "metadata": {
     "collapsed": true
    },
@@ -2290,7 +2144,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 41,
    "metadata": {},
    "outputs": [
     {
@@ -2322,7 +2176,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 42,
    "metadata": {
     "collapsed": true
    },
@@ -2349,7 +2203,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 43,
    "metadata": {
     "collapsed": true
    },
@@ -2398,7 +2252,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 44,
    "metadata": {
     "collapsed": true
    },
@@ -2417,39 +2271,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['Fagaras',\n",
-       " 'Neamt',\n",
-       " 'Iasi',\n",
-       " 'Vaslui',\n",
-       " 'Hirsova',\n",
-       " 'Eforie',\n",
-       " 'Urziceni',\n",
-       " 'Bucharest',\n",
-       " 'Giurgiu',\n",
-       " 'Pitesti',\n",
-       " 'Craiova',\n",
-       " 'Drobeta',\n",
-       " 'Mehadia',\n",
-       " 'Lugoj',\n",
-       " 'Timisoara',\n",
-       " 'Arad',\n",
-       " 'Zerind',\n",
-       " 'Oradea',\n",
-       " 'Sibiu',\n",
-       " 'Rimnicu']"
-      ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "hill_climbing(tsp)"
    ]
diff --git a/search.py b/search.py
index 9d3906aec..d517ecc55 100644
--- a/search.py
+++ b/search.py
@@ -154,7 +154,7 @@ def __init__(self, initial_state=None):
     def __call__(self, percept):
         """[Figure 3.1] Formulate a goal and problem, then
         search for a sequence of actions to solve it."""
-        self.state = self.update_state(percept)
+        self.state = self.update_state(self.state, percept)
         if not self.seq:
             goal = self.formulate_goal(self.state)
             problem = self.formulate_problem(self.state, goal)
@@ -163,7 +163,7 @@ def __call__(self, percept):
                 return None
         return self.seq.pop(0)
 
-    def update_state(self, percept):
+    def update_state(self, state, percept):
         raise NotImplementedError
 
     def formulate_goal(self, state):
@@ -960,12 +960,15 @@ def get(self, a, b=None):
 
     def nodes(self):
         """Return a list of nodes in the graph."""
-        return list(self.graph_dict.keys())
+        s1 = set([k for k in self.graph_dict.keys()])
+        s2 = set([k2 for v in self.graph_dict.values() for k2, v2 in v.items()])
+        nodes = s1.union(s2)
+        return list(nodes)
 
 
-def UndirectedGraph(dict=None):
+def UndirectedGraph(graph_dict=None):
     """Build a Graph where every edge (including future ones) goes both ways."""
-    return Graph(dict=dict, directed=False)
+    return Graph(graph_dict = graph_dict, directed=False)
 
 
 def RandomGraph(nodes=list(range(10)), min_links=2, width=400, height=300,

From e630ff5730d8906153a507080805b5a030f8b6ee Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Wed, 7 Mar 2018 02:14:19 -0500
Subject: [PATCH 3/9] Changed use of 'next'

---
 search.ipynb | 34 ++++++++++++++++++++++++++++++++--
 search.py    | 18 +++++++++---------
 2 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/search.ipynb b/search.ipynb
index 5027257a9..7d95d7286 100644
--- a/search.ipynb
+++ b/search.ipynb
@@ -2271,9 +2271,39 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 45,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['Fagaras',\n",
+       " 'Drobeta',\n",
+       " 'Craiova',\n",
+       " 'Vaslui',\n",
+       " 'Rimnicu',\n",
+       " 'Neamt',\n",
+       " 'Bucharest',\n",
+       " 'Giurgiu',\n",
+       " 'Eforie',\n",
+       " 'Sibiu',\n",
+       " 'Iasi',\n",
+       " 'Urziceni',\n",
+       " 'Zerind',\n",
+       " 'Lugoj',\n",
+       " 'Hirsova',\n",
+       " 'Oradea',\n",
+       " 'Arad',\n",
+       " 'Mehadia',\n",
+       " 'Pitesti',\n",
+       " 'Timisoara']"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "hill_climbing(tsp)"
    ]
diff --git a/search.py b/search.py
index d517ecc55..a80a48c8c 100644
--- a/search.py
+++ b/search.py
@@ -109,10 +109,10 @@ def expand(self, problem):
 
     def child_node(self, problem, action):
         """[Figure 3.10]"""
-        next = problem.result(self.state, action)
-        return Node(next, self, action,
+        next_node = problem.result(self.state, action)
+        return Node(next_node, self, action,
                     problem.path_cost(self.path_cost, self.state,
-                                      action, next))
+                                      action, next_node))
 
     def solution(self):
         """Return the sequence of actions to go from the root to this node."""
@@ -576,10 +576,10 @@ def simulated_annealing(problem, schedule=exp_schedule()):
         neighbors = current.expand(problem)
         if not neighbors:
             return current.state
-        next = random.choice(neighbors)
-        delta_e = problem.value(next.state) - problem.value(current.state)
+        next_choice = random.choice(neighbors)
+        delta_e = problem.value(next_choice.state) - problem.value(current.state)
         if delta_e > 0 or probability(math.exp(delta_e / T)):
-            current = next
+            current = next_choice
 
 def simulated_annealing_full(problem, schedule=exp_schedule()):
     """ This version returns all the states encountered in reaching 
@@ -594,10 +594,10 @@ def simulated_annealing_full(problem, schedule=exp_schedule()):
         neighbors = current.expand(problem)
         if not neighbors:
             return current.state
-        next = random.choice(neighbors)
-        delta_e = problem.value(next.state) - problem.value(current.state)
+        next_choice = random.choice(neighbors)
+        delta_e = problem.value(next_choice.state) - problem.value(current.state)
         if delta_e > 0 or probability(math.exp(delta_e / T)):
-            current = next
+            current = next_choice
 
 def and_or_graph_search(problem):
     """[Figure 4.11]Used when the environment is nondeterministic and completely observable.

From a467c0385a724a6a3761175bc3c1b0527604842b Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Wed, 7 Mar 2018 02:19:38 -0500
Subject: [PATCH 4/9] Added networkx to .travis.yml

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index e0932e6b2..596af0136 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -12,6 +12,7 @@ install:
   - pip install flake8
   - pip install ipython
   - pip install matplotlib
+  - pip install networkx
 
 script:
   - py.test

From 8f3552e9f30de1efe3ac0ba0c8b120cb8cd238ec Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Wed, 7 Mar 2018 02:24:22 -0500
Subject: [PATCH 5/9] Added others to .travis.yml

---
 .travis.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 596af0136..da1a0917a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,6 +13,8 @@ install:
   - pip install ipython
   - pip install matplotlib
   - pip install networkx
+  - pip install ipywidgets
+  - pip install time
 
 script:
   - py.test

From 35ed3dcf1ebcdf3cc833b8d821d991568e9d7a6f Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Wed, 7 Mar 2018 02:26:46 -0500
Subject: [PATCH 6/9] Remove time from .travis.yml

---
 .travis.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index da1a0917a..600d6bd00 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,7 +14,6 @@ install:
   - pip install matplotlib
   - pip install networkx
   - pip install ipywidgets
-  - pip install time
 
 script:
   - py.test

From 4ca566601dd920ad1dec1d16ff14aadb1dfd7adb Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Wed, 7 Mar 2018 12:03:46 -0500
Subject: [PATCH 7/9] Added linebreaks and fixed case for no algo

---
 notebook.py  |   29 +-
 search.ipynb | 1978 ++++++--------------------------------------------
 2 files changed, 237 insertions(+), 1770 deletions(-)

diff --git a/notebook.py b/notebook.py
index fdd7b9a7c..ae0976900 100644
--- a/notebook.py
+++ b/notebook.py
@@ -900,6 +900,7 @@ def draw_table(self):
 import ipywidgets as widgets
 from IPython.display import display
 import time
+from search import GraphProblem, romania_map
 
 def show_map(graph_data, node_colors = None):
     G = nx.Graph(graph_data['graph_dict'])
@@ -984,17 +985,21 @@ def visualize_callback(Visualize):
     
     if user_input == True:
         node_colors = dict(initial_node_colors)
-        if algorithm == None:
-            algorithms = {"Breadth First Tree Search": breadth_first_tree_search,
-                          "Depth First Tree Search": depth_first_tree_search,
-                          "Breadth First Search": breadth_first_search,
-                          "Depth First Graph Search": depth_first_graph_search,
-                          "Uniform Cost Search": uniform_cost_search,
-                          "A-star Search": astar_search}
+        if isinstance(algorithm, dict):
+            assert set(algorithm.keys()).issubset(set(["Breadth First Tree Search", 
+                                                       "Depth First Tree Search", 
+                                                       "Breadth First Search", 
+                                                       "Depth First Graph Search", 
+                                                       "Uniform Cost Search", 
+                                                       "A-star Search"]))
+
             algo_dropdown = widgets.Dropdown(description = "Search algorithm: ",
-                                             options = sorted(list(algorithms.keys())),
+                                             options = sorted(list(algorithm.keys())),
                                              value = "Breadth First Tree Search")
             display(algo_dropdown)
+        elif algorithm is None:
+            print("No algorithm to run.")
+            return 0
         
         def slider_callback(iteration):
             # don't show graph for the first time running the cell calling this function
@@ -1010,11 +1015,7 @@ def visualize_callback(Visualize):
                 problem = GraphProblem(start_dropdown.value, end_dropdown.value, romania_map)
                 global all_node_colors
                 
-                if algorithm == None:
-                    user_algorithm = algorithms[algo_dropdown.value]
-                
-#                 print(user_algorithm)
-#                 print(problem)
+                user_algorithm = algorithm[algo_dropdown.value]
                 
                 iterations, all_node_colors, node = user_algorithm(problem)
                 solution = node.solution()
@@ -1024,7 +1025,7 @@ def visualize_callback(Visualize):
                 
                 for i in range(slider.max + 1):
                     slider.value = i
-#                     time.sleep(.5)
+                    #time.sleep(.5)
                          
         start_dropdown = widgets.Dropdown(description = "Start city: ",
                                           options = sorted(list(node_colors.keys())), value = "Arad")
diff --git a/search.ipynb b/search.ipynb
index 7d95d7286..d1a26f2b0 100644
--- a/search.ipynb
+++ b/search.ipynb
@@ -13,7 +13,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": true,
     "scrolled": true
@@ -83,7 +83,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -111,159 +111,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Problem</span><span class=\"p\">(</span><span class=\"nb\">object</span><span class=\"p\">):</span>\n",
-       "\n",
-       "    <span class=\"sd\">&quot;&quot;&quot;The abstract class for a formal problem. You should subclass</span>\n",
-       "<span class=\"sd\">    this and implement the methods actions and result, and possibly</span>\n",
-       "<span class=\"sd\">    __init__, goal_test, and path_cost. Then you will create instances</span>\n",
-       "<span class=\"sd\">    of your subclass and solve them with the various search functions.&quot;&quot;&quot;</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">initial</span><span class=\"p\">,</span> <span class=\"n\">goal</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;The constructor specifies the initial state, and possibly a goal</span>\n",
-       "<span class=\"sd\">        state, if there is a unique goal. Your subclass&#39;s constructor can add</span>\n",
-       "<span class=\"sd\">        other arguments.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">initial</span> <span class=\"o\">=</span> <span class=\"n\">initial</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">goal</span> <span class=\"o\">=</span> <span class=\"n\">goal</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">actions</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;Return the actions that can be executed in the given</span>\n",
-       "<span class=\"sd\">        state. The result would typically be a list, but if there are</span>\n",
-       "<span class=\"sd\">        many actions, consider yielding them one at a time in an</span>\n",
-       "<span class=\"sd\">        iterator, rather than building them all at once.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">raise</span> <span class=\"ne\">NotImplementedError</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">result</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;Return the state that results from executing the given</span>\n",
-       "<span class=\"sd\">        action in the given state. The action must be one of</span>\n",
-       "<span class=\"sd\">        self.actions(state).&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">raise</span> <span class=\"ne\">NotImplementedError</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">goal_test</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;Return True if the state is a goal. The default method compares the</span>\n",
-       "<span class=\"sd\">        state to self.goal or checks for state in self.goal if it is a</span>\n",
-       "<span class=\"sd\">        list, as specified in the constructor. Override this method if</span>\n",
-       "<span class=\"sd\">        checking against a single self.goal is not enough.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">if</span> <span class=\"nb\">isinstance</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">goal</span><span class=\"p\">,</span> <span class=\"nb\">list</span><span class=\"p\">):</span>\n",
-       "            <span class=\"k\">return</span> <span class=\"n\">is_in</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">goal</span><span class=\"p\">)</span>\n",
-       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
-       "            <span class=\"k\">return</span> <span class=\"n\">state</span> <span class=\"o\">==</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">goal</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">path_cost</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">c</span><span class=\"p\">,</span> <span class=\"n\">state1</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"p\">,</span> <span class=\"n\">state2</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;Return the cost of a solution path that arrives at state2 from</span>\n",
-       "<span class=\"sd\">        state1 via action, assuming cost c to get up to state1. If the problem</span>\n",
-       "<span class=\"sd\">        is such that the path doesn&#39;t matter, this function will only look at</span>\n",
-       "<span class=\"sd\">        state2.  If the path does matter, it will consider c and maybe state1</span>\n",
-       "<span class=\"sd\">        and action. The default method costs 1 for every step in the path.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"n\">c</span> <span class=\"o\">+</span> <span class=\"mi\">1</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">value</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;For optimization problems, each state has a value.  Hill-climbing</span>\n",
-       "<span class=\"sd\">        and related algorithms try to maximize this value.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">raise</span> <span class=\"ne\">NotImplementedError</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(Problem)"
    ]
@@ -303,171 +155,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">Node</span><span class=\"p\">:</span>\n",
-       "\n",
-       "    <span class=\"sd\">&quot;&quot;&quot;A node in a search tree. Contains a pointer to the parent (the node</span>\n",
-       "<span class=\"sd\">    that this is a successor of) and to the actual state for this node. Note</span>\n",
-       "<span class=\"sd\">    that if a state is arrived at by two paths, then there are two nodes with</span>\n",
-       "<span class=\"sd\">    the same state.  Also includes the action that got us to this state, and</span>\n",
-       "<span class=\"sd\">    the total path_cost (also known as g) to reach the node.  Other functions</span>\n",
-       "<span class=\"sd\">    may add an f and h value; see best_first_graph_search and astar_search for</span>\n",
-       "<span class=\"sd\">    an explanation of how the f and h values are handled. You will not need to</span>\n",
-       "<span class=\"sd\">    subclass this class.&quot;&quot;&quot;</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">parent</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"n\">path_cost</span><span class=\"o\">=</span><span class=\"mi\">0</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;Create a search tree Node, derived from a parent by an action.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span> <span class=\"o\">=</span> <span class=\"n\">state</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">parent</span> <span class=\"o\">=</span> <span class=\"n\">parent</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">action</span> <span class=\"o\">=</span> <span class=\"n\">action</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">path_cost</span> <span class=\"o\">=</span> <span class=\"n\">path_cost</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">depth</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n",
-       "        <span class=\"k\">if</span> <span class=\"n\">parent</span><span class=\"p\">:</span>\n",
-       "            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">depth</span> <span class=\"o\">=</span> <span class=\"n\">parent</span><span class=\"o\">.</span><span class=\"n\">depth</span> <span class=\"o\">+</span> <span class=\"mi\">1</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__repr__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"s2\">&quot;&lt;Node {}&gt;&quot;</span><span class=\"o\">.</span><span class=\"n\">format</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">)</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__lt__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">node</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span> <span class=\"o\">&lt;</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">state</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">expand</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">problem</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;List the nodes reachable in one step from this node.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"p\">[</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">child_node</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"p\">)</span>\n",
-       "                <span class=\"k\">for</span> <span class=\"n\">action</span> <span class=\"ow\">in</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">actions</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">)]</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">child_node</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;[Figure 3.10]&quot;&quot;&quot;</span>\n",
-       "        <span class=\"nb\">next</span> <span class=\"o\">=</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">result</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"p\">)</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"n\">Node</span><span class=\"p\">(</span><span class=\"nb\">next</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"p\">,</span>\n",
-       "                    <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">path_cost</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">path_cost</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">,</span>\n",
-       "                                      <span class=\"n\">action</span><span class=\"p\">,</span> <span class=\"nb\">next</span><span class=\"p\">))</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">solution</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;Return the sequence of actions to go from the root to this node.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"p\">[</span><span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">action</span> <span class=\"k\">for</span> <span class=\"n\">node</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">path</span><span class=\"p\">()[</span><span class=\"mi\">1</span><span class=\"p\">:]]</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">path</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;Return a list of nodes forming the path from the root to this node.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"n\">node</span><span class=\"p\">,</span> <span class=\"n\">path_back</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"p\">[]</span>\n",
-       "        <span class=\"k\">while</span> <span class=\"n\">node</span><span class=\"p\">:</span>\n",
-       "            <span class=\"n\">path_back</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">node</span><span class=\"p\">)</span>\n",
-       "            <span class=\"n\">node</span> <span class=\"o\">=</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">parent</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">reversed</span><span class=\"p\">(</span><span class=\"n\">path_back</span><span class=\"p\">))</span>\n",
-       "\n",
-       "    <span class=\"c1\"># We want for a queue of nodes in breadth_first_search or</span>\n",
-       "    <span class=\"c1\"># astar_search to have no duplicated states, so we treat nodes</span>\n",
-       "    <span class=\"c1\"># with the same state as equal. [Problem: this may not be what you</span>\n",
-       "    <span class=\"c1\"># want in other contexts.]</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__eq__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">other</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"nb\">isinstance</span><span class=\"p\">(</span><span class=\"n\">other</span><span class=\"p\">,</span> <span class=\"n\">Node</span><span class=\"p\">)</span> <span class=\"ow\">and</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span> <span class=\"o\">==</span> <span class=\"n\">other</span><span class=\"o\">.</span><span class=\"n\">state</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__hash__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"nb\">hash</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">)</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(Node)"
    ]
@@ -506,148 +198,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">GraphProblem</span><span class=\"p\">(</span><span class=\"n\">Problem</span><span class=\"p\">):</span>\n",
-       "\n",
-       "    <span class=\"sd\">&quot;&quot;&quot;The problem of searching a graph from one node to another.&quot;&quot;&quot;</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">initial</span><span class=\"p\">,</span> <span class=\"n\">goal</span><span class=\"p\">,</span> <span class=\"n\">graph</span><span class=\"p\">):</span>\n",
-       "        <span class=\"n\">Problem</span><span class=\"o\">.</span><span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">initial</span><span class=\"p\">,</span> <span class=\"n\">goal</span><span class=\"p\">)</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">graph</span> <span class=\"o\">=</span> <span class=\"n\">graph</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">actions</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">A</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;The actions at a graph node are just its neighbors.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">graph</span><span class=\"o\">.</span><span class=\"n\">get</span><span class=\"p\">(</span><span class=\"n\">A</span><span class=\"p\">)</span><span class=\"o\">.</span><span class=\"n\">keys</span><span class=\"p\">())</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">result</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;The result of going to a neighbor is just that neighbor.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"n\">action</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">path_cost</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">cost_so_far</span><span class=\"p\">,</span> <span class=\"n\">A</span><span class=\"p\">,</span> <span class=\"n\">action</span><span class=\"p\">,</span> <span class=\"n\">B</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"n\">cost_so_far</span> <span class=\"o\">+</span> <span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">graph</span><span class=\"o\">.</span><span class=\"n\">get</span><span class=\"p\">(</span><span class=\"n\">A</span><span class=\"p\">,</span> <span class=\"n\">B</span><span class=\"p\">)</span> <span class=\"ow\">or</span> <span class=\"n\">infinity</span><span class=\"p\">)</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">find_min_edge</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;Find minimum value of edges.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"n\">m</span> <span class=\"o\">=</span> <span class=\"n\">infinity</span>\n",
-       "        <span class=\"k\">for</span> <span class=\"n\">d</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">graph</span><span class=\"o\">.</span><span class=\"n\">graph_dict</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">():</span>\n",
-       "            <span class=\"n\">local_min</span> <span class=\"o\">=</span> <span class=\"nb\">min</span><span class=\"p\">(</span><span class=\"n\">d</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">())</span>\n",
-       "            <span class=\"n\">m</span> <span class=\"o\">=</span> <span class=\"nb\">min</span><span class=\"p\">(</span><span class=\"n\">m</span><span class=\"p\">,</span> <span class=\"n\">local_min</span><span class=\"p\">)</span>\n",
-       "\n",
-       "        <span class=\"k\">return</span> <span class=\"n\">m</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">h</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">node</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;h function is straight-line distance from a node&#39;s state to goal.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"n\">locs</span> <span class=\"o\">=</span> <span class=\"nb\">getattr</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">graph</span><span class=\"p\">,</span> <span class=\"s1\">&#39;locations&#39;</span><span class=\"p\">,</span> <span class=\"bp\">None</span><span class=\"p\">)</span>\n",
-       "        <span class=\"k\">if</span> <span class=\"n\">locs</span><span class=\"p\">:</span>\n",
-       "            <span class=\"k\">if</span> <span class=\"nb\">type</span><span class=\"p\">(</span><span class=\"n\">node</span><span class=\"p\">)</span> <span class=\"ow\">is</span> <span class=\"nb\">str</span><span class=\"p\">:</span>\n",
-       "                <span class=\"k\">return</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"n\">distance</span><span class=\"p\">(</span><span class=\"n\">locs</span><span class=\"p\">[</span><span class=\"n\">node</span><span class=\"p\">],</span> <span class=\"n\">locs</span><span class=\"p\">[</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">goal</span><span class=\"p\">]))</span>\n",
-       "\n",
-       "            <span class=\"k\">return</span> <span class=\"nb\">int</span><span class=\"p\">(</span><span class=\"n\">distance</span><span class=\"p\">(</span><span class=\"n\">locs</span><span class=\"p\">[</span><span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">],</span> <span class=\"n\">locs</span><span class=\"p\">[</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">goal</span><span class=\"p\">]))</span>\n",
-       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
-       "            <span class=\"k\">return</span> <span class=\"n\">infinity</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(GraphProblem)"
    ]
@@ -661,7 +216,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -708,7 +263,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -735,17 +290,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{'Arad': (91, 492), 'Bucharest': (400, 327), 'Craiova': (253, 288), 'Drobeta': (165, 299), 'Eforie': (562, 293), 'Fagaras': (305, 449), 'Giurgiu': (375, 270), 'Hirsova': (534, 350), 'Iasi': (473, 506), 'Lugoj': (165, 379), 'Mehadia': (168, 339), 'Neamt': (406, 537), 'Oradea': (131, 571), 'Pitesti': (320, 368), 'Rimnicu': (233, 410), 'Sibiu': (207, 457), 'Timisoara': (94, 410), 'Urziceni': (456, 350), 'Vaslui': (509, 444), 'Zerind': (108, 531)}\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "romania_locations = romania_map.locations\n",
     "print(romania_locations)"
@@ -760,7 +309,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -796,22 +345,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "scrolled": true
    },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAABTsAAAPKCAYAAABbVI7QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n",
-      "text/plain": [
-       "<matplotlib.figure.Figure at 0x7faa59a8af28>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "show_map(romania_graph_data)"
    ]
@@ -834,144 +373,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">class</span> <span class=\"nc\">SimpleProblemSolvingAgentProgram</span><span class=\"p\">:</span>\n",
-       "\n",
-       "    <span class=\"sd\">&quot;&quot;&quot;Abstract framework for a problem-solving agent. [Figure 3.1]&quot;&quot;&quot;</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__init__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">initial_state</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;State is an abstract representation of the state</span>\n",
-       "<span class=\"sd\">        of the world, and seq is the list of actions required</span>\n",
-       "<span class=\"sd\">        to get to a particular state from the initial state(root).&quot;&quot;&quot;</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span> <span class=\"o\">=</span> <span class=\"n\">initial_state</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">seq</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"fm\">__call__</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">percept</span><span class=\"p\">):</span>\n",
-       "        <span class=\"sd\">&quot;&quot;&quot;[Figure 3.1] Formulate a goal and problem, then</span>\n",
-       "<span class=\"sd\">        search for a sequence of actions to solve it.&quot;&quot;&quot;</span>\n",
-       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">update_state</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">percept</span><span class=\"p\">)</span>\n",
-       "        <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">seq</span><span class=\"p\">:</span>\n",
-       "            <span class=\"n\">goal</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">formulate_goal</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">)</span>\n",
-       "            <span class=\"n\">problem</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">formulate_problem</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">goal</span><span class=\"p\">)</span>\n",
-       "            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">seq</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">search</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">)</span>\n",
-       "            <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">seq</span><span class=\"p\">:</span>\n",
-       "                <span class=\"k\">return</span> <span class=\"bp\">None</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">seq</span><span class=\"o\">.</span><span class=\"n\">pop</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">)</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">update_state</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">percept</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">raise</span> <span class=\"ne\">NotImplementedError</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">formulate_goal</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">raise</span> <span class=\"ne\">NotImplementedError</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">formulate_problem</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">goal</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">raise</span> <span class=\"ne\">NotImplementedError</span>\n",
-       "\n",
-       "    <span class=\"k\">def</span> <span class=\"nf\">search</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">problem</span><span class=\"p\">):</span>\n",
-       "        <span class=\"k\">raise</span> <span class=\"ne\">NotImplementedError</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(SimpleProblemSolvingAgentProgram)"
    ]
@@ -1006,7 +412,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1049,19 +455,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Left\n",
-      "Suck\n",
-      "Right\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "state1 = [(0, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Dirty\"]]]\n",
     "state2 = [(1, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Dirty\"]]]\n",
@@ -1116,7 +514,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1184,43 +582,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "be89c3400c414da5910ee3add884779b",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "a8a6b81612074acfaa93c65f4f136006",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Fagaras', romania_map)\n",
     "a, b, c = breadth_first_tree_search(romania_problem)\n",
-    "display_visual(romania_graph_data, user_input = False, algorithm = breadth_first_tree_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input=False, \n",
+    "               algorithm=breadth_first_tree_search, \n",
+    "               problem=romania_problem)"
    ]
   },
   {
@@ -1233,7 +606,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1249,42 +622,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f15901b690cb4d07a25cb398a88eead7",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "e9919397595f4f0899f988ec83c55b2e",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Oradea', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, algorithm = depth_first_tree_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, \n",
+    "               algorithm = depth_first_tree_search, \n",
+    "               problem = romania_problem)"
    ]
   },
   {
@@ -1300,7 +648,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1364,42 +712,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "433e357d16f24df4915558c55d1acfce",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "57422ca786e3497d8032df57589e7539",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, algorithm = breadth_first_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, \n",
+    "               algorithm = breadth_first_search, \n",
+    "               problem = romania_problem)"
    ]
   },
   {
@@ -1412,7 +735,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1478,42 +801,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "8e8f4f8ac5e840c68daac1d0f25b8786",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "3a3b877f596c42a4a5e822d0cfb43557",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, algorithm = depth_first_graph_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, \n",
+    "               algorithm = depth_first_graph_search, \n",
+    "               problem = romania_problem)"
    ]
   },
   {
@@ -1527,7 +825,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1614,7 +912,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1629,42 +927,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "4d163c43d0de4cbba511203ce70ff42c",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "4124f2b065a042fd9f22c24752efac62",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, algorithm = uniform_cost_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, \n",
+    "               algorithm = uniform_cost_search, \n",
+    "               problem = romania_problem)"
    ]
   },
   {
@@ -1677,7 +950,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1694,42 +967,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "d8e3ac7446a140278648c03c1e73cccd",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "12f2a6e525e2411c858e3aef3bfe48eb",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, algorithm = greedy_best_first_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, \n",
+    "               algorithm = greedy_best_first_search, \n",
+    "               problem = romania_problem)"
    ]
   },
   {
@@ -1743,7 +991,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1754,74 +1002,44 @@
     "    You need to specify the h function when you call astar_search, or\n",
     "    else in your Problem subclass.\"\"\"\n",
     "    h = memoize(h or problem.h, 'h')\n",
-    "    iterations, all_node_colors, node = best_first_graph_search(problem, lambda n: n.path_cost + h(n))\n",
+    "    iterations, all_node_colors, node = best_first_graph_search(problem, \n",
+    "                                                                lambda n: n.path_cost + h(n))\n",
     "    return(iterations, all_node_colors, node)\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "c53e9003385741398e11639b52bdf53a",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "application/vnd.jupyter.widget-view+json": {
-       "model_id": "f8a00ed468174908b387f6f2b74e46a5",
-       "version_major": 2,
-       "version_minor": 0
-      },
-      "text/plain": [
-       "A Jupyter Widget"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, algorithm = astar_search, problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input = False, \n",
+    "               algorithm = astar_search, \n",
+    "               problem = romania_problem)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "scrolled": false
    },
-   "outputs": [
-    {
-     "ename": "NameError",
-     "evalue": "name 'breadth_first_tree_search' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-36-2ce59a236ac3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mall_node_colors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;31m# display_visual(romania_graph_data, user_input = True, algorithm = breadth_first_tree_search)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mdisplay_visual\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mromania_graph_data\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0muser_input\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[0;32m~/Documents/dev/aima-python/notebook.py\u001b[0m in \u001b[0;36mdisplay_visual\u001b[0;34m(graph_data, user_input, algorithm, problem)\u001b[0m\n\u001b[1;32m    986\u001b[0m         \u001b[0mnode_colors\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minitial_node_colors\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    987\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0malgorithm\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 988\u001b[0;31m             algorithms = {\"Breadth First Tree Search\": breadth_first_tree_search,\n\u001b[0m\u001b[1;32m    989\u001b[0m                           \u001b[0;34m\"Depth First Tree Search\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mdepth_first_tree_search\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    990\u001b[0m                           \u001b[0;34m\"Breadth First Search\"\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbreadth_first_search\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'breadth_first_tree_search' is not defined"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "all_node_colors = []\n",
     "# display_visual(romania_graph_data, user_input = True, algorithm = breadth_first_tree_search)\n",
-    "display_visual(romania_graph_data, user_input = True)"
+    "algorithms = {  \"Breadth First Tree Search\": breadth_first_tree_search,\n",
+    "                \"Depth First Tree Search\": depth_first_tree_search,\n",
+    "                \"Breadth First Search\": breadth_first_search,\n",
+    "                \"Depth First Graph Search\": depth_first_graph_search,\n",
+    "                \"Uniform Cost Search\": uniform_cost_search,\n",
+    "                \"A-star Search\": astar_search}\n",
+    "display_visual(romania_graph_data, algorithm = algorithms, user_input = True)"
    ]
   },
   {
@@ -1858,7 +1076,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -1911,21 +1129,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "TypeError",
-     "evalue": "__init__() missing 1 required positional argument: 'initial'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-38-7c2caf95bba3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Solving the puzzle\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mpuzzle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEightPuzzle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mpuzzle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheckSolvability\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# checks whether the initialized configuration is solvable or not\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mpuzzle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmax_heuristic\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Max_heuristic\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mpuzzle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolve\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mlinear\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Linear\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'initial'"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "# Solving the puzzle \n",
     "puzzle = EightPuzzle()\n",
@@ -1957,124 +1165,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">hill_climbing</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">):</span>\n",
-       "    <span class=\"sd\">&quot;&quot;&quot;From the initial node, keep choosing the neighbor with highest value,</span>\n",
-       "<span class=\"sd\">    stopping when no neighbor is better. [Figure 4.2]&quot;&quot;&quot;</span>\n",
-       "    <span class=\"n\">current</span> <span class=\"o\">=</span> <span class=\"n\">Node</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">initial</span><span class=\"p\">)</span>\n",
-       "    <span class=\"k\">while</span> <span class=\"bp\">True</span><span class=\"p\">:</span>\n",
-       "        <span class=\"n\">neighbors</span> <span class=\"o\">=</span> <span class=\"n\">current</span><span class=\"o\">.</span><span class=\"n\">expand</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">)</span>\n",
-       "        <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"n\">neighbors</span><span class=\"p\">:</span>\n",
-       "            <span class=\"k\">break</span>\n",
-       "        <span class=\"n\">neighbor</span> <span class=\"o\">=</span> <span class=\"n\">argmax_random_tie</span><span class=\"p\">(</span><span class=\"n\">neighbors</span><span class=\"p\">,</span>\n",
-       "                                     <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"k\">lambda</span> <span class=\"n\">node</span><span class=\"p\">:</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">value</span><span class=\"p\">(</span><span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">))</span>\n",
-       "        <span class=\"k\">if</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">value</span><span class=\"p\">(</span><span class=\"n\">neighbor</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">)</span> <span class=\"o\">&lt;=</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">value</span><span class=\"p\">(</span><span class=\"n\">current</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">):</span>\n",
-       "            <span class=\"k\">break</span>\n",
-       "        <span class=\"n\">current</span> <span class=\"o\">=</span> <span class=\"n\">neighbor</span>\n",
-       "    <span class=\"k\">return</span> <span class=\"n\">current</span><span class=\"o\">.</span><span class=\"n\">state</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(hill_climbing)"
    ]
@@ -2092,7 +1187,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -2144,17 +1239,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['Arad', 'Bucharest', 'Craiova', 'Drobeta', 'Eforie', 'Fagaras', 'Giurgiu', 'Hirsova', 'Iasi', 'Lugoj', 'Mehadia', 'Neamt', 'Oradea', 'Pitesti', 'Rimnicu', 'Sibiu', 'Timisoara', 'Urziceni', 'Vaslui', 'Zerind']\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "distances = {}\n",
     "all_cities = []\n",
@@ -2176,7 +1265,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -2203,7 +1292,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -2252,7 +1341,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -2271,39 +1360,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "['Fagaras',\n",
-       " 'Drobeta',\n",
-       " 'Craiova',\n",
-       " 'Vaslui',\n",
-       " 'Rimnicu',\n",
-       " 'Neamt',\n",
-       " 'Bucharest',\n",
-       " 'Giurgiu',\n",
-       " 'Eforie',\n",
-       " 'Sibiu',\n",
-       " 'Iasi',\n",
-       " 'Urziceni',\n",
-       " 'Zerind',\n",
-       " 'Lugoj',\n",
-       " 'Hirsova',\n",
-       " 'Oradea',\n",
-       " 'Arad',\n",
-       " 'Mehadia',\n",
-       " 'Pitesti',\n",
-       " 'Timisoara']"
-      ]
-     },
-     "execution_count": 45,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "hill_climbing(tsp)"
    ]
@@ -2427,122 +1488,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">genetic_algorithm</span><span class=\"p\">(</span><span class=\"n\">population</span><span class=\"p\">,</span> <span class=\"n\">fitness_fn</span><span class=\"p\">,</span> <span class=\"n\">gene_pool</span><span class=\"o\">=</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">],</span> <span class=\"n\">f_thres</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"n\">ngen</span><span class=\"o\">=</span><span class=\"mi\">1000</span><span class=\"p\">,</span> <span class=\"n\">pmut</span><span class=\"o\">=</span><span class=\"mf\">0.1</span><span class=\"p\">):</span>\n",
-       "    <span class=\"sd\">&quot;&quot;&quot;[Figure 4.8]&quot;&quot;&quot;</span>\n",
-       "    <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">ngen</span><span class=\"p\">):</span>\n",
-       "        <span class=\"n\">population</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">mutate</span><span class=\"p\">(</span><span class=\"n\">recombine</span><span class=\"p\">(</span><span class=\"o\">*</span><span class=\"n\">select</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"n\">population</span><span class=\"p\">,</span> <span class=\"n\">fitness_fn</span><span class=\"p\">)),</span> <span class=\"n\">gene_pool</span><span class=\"p\">,</span> <span class=\"n\">pmut</span><span class=\"p\">)</span>\n",
-       "                      <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">population</span><span class=\"p\">))]</span>\n",
-       "\n",
-       "        <span class=\"n\">fittest_individual</span> <span class=\"o\">=</span> <span class=\"n\">fitness_threshold</span><span class=\"p\">(</span><span class=\"n\">fitness_fn</span><span class=\"p\">,</span> <span class=\"n\">f_thres</span><span class=\"p\">,</span> <span class=\"n\">population</span><span class=\"p\">)</span>\n",
-       "        <span class=\"k\">if</span> <span class=\"n\">fittest_individual</span><span class=\"p\">:</span>\n",
-       "            <span class=\"k\">return</span> <span class=\"n\">fittest_individual</span>\n",
-       "\n",
-       "\n",
-       "    <span class=\"k\">return</span> <span class=\"n\">argmax</span><span class=\"p\">(</span><span class=\"n\">population</span><span class=\"p\">,</span> <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"n\">fitness_fn</span><span class=\"p\">)</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(genetic_algorithm)"
    ]
@@ -2579,114 +1529,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">recombine</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">y</span><span class=\"p\">):</span>\n",
-       "    <span class=\"n\">n</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">)</span>\n",
-       "    <span class=\"n\">c</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">n</span><span class=\"p\">)</span>\n",
-       "    <span class=\"k\">return</span> <span class=\"n\">x</span><span class=\"p\">[:</span><span class=\"n\">c</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">y</span><span class=\"p\">[</span><span class=\"n\">c</span><span class=\"p\">:]</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(recombine)"
    ]
@@ -2702,121 +1549,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">mutate</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">,</span> <span class=\"n\">gene_pool</span><span class=\"p\">,</span> <span class=\"n\">pmut</span><span class=\"p\">):</span>\n",
-       "    <span class=\"k\">if</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">uniform</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span> <span class=\"o\">&gt;=</span> <span class=\"n\">pmut</span><span class=\"p\">:</span>\n",
-       "        <span class=\"k\">return</span> <span class=\"n\">x</span>\n",
-       "\n",
-       "    <span class=\"n\">n</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">x</span><span class=\"p\">)</span>\n",
-       "    <span class=\"n\">g</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">gene_pool</span><span class=\"p\">)</span>\n",
-       "    <span class=\"n\">c</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">n</span><span class=\"p\">)</span>\n",
-       "    <span class=\"n\">r</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">g</span><span class=\"p\">)</span>\n",
-       "\n",
-       "    <span class=\"n\">new_gene</span> <span class=\"o\">=</span> <span class=\"n\">gene_pool</span><span class=\"p\">[</span><span class=\"n\">r</span><span class=\"p\">]</span>\n",
-       "    <span class=\"k\">return</span> <span class=\"n\">x</span><span class=\"p\">[:</span><span class=\"n\">c</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"n\">new_gene</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">x</span><span class=\"p\">[</span><span class=\"n\">c</span><span class=\"o\">+</span><span class=\"mi\">1</span><span class=\"p\">:]</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(mutate)"
    ]
@@ -2832,122 +1569,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">init_population</span><span class=\"p\">(</span><span class=\"n\">pop_number</span><span class=\"p\">,</span> <span class=\"n\">gene_pool</span><span class=\"p\">,</span> <span class=\"n\">state_length</span><span class=\"p\">):</span>\n",
-       "    <span class=\"sd\">&quot;&quot;&quot;Initializes population for genetic algorithm</span>\n",
-       "<span class=\"sd\">    pop_number  :  Number of individuals in population</span>\n",
-       "<span class=\"sd\">    gene_pool   :  List of possible values for individuals</span>\n",
-       "<span class=\"sd\">    state_length:  The length of each individual&quot;&quot;&quot;</span>\n",
-       "    <span class=\"n\">g</span> <span class=\"o\">=</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">gene_pool</span><span class=\"p\">)</span>\n",
-       "    <span class=\"n\">population</span> <span class=\"o\">=</span> <span class=\"p\">[]</span>\n",
-       "    <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">pop_number</span><span class=\"p\">):</span>\n",
-       "        <span class=\"n\">new_individual</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">gene_pool</span><span class=\"p\">[</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">randrange</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">g</span><span class=\"p\">)]</span> <span class=\"k\">for</span> <span class=\"n\">j</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">state_length</span><span class=\"p\">)]</span>\n",
-       "        <span class=\"n\">population</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">new_individual</span><span class=\"p\">)</span>\n",
-       "\n",
-       "    <span class=\"k\">return</span> <span class=\"n\">population</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(init_population)"
    ]
@@ -2999,7 +1625,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3019,7 +1645,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3045,7 +1671,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3063,7 +1689,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3081,7 +1707,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3106,7 +1732,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3124,7 +1750,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3135,7 +1761,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3154,7 +1780,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3176,7 +1802,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3194,7 +1820,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3212,17 +1838,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['j', 'F', 'm', 'F', 'N', 'i', 'c', 'v', 'm', 'j', 'V', 'o', 'd', 'r', 't', 'V', 'H']\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "print(current_best)"
    ]
@@ -3236,17 +1856,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "jFmFNicvmjVodrtVH\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "current_best_string = ''.join(current_best)\n",
     "print(current_best_string)"
@@ -3265,7 +1879,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3289,7 +1903,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3320,122 +1934,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
-       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
-       "\n",
-       "<html>\n",
-       "<head>\n",
-       "  <title></title>\n",
-       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
-       "  <style type=\"text/css\">\n",
-       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
-       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
-       "pre { line-height: 125%; }\n",
-       "body .hll { background-color: #ffffcc }\n",
-       "body  { background: #f8f8f8; }\n",
-       "body .c { color: #408080; font-style: italic } /* Comment */\n",
-       "body .err { border: 1px solid #FF0000 } /* Error */\n",
-       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
-       "body .o { color: #666666 } /* Operator */\n",
-       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
-       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
-       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
-       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
-       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
-       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
-       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
-       "body .ge { font-style: italic } /* Generic.Emph */\n",
-       "body .gr { color: #FF0000 } /* Generic.Error */\n",
-       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
-       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
-       "body .go { color: #888888 } /* Generic.Output */\n",
-       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
-       "body .gs { font-weight: bold } /* Generic.Strong */\n",
-       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
-       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
-       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
-       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
-       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
-       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
-       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
-       "body .kt { color: #B00040 } /* Keyword.Type */\n",
-       "body .m { color: #666666 } /* Literal.Number */\n",
-       "body .s { color: #BA2121 } /* Literal.String */\n",
-       "body .na { color: #7D9029 } /* Name.Attribute */\n",
-       "body .nb { color: #008000 } /* Name.Builtin */\n",
-       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
-       "body .no { color: #880000 } /* Name.Constant */\n",
-       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
-       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
-       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
-       "body .nf { color: #0000FF } /* Name.Function */\n",
-       "body .nl { color: #A0A000 } /* Name.Label */\n",
-       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
-       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
-       "body .nv { color: #19177C } /* Name.Variable */\n",
-       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
-       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
-       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
-       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
-       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
-       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
-       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
-       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
-       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
-       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
-       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
-       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
-       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
-       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
-       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
-       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
-       "body .sx { color: #008000 } /* Literal.String.Other */\n",
-       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
-       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
-       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
-       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
-       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
-       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
-       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
-       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
-       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
-       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
-       "\n",
-       "  </style>\n",
-       "</head>\n",
-       "<body>\n",
-       "<h2></h2>\n",
-       "\n",
-       "<div class=\"highlight\"><pre><span></span><span class=\"k\">def</span> <span class=\"nf\">genetic_algorithm</span><span class=\"p\">(</span><span class=\"n\">population</span><span class=\"p\">,</span> <span class=\"n\">fitness_fn</span><span class=\"p\">,</span> <span class=\"n\">gene_pool</span><span class=\"o\">=</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">],</span> <span class=\"n\">f_thres</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"n\">ngen</span><span class=\"o\">=</span><span class=\"mi\">1000</span><span class=\"p\">,</span> <span class=\"n\">pmut</span><span class=\"o\">=</span><span class=\"mf\">0.1</span><span class=\"p\">):</span>\n",
-       "    <span class=\"sd\">&quot;&quot;&quot;[Figure 4.8]&quot;&quot;&quot;</span>\n",
-       "    <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">ngen</span><span class=\"p\">):</span>\n",
-       "        <span class=\"n\">population</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">mutate</span><span class=\"p\">(</span><span class=\"n\">recombine</span><span class=\"p\">(</span><span class=\"o\">*</span><span class=\"n\">select</span><span class=\"p\">(</span><span class=\"mi\">2</span><span class=\"p\">,</span> <span class=\"n\">population</span><span class=\"p\">,</span> <span class=\"n\">fitness_fn</span><span class=\"p\">)),</span> <span class=\"n\">gene_pool</span><span class=\"p\">,</span> <span class=\"n\">pmut</span><span class=\"p\">)</span>\n",
-       "                      <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">population</span><span class=\"p\">))]</span>\n",
-       "\n",
-       "        <span class=\"n\">fittest_individual</span> <span class=\"o\">=</span> <span class=\"n\">fitness_threshold</span><span class=\"p\">(</span><span class=\"n\">fitness_fn</span><span class=\"p\">,</span> <span class=\"n\">f_thres</span><span class=\"p\">,</span> <span class=\"n\">population</span><span class=\"p\">)</span>\n",
-       "        <span class=\"k\">if</span> <span class=\"n\">fittest_individual</span><span class=\"p\">:</span>\n",
-       "            <span class=\"k\">return</span> <span class=\"n\">fittest_individual</span>\n",
-       "\n",
-       "\n",
-       "    <span class=\"k\">return</span> <span class=\"n\">argmax</span><span class=\"p\">(</span><span class=\"n\">population</span><span class=\"p\">,</span> <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"n\">fitness_fn</span><span class=\"p\">)</span>\n",
-       "</pre></div>\n",
-       "</body>\n",
-       "</html>\n"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "psource(genetic_algorithm)"
    ]
@@ -3449,17 +1952,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Current best: Genetic Algorithm\t\tGeneration: 472\t\tFitness: 17\r"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "population = init_population(max_population, gene_pool, len(target))\n",
     "solution, generations = genetic_algorithm_stepwise(population, fitness_fn, gene_pool, f_thres, ngen, mutation_rate)"
@@ -3502,7 +1999,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3527,17 +2024,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[['R', 'G', 'G', 'R'], ['R', 'G', 'R', 'R'], ['G', 'R', 'G', 'R'], ['R', 'G', 'R', 'G'], ['G', 'R', 'R', 'G'], ['G', 'R', 'G', 'R'], ['G', 'R', 'R', 'R'], ['R', 'G', 'G', 'G']]\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "population = init_population(8, ['R', 'G'], 4)\n",
     "print(population)"
@@ -3554,7 +2045,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3573,17 +2064,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "['R', 'G', 'R', 'G']\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "solution = genetic_algorithm(population, fitness, gene_pool=['R', 'G'])\n",
     "print(solution)"
@@ -3598,17 +2083,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "4\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "print(fitness(solution))"
    ]
@@ -3643,17 +2122,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[0, 2, 7, 1, 7, 3, 2, 4], [2, 7, 5, 4, 4, 5, 2, 0], [7, 1, 6, 0, 1, 3, 0, 2], [0, 3, 6, 1, 3, 0, 5, 4], [0, 4, 6, 4, 7, 4, 1, 6]]\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "population = init_population(100, range(8), 8)\n",
     "print(population[:5])"
@@ -3674,7 +2147,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -3706,18 +2179,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[5, 0, 6, 3, 7, 4, 1, 3]\n",
-      "26\n"
-     ]
-    }
-   ],
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
    "source": [
     "solution = genetic_algorithm(population, fitness, f_thres=25, gene_pool=range(8))\n",
     "print(solution)\n",
@@ -3755,7 +2221,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.3"
+   "version": "3.6.1"
   }
  },
  "nbformat": 4,

From e375d4e04fa0ea343a16dab7fb0ef59248743ae6 Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Wed, 7 Mar 2018 21:15:45 -0500
Subject: [PATCH 8/9] Fixed spaces for args

---
 search.ipynb | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/search.ipynb b/search.ipynb
index d1a26f2b0..fe300053f 100644
--- a/search.ipynb
+++ b/search.ipynb
@@ -630,9 +630,9 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Oradea', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, \n",
-    "               algorithm = depth_first_tree_search, \n",
-    "               problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input=False, \n",
+    "               algorithm=depth_first_tree_search, \n",
+    "               problem=romania_problem)"
    ]
   },
   {
@@ -720,9 +720,9 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, \n",
-    "               algorithm = breadth_first_search, \n",
-    "               problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input=False, \n",
+    "               algorithm=breadth_first_search, \n",
+    "               problem=romania_problem)"
    ]
   },
   {
@@ -809,9 +809,9 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, \n",
-    "               algorithm = depth_first_graph_search, \n",
-    "               problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input=False, \n",
+    "               algorithm=depth_first_graph_search, \n",
+    "               problem=romania_problem)"
    ]
   },
   {
@@ -935,9 +935,9 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, \n",
-    "               algorithm = uniform_cost_search, \n",
-    "               problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input=False, \n",
+    "               algorithm=uniform_cost_search, \n",
+    "               problem=romania_problem)"
    ]
   },
   {
@@ -975,9 +975,9 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, \n",
-    "               algorithm = greedy_best_first_search, \n",
-    "               problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input=False, \n",
+    "               algorithm=greedy_best_first_search, \n",
+    "               problem=romania_problem)"
    ]
   },
   {
@@ -1017,9 +1017,9 @@
    "source": [
     "all_node_colors = []\n",
     "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
-    "display_visual(romania_graph_data, user_input = False, \n",
-    "               algorithm = astar_search, \n",
-    "               problem = romania_problem)"
+    "display_visual(romania_graph_data, user_input=False, \n",
+    "               algorithm=astar_search, \n",
+    "               problem=romania_problem)"
    ]
   },
   {
@@ -1032,14 +1032,14 @@
    "outputs": [],
    "source": [
     "all_node_colors = []\n",
-    "# display_visual(romania_graph_data, user_input = True, algorithm = breadth_first_tree_search)\n",
+    "# display_visual(romania_graph_data, user_input=True, algorithm=breadth_first_tree_search)\n",
     "algorithms = {  \"Breadth First Tree Search\": breadth_first_tree_search,\n",
     "                \"Depth First Tree Search\": depth_first_tree_search,\n",
     "                \"Breadth First Search\": breadth_first_search,\n",
     "                \"Depth First Graph Search\": depth_first_graph_search,\n",
     "                \"Uniform Cost Search\": uniform_cost_search,\n",
     "                \"A-star Search\": astar_search}\n",
-    "display_visual(romania_graph_data, algorithm = algorithms, user_input = True)"
+    "display_visual(romania_graph_data, algorithm=algorithms, user_input=True)"
    ]
   },
   {

From 9ce57332a3762327a9cce22774e63bbbca2db068 Mon Sep 17 00:00:00 2001
From: Aabir Abubaker Kar <aabir22@gmail.com>
Date: Sat, 10 Mar 2018 03:18:10 -0500
Subject: [PATCH 9/9] Renamed *search as *search_for_vis

---
 search.ipynb | 78 ++++++++++++++++------------------------------------
 1 file changed, 24 insertions(+), 54 deletions(-)

diff --git a/search.ipynb b/search.ipynb
index fe300053f..1ac4b075a 100644
--- a/search.ipynb
+++ b/search.ipynb
@@ -112,9 +112,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "psource(Problem)"
@@ -156,9 +154,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "psource(Node)"
@@ -199,9 +195,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "psource(GraphProblem)"
@@ -291,9 +285,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "romania_locations = romania_map.locations\n",
@@ -347,7 +339,6 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "collapsed": true,
     "scrolled": true
    },
    "outputs": [],
@@ -374,9 +365,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "psource(SimpleProblemSolvingAgentProgram)"
@@ -456,9 +445,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "state1 = [(0, 0), [(0, 0), \"Dirty\"], [(1, 0), [\"Dirty\"]]]\n",
@@ -520,7 +507,7 @@
    },
    "outputs": [],
    "source": [
-    "def tree_search(problem, frontier):\n",
+    "def tree_search_for_vis(problem, frontier):\n",
     "    \"\"\"Search through the successors of a problem to find a goal.\n",
     "    The argument frontier should be an empty queue.\n",
     "    Don't worry about repeated paths to a state. [Figure 3.7]\"\"\"\n",
@@ -569,7 +556,7 @@
     "\n",
     "def breadth_first_tree_search(problem):\n",
     "    \"Search the shallowest nodes in the search tree first.\"\n",
-    "    iterations, all_node_colors, node = tree_search(problem, FIFOQueue())\n",
+    "    iterations, all_node_colors, node = tree_search_for_vis(problem, FIFOQueue())\n",
     "    return(iterations, all_node_colors, node)"
    ]
   },
@@ -583,9 +570,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "all_node_colors = []\n",
@@ -616,16 +601,14 @@
     "    \"Search the deepest nodes in the search tree first.\"\n",
     "    # This algorithm might not work in case of repeated paths\n",
     "    # and may run into an infinite while loop.\n",
-    "    iterations, all_node_colors, node = tree_search(problem, Stack())\n",
+    "    iterations, all_node_colors, node = tree_search_for_vis(problem, Stack())\n",
     "    return(iterations, all_node_colors, node)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "all_node_colors = []\n",
@@ -713,9 +696,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "all_node_colors = []\n",
@@ -741,7 +722,7 @@
    },
    "outputs": [],
    "source": [
-    "def graph_search(problem, frontier):\n",
+    "def graph_search_for_vis(problem, frontier):\n",
     "    \"\"\"Search through the successors of a problem to find a goal.\n",
     "    The argument frontier should be an empty queue.\n",
     "    If two paths reach a state, only use the first one. [Figure 3.7]\"\"\"\n",
@@ -795,16 +776,14 @@
     "\n",
     "def depth_first_graph_search(problem):\n",
     "    \"\"\"Search the deepest nodes in the search tree first.\"\"\"\n",
-    "    iterations, all_node_colors, node = graph_search(problem, Stack())\n",
+    "    iterations, all_node_colors, node = graph_search_for_vis(problem, Stack())\n",
     "    return(iterations, all_node_colors, node)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "all_node_colors = []\n",
@@ -831,7 +810,7 @@
    },
    "outputs": [],
    "source": [
-    "def best_first_graph_search(problem, f):\n",
+    "def best_first_graph_search_for_vis(problem, f):\n",
     "    \"\"\"Search the nodes with the lowest f scores first.\n",
     "    You specify the function f(node) that you want to minimize; for example,\n",
     "    if f is a heuristic estimate to the goal, then we have greedy best\n",
@@ -921,16 +900,14 @@
     "def uniform_cost_search(problem):\n",
     "    \"[Figure 3.14]\"\n",
     "    #Uniform Cost Search uses Best First Search algorithm with f(n) = g(n)\n",
-    "    iterations, all_node_colors, node = best_first_graph_search(problem, lambda node: node.path_cost)\n",
+    "    iterations, all_node_colors, node = best_first_graph_search_for_vis(problem, lambda node: node.path_cost)\n",
     "    return(iterations, all_node_colors, node)\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "all_node_colors = []\n",
@@ -961,16 +938,14 @@
     "    You need to specify the h function when you call best_first_search, or\n",
     "    else in your Problem subclass.\"\"\"\n",
     "    h = memoize(h or problem.h, 'h')\n",
-    "    iterations, all_node_colors, node = best_first_graph_search(problem, lambda n: h(n))\n",
+    "    iterations, all_node_colors, node = best_first_graph_search_for_vis(problem, lambda n: h(n))\n",
     "    return(iterations, all_node_colors, node)\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "all_node_colors = []\n",
@@ -1002,7 +977,7 @@
     "    You need to specify the h function when you call astar_search, or\n",
     "    else in your Problem subclass.\"\"\"\n",
     "    h = memoize(h or problem.h, 'h')\n",
-    "    iterations, all_node_colors, node = best_first_graph_search(problem, \n",
+    "    iterations, all_node_colors, node = best_first_graph_search_for_vis(problem, \n",
     "                                                                lambda n: n.path_cost + h(n))\n",
     "    return(iterations, all_node_colors, node)\n"
    ]
@@ -1010,9 +985,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "all_node_colors = []\n",
@@ -1026,7 +999,6 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
-    "collapsed": true,
     "scrolled": false
    },
    "outputs": [],
@@ -1130,9 +1102,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "# Solving the puzzle \n",
@@ -2221,7 +2191,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.1"
+   "version": "3.6.3"
   }
  },
  "nbformat": 4,