text edits to search.ipynb (#236)

go-bears · SnShine · commit 7ce9a2ae67ec · 2016-05-27T12:38:38.000+05:30
* some fixes for typos and spacing and some edits for clarity

* some fixes for typos and spacing and some edits for clarity

* format and edit intro
diff --git a/search.ipynb b/search.ipynb
@@ -14,11 +14,15 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Introduction\n",
+    "Introduction\n",
+    "============\n",
+    "\n",
     "Hello!\n",
-    "    In this IPython notebook, we study different kinds of search techniques used in [ search.py ]( https://github.com/aimacode/aima-python/blob/master/search.py ) and try to get an intuition of what search algorithms are best suited for various problems. We first explore uninformed search algorithms and later get our hands on heuristic search strategies.\n",
+    "In this IPython notebook, we'll study different kinds of search techniques used in [ search.py ]( https://github.com/aimacode/aima-python/blob/master/search.py ) and try to get an intuition of what search algorithms are best suited for various problems. We first explore uninformed search algorithms and later get our hands on heuristic search strategies.\n",
+    "\n",
+    "The code in this IPython notebook, and the entire `aima-python` repository is intended to work with Python 3 (specifically, Python 3.4). So if you happen to be working on Python 2, you should switch to Python 3. For more help on how to install python3, or if you are having other problems, you can always have a look the `intro` IPython notebook. \n",
     "\n",
-    "    The code in this IPython notebook, and the entire aima-python repository is intended to work with Python 3 (specifically, Python 3.4). So if you happen to be working on Python 2, you should switch to Python 3. For more help on how to install python3, or if you are having other problems, you can always have a look the 'intro' IPython notebook. Now that you have all that sorted out, lets get started!"
+    "Now that you have all that sorted out, let's get started!"
    ]
   },
   {
@@ -32,14 +36,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Also called `blind search`, in such search strategies with all the information we have about any state all we can do is generate its successors and check whether it's a `goal state` or not. THAT'S IT. NOTHING MORE(Well ....not really. See the `value` method defined in the following section).\n",
+    "Uninformed Search strategies are called `blind search`. In such search strategies, the only information we have about any state is generated by checking if a piece of data, or any of its successors, matches our `goal state` or not. THAT'S IT. NOTHING MORE. (Well ....not really. See the `value` method defined in the following section).\n",
     "\n",
     "First let's formulate the problem we intend to solve. So let's import everything from our module."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 16,
    "metadata": {
     "collapsed": false
    },
@@ -55,12 +59,12 @@
     "The first thing we observe is '`from utils import *`'. This means that everything in utils.py is imported for use in this module. Don't worry. You don't need to read utils.py in order to understand search algorithms.\n",
     "    \n",
     "The `Problem` class is an abstract class on which we define our problems(*duh*).\n",
-    "Again, if you are confused about what `abstract class` means have a look at the 'Intro' notebook.\n",
+    "Again, if you are confused about what `abstract class` means have a look at the `Intro` notebook.\n",
     "The `Problem` class has six methods.\n",
-    "* `__init__(self, initial, goal)` : This is what is called a `constructor` and is the first method called when you create an instance of class. In this and all of the below methods `self` refers to the object itself- the object whose method is called. `initial` specifies the initial state of our search problem. It represents the start state from where our agent begins his task of exploration to find the goal state(s) which is given in the `goal` parameter.\n",
+    "* `__init__(self, initial, goal)` : This is what is called a `constructor` and is the first method called when you create an instance of class. In this and all of the below methods `self` refers to the object itself--the object whose method is called. `initial` specifies the initial state of our search problem. It represents the start state from where our agent begins his task of exploration to find the goal state(s) which is given in the `goal` parameter.\n",
     "* `actions(self, state)` : This method returns all the possible actions our agent can make in state `state`.\n",
     "* `result(self, state, action)` : This returns the resulting state if action `action` is taken in the state `state`. This `Problem` class only deals with deterministic outcomes. So we know for sure what every action in a state would result to.\n",
-    "* `goal_test(self, state)` : Given a graph state, it checks if it is a terminal state. If the state is indeed a goal state, value of `True` is returned. Else , ofcourse, `False` is returned.\n",
+    "* `goal_test(self, state)` : Given a graph state, it checks if it is a terminal state. If the state is indeed a goal state, value of `True` is returned. Else, of course, `False` is returned.\n",
     "* `path_cost(self, c, state1, action, state2)` : Return the cost of the path that arrives at `state2` as a result of taking `action` from `state1`, assuming total cost of `c` to get up to `state1`.\n",
     "* `value(self, state)` : This acts as a bit of extra information in problems where we try to optimize a value when we cannot do a goal test."
    ]
@@ -69,7 +73,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now using the above abstract class as a parent there is another named called `GraphProblem` in our module. It creates a graph problem from an instance of the `Graph` class. To create a graph, simply do `graph = Graph(dict(...))`. The dictionary must contain nodes of the graph as keys, so make sure they are `hashable`. If you don't know what that means just use strings or numbers. Each node in the dictionary should correspond to another dictionary which contain the adjacent nodes as keys and the edge length as its value. The `Graph` class creates a directed(edges allow only one way traffic) by default.If you want to make an undirected graph, use `UndirectedGraph` instead, but make sure to mention any edge in only one of its nodes."
+    "Now the above abstract class acts as a parent class, and there is another named called `GraphProblem` in our module. It creates a graph problem from an instance of the `Graph` class. To create a graph, simply type `graph = Graph(dict(...))`. The dictionary must contain nodes of the graph as keys, so make sure they are `hashable`. If you don't know what that means just use strings or numbers. Each node contains the adjacent nodes as keys and the edge length as its value. Each dictionary then should correspond to another dictionary in the graph.  The `Graph` class creates a directed(edges allow only one way traffic) by default. If you want to make an undirected graph, use `UndirectedGraph` instead, but make sure to mention any edge in only one of its nodes."
    ]
   },
   {
@@ -81,7 +85,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 17,
    "metadata": {
     "collapsed": true
    },
@@ -105,7 +109,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Suppose we are in a museum showcasing statues of various animals. To navigate through the museum there are paths between some statues and the entrance. We define the entrance and the statues as nodes in our graph with the path connecting them as edges. The cost/weight of an edge specifies its length. So `Start = dict(Dog = 3, Cat = 9, Mouse = 4)` means that there are paths from `Start` to `Dog`, `Cat` and `Mouse` with path costs 3, 9 and 4 respectively. See the image below to better understand the graph."
+    "Imagine we are in a museum showcasing statues of various animals. To navigate through the museum there are paths between some statues and the entrance. We define the entrance and the statues as nodes in our graph with the path connecting them as edges. The cost/weight of an edge specifies is its length. So `Start = dict(Dog = 3, Cat = 9, Mouse = 4)` means that there are paths from `Start` to `Dog`, `Cat` and `Mouse` with path costs 3, 9 and 4 respectively. \n",
+    "\n",
+    "Here's an image below to better understand our graph."
    ]
   },
   {
@@ -127,12 +133,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In breadth first search the `shallowest` unexpanded node is chosen for expansion. That means that all nodes of a given depth must be expanded before any node of the next depth level. It accomplishes this by using a `FIFO` meaning 'First In First Out' queue. Any thing thats gets in the queue first also gets out first just like the checkout queue in a supermarket. To use the algorithm, first we need to define our problem. Say we want to find the statue of `Monkey` and we start from the entrance which is the `Start` state. We define our problem using the `GraphProblem` class."
+    "In Breadth First Search, the `shallowest` unexpanded node is chosen for expansion. That means that all nodes of a given depth must be expanded before any node of the next depth level. This search strategy accomplishes this by using a `FIFO` meaning 'First In First Out' queue. Anything that gets in the queue first also gets out first just like the checkout queue in a supermarket. To use the algorithm, first we need to define our problem. Say we want to find the statue of `Monkey` and we start from the entrance which is the `Start` state. We'll define our problem using the `GraphProblem` class."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 18,
    "metadata": {
     "collapsed": false
    },
@@ -150,7 +156,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 19,
    "metadata": {
     "collapsed": false
    },
@@ -161,7 +167,7 @@
        "['Cat', 'Monkey']"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 19,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -175,7 +181,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We get the output as `['Cat', 'Monkey']`. That is because first the nodes `Dog`, `Cat` and `Mouse` are added to the `FIFO` queue in `some` order when we are explanding the `Start` node. Now when we start expanding nodes in the next level, only the `Cat` node gets us to `Monkey`. Note that in breadth first search the goal test is done when it is being added to the queue."
+    "We get the output as `['Cat', 'Monkey']`. That is because first the nodes `Dog`, `Cat` and `Mouse` are added to the `FIFO` queue in `some` order when we are expanding the `Start` node. Now when we start expanding nodes in the next level, only the `Cat` node gets us to `Monkey`. Note that during a breadth first search, the goal test is done when the node is being added to the queue."
    ]
   },
   {
@@ -189,12 +195,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In uniform cost search instead of expanding the shallowest node we expand the node with the lowest path cost(cost to reach upto that node from the start). Instead of a `FIFO` queue we use something called a `priority queue` which selects the element with the highest `priority` of all elements in the queue. For our problem lower path cost means higher priority. Whenever we need to enqueue a node already in the queue we update its path cost if the newer path is better. This is a very important step and it means that the path cost to a node may keep getting better until it is selected for expansion. This is the reason that we do a goal check only when a node is selected for expanion."
+    "In Uniform-cost Search, we expand the node with the lowest path cost (the cost to reach that node from the start) instead of expanding the shallowest node. Rather than a `FIFO` queue, we use something called a `priority queue` which selects the element with the highest `priority` of all elements in the queue. For our problem, the shortest path between animals has the higher priority; the shortest path has the lowest path cost. Whenever we need to enqueue a node already in the queue, we will update its path cost if the newer path is better. This is a very important step, and it means that the path cost to a node may keep getting better until it is selected for expansion. This is the reason that we do a goal check only when a node is selected for expanion."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 20,
    "metadata": {
     "collapsed": false
    },
@@ -205,7 +211,7 @@
        "['Dog', 'Bear', 'Monkey']"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -219,12 +225,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We got `['Dog', 'Bear', 'Monkey']` instead of `['Cat', 'Monkey']` because the path cost is lower! We can also see the path cost with the path_cost attribute. Lets compare the path cost of the Breadth first search solution and Uniform cost search solution"
+    "We got the path`['Dog', 'Bear', 'Monkey']` instead of `['Cat', 'Monkey']`. Why? The path cost is lower! We can also see the path cost with the path_cost attribute. Let's compare the path cost of the Breadth first search solution and Uniform cost search solution"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 21,
    "metadata": {
     "collapsed": false
    },
@@ -235,7 +241,7 @@
        "(18, 17)"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -248,8 +254,19 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We were right! The path cost through the `Cat` statue is indeed more than the path cost through `Dog` even though the former has only two roads compared to three roads in `ucs_node`."
+    "We were right! \n",
+    "\n",
+    "The path cost through the `Cat` statue is indeed more than the path cost through `Dog` even though the former passes through two roads compared to the three roads in the `ucs_node` solution."
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -268,7 +285,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.0"
+   "version": "3.4.3"
   }
  },
  "nbformat": 4,
