search.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Solving problems by Searching\n",
    "\n",
    "This notebook serves as supporting material for topics covered in **Chapter 3 - Solving Problems by Searching** and **Chapter 4 - Beyond Classical Search** from the book *Artificial Intelligence: A Modern Approach.* This notebook uses implementations from [search.py](https://github.com/aimacode/aima-python/blob/master/search.py) module. Let's start by importing everything from search module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from search import *\n",
    "from notebook import psource, heatmap, gaussian_kernel, show_map, final_path_colors, display_visual, plot_NQueens\n",
    "\n",
    "# Needed to hide warnings in the matplotlib sections\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CONTENTS\n",
    "\n",
    "* Overview\n",
    "* Problem\n",
    "* Node\n",
    "* Simple Problem Solving Agent\n",
    "* Search Algorithms Visualization\n",
    "* Breadth-First Tree Search\n",
    "* Breadth-First Search\n",
    "* Best First Search\n",
    "* Uniform Cost Search\n",
    "* Greedy Best First Search\n",
    "* A\\* Search\n",
    "* Hill Climbing\n",
    "* Simulated Annealing\n",
    "* Genetic Algorithm\n",
    "* AND-OR Graph Search\n",
    "* Online DFS Agent\n",
    "* LRTA* Agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OVERVIEW\n",
    "\n",
    "Here, we learn about a specific kind of problem solving - building goal-based agents that can plan ahead to solve problems. In particular, we examine navigation problem/route finding problem. We must begin by precisely defining **problems** and their **solutions**. We will look at several general-purpose search algorithms.\n",
    "\n",
    "Search algorithms can be classified into two types:\n",
    "\n",
    "* **Uninformed search algorithms**: Search algorithms which explore the search space without having any information about the problem other than its definition.\n",
    "    * Examples:\n",
    "        1. Breadth First Search\n",
    "        2. Depth First Search\n",
    "        3. Depth Limited Search\n",
    "        4. Iterative Deepening Search\n",
    "\n",
    "\n",
    "* **Informed search algorithms**: These type of algorithms leverage any information (heuristics, path cost) on the problem to search through the search space to find the solution efficiently.\n",
    "    * Examples:\n",
    "        1. Best First Search\n",
    "        2. Uniform Cost Search\n",
    "        3. A\\* Search\n",
    "        4. Recursive Best First Search\n",
    "\n",
    "*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": {},
   "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": {},
   "source": [
    "## PROBLEM\n",
    "\n",
    "Let's see how we define a Problem. Run the next cell to see how abstract class `Problem` is defined in the search module."
   ]
  },
  {
   "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"
    }
   ],
   "source": [
    "psource(Problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Problem` class has six methods.\n",
    "\n",
    "* `__init__(self, initial, goal)` : This is what is called a `constructor`. It is the first method called when you create an instance of the class as `Problem(initial, goal)`. The variable `initial` specifies the initial state $s_0$ of the search problem. It represents the beginning state. From here, our agent begins its task of exploration to find the goal state(s) which is given in the `goal` parameter.\n",
    "\n",
    "\n",
    "* `actions(self, state)` : This method returns all the possible actions agent can execute in the given state `state`.\n",
    "\n",
    "\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",
    "\n",
    "\n",
    "* `goal_test(self, state)` : Return a boolean for a given state - `True` if it is a goal state, else `False`.\n",
    "\n",
    "\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",
    "\n",
    "\n",
    "* `value(self, state)` : This acts as a bit of extra information in problems where we try to optimise a value when we cannot do a goal test."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NODE\n",
    "\n",
    "Let's see how we define a Node. Run the next cell to see how abstract class `Node` is defined in the search module."
   ]
  },
  {
   "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=\"n\">next_state</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=\"n\">next_node</span> <span class=\"o\">=</span> <span class=\"n\">Node</span><span class=\"p\">(</span><span class=\"n\">next_state</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=\"n\">next_state</span><span class=\"p\">))</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">next_node</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_graph_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"
    }
   ],
   "source": [
    "psource(Node)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `Node` class has nine methods. The first is the `__init__` method.\n",
    "\n",
    "* `__init__(self, state, parent, action, path_cost)` : This method creates a node. `parent` represents the node that this is a successor of and `action` is the action required to get from the parent node to this node. `path_cost` is the cost to reach current node from parent node.\n",
    "\n",
    "The next 4 methods are specific `Node`-related functions.\n",
    "\n",
    "* `expand(self, problem)` : This method lists all the neighbouring(reachable in one step) nodes of current node. \n",
    "\n",
    "* `child_node(self, problem, action)` : Given an `action`, this method returns the immediate neighbour that can be reached with that `action`.\n",
    "\n",
    "* `solution(self)` : This returns the sequence of actions required to reach this node from the root node. \n",
    "\n",
    "* `path(self)` : This returns a list of all the nodes that lies in the path from the root to this node.\n",
    "\n",
    "The remaining 4 methods override standards Python functionality for representing an object as a string, the less-than ($<$) operator, the equal-to ($=$) operator, and the `hash` function.\n",
    "\n",
    "* `__repr__(self)` : This returns the state of this node.\n",
    "\n",
    "* `__lt__(self, node)` : Given a `node`, this method returns `True` if the state of current node is less than the state of the `node`. Otherwise it returns `False`.\n",
    "\n",
    "* `__eq__(self, other)` : This method returns `True` if the state of current node is equal to the other node. Else it returns `False`.\n",
    "\n",
    "* `__hash__(self)` : This returns the hash of the state of current node."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use the abstract class `Problem` to define our real **problem** named `GraphProblem`. You can see how we define `GraphProblem` by running the next cell."
   ]
  },
  {
   "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"
    }
   ],
   "source": [
    "psource(GraphProblem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have a look at our romania_map, which is an Undirected Graph containing a dict of nodes as keys and neighbours as values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "romania_map = UndirectedGraph(dict(\n",
    "    Arad=dict(Zerind=75, Sibiu=140, Timisoara=118),\n",
    "    Bucharest=dict(Urziceni=85, Pitesti=101, Giurgiu=90, Fagaras=211),\n",
    "    Craiova=dict(Drobeta=120, Rimnicu=146, Pitesti=138),\n",
    "    Drobeta=dict(Mehadia=75),\n",
    "    Eforie=dict(Hirsova=86),\n",
    "    Fagaras=dict(Sibiu=99),\n",
    "    Hirsova=dict(Urziceni=98),\n",
    "    Iasi=dict(Vaslui=92, Neamt=87),\n",
    "    Lugoj=dict(Timisoara=111, Mehadia=70),\n",
    "    Oradea=dict(Zerind=71, Sibiu=151),\n",
    "    Pitesti=dict(Rimnicu=97),\n",
    "    Rimnicu=dict(Sibiu=80),\n",
    "    Urziceni=dict(Vaslui=142)))\n",
    "\n",
    "romania_map.locations = dict(\n",
    "    Arad=(91, 492), Bucharest=(400, 327), Craiova=(253, 288),\n",
    "    Drobeta=(165, 299), Eforie=(562, 293), Fagaras=(305, 449),\n",
    "    Giurgiu=(375, 270), Hirsova=(534, 350), Iasi=(473, 506),\n",
    "    Lugoj=(165, 379), Mehadia=(168, 339), Neamt=(406, 537),\n",
    "    Oradea=(131, 571), Pitesti=(320, 368), Rimnicu=(233, 410),\n",
    "    Sibiu=(207, 457), Timisoara=(94, 410), Urziceni=(456, 350),\n",
    "    Vaslui=(509, 444), Zerind=(108, 531))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "It is pretty straightforward to understand this `romania_map`. The first node **Arad** has three neighbours named **Zerind**, **Sibiu**, **Timisoara**. Each of these nodes are 75, 140, 118 units apart from **Arad** respectively. And the same goes with other nodes.\n",
    "\n",
    "And `romania_map.locations` contains the positions of each of the nodes. We will use the straight line distance (which is different from the one provided in `romania_map`) between two cities in algorithms like A\\*-search and Recursive Best First Search.\n",
    "\n",
    "**Define a problem:**\n",
    "Now it's time to define our problem. We will define it by passing `initial`, `goal`, `graph` to `GraphProblem`. So, our problem is to find the goal state starting from the given initial state on the provided graph. \n",
    "\n",
    "Say we want to start exploring from **Arad** and try to find **Bucharest** in our romania_map. So, this is how we do it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Romania Map Visualisation\n",
    "\n",
    "Let's have a visualisation of Romania map [Figure 3.2] from the book and see how different searching algorithms perform / how frontier expands in each search algorithm for a simple problem named `romania_problem`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Have a look at `romania_locations`. It is a dictionary defined in search module. We will use these location values to draw the romania graph using **networkx**."
   ]
  },
  {
   "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"
     ]
    }
   ],
   "source": [
    "romania_locations = romania_map.locations\n",
    "print(romania_locations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's get started by initializing an empty graph. We will add nodes, place the nodes in their location as shown in the book, add edges to the graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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",
    "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",
    "                     }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "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": "markdown",
   "metadata": {},
   "source": [
    "We can simply call the function with node_colors dictionary object to display it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1eddc448e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_map(romania_graph_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voila! You see, the romania map as shown in the Figure[3.2] in the book. Now, see how different searching algorithms perform with our problem statements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SIMPLE PROBLEM SOLVING AGENT PROGRAM\n",
    "\n",
    "Let us now define a Simple Problem Solving Agent Program. Run the next cell to see how the abstract class `SimpleProblemSolvingAgentProgram` is defined in the search module."
   ]
  },
  {
   "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"
    }
   ],
   "source": [
    "psource(SimpleProblemSolvingAgentProgram)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The SimpleProblemSolvingAgentProgram class has six methods:  \n",
    "\n",
    "* `__init__(self, intial_state=None)`: This is the `contructor` of the class and is the first method to be called when the class is instantiated. It takes in a keyword argument, `initial_state` which is initially `None`. The argument `initial_state` represents the state from which the agent starts.\n",
    "\n",
    "* `__call__(self, percept)`: This method updates the `state` of the agent based on its `percept` using the `update_state` method. It then formulates a `goal` with the help of `formulate_goal` method and a `problem` using the `formulate_problem` method and returns a sequence of actions to solve it (using the `search` method).\n",
    "\n",
    "* `update_state(self, percept)`: This method updates the `state` of the agent based on its `percept`.\n",
    "\n",
    "* `formulate_goal(self, state)`: Given a `state` of the agent, this method formulates the `goal` for it.\n",
    "\n",
    "* `formulate_problem(self, state, goal)`: It is used in problem formulation given a `state` and a `goal` for the `agent`.\n",
    "\n",
    "* `search(self, problem)`: This method is used to search a sequence of `actions` to solve a `problem`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now define a Simple Problem Solving Agent Program. We will create a simple `vacuumAgent` class which will inherit from the abstract class `SimpleProblemSolvingAgentProgram` and overrides its methods. We will create a simple intelligent vacuum agent which can be in any one of the following states. It will move to any other state depending upon the current state as shown in the picture by arrows:\n",
    "\n",
    "![simple problem solving agent](images/simple_problem_solving_agent.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class vacuumAgent(SimpleProblemSolvingAgentProgram):\n",
    "        def update_state(self, state, percept):\n",
    "            return percept\n",
    "\n",
    "        def formulate_goal(self, state):\n",
    "            goal = [state7, state8]\n",
    "            return goal  \n",
    "\n",
    "        def formulate_problem(self, state, goal):\n",
    "            problem = state\n",
    "            return problem   \n",
    "    \n",
    "        def search(self, problem):\n",
    "            if problem == state1:\n",
    "                seq = [\"Suck\", \"Right\", \"Suck\"]\n",
    "            elif problem == state2:\n",
    "                seq = [\"Suck\", \"Left\", \"Suck\"]\n",
    "            elif problem == state3:\n",
    "                seq = [\"Right\", \"Suck\"]\n",
    "            elif problem == state4:\n",
    "                seq = [\"Suck\"]\n",
    "            elif problem == state5:\n",
    "                seq = [\"Suck\"]\n",
    "            elif problem == state6:\n",
    "                seq = [\"Left\", \"Suck\"]\n",
    "            return seq"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we will define all the 8 states and create an object of the above class. Then, we will pass it different states and check the output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Left\n",
      "Suck\n",
      "Right\n"
     ]
    }
   ],
   "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",
    "\n",
    "a = vacuumAgent(state1)\n",
    "\n",
    "print(a(state6)) \n",
    "print(a(state1))\n",
    "print(a(state3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SEARCHING ALGORITHMS VISUALIZATION\n",
    "\n",
    "In this section, we have visualizations of the following searching algorithms:\n",
    "\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. Greedy Best First Search\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>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tree_breadth_search_for_vis(problem):\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",
    "    \n",
    "    # we use these two variables at the time of visualisations\n",
    "    iterations = 0\n",
    "    all_node_colors = []\n",
    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
    "    \n",
    "    #Adding first node to the queue\n",
    "    frontier = deque([Node(problem.initial)])\n",
    "    \n",
    "    node_colors[Node(problem.initial).state] = \"orange\"\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "    \n",
    "    while frontier:\n",
    "        #Popping first node of queue\n",
    "        node = frontier.popleft()\n",
    "        \n",
    "        # modify the currently searching node to red\n",
    "        node_colors[node.state] = \"red\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "        if problem.goal_test(node.state):\n",
    "            # modify goal node to green after reaching the goal\n",
    "            node_colors[node.state] = \"green\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "            return(iterations, all_node_colors, node)\n",
    "        \n",
    "        frontier.extend(node.expand(problem))\n",
    "           \n",
    "        for n in node.expand(problem):\n",
    "            node_colors[n.state] = \"orange\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "\n",
    "        # modify the color of explored nodes to gray\n",
    "        node_colors[node.state] = \"gray\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "    return None\n",
    "\n",
    "def breadth_first_tree_search(problem):\n",
    "    \"Search the shallowest nodes in the search tree first.\"\n",
    "    iterations, all_node_colors, node = tree_breadth_search_for_vis(problem)\n",
    "    return(iterations, all_node_colors, node)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we use `ipywidgets` to display a slider, a button and our romania map. By sliding the slider we can have a look at all the intermediate steps of a particular search algorithm. By pressing the button **Visualize**, you can see all the steps without interacting with the slider. These two helper functions are the callback functions which are called when we interact with the slider and the button."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_node_colors = []\n",
    "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
    "a, b, c = breadth_first_tree_search(romania_problem)\n",
    "display_visual(romania_graph_data, user_input=False, \n",
    "               algorithm=breadth_first_tree_search, \n",
    "               problem=romania_problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. DEPTH-FIRST TREE SEARCH\n",
    "Now let's discuss another searching algorithm, Depth-First Tree Search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tree_depth_search_for_vis(problem):\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",
    "    \n",
    "    # we use these two variables at the time of visualisations\n",
    "    iterations = 0\n",
    "    all_node_colors = []\n",
    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
    "    \n",
    "    #Adding first node to the stack\n",
    "    frontier = [Node(problem.initial)]\n",
    "    \n",
    "    node_colors[Node(problem.initial).state] = \"orange\"\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "    \n",
    "    while frontier:\n",
    "        #Popping first node of stack\n",
    "        node = frontier.pop()\n",
    "        \n",
    "        # modify the currently searching node to red\n",
    "        node_colors[node.state] = \"red\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "        if problem.goal_test(node.state):\n",
    "            # modify goal node to green after reaching the goal\n",
    "            node_colors[node.state] = \"green\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "            return(iterations, all_node_colors, node)\n",
    "        \n",
    "        frontier.extend(node.expand(problem))\n",
    "           \n",
    "        for n in node.expand(problem):\n",
    "            node_colors[n.state] = \"orange\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "\n",
    "        # modify the color of explored nodes to gray\n",
    "        node_colors[node.state] = \"gray\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "    return None\n",
    "\n",
    "def depth_first_tree_search(problem):\n",
    "    \"Search the deepest nodes in the search tree first.\"\n",
    "    iterations, all_node_colors, node = tree_depth_search_for_vis(problem)\n",
    "    return(iterations, all_node_colors, node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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_tree_search, \n",
    "               problem=romania_problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 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": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def breadth_first_search_graph(problem):\n",
    "    \"[Figure 3.11]\"\n",
    "    \n",
    "    # we use these two variables at the time of visualisations\n",
    "    iterations = 0\n",
    "    all_node_colors = []\n",
    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
    "    \n",
    "    node = Node(problem.initial)\n",
    "    \n",
    "    node_colors[node.state] = \"red\"\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "      \n",
    "    if problem.goal_test(node.state):\n",
    "        node_colors[node.state] = \"green\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        return(iterations, all_node_colors, node)\n",
    "    \n",
    "    frontier = deque([node])\n",
    "    \n",
    "    # modify the color of frontier nodes to blue\n",
    "    node_colors[node.state] = \"orange\"\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "    explored = set()\n",
    "    while frontier:\n",
    "        node = frontier.popleft()\n",
    "        node_colors[node.state] = \"red\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "        explored.add(node.state)     \n",
    "        \n",
    "        for child in node.expand(problem):\n",
    "            if child.state not in explored and child not in frontier:\n",
    "                if problem.goal_test(child.state):\n",
    "                    node_colors[child.state] = \"green\"\n",
    "                    iterations += 1\n",
    "                    all_node_colors.append(dict(node_colors))\n",
    "                    return(iterations, all_node_colors, child)\n",
    "                frontier.append(child)\n",
    "\n",
    "                node_colors[child.state] = \"orange\"\n",
    "                iterations += 1\n",
    "                all_node_colors.append(dict(node_colors))\n",
    "                    \n",
    "        node_colors[node.state] = \"gray\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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_graph, \n",
    "               problem=romania_problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def graph_search_for_vis(problem):\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",
    "    # we use these two variables at the time of visualisations\n",
    "    iterations = 0\n",
    "    all_node_colors = []\n",
    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
    "    \n",
    "    frontier = [(Node(problem.initial))]\n",
    "    explored = set()\n",
    "    \n",
    "    # modify the color of frontier nodes to orange\n",
    "    node_colors[Node(problem.initial).state] = \"orange\"\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "      \n",
    "    while frontier:\n",
    "        # Popping first node of stack\n",
    "        node = frontier.pop()\n",
    "        \n",
    "        # modify the currently searching node to red\n",
    "        node_colors[node.state] = \"red\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "        if problem.goal_test(node.state):\n",
    "            # modify goal node to green after reaching the goal\n",
    "            node_colors[node.state] = \"green\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "            return(iterations, all_node_colors, node)\n",
    "        \n",
    "        explored.add(node.state)\n",
    "        frontier.extend(child for child in node.expand(problem)\n",
    "                        if child.state not in explored and\n",
    "                        child not in frontier)\n",
    "        \n",
    "        for n in frontier:\n",
    "            # modify the color of frontier nodes to orange\n",
    "            node_colors[n.state] = \"orange\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "\n",
    "        # modify the color of explored nodes to gray\n",
    "        node_colors[node.state] = \"gray\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "    return None\n",
    "\n",
    "\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_for_vis(problem)\n",
    "    return(iterations, all_node_colors, node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "    first search; if f is node.depth then we have breadth-first search.\n",
    "    There is a subtlety: the line \"f = memoize(f, 'f')\" means that the f\n",
    "    values will be cached on the nodes as they are computed. So after doing\n",
    "    a best first search you can examine the f values of the path returned.\"\"\"\n",
    "    \n",
    "    # we use these two variables at the time of visualisations\n",
    "    iterations = 0\n",
    "    all_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",
    "    \n",
    "    node_colors[node.state] = \"red\"\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "    \n",
    "    if problem.goal_test(node.state):\n",
    "        node_colors[node.state] = \"green\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        return(iterations, all_node_colors, node)\n",
    "    \n",
    "    frontier = PriorityQueue('min', f)\n",
    "    frontier.append(node)\n",
    "    \n",
    "    node_colors[node.state] = \"orange\"\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "    \n",
    "    explored = set()\n",
    "    while frontier:\n",
    "        node = frontier.pop()\n",
    "        \n",
    "        node_colors[node.state] = \"red\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "        if problem.goal_test(node.state):\n",
    "            node_colors[node.state] = \"green\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "            return(iterations, all_node_colors, node)\n",
    "        \n",
    "        explored.add(node.state)\n",
    "        for child in node.expand(problem):\n",
    "            if child.state not in explored and child not in frontier:\n",
    "                frontier.append(child)\n",
    "                node_colors[child.state] = \"orange\"\n",
    "                iterations += 1\n",
    "                all_node_colors.append(dict(node_colors))\n",
    "            elif child in frontier:\n",
    "                incumbent = frontier[child]\n",
    "                if f(child) < f(incumbent):\n",
    "                    del frontier[incumbent]\n",
    "                    frontier.append(child)\n",
    "                    node_colors[child.state] = \"orange\"\n",
    "                    iterations += 1\n",
    "                    all_node_colors.append(dict(node_colors))\n",
    "\n",
    "        node_colors[node.state] = \"gray\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "    return None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uniform_cost_search_graph(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_for_vis(problem, lambda node: node.path_cost)\n",
    "    return(iterations, all_node_colors, node)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "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_graph, \n",
    "               problem=romania_problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. DEPTH LIMITED SEARCH\n",
    "\n",
    "Let's change all the 'node_colors' to starting position and define a different problem statement.  \n",
    "Although we have a working implementation, but we need to make changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def depth_limited_search_graph(problem, limit = -1):\n",
    "    '''\n",
    "    Perform depth first search of graph g.\n",
    "    if limit >= 0, that is the maximum depth of the search.\n",
    "    '''\n",
    "    # we use these two variables at the time of visualisations\n",
    "    iterations = 0\n",
    "    all_node_colors = []\n",
    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
    "    \n",
    "    frontier = [Node(problem.initial)]\n",
    "    explored = set()\n",
    "    \n",
    "    cutoff_occurred = False\n",
    "    node_colors[Node(problem.initial).state] = \"orange\"\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "      \n",
    "    while frontier:\n",
    "        # Popping first node of queue\n",
    "        node = frontier.pop()\n",
    "        \n",
    "        # modify the currently searching node to red\n",
    "        node_colors[node.state] = \"red\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "        if problem.goal_test(node.state):\n",
    "            # modify goal node to green after reaching the goal\n",
    "            node_colors[node.state] = \"green\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "            return(iterations, all_node_colors, node)\n",
    "\n",
    "        elif limit >= 0:\n",
    "            cutoff_occurred = True\n",
    "            limit += 1\n",
    "            all_node_color.pop()\n",
    "            iterations -= 1\n",
    "            node_colors[node.state] = \"gray\"\n",
    "\n",
    "        \n",
    "        explored.add(node.state)\n",
    "        frontier.extend(child for child in node.expand(problem)\n",
    "                        if child.state not in explored and\n",
    "                        child not in frontier)\n",
    "        \n",
    "        for n in frontier:\n",
    "            limit -= 1\n",
    "            # modify the color of frontier nodes to orange\n",
    "            node_colors[n.state] = \"orange\"\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "\n",
    "        # modify the color of explored nodes to gray\n",
    "        node_colors[node.state] = \"gray\"\n",
    "        iterations += 1\n",
    "        all_node_colors.append(dict(node_colors))\n",
    "        \n",
    "    return 'cutoff' if cutoff_occurred else None\n",
    "\n",
    "\n",
    "def depth_limited_search_for_vis(problem):\n",
    "    \"\"\"Search the deepest nodes in the search tree first.\"\"\"\n",
    "    iterations, all_node_colors, node = depth_limited_search_graph(problem)\n",
    "    return(iterations, all_node_colors, node)     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_node_colors = []\n",
    "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
    "display_visual(romania_graph_data, user_input=False, \n",
    "               algorithm=depth_limited_search_for_vis, \n",
    "               problem=romania_problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. ITERATIVE DEEPENING SEARCH\n",
    "\n",
    "Let's change all the 'node_colors' to starting position and define a different problem statement.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def iterative_deepening_search_for_vis(problem):\n",
    "    for depth in range(sys.maxsize):\n",
    "        iterations, all_node_colors, node=depth_limited_search_for_vis(problem)\n",
    "        if iterations:\n",
    "            return (iterations, all_node_colors, node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_node_colors = []\n",
    "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
    "display_visual(romania_graph_data, user_input=False, \n",
    "               algorithm=iterative_deepening_search_for_vis, \n",
    "               problem=romania_problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9. GREEDY BEST FIRST SEARCH\n",
    "Let's change all the node_colors to starting position and define a different problem statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greedy_best_first_search(problem, h=None):\n",
    "    \"\"\"Greedy Best-first graph search is an informative searching algorithm with f(n) = h(n).\n",
    "    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_for_vis(problem, lambda n: h(n))\n",
    "    return(iterations, all_node_colors, node)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. 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": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def astar_search_graph(problem, h=None):\n",
    "    \"\"\"A* search is best-first graph search with f(n) = g(n)+h(n).\n",
    "    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_for_vis(problem, \n",
    "                                                                lambda n: n.path_cost + h(n))\n",
    "    return(iterations, all_node_colors, node)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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_graph, \n",
    "               problem=romania_problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. RECURSIVE BEST FIRST SEARCH\n",
    "Let's change all the `node_colors` to starting position and define a different problem statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def recursive_best_first_search_for_vis(problem, h=None):\n",
    "    \"\"\"[Figure 3.26] Recursive best-first search\"\"\"\n",
    "    # we use these two variables at the time of visualizations\n",
    "    iterations = 0\n",
    "    all_node_colors = []\n",
    "    node_colors = {k : 'white' for k in problem.graph.nodes()}\n",
    "    \n",
    "    h = memoize(h or problem.h, 'h')\n",
    "    \n",
    "    def RBFS(problem, node, flimit):\n",
    "        nonlocal iterations\n",
    "        def color_city_and_update_map(node, color):\n",
    "            node_colors[node.state] = color\n",
    "            nonlocal iterations\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "            \n",
    "        if problem.goal_test(node.state):\n",
    "            color_city_and_update_map(node, 'green')\n",
    "            return (iterations, all_node_colors, node), 0  # the second value is immaterial\n",
    "        \n",
    "        successors = node.expand(problem)\n",
    "        if len(successors) == 0:\n",
    "            color_city_and_update_map(node, 'gray')\n",
    "            return (iterations, all_node_colors, None), infinity\n",
    "        \n",
    "        for s in successors:\n",
    "            color_city_and_update_map(s, 'orange')\n",
    "            s.f = max(s.path_cost + h(s), node.f)\n",
    "            \n",
    "        while True:\n",
    "            # Order by lowest f value\n",
    "            successors.sort(key=lambda x: x.f)\n",
    "            best = successors[0]\n",
    "            if best.f > flimit:\n",
    "                color_city_and_update_map(node, 'gray')\n",
    "                return (iterations, all_node_colors, None), best.f\n",
    "            \n",
    "            if len(successors) > 1:\n",
    "                alternative = successors[1].f\n",
    "            else:\n",
    "                alternative = infinity\n",
    "                \n",
    "            node_colors[node.state] = 'gray'\n",
    "            node_colors[best.state] = 'red'\n",
    "            iterations += 1\n",
    "            all_node_colors.append(dict(node_colors))\n",
    "            result, best.f = RBFS(problem, best, min(flimit, alternative))\n",
    "            if result[2] is not None:\n",
    "                color_city_and_update_map(node, 'green')\n",
    "                return result, best.f\n",
    "            else:\n",
    "                color_city_and_update_map(node, 'red')\n",
    "                \n",
    "    node = Node(problem.initial)\n",
    "    node.f = h(node)\n",
    "    \n",
    "    node_colors[node.state] = 'red'\n",
    "    iterations += 1\n",
    "    all_node_colors.append(dict(node_colors))\n",
    "    result, bestf = RBFS(problem, node, infinity)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_node_colors = []\n",
    "romania_problem = GraphProblem('Arad', 'Bucharest', romania_map)\n",
    "display_visual(romania_graph_data, user_input=False,\n",
    "               algorithm=recursive_best_first_search_for_vis,\n",
    "               problem=romania_problem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "all_node_colors = []\n",
    "# display_visual(romania_graph_data, user_input=True, algorithm=breadth_first_tree_search)\n",
    "algorithms = {  \"Breadth First Tree Search\": tree_breadth_search_for_vis,\n",
    "                \"Depth First Tree Search\": tree_depth_search_for_vis,\n",
    "                \"Breadth First Search\": breadth_first_search_graph,\n",
    "                \"Depth First Graph Search\": graph_search_for_vis,\n",
    "                \"Best First Graph Search\": best_first_graph_search_for_vis,\n",
    "                \"Uniform Cost Search\": uniform_cost_search_graph,\n",
    "                \"Depth Limited Search\": depth_limited_search_for_vis,\n",
    "                \"Iterative Deepening Search\": iterative_deepening_search_for_vis,\n",
    "                \"Greedy Best First Search\": greedy_best_first_search,\n",
    "                \"A-star Search\": astar_search_graph,\n",
    "                \"Recursive Best First Search\": recursive_best_first_search_for_vis}\n",
    "display_visual(romania_graph_data, algorithm=algorithms, user_input=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## RECURSIVE BEST-FIRST SEARCH\n",
    "Recursive best-first search is a simple recursive algorithm that improves upon heuristic search by reducing the memory requirement.\n",
    "RBFS uses only linear space and it attempts to mimic the operation of standard best-first search.\n",
    "Its structure is similar to recursive depth-first search but it doesn't continue indefinitely down the current path, the `f_limit` variable is used to keep track of the f-value of the best _alternative_ path available from any ancestor of the current node.\n",
    "RBFS remembers the f-value of the best leaf in the forgotten subtree and can decide whether it is worth re-expanding the tree later.\n",
    "<br>\n",
    "However, RBFS still suffers from excessive node regeneration.\n",
    "<br>\n",
    "Let's have a look at the implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "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\">recursive_best_first_search</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">h</span><span class=\"o\">=</span><span class=\"bp\">None</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;[Figure 3.26] Recursive best-first search (RBFS) is an</span>\n",
       "<span class=\"sd\">    informative search algorithm. Like A*, it uses the heuristic</span>\n",
       "<span class=\"sd\">    f(n) = g(n) + h(n) to determine the next node to expand, making</span>\n",
       "<span class=\"sd\">    it both optimal and complete (iff the heuristic is consistent).</span>\n",
       "<span class=\"sd\">    To reduce memory consumption, RBFS uses a depth first search</span>\n",
       "<span class=\"sd\">    and only retains the best f values of its ancestors.&quot;&quot;&quot;</span>\n",
       "    <span class=\"n\">h</span> <span class=\"o\">=</span> <span class=\"n\">memoize</span><span class=\"p\">(</span><span class=\"n\">h</span> <span class=\"ow\">or</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">h</span><span class=\"p\">,</span> <span class=\"s1\">&#39;h&#39;</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">RBFS</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">node</span><span class=\"p\">,</span> <span class=\"n\">flimit</span><span class=\"p\">):</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">goal_test</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\">return</span> <span class=\"n\">node</span><span class=\"p\">,</span> <span class=\"mi\">0</span>   <span class=\"c1\"># (The second value is immaterial)</span>\n",
       "        <span class=\"n\">successors</span> <span class=\"o\">=</span> <span class=\"n\">node</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=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">successors</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"n\">infinity</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">s</span> <span class=\"ow\">in</span> <span class=\"n\">successors</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">s</span><span class=\"o\">.</span><span class=\"n\">f</span> <span class=\"o\">=</span> <span class=\"nb\">max</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"o\">.</span><span class=\"n\">path_cost</span> <span class=\"o\">+</span> <span class=\"n\">h</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">),</span> <span class=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">f</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">while</span> <span class=\"bp\">True</span><span class=\"p\">:</span>\n",
       "            <span class=\"c1\"># Order by lowest f value</span>\n",
       "            <span class=\"n\">successors</span><span class=\"o\">.</span><span class=\"n\">sort</span><span class=\"p\">(</span><span class=\"n\">key</span><span class=\"o\">=</span><span class=\"k\">lambda</span> <span class=\"n\">x</span><span class=\"p\">:</span> <span class=\"n\">x</span><span class=\"o\">.</span><span class=\"n\">f</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">best</span> <span class=\"o\">=</span> <span class=\"n\">successors</span><span class=\"p\">[</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n",
       "            <span class=\"k\">if</span> <span class=\"n\">best</span><span class=\"o\">.</span><span class=\"n\">f</span> <span class=\"o\">&gt;</span> <span class=\"n\">flimit</span><span class=\"p\">:</span>\n",
       "                <span class=\"k\">return</span> <span class=\"bp\">None</span><span class=\"p\">,</span> <span class=\"n\">best</span><span class=\"o\">.</span><span class=\"n\">f</span>\n",
       "            <span class=\"k\">if</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">successors</span><span class=\"p\">)</span> <span class=\"o\">&gt;</span> <span class=\"mi\">1</span><span class=\"p\">:</span>\n",
       "                <span class=\"n\">alternative</span> <span class=\"o\">=</span> <span class=\"n\">successors</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">f</span>\n",
       "            <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "                <span class=\"n\">alternative</span> <span class=\"o\">=</span> <span class=\"n\">infinity</span>\n",
       "            <span class=\"n\">result</span><span class=\"p\">,</span> <span class=\"n\">best</span><span class=\"o\">.</span><span class=\"n\">f</span> <span class=\"o\">=</span> <span class=\"n\">RBFS</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">best</span><span class=\"p\">,</span> <span class=\"nb\">min</span><span class=\"p\">(</span><span class=\"n\">flimit</span><span class=\"p\">,</span> <span class=\"n\">alternative</span><span class=\"p\">))</span>\n",
       "            <span class=\"k\">if</span> <span class=\"n\">result</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "                <span class=\"k\">return</span> <span class=\"n\">result</span><span class=\"p\">,</span> <span class=\"n\">best</span><span class=\"o\">.</span><span class=\"n\">f</span>\n",
       "\n",
       "    <span class=\"n\">node</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=\"n\">node</span><span class=\"o\">.</span><span class=\"n\">f</span> <span class=\"o\">=</span> <span class=\"n\">h</span><span class=\"p\">(</span><span class=\"n\">node</span><span class=\"p\">)</span>\n",
       "    <span class=\"n\">result</span><span class=\"p\">,</span> <span class=\"n\">bestf</span> <span class=\"o\">=</span> <span class=\"n\">RBFS</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">node</span><span class=\"p\">,</span> <span class=\"n\">infinity</span><span class=\"p\">)</span>\n",
       "    <span class=\"k\">return</span> <span class=\"n\">result</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(recursive_best_first_search)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how `recursive_best_first_search` can solve the `romania_problem`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Sibiu', 'Rimnicu', 'Pitesti', 'Bucharest']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursive_best_first_search(romania_problem).solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`recursive_best_first_search` can be used to solve the 8 puzzle problem too, as discussed later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['UP', 'LEFT', 'UP', 'LEFT', 'DOWN', 'RIGHT', 'RIGHT', 'DOWN']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "puzzle = EightPuzzle((2, 4, 3, 1, 5, 6, 7, 8, 0))\n",
    "assert puzzle.check_solvability((2, 4, 3, 1, 5, 6, 7, 8, 0))\n",
    "recursive_best_first_search(puzzle).solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A* HEURISTICS\n",
    "\n",
    "Different heuristics provide different efficiency in solving A* problems which are generally defined by the number of explored nodes as well as the branching factor. With the classic 8 puzzle we can show the efficiency of different heuristics through the number of explored nodes.\n",
    "\n",
    "### 8 Puzzle Problem\n",
    "\n",
    "The *8 Puzzle Problem* consists of a 3x3 tray in which the goal is to get the initial configuration to the goal state by shifting the numbered tiles into the blank space.\n",
    "\n",
    "example:- \n",
    "\n",
    "              Initial State                        Goal State\n",
    "              | 7 | 2 | 4 |                       | 1 | 2 | 3 |\n",
    "              | 5 | 0 | 6 |                       | 4 | 5 | 6 |\n",
    "              | 8 | 3 | 1 |                       | 7 | 8 | 0 |\n",
    "              \n",
    "We have a total of 9 blank tiles giving us a total of 9! initial configuration but not all of these are solvable. The solvability of a configuration can be checked by calculating the Inversion Permutation. If the total Inversion Permutation is even then the initial configuration is solvable else the initial configuration is not solvable which means that only 9!/2 initial states lead to a solution.\n",
    "<br>\n",
    "Let's define our goal state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "goal = [1, 2, 3, 4, 5, 6, 7, 8, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Heuristics :-\n",
    "\n",
    "1) Manhattan Distance:- For the 8 puzzle problem Manhattan distance is defined as the distance of a tile from its goal state( for the tile numbered '1' in the initial configuration Manhattan distance is 4 \"2 for left and 2 for upward displacement\").\n",
    "\n",
    "2) No. of Misplaced Tiles:- The heuristic calculates the number of misplaced tiles between the current state and goal state.\n",
    "\n",
    "3) Sqrt of Manhattan Distance:- It calculates the square root of Manhattan distance.\n",
    "\n",
    "4) Max Heuristic:- It assign the score as the maximum between \"Manhattan Distance\" and \"No. of Misplaced Tiles\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Heuristics for 8 Puzzle Problem\n",
    "def linear(node):\n",
    "    return sum([1 if node.state[i] != goal[i] else 0 for i in range(8)])\n",
    "\n",
    "def manhattan(node):\n",
    "    state = node.state\n",
    "    index_goal = {0:[2,2], 1:[0,0], 2:[0,1], 3:[0,2], 4:[1,0], 5:[1,1], 6:[1,2], 7:[2,0], 8:[2,1]}\n",
    "    index_state = {}\n",
    "    index = [[0,0], [0,1], [0,2], [1,0], [1,1], [1,2], [2,0], [2,1], [2,2]]\n",
    "    x, y = 0, 0\n",
    "    \n",
    "    for i in range(len(state)):\n",
    "        index_state[state[i]] = index[i]\n",
    "    \n",
    "    mhd = 0\n",
    "    \n",
    "    for i in range(8):\n",
    "        for j in range(2):\n",
    "            mhd = abs(index_goal[i][j] - index_state[i][j]) + mhd\n",
    "    \n",
    "    return mhd\n",
    "\n",
    "def sqrt_manhattan(node):\n",
    "    state = node.state\n",
    "    index_goal = {0:[2,2], 1:[0,0], 2:[0,1], 3:[0,2], 4:[1,0], 5:[1,1], 6:[1,2], 7:[2,0], 8:[2,1]}\n",
    "    index_state = {}\n",
    "    index = [[0,0], [0,1], [0,2], [1,0], [1,1], [1,2], [2,0], [2,1], [2,2]]\n",
    "    x, y = 0, 0\n",
    "    \n",
    "    for i in range(len(state)):\n",
    "        index_state[state[i]] = index[i]\n",
    "    \n",
    "    mhd = 0\n",
    "    \n",
    "    for i in range(8):\n",
    "        for j in range(2):\n",
    "            mhd = (index_goal[i][j] - index_state[i][j])**2 + mhd\n",
    "    \n",
    "    return math.sqrt(mhd)\n",
    "\n",
    "def max_heuristic(node):\n",
    "    score1 = manhattan(node)\n",
    "    score2 = linear(node)\n",
    "    return max(score1, score2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can solve the puzzle using the `astar_search` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solving the puzzle \n",
    "puzzle = EightPuzzle((2, 4, 3, 1, 5, 6, 7, 8, 0))\n",
    "puzzle.check_solvability((2, 4, 3, 1, 5, 6, 7, 8, 0)) # checks whether the initialized configuration is solvable or not"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This case is solvable, let's proceed.\n",
    "<br>\n",
    "The default heuristic function returns the number of misplaced tiles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['UP', 'LEFT', 'UP', 'LEFT', 'DOWN', 'RIGHT', 'RIGHT', 'DOWN']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "astar_search(puzzle).solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the following cells, we use different heuristic functions.\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['UP', 'LEFT', 'UP', 'LEFT', 'DOWN', 'RIGHT', 'RIGHT', 'DOWN']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "astar_search(puzzle, linear).solution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['LEFT', 'UP', 'UP', 'LEFT', 'DOWN', 'RIGHT', 'DOWN', 'RIGHT']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "astar_search(puzzle, manhattan).solution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['LEFT', 'UP', 'UP', 'LEFT', 'DOWN', 'RIGHT', 'DOWN', 'RIGHT']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "astar_search(puzzle, sqrt_manhattan).solution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['LEFT', 'UP', 'UP', 'LEFT', 'DOWN', 'RIGHT', 'DOWN', 'RIGHT']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "astar_search(puzzle, max_heuristic).solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here's how `recursive_best_first_search` can be used to solve this problem too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['LEFT', 'UP', 'UP', 'LEFT', 'DOWN', 'RIGHT', 'DOWN', 'UP', 'DOWN', 'RIGHT']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "recursive_best_first_search(puzzle, manhattan).solution()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though all the heuristic functions give the same solution, the difference lies in the computation time.\n",
    "<br>\n",
    "This might make all the difference in a scenario where high computational efficiency is required.\n",
    "<br>\n",
    "Let's define a few puzzle states and time `astar_search` for every heuristic function.\n",
    "We will use the %%timeit magic for this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "puzzle_1 = EightPuzzle((2, 4, 3, 1, 5, 6, 7, 8, 0))\n",
    "puzzle_2 = EightPuzzle((1, 2, 3, 4, 5, 6, 0, 7, 8))\n",
    "puzzle_3 = EightPuzzle((1, 2, 3, 4, 5, 7, 8, 6, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The default heuristic function is the same as the `linear` heuristic function, but we'll still check both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.24 ms ± 190 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "astar_search(puzzle_1)\n",
    "astar_search(puzzle_2)\n",
    "astar_search(puzzle_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.68 ms ± 368 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "astar_search(puzzle_1, linear)\n",
    "astar_search(puzzle_2, linear)\n",
    "astar_search(puzzle_3, linear)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.12 ms ± 88.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "astar_search(puzzle_1, manhattan)\n",
    "astar_search(puzzle_2, manhattan)\n",
    "astar_search(puzzle_3, manhattan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "22.7 ms ± 1.69 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "astar_search(puzzle_1, sqrt_manhattan)\n",
    "astar_search(puzzle_2, sqrt_manhattan)\n",
    "astar_search(puzzle_3, sqrt_manhattan)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.91 ms ± 434 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "astar_search(puzzle_1, max_heuristic)\n",
    "astar_search(puzzle_2, max_heuristic)\n",
    "astar_search(puzzle_3, max_heuristic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can infer that the `manhattan` heuristic function works the fastest.\n",
    "<br>\n",
    "`sqrt_manhattan` has an extra `sqrt` operation which makes it quite a lot slower than the others.\n",
    "<br>\n",
    "`max_heuristic` should have been a bit slower as it calls two functions, but in this case, those values were already calculated which saved some time.\n",
    "Feel free to play around with these functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For comparison, this is how RBFS performs on this problem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "140 ms ± 9.89 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "recursive_best_first_search(puzzle_1, linear)\n",
    "recursive_best_first_search(puzzle_2, linear)\n",
    "recursive_best_first_search(puzzle_3, linear)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is quite a lot slower than `astar_search` as we can see."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## HILL CLIMBING\n",
    "\n",
    "Hill Climbing is a heuristic search used for optimization problems.\n",
    "Given a large set of inputs and a good heuristic function, it tries to find a sufficiently good solution to the problem. \n",
    "This solution may or may not be the global optimum.\n",
    "The algorithm is a variant of generate and test algorithm. \n",
    "<br>\n",
    "As a whole, the algorithm works as follows:\n",
    "- Evaluate the initial state.\n",
    "- If it is equal to the goal state, return.\n",
    "- Find a neighboring state (one which is heuristically similar to the current state)\n",
    "- Evaluate this state. If it is closer to the goal state than before, replace the initial state with this state and repeat these steps.\n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "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"
    }
   ],
   "source": [
    "psource(hill_climbing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will find an approximate solution to the traveling salespersons problem using this algorithm.\n",
    "<br>\n",
    "We need to define a class for this problem.\n",
    "<br>\n",
    "`Problem` will be used as a base class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TSP_problem(Problem):\n",
    "\n",
    "    \"\"\" subclass of Problem to define various functions \"\"\"\n",
    "\n",
    "    def two_opt(self, state):\n",
    "        \"\"\" Neighbour generating function for Traveling Salesman Problem \"\"\"\n",
    "        neighbour_state = state[:]\n",
    "        left = random.randint(0, len(neighbour_state) - 1)\n",
    "        right = random.randint(0, len(neighbour_state) - 1)\n",
    "        if left > right:\n",
    "            left, right = right, left\n",
    "        neighbour_state[left: right + 1] = reversed(neighbour_state[left: right + 1])\n",
    "        return neighbour_state\n",
    "\n",
    "    def actions(self, state):\n",
    "        \"\"\" action that can be excuted in given state \"\"\"\n",
    "        return [self.two_opt]\n",
    "\n",
    "    def result(self, state, action):\n",
    "        \"\"\"  result after applying the given action on the given state \"\"\"\n",
    "        return action(state)\n",
    "\n",
    "    def path_cost(self, c, state1, action, state2):\n",
    "        \"\"\" total distance for the Traveling Salesman to be covered if in state2  \"\"\"\n",
    "        cost = 0\n",
    "        for i in range(len(state2) - 1):\n",
    "            cost += distances[state2[i]][state2[i + 1]]\n",
    "        cost += distances[state2[0]][state2[-1]]\n",
    "        return cost\n",
    "\n",
    "    def value(self, state):\n",
    "        \"\"\" value of path cost given negative for the given state \"\"\"\n",
    "        return -1 * self.path_cost(None, None, None, state)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use cities from the Romania map as our cities for this problem.\n",
    "<br>\n",
    "A list of all cities and a dictionary storing distances between them will be populated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "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"
     ]
    }
   ],
   "source": [
    "distances = {}\n",
    "all_cities = []\n",
    "\n",
    "for city in romania_map.locations.keys():\n",
    "    distances[city] = {}\n",
    "    all_cities.append(city)\n",
    "    \n",
    "all_cities.sort()\n",
    "print(all_cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we need to populate the individual lists inside the dictionary with the manhattan distance between the cities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "for name_1, coordinates_1 in romania_map.locations.items():\n",
    "        for name_2, coordinates_2 in romania_map.locations.items():\n",
    "            distances[name_1][name_2] = np.linalg.norm(\n",
    "                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])\n",
    "            distances[name_2][name_1] = np.linalg.norm(\n",
    "                [coordinates_1[0] - coordinates_2[0], coordinates_1[1] - coordinates_2[1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The way neighbours are chosen currently isn't suitable for the travelling salespersons problem.\n",
    "We need a neighboring state that is similar in total path distance to the current state.\n",
    "<br>\n",
    "We need to change the function that finds neighbors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hill_climbing(problem):\n",
    "    \n",
    "    \"\"\"From the initial node, keep choosing the neighbor with highest value,\n",
    "    stopping when no neighbor is better. [Figure 4.2]\"\"\"\n",
    "    \n",
    "    def find_neighbors(state, number_of_neighbors=100):\n",
    "        \"\"\" finds neighbors using two_opt method \"\"\"\n",
    "        \n",
    "        neighbors = []\n",
    "        \n",
    "        for i in range(number_of_neighbors):\n",
    "            new_state = problem.two_opt(state)\n",
    "            neighbors.append(Node(new_state))\n",
    "            state = new_state\n",
    "            \n",
    "        return neighbors\n",
    "\n",
    "    # as this is a stochastic algorithm, we will set a cap on the number of iterations\n",
    "    iterations = 10000\n",
    "    \n",
    "    current = Node(problem.initial)\n",
    "    while iterations:\n",
    "        neighbors = find_neighbors(current.state)\n",
    "        if not neighbors:\n",
    "            break\n",
    "        neighbor = argmax_random_tie(neighbors,\n",
    "                                     key=lambda node: problem.value(node.state))\n",
    "        if problem.value(neighbor.state) <= problem.value(current.state):\n",
    "            current.state = neighbor.state\n",
    "        iterations -= 1\n",
    "        \n",
    "    return current.state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An instance of the TSP_problem class will be created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "tsp = TSP_problem(all_cities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now generate an approximate solution to the problem by calling `hill_climbing`.\n",
    "The results will vary a bit each time you run it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Arad',\n",
       " 'Timisoara',\n",
       " 'Lugoj',\n",
       " 'Mehadia',\n",
       " 'Drobeta',\n",
       " 'Craiova',\n",
       " 'Pitesti',\n",
       " 'Giurgiu',\n",
       " 'Bucharest',\n",
       " 'Urziceni',\n",
       " 'Eforie',\n",
       " 'Hirsova',\n",
       " 'Vaslui',\n",
       " 'Iasi',\n",
       " 'Neamt',\n",
       " 'Fagaras',\n",
       " 'Rimnicu',\n",
       " 'Sibiu',\n",
       " 'Oradea',\n",
       " 'Zerind']"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hill_climbing(tsp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution looks like this.\n",
    "It is not difficult to see why this might be a good solution.\n",
    "<br>\n",
    "![title](images/hillclimb-tsp.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SIMULATED ANNEALING\n",
    "\n",
    "The intuition behind Hill Climbing was developed from the metaphor of climbing up the graph of a function to find its peak. \n",
    "There is a fundamental problem in the implementation of the algorithm however.\n",
    "To find the highest hill, we take one step at a time, always uphill, hoping to find the highest point, \n",
    "but if we are unlucky to start from the shoulder of the second-highest hill, there is no way we can find the highest one. \n",
    "The algorithm will always converge to the local optimum.\n",
    "Hill Climbing is also bad at dealing with functions that flatline in certain regions.\n",
    "If all neighboring states have the same value, we cannot find the global optimum using this algorithm.\n",
    "<br>\n",
    "<br>\n",
    "Let's now look at an algorithm that can deal with these situations.\n",
    "<br>\n",
    "Simulated Annealing is quite similar to Hill Climbing, \n",
    "but instead of picking the _best_ move every iteration, it picks a _random_ move. \n",
    "If this random move brings us closer to the global optimum, it will be accepted, \n",
    "but if it doesn't, the algorithm may accept or reject the move based on a probability dictated by the _temperature_. \n",
    "When the `temperature` is high, the algorithm is more likely to accept a random move even if it is bad.\n",
    "At low temperatures, only good moves are accepted, with the occasional exception.\n",
    "This allows exploration of the state space and prevents the algorithm from getting stuck at the local optimum.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "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\">simulated_annealing</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">schedule</span><span class=\"o\">=</span><span class=\"n\">exp_schedule</span><span class=\"p\">()):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;[Figure 4.5] CAUTION: This differs from the pseudocode as it</span>\n",
       "<span class=\"sd\">    returns a state instead of a Node.&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\">for</span> <span class=\"n\">t</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">sys</span><span class=\"o\">.</span><span class=\"n\">maxsize</span><span class=\"p\">):</span>\n",
       "        <span class=\"n\">T</span> <span class=\"o\">=</span> <span class=\"n\">schedule</span><span class=\"p\">(</span><span class=\"n\">t</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">T</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">current</span><span class=\"o\">.</span><span class=\"n\">state</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\">return</span> <span class=\"n\">current</span><span class=\"o\">.</span><span class=\"n\">state</span>\n",
       "        <span class=\"n\">next_choice</span> <span class=\"o\">=</span> <span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">choice</span><span class=\"p\">(</span><span class=\"n\">neighbors</span><span class=\"p\">)</span>\n",
       "        <span class=\"n\">delta_e</span> <span class=\"o\">=</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">value</span><span class=\"p\">(</span><span class=\"n\">next_choice</span><span class=\"o\">.</span><span class=\"n\">state</span><span class=\"p\">)</span> <span class=\"o\">-</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\">if</span> <span class=\"n\">delta_e</span> <span class=\"o\">&gt;</span> <span class=\"mi\">0</span> <span class=\"ow\">or</span> <span class=\"n\">probability</span><span class=\"p\">(</span><span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">exp</span><span class=\"p\">(</span><span class=\"n\">delta_e</span> <span class=\"o\">/</span> <span class=\"n\">T</span><span class=\"p\">)):</span>\n",
       "            <span class=\"n\">current</span> <span class=\"o\">=</span> <span class=\"n\">next_choice</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(simulated_annealing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The temperature is gradually decreased over the course of the iteration.\n",
    "This is done by a scheduling routine.\n",
    "The current implementation uses exponential decay of temperature, but we can use a different scheduling routine instead.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "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\">exp_schedule</span><span class=\"p\">(</span><span class=\"n\">k</span><span class=\"o\">=</span><span class=\"mi\">20</span><span class=\"p\">,</span> <span class=\"n\">lam</span><span class=\"o\">=</span><span class=\"mf\">0.005</span><span class=\"p\">,</span> <span class=\"n\">limit</span><span class=\"o\">=</span><span class=\"mi\">100</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;One possible schedule function for simulated annealing&quot;&quot;&quot;</span>\n",
       "    <span class=\"k\">return</span> <span class=\"k\">lambda</span> <span class=\"n\">t</span><span class=\"p\">:</span> <span class=\"p\">(</span><span class=\"n\">k</span> <span class=\"o\">*</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">exp</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"n\">lam</span> <span class=\"o\">*</span> <span class=\"n\">t</span><span class=\"p\">)</span> <span class=\"k\">if</span> <span class=\"n\">t</span> <span class=\"o\">&lt;</span> <span class=\"n\">limit</span> <span class=\"k\">else</span> <span class=\"mi\">0</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"
    }
   ],
   "source": [
    "psource(exp_schedule)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we'll define a peak-finding problem and try to solve it using Simulated Annealing.\n",
    "Let's define the grid and the initial state first.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial = (0, 0)\n",
    "grid = [[3, 7, 2, 8], [5, 2, 9, 1], [5, 3, 3, 1]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to allow only four directions, namely `N`, `S`, `E` and `W`.\n",
    "Let's use the predefined `directions4` dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'E': (1, 0), 'N': (0, 1), 'S': (0, -1), 'W': (-1, 0)}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "directions4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a problem with these parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "problem = PeakFindingProblem(initial, grid, directions4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll run `simulated_annealing` a few times and store the solutions in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "solutions = {problem.value(simulated_annealing(problem)) for i in range(100)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(solutions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hence, the maximum value is 9."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's find the peak of a two-dimensional gaussian distribution.\n",
    "We'll use the `gaussian_kernel` function from notebook.py to get the distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = gaussian_kernel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use the `heatmap` function from notebook.py to plot this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1eddfe679b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "heatmap(grid, cmap='jet', interpolation='spline16')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define the problem.\n",
    "This time, we will allow movement in eight directions as defined in `directions8`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'E': (1, 0),\n",
       " 'N': (0, 1),\n",
       " 'NE': (1, 1),\n",
       " 'NW': (-1, 1),\n",
       " 'S': (0, -1),\n",
       " 'SE': (1, -1),\n",
       " 'SW': (-1, -1),\n",
       " 'W': (-1, 0)}"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "directions8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll solve the problem just like we did last time.\n",
    "<br>\n",
    "Let's also time it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "problem = PeakFindingProblem(initial, grid, directions8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "533 ms ± 51 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "solutions = {problem.value(simulated_annealing(problem)) for i in range(100)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(solutions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The peak is at 1.0 which is how gaussian distributions are defined.\n",
    "<br>\n",
    "This could also be solved by Hill Climbing as follows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "206 µs ± 21.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "solution = problem.value(hill_climbing(problem))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution = problem.value(hill_climbing(problem))\n",
    "solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, Hill-Climbing is about 24 times faster than Simulated Annealing.\n",
    "(Notice that we ran Simulated Annealing for 100 iterations whereas we ran Hill Climbing only once.)\n",
    "<br>\n",
    "Simulated Annealing makes up for its tardiness by its ability to be applicable in a larger number of scenarios than Hill Climbing as illustrated by the example below.\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a 2D surface as a matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid = [[0, 0, 0, 1, 4], \n",
    "        [0, 0, 2, 8, 10], \n",
    "        [0, 0, 2, 4, 12], \n",
    "        [0, 2, 4, 8, 16], \n",
    "        [1, 4, 8, 16, 32]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1ede2e5b1d0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "heatmap(grid, cmap='jet', interpolation='spline16')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The peak value is 32 at the lower right corner.\n",
    "<br>\n",
    "The region at the upper left corner is planar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's instantiate `PeakFindingProblem` one last time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "problem = PeakFindingProblem(initial, grid, directions8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution by Hill Climbing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "solution = problem.value(hill_climbing(problem))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution by Simulated Annealing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solutions = {problem.value(simulated_annealing(problem)) for i in range(100)}\n",
    "max(solutions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that even though both algorithms started at the same initial state, \n",
    "Hill Climbing could never escape from the planar region and gave a locally optimum solution of **0**,\n",
    "whereas Simulated Annealing could reach the peak at **32**.\n",
    "<br>\n",
    "A very similar situation arises when there are two peaks of different heights.\n",
    "One should carefully consider the possible search space before choosing the algorithm for the task."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GENETIC ALGORITHM\n",
    "\n",
    "Genetic algorithms (or GA) are inspired by natural evolution and are particularly useful in optimization and search problems with large state spaces.\n",
    "\n",
    "Given a problem, algorithms in the domain make use of a *population* of solutions (also called *states*), where each solution/state represents a feasible solution. At each iteration (often called *generation*), the population gets updated using methods inspired by biology and evolution, like *crossover*, *mutation* and *natural selection*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overview\n",
    "\n",
    "A genetic algorithm works in the following way:\n",
    "\n",
    "1) Initialize random population.\n",
    "\n",
    "2) Calculate population fitness.\n",
    "\n",
    "3) Select individuals for mating.\n",
    "\n",
    "4) Mate selected individuals to produce new population.\n",
    "\n",
    "     * Random chance to mutate individuals.\n",
    "\n",
    "5) Repeat from step 2) until an individual is fit enough or the maximum number of iterations is reached."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Glossary\n",
    "\n",
    "Before we continue, we will lay the basic terminology of the algorithm.\n",
    "\n",
    "* Individual/State: A list of elements (called *genes*) that represent possible solutions.\n",
    "\n",
    "* Population: The list of all the individuals/states.\n",
    "\n",
    "* Gene pool: The alphabet of possible values for an individual's genes.\n",
    "\n",
    "* Generation/Iteration: The number of times the population will be updated.\n",
    "\n",
    "* Fitness: An individual's score, calculated by a function specific to the problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Crossover\n",
    "\n",
    "Two individuals/states can \"mate\" and produce one child. This offspring bears characteristics from both of its parents. There are many ways we can implement this crossover. Here we will take a look at the most common ones. Most other methods are variations of those below.\n",
    "\n",
    "* Point Crossover: The crossover occurs around one (or more) point. The parents get \"split\" at the chosen point or points and then get merged. In the example below we see two parents get split and merged at the 3rd digit, producing the following offspring after the crossover.\n",
    "\n",
    "![point crossover](images/point_crossover.png)\n",
    "\n",
    "* Uniform Crossover: This type of crossover chooses randomly the genes to get merged. Here the genes 1, 2 and 5 were chosen from the first parent, so the genes 3, 4 were added by the second parent.\n",
    "\n",
    "![uniform crossover](images/uniform_crossover.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutation\n",
    "\n",
    "When an offspring is produced, there is a chance it will mutate, having one (or more, depending on the implementation) of its genes altered.\n",
    "\n",
    "For example, let's say the new individual to undergo mutation is \"abcde\". Randomly we pick to change its third gene to 'z'. The individual now becomes \"abzde\" and is added to the population."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Selection\n",
    "\n",
    "At each iteration, the fittest individuals are picked randomly to mate and produce offsprings. We measure an individual's fitness with a *fitness function*. That function depends on the given problem and it is used to score an individual. Usually the higher the better.\n",
    "\n",
    "The selection process is this:\n",
    "\n",
    "1) Individuals are scored by the fitness function.\n",
    "\n",
    "2) Individuals are picked randomly, according to their score (higher score means higher chance to get picked). Usually the formula to calculate the chance to pick an individual is the following (for population *P* and individual *i*):\n",
    "\n",
    "$$ chance(i) = \\dfrac{fitness(i)}{\\sum_{k \\, in \\, P}{fitness(k)}} $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementation\n",
    "\n",
    "Below we look over the implementation of the algorithm in the `search` module.\n",
    "\n",
    "First the implementation of the main core of the algorithm:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "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"
    }
   ],
   "source": [
    "psource(genetic_algorithm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The algorithm takes the following input:\n",
    "\n",
    "* `population`: The initial population.\n",
    "\n",
    "* `fitness_fn`: The problem's fitness function.\n",
    "\n",
    "* `gene_pool`: The gene pool of the states/individuals. By default 0 and 1.\n",
    "\n",
    "* `f_thres`: The fitness threshold. If an individual reaches that score, iteration stops. By default 'None', which means the algorithm will not halt until the generations are ran.\n",
    "\n",
    "* `ngen`: The number of iterations/generations.\n",
    "\n",
    "* `pmut`: The probability of mutation.\n",
    "\n",
    "The algorithm gives as output the state with the largest score."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each generation, the algorithm updates the population. First it calculates the fitnesses of the individuals, then it selects the most fit ones and finally crosses them over to produce offsprings. There is a chance that the offspring will be mutated, given by `pmut`. If at the end of the generation an individual meets the fitness threshold, the algorithm halts and returns that individual.\n",
    "\n",
    "The function of mating is accomplished by the method `recombine`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "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"
    }
   ],
   "source": [
    "psource(recombine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The method picks at random a point and merges the parents (`x` and `y`) around it.\n",
    "\n",
    "The mutation is done in the method `mutate`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "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"
    }
   ],
   "source": [
    "psource(mutate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We pick a gene in `x` to mutate and a gene from the gene pool to replace it with.\n",
    "\n",
    "To help initializing the population we have the helper function `init_population`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "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"
    }
   ],
   "source": [
    "psource(init_population)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function takes as input the number of individuals in the population, the gene pool and the length of each individual/state. It creates individuals with random genes and returns the population when done."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Explanation\n",
    "\n",
    "Before we solve problems using the genetic algorithm, we will explain how to intuitively understand the algorithm using a trivial example.\n",
    "\n",
    "#### Generating Phrases\n",
    "\n",
    "In this problem, we use a genetic algorithm to generate a particular target phrase from a population of random strings. This is a classic example that helps build intuition about how to use this algorithm in other problems as well. Before we break the problem down, let us try to brute force the solution. Let us say that we want to generate the phrase \"genetic algorithm\". The phrase is 17 characters long. We can use any character from the 26 lowercase characters and the space character. To generate a random phrase of length 17, each space can be filled in 27 ways. So the total number of possible phrases is\n",
    "\n",
    "$$ 27^{17} = 2153693963075557766310747 $$\n",
    "\n",
    "which is a massive number. If we wanted to generate the phrase \"Genetic Algorithm\", we would also have to include all the 26 uppercase characters into consideration thereby increasing the sample space from 27 characters to 53 characters and the total number of possible phrases then would be\n",
    "\n",
    "$$ 53^{17} = 205442259656281392806087233013 $$\n",
    "\n",
    "If we wanted to include punctuations and numerals into the sample space, we would have further complicated an already impossible problem. Hence, brute forcing is not an option. Now we'll apply the genetic algorithm and see how it significantly reduces the search space. We essentially want to *evolve* our population of random strings so that they better approximate the target phrase as the number of generations increase. Genetic algorithms work on the principle of Darwinian Natural Selection according to which, there are three key concepts that need to be in place for evolution to happen. They are:\n",
    "\n",
    "* **Heredity**: There must be a process in place by which children receive the properties of their parents. <br> \n",
    "For this particular problem, two strings from the population will be chosen as parents and will be split at a random index and recombined as described in the `recombine` function to create a child. This child string will then be added to the new generation.\n",
    "\n",
    "\n",
    "* **Variation**: There must be a variety of traits present in the population or a means with which to introduce variation. <br>If there is no variation in the sample space, we might never reach the global optimum. To ensure that there is enough variation, we can initialize a large population, but this gets computationally expensive as the population gets larger. Hence, we often use another method called mutation. In this method, we randomly change one or more characters of some strings in the population based on a predefined probability value called the mutation rate or mutation probability as described in the `mutate` function. The mutation rate is usually kept quite low. A mutation rate of zero fails to introduce variation in the population and a high mutation rate (say 50%) is as good as a coin flip and the population fails to benefit from the previous recombinations. An optimum balance has to be maintained between population size and mutation rate so as to reduce the computational cost as well as have sufficient variation in the population.\n",
    "\n",
    "\n",
    "* **Selection**: There must be some mechanism by which some members of the population have the opportunity to be parents and pass down their genetic information and some do not. This is typically referred to as \"survival of the fittest\". <br>\n",
    "There has to be some way of determining which phrases in our population have a better chance of eventually evolving into the target phrase. This is done by introducing a fitness function that calculates how close the generated phrase is to the target phrase. The function will simply return a scalar value corresponding to the number of matching characters between the generated phrase and the target phrase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before solving the problem, we first need to define our target phrase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "target = 'Genetic Algorithm'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "We then need to define our gene pool, i.e the elements which an individual from the population might comprise of. Here, the gene pool contains all uppercase and lowercase letters of the English alphabet and the space character."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# The ASCII values of uppercase characters ranges from 65 to 91\n",
    "u_case = [chr(x) for x in range(65, 91)]\n",
    "# The ASCII values of lowercase characters ranges from 97 to 123\n",
    "l_case = [chr(x) for x in range(97, 123)]\n",
    "\n",
    "gene_pool = []\n",
    "gene_pool.extend(u_case) # adds the uppercase list to the gene pool\n",
    "gene_pool.extend(l_case) # adds the lowercase list to the gene pool\n",
    "gene_pool.append(' ')    # adds the space character to the gene pool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now need to define the maximum size of each population. Larger populations have more variation but are computationally more  expensive to run algorithms on."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "max_population = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As our population is not very large, we can afford to keep a relatively large mutation rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mutation_rate = 0.07 # 7%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! Now, we need to define the most important metric for the genetic algorithm, i.e the fitness function. This will simply return the number of matching characters between the generated sample and the target phrase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fitness_fn(sample):\n",
    "    # initialize fitness to 0\n",
    "    fitness = 0\n",
    "    for i in range(len(sample)):\n",
    "        # increment fitness by 1 for every matching character\n",
    "        if sample[i] == target[i]:\n",
    "            fitness += 1\n",
    "    return fitness"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we run our genetic algorithm, we need to initialize a random population. We will use the `init_population` function to do this. We need to pass in the maximum population size, the gene pool and the length of each individual, which in this case will be the same as the length of the target phrase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "population = init_population(max_population, gene_pool, len(target))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now define how the individuals in the population should change as the number of generations increases. First, the `select` function will be run on the population to select *two* individuals with high fitness values. These will be the parents which will then be recombined using the `recombine` function to generate the child."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "parents = select(2, population, fitness_fn) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# The recombine function takes two parents as arguments, so we need to unpack the previous variable\n",
    "child = recombine(*parents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we need to apply a mutation according to the mutation rate. We call the `mutate` function on the child with the gene pool and mutation rate as the additional arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "child = mutate(child, gene_pool, mutation_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above lines can be condensed into\n",
    "\n",
    "`child = mutate(recombine(*select(2, population, fitness_fn)), gene_pool, mutation_rate)`\n",
    "\n",
    "And, we need to do this `for` every individual in the current population to generate the new population."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "population = [mutate(recombine(*select(2, population, fitness_fn)), gene_pool, mutation_rate) for i in range(len(population))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The individual with the highest fitness can then be found using the `max` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "current_best = max(population, key=fitness_fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's print this out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['J', 'y', 'O', 'e', ' ', 'h', 'c', 'r', 'C', 'W', 'H', 'o', 'r', 'R', 'y', 'P', 'U']\n"
     ]
    }
   ],
   "source": [
    "print(current_best)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that this is a list of characters. This can be converted to a string using the join function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "JyOe hcrCWHorRyPU\n"
     ]
    }
   ],
   "source": [
    "current_best_string = ''.join(current_best)\n",
    "print(current_best_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now need to define the conditions to terminate the algorithm. This can happen in two ways\n",
    "1. Termination after a predefined number of generations\n",
    "2. Termination when the fitness of the best individual of the current generation reaches a predefined threshold value.\n",
    "\n",
    "We define these variables below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ngen = 1200 # maximum number of generations\n",
    "# we set the threshold fitness equal to the length of the target phrase\n",
    "# i.e the algorithm only terminates whne it has got all the characters correct \n",
    "# or it has completed 'ngen' number of generations\n",
    "f_thres = len(target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "To generate `ngen` number of generations, we run a `for` loop `ngen` number of times. After each generation, we calculate the fitness of the best individual of the generation and compare it to the value of `f_thres` using the `fitness_threshold` function. After every generation, we print out the best individual of the generation and the corresponding fitness value. Lets now write a function to do this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def genetic_algorithm_stepwise(population, fitness_fn, gene_pool=[0, 1], f_thres=None, ngen=1200, pmut=0.1):\n",
    "    for generation in range(ngen):\n",
    "        population = [mutate(recombine(*select(2, population, fitness_fn)), gene_pool, pmut) for i in range(len(population))]\n",
    "        # stores the individual genome with the highest fitness in the current population\n",
    "        current_best = ''.join(max(population, key=fitness_fn))\n",
    "        print(f'Current best: {current_best}\\t\\tGeneration: {str(generation)}\\t\\tFitness: {fitness_fn(current_best)}\\r', end='')\n",
    "        \n",
    "        # compare the fitness of the current best individual to f_thres\n",
    "        fittest_individual = fitness_threshold(fitness_fn, f_thres, population)\n",
    "        \n",
    "        # if fitness is greater than or equal to f_thres, we terminate the algorithm\n",
    "        if fittest_individual:\n",
    "            return fittest_individual, generation\n",
    "    return max(population, key=fitness_fn) , generation       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function defined above is essentially the same as the one defined in `search.py` with the added functionality of printing out the data of each generation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "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"
    }
   ],
   "source": [
    "psource(genetic_algorithm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have defined all the required functions and variables. Let's now create a new population and test the function we wrote above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current best: Genetic Algorithm\t\tGeneration: 985\t\tFitness: 17\r"
     ]
    }
   ],
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The genetic algorithm was able to converge!\n",
    "We implore you to rerun the above cell and play around with `target, max_population, f_thres, ngen` etc parameters to get a better intuition of how the algorithm works. To summarize, if we can define the problem states in simple array format and if we can create a fitness function to gauge how good or bad our approximate solutions are, there is a high chance that we can get a satisfactory solution using a genetic algorithm. \n",
    "- There is also a better GUI version of this program `genetic_algorithm_example.py` in the GUI folder for you to play around with."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usage\n",
    "\n",
    "Below we give two example usages for the genetic algorithm, for a graph coloring problem and the 8 queens problem.\n",
    "\n",
    "#### Graph Coloring\n",
    "\n",
    "First we will take on the simpler problem of coloring a small graph with two colors. Before we do anything, let's imagine how a solution might look. First, we have to represent our colors. Say, 'R' for red and 'G' for green. These make up our gene pool. What of the individual solutions though? For that, we will look at our problem. We stated we have a graph. A graph has nodes and edges, and we want to color the nodes. Naturally, we want to store each node's color. If we have four nodes, we can store their colors in a list of genes, one for each node. A possible solution will then look like this: ['R', 'R', 'G', 'R']. In the general case, we will represent each solution with a list of chars ('R' and 'G'), with length the number of nodes.\n",
    "\n",
    "Next we need to come up with a fitness function that appropriately scores individuals. Again, we will look at the problem definition at hand. We want to color a graph. For a solution to be optimal, no edge should connect two nodes of the same color. How can we use this information to score a solution? A naive (and ineffective) approach would be to count the different colors in the string. So ['R', 'R', 'R', 'R'] has a score of 1 and ['R', 'R', 'G', 'G'] has a score of 2. Why that fitness function is not ideal though? Why, we forgot the information about the edges! The edges are pivotal to the problem and the above function only deals with node colors. We didn't use all the information at hand and ended up with an ineffective answer. How, then, can we use that information to our advantage?\n",
    "\n",
    "We said that the optimal solution will have all the edges connecting nodes of different color. So, to score a solution we can count how many edges are valid (aka connecting nodes of different color). That is a great fitness function!\n",
    "\n",
    "Let's jump into solving this problem using the `genetic_algorithm` function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we need to represent the graph. Since we mostly need information about edges, we will just store the edges. We will denote edges with capital letters and nodes with integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "edges = {\n",
    "    'A': [0, 1],\n",
    "    'B': [0, 3],\n",
    "    'C': [1, 2],\n",
    "    'D': [2, 3]\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Edge 'A' connects nodes 0 and 1, edge 'B' connects nodes 0 and 3 etc.\n",
    "\n",
    "We already said our gene pool is 'R' and 'G', so we can jump right into initializing our population. Since we have only four nodes, `state_length` should be 4. For the number of individuals, we will try 8. We can increase this number if we need higher accuracy, but be careful! Larger populations need more computating power and take longer. You need to strike that sweet balance between accuracy and cost (the ultimate dilemma of the programmer!)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['R', 'G', 'G', 'G'], ['G', 'R', 'R', 'G'], ['G', 'G', 'G', 'G'], ['G', 'R', 'G', 'G'], ['G', 'G', 'G', 'R'], ['G', 'R', 'R', 'G'], ['G', 'R', 'G', 'G'], ['G', 'G', 'R', 'G']]\n"
     ]
    }
   ],
   "source": [
    "population = init_population(8, ['R', 'G'], 4)\n",
    "print(population)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We created and printed the population. You can see that the genes in the individuals are random and there are 8 individuals each with 4 genes.\n",
    "\n",
    "Next we need to write our fitness function. We previously said we want the function to count how many edges are valid. So, given a coloring/individual `c`, we will do just that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fitness(c):\n",
    "    return sum(c[n1] != c[n2] for (n1, n2) in edges.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! Now we will run the genetic algorithm and see what solution it gives."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['R', 'G', 'R', 'G']\n"
     ]
    }
   ],
   "source": [
    "solution = genetic_algorithm(population, fitness, gene_pool=['R', 'G'])\n",
    "print(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The algorithm converged to a solution. Let's check its score:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print(fitness(solution))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The solution has a score of 4. Which means it is optimal, since we have exactly 4 edges in our graph, meaning all are valid!\n",
    "\n",
    "*NOTE: Because the algorithm is non-deterministic, there is a chance a different solution is given. It might even be wrong, if we are very unlucky!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Eight Queens\n",
    "\n",
    "Let's take a look at a more complicated problem.\n",
    "\n",
    "In the *Eight Queens* problem, we are tasked with placing eight queens on an 8x8 chessboard without any queen threatening the others (aka queens should not be in the same row, column or diagonal). In its general form the problem is defined as placing *N* queens in an NxN chessboard without any conflicts.\n",
    "\n",
    "First we need to think about the representation of each solution. We can go the naive route of representing the whole chessboard with the queens' placements on it. That is definitely one way to go about it, but for the purpose of this tutorial we will do something different. We have eight queens, so we will have a gene for each of them. The gene pool will be numbers from 0 to 7, for the different columns. The *position* of the gene in the state will denote the row the particular queen is placed in.\n",
    "\n",
    "For example, we can have the state \"03304577\". Here the first gene with a value of 0 means \"the queen at row 0 is placed at column 0\", for the second gene \"the queen at row 1 is placed at column 3\" and so forth.\n",
    "\n",
    "We now need to think about the fitness function. On the graph coloring problem we counted the valid edges. The same thought process can be applied here. Instead of edges though, we have positioning between queens. If two queens are not threatening each other, we say they are at a \"non-attacking\" positioning. We can, therefore, count how many such positionings are there.\n",
    "\n",
    "Let's dive right in and initialize our population:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2, 6, 2, 0, 2, 3, 4, 7], [7, 2, 0, 6, 3, 3, 0, 6], [2, 3, 0, 6, 6, 2, 5, 5], [2, 6, 4, 2, 3, 5, 5, 5], [3, 1, 5, 1, 5, 1, 0, 3]]\n"
     ]
    }
   ],
   "source": [
    "population = init_population(100, range(8), 8)\n",
    "print(population[:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have a population of 100 and each individual has 8 genes. The gene pool is the integers from 0 to 7, in string form. Above you can see the first five individuals.\n",
    "\n",
    "Next we need to write our fitness function. Remember, queens threaten each other if they are at the same row, column or diagonal.\n",
    "\n",
    "Since positionings are mutual, we must take care not to count them twice. Therefore for each queen, we will only check for conflicts for the queens after her.\n",
    "\n",
    "A gene's value in an individual `q` denotes the queen's column, and the position of the gene denotes its row. We can check if the aforementioned values between two genes are the same. We also need to check for diagonals. A queen *a* is in the diagonal of another queen, *b*, if the difference of the rows between them is equal to either their difference in columns (for the diagonal on the right of *a*) or equal to the negative difference of their columns (for the left diagonal of *a*). Below is given the fitness function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fitness(q):\n",
    "    non_attacking = 0\n",
    "    for row1 in range(len(q)):\n",
    "        for row2 in range(row1+1, len(q)):\n",
    "            col1 = int(q[row1])\n",
    "            col2 = int(q[row2])\n",
    "            row_diff = row1 - row2\n",
    "            col_diff = col1 - col2\n",
    "\n",
    "            if col1 != col2 and row_diff != col_diff and row_diff != -col_diff:\n",
    "                non_attacking += 1\n",
    "\n",
    "    return non_attacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the best score achievable is 28. That is because for each queen we only check for the queens after her. For the first queen we check 7 other queens, for the second queen 6 others and so on. In short, the number of checks we make is the sum 7+6+5+...+1. Which is equal to 7\\*(7+1)/2 = 28.\n",
    "\n",
    "Because it is very hard and will take long to find a perfect solution, we will set the fitness threshold at 25. If we find an individual with a score greater or equal to that, we will halt. Let's see how the genetic algorithm will fare."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5, 7, 1, 3, 6, 4, 6]\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "solution = genetic_algorithm(population, fitness, f_thres=25, gene_pool=range(8))\n",
    "print(solution)\n",
    "print(fitness(solution))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above you can see the solution and its fitness score, which should be no less than 25."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is where we conclude Genetic Algorithms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### N-Queens Problem\n",
    "Here, we will look at the generalized cae of the Eight Queens problem.\n",
    "<br>\n",
    "We are given a `N` x `N` chessboard, with `N` queens, and we need to place them in such a way that no two queens can attack each other.\n",
    "<br>\n",
    "We will solve this problem using search algorithms.\n",
    "To do this, we already have a `NQueensProblem` class in `search.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "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\">NQueensProblem</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 placing N queens on an NxN board with none attacking</span>\n",
       "<span class=\"sd\">    each other.  A state is represented as an N-element array, where</span>\n",
       "<span class=\"sd\">    a value of r in the c-th entry means there is a queen at column c,</span>\n",
       "<span class=\"sd\">    row r, and a value of -1 means that the c-th column has not been</span>\n",
       "<span class=\"sd\">    filled in yet.  We fill in columns left to right.</span>\n",
       "<span class=\"sd\">    &gt;&gt;&gt; depth_first_tree_search(NQueensProblem(8))</span>\n",
       "<span class=\"sd\">    &lt;Node (7, 3, 0, 2, 5, 1, 6, 4)&gt;</span>\n",
       "<span class=\"sd\">    &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\">N</span><span class=\"p\">):</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">N</span> <span class=\"o\">=</span> <span class=\"n\">N</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">initial</span> <span class=\"o\">=</span> <span class=\"nb\">tuple</span><span class=\"p\">([</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">N</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=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">initial</span><span class=\"p\">)</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;In the leftmost empty column, try all non-conflicting rows.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">state</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"p\">[]</span>  <span class=\"c1\"># All columns filled; no successors</span>\n",
       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">col</span> <span class=\"o\">=</span> <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">index</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">)</span>\n",
       "            <span class=\"k\">return</span> <span class=\"p\">[</span><span class=\"n\">row</span> <span class=\"k\">for</span> <span class=\"n\">row</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">N</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\">conflicted</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">row</span><span class=\"p\">,</span> <span class=\"n\">col</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\">row</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Place the next queen at the given row.&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">col</span> <span class=\"o\">=</span> <span class=\"n\">state</span><span class=\"o\">.</span><span class=\"n\">index</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">)</span>\n",
       "        <span class=\"n\">new</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">[:])</span>\n",
       "        <span class=\"n\">new</span><span class=\"p\">[</span><span class=\"n\">col</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">row</span>\n",
       "        <span class=\"k\">return</span> <span class=\"nb\">tuple</span><span class=\"p\">(</span><span class=\"n\">new</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">conflicted</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\">row</span><span class=\"p\">,</span> <span class=\"n\">col</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Would placing a queen at (row, col) conflict with anything?&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">return</span> <span class=\"nb\">any</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">conflict</span><span class=\"p\">(</span><span class=\"n\">row</span><span class=\"p\">,</span> <span class=\"n\">col</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">[</span><span class=\"n\">c</span><span class=\"p\">],</span> <span class=\"n\">c</span><span class=\"p\">)</span>\n",
       "                   <span class=\"k\">for</span> <span class=\"n\">c</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">col</span><span class=\"p\">))</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">conflict</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">row1</span><span class=\"p\">,</span> <span class=\"n\">col1</span><span class=\"p\">,</span> <span class=\"n\">row2</span><span class=\"p\">,</span> <span class=\"n\">col2</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Would putting two queens in (row1, col1) and (row2, col2) conflict?&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">return</span> <span class=\"p\">(</span><span class=\"n\">row1</span> <span class=\"o\">==</span> <span class=\"n\">row2</span> <span class=\"ow\">or</span>  <span class=\"c1\"># same row</span>\n",
       "                <span class=\"n\">col1</span> <span class=\"o\">==</span> <span class=\"n\">col2</span> <span class=\"ow\">or</span>  <span class=\"c1\"># same column</span>\n",
       "                <span class=\"n\">row1</span> <span class=\"o\">-</span> <span class=\"n\">col1</span> <span class=\"o\">==</span> <span class=\"n\">row2</span> <span class=\"o\">-</span> <span class=\"n\">col2</span> <span class=\"ow\">or</span>  <span class=\"c1\"># same \\ diagonal</span>\n",
       "                <span class=\"n\">row1</span> <span class=\"o\">+</span> <span class=\"n\">col1</span> <span class=\"o\">==</span> <span class=\"n\">row2</span> <span class=\"o\">+</span> <span class=\"n\">col2</span><span class=\"p\">)</span>   <span class=\"c1\"># same / diagonal</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;Check if all columns filled, no conflicts.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">state</span><span class=\"p\">[</span><span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">]</span> <span class=\"ow\">is</span> <span class=\"o\">-</span><span class=\"mi\">1</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"bp\">False</span>\n",
       "        <span class=\"k\">return</span> <span class=\"ow\">not</span> <span class=\"nb\">any</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">conflicted</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">state</span><span class=\"p\">[</span><span class=\"n\">col</span><span class=\"p\">],</span> <span class=\"n\">col</span><span class=\"p\">)</span>\n",
       "                       <span class=\"k\">for</span> <span class=\"n\">col</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\">state</span><span class=\"p\">)))</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;Return number of conflicting queens for a given node&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">num_conflicts</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n",
       "        <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"n\">r1</span><span class=\"p\">,</span> <span class=\"n\">c1</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"nb\">enumerate</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\">for</span> <span class=\"p\">(</span><span class=\"n\">r2</span><span class=\"p\">,</span> <span class=\"n\">c2</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"nb\">enumerate</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=\"p\">(</span><span class=\"n\">r1</span><span class=\"p\">,</span> <span class=\"n\">c1</span><span class=\"p\">)</span> <span class=\"o\">!=</span> <span class=\"p\">(</span><span class=\"n\">r2</span><span class=\"p\">,</span> <span class=\"n\">c2</span><span class=\"p\">):</span>\n",
       "                    <span class=\"n\">num_conflicts</span> <span class=\"o\">+=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">conflict</span><span class=\"p\">(</span><span class=\"n\">r1</span><span class=\"p\">,</span> <span class=\"n\">c1</span><span class=\"p\">,</span> <span class=\"n\">r2</span><span class=\"p\">,</span> <span class=\"n\">c2</span><span class=\"p\">)</span>\n",
       "\n",
       "        <span class=\"k\">return</span> <span class=\"n\">num_conflicts</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NQueensProblem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In [`csp.ipynb`](https://github.com/aimacode/aima-python/blob/master/csp.ipynb) we have seen that the N-Queens problem can be formulated as a CSP and can be solved by \n",
    "the `min_conflicts` algorithm in a way similar to Hill-Climbing. \n",
    "Here, we want to solve it using heuristic search algorithms and even some classical search algorithms.\n",
    "The `NQueensProblem` class derives from the `Problem` class and is implemented in such a way that the search algorithms we already have, can solve it.\n",
    "<br>\n",
    "Let's instantiate the class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "nqp = NQueensProblem(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use `depth_first_tree_search` first.\n",
    "<br>\n",
    "We will also use the %%timeit magic with each algorithm to see how much time they take."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.82 ms ± 498 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "depth_first_tree_search(nqp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dfts = depth_first_tree_search(nqp).solution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAewAAAHwCAYAAABkPlyAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2871fddf550>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_NQueens(dfts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`breadth_first_tree_search`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "88.6 ms ± 2.01 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "breadth_first_tree_search(nqp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bfts = breadth_first_tree_search(nqp).solution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAewAAAHwCAYAAABkPlyAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/P+uMuaa/akHvAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2871fde6898>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_NQueens(bfts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`uniform_cost_search`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.08 s ± 154 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "uniform_cost_search(nqp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ucs = uniform_cost_search(nqp).solution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAewAAAHwCAYAAABkPlyAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/P+uMuaa/akHvAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2871f6c04e0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_NQueens(ucs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`depth_first_tree_search` is almost 20 times faster than `breadth_first_tree_search` and more than 200 times faster than `uniform_cost_search`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also solve this problem using `astar_search` with a suitable heuristic function. \n",
    "<br>\n",
    "The best heuristic function for this scenario will be one that returns the number of conflicts in the current state."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "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\">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;Return number of conflicting queens for a given node&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">num_conflicts</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n",
       "        <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"n\">r1</span><span class=\"p\">,</span> <span class=\"n\">c1</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"nb\">enumerate</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\">for</span> <span class=\"p\">(</span><span class=\"n\">r2</span><span class=\"p\">,</span> <span class=\"n\">c2</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"nb\">enumerate</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=\"p\">(</span><span class=\"n\">r1</span><span class=\"p\">,</span> <span class=\"n\">c1</span><span class=\"p\">)</span> <span class=\"o\">!=</span> <span class=\"p\">(</span><span class=\"n\">r2</span><span class=\"p\">,</span> <span class=\"n\">c2</span><span class=\"p\">):</span>\n",
       "                    <span class=\"n\">num_conflicts</span> <span class=\"o\">+=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">conflict</span><span class=\"p\">(</span><span class=\"n\">r1</span><span class=\"p\">,</span> <span class=\"n\">c1</span><span class=\"p\">,</span> <span class=\"n\">r2</span><span class=\"p\">,</span> <span class=\"n\">c2</span><span class=\"p\">)</span>\n",
       "\n",
       "        <span class=\"k\">return</span> <span class=\"n\">num_conflicts</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NQueensProblem.h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8.85 ms ± 424 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "astar_search(nqp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`astar_search` is faster than both `uniform_cost_search` and `breadth_first_tree_search`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "astar = astar_search(nqp).solution()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAewAAAHwCAYAAABkPlyAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nELABAMgAAjYAABnw/wPRIOc/pYUmbAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2871ff9f518>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_NQueens(astar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AND-OR GRAPH SEARCH\n",
    "An _AND-OR_ graph is a graphical representation of the reduction of goals to _conjunctions_ and _disjunctions_ of subgoals.\n",
    "<br>\n",
    "An _AND-OR_ graph can be seen as a generalization of a directed graph.\n",
    "It contains a number of vertices and generalized edges that connect the vertices.\n",
    "<br>\n",
    "Each connector in an _AND-OR_ graph connects a set of vertices $V$ to a single vertex, $v_0$.\n",
    "A connector can be an _AND_ connector or an _OR_ connector.\n",
    "An __AND__ connector connects two edges having a logical _AND_ relationship,\n",
    "while and __OR__ connector connects two edges having a logical _OR_ relationship.\n",
    "<br>\n",
    "A vertex can have more than one _AND_ or _OR_ connector.\n",
    "This is why _AND-OR_ graphs can be expressed as logical statements.\n",
    "<br>\n",
    "<br>\n",
    "_AND-OR_ graphs also provide a computational model for executing logic programs and you will come across this data-structure in the `logic` module as well.\n",
    "_AND-OR_ graphs can be searched in depth-first, breadth-first or best-first ways searching the state sapce linearly or parallely.\n",
    "<br>\n",
    "Our implementation of _AND-OR_ search searches over graphs generated by non-deterministic environments and returns a conditional plan that reaches a goal state in all circumstances.\n",
    "Let's have a look at the implementation of `and_or_graph_search`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "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\">and_or_graph_search</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;[Figure 4.11]Used when the environment is nondeterministic and completely observable.</span>\n",
       "<span class=\"sd\">    Contains OR nodes where the agent is free to choose any action.</span>\n",
       "<span class=\"sd\">    After every action there is an AND node which contains all possible states</span>\n",
       "<span class=\"sd\">    the agent may reach due to stochastic nature of environment.</span>\n",
       "<span class=\"sd\">    The agent must be able to handle all possible states of the AND node (as it</span>\n",
       "<span class=\"sd\">    may end up in any of them).</span>\n",
       "<span class=\"sd\">    Returns a conditional plan to reach goal state,</span>\n",
       "<span class=\"sd\">    or failure if the former is not possible.&quot;&quot;&quot;</span>\n",
       "\n",
       "    <span class=\"c1\"># functions used by and_or_search</span>\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">or_search</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">path</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;returns a plan as a list of actions&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">goal_test</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">):</span>\n",
       "            <span class=\"k\">return</span> <span class=\"p\">[]</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">state</span> <span class=\"ow\">in</span> <span class=\"n\">path</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"bp\">None</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=\"n\">state</span><span class=\"p\">):</span>\n",
       "            <span class=\"n\">plan</span> <span class=\"o\">=</span> <span class=\"n\">and_search</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">result</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=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">path</span> <span class=\"o\">+</span> <span class=\"p\">[</span><span class=\"n\">state</span><span class=\"p\">,</span> <span class=\"p\">])</span>\n",
       "            <span class=\"k\">if</span> <span class=\"n\">plan</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "                <span class=\"k\">return</span> <span class=\"p\">[</span><span class=\"n\">action</span><span class=\"p\">,</span> <span class=\"n\">plan</span><span class=\"p\">]</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">and_search</span><span class=\"p\">(</span><span class=\"n\">states</span><span class=\"p\">,</span> <span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">path</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Returns plan in form of dictionary where we take action plan[s] if we reach state s.&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">plan</span> <span class=\"o\">=</span> <span class=\"p\">{}</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">s</span> <span class=\"ow\">in</span> <span class=\"n\">states</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">plan</span><span class=\"p\">[</span><span class=\"n\">s</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">or_search</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">problem</span><span class=\"p\">,</span> <span class=\"n\">path</span><span class=\"p\">)</span>\n",
       "            <span class=\"k\">if</span> <span class=\"n\">plan</span><span class=\"p\">[</span><span class=\"n\">s</span><span class=\"p\">]</span> <span class=\"ow\">is</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "                <span class=\"k\">return</span> <span class=\"bp\">None</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">plan</span>\n",
       "\n",
       "    <span class=\"c1\"># body of and or search</span>\n",
       "    <span class=\"k\">return</span> <span class=\"n\">or_search</span><span class=\"p\">(</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">initial</span><span class=\"p\">,</span> <span class=\"n\">problem</span><span class=\"p\">,</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"
    }
   ],
   "source": [
    "psource(and_or_graph_search)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The search is carried out by two functions `and_search` and `or_search` that recursively call each other, traversing nodes sequentially.\n",
    "It is a recursive depth-first algorithm for searching an _AND-OR_ graph.\n",
    "<br>\n",
    "A very similar algorithm `fol_bc_ask` can be found in the `logic` module, which carries out inference on first-order logic knowledge bases using _AND-OR_ graph-derived data-structures.\n",
    "<br>\n",
    "_AND-OR_ trees can also be used to represent the search spaces for two-player games, where a vertex of the tree represents the problem of one of the players winning the game, starting from the initial state of the game.\n",
    "<br>\n",
    "Problems involving _MIN-MAX_ trees can be reformulated as _AND-OR_ trees by representing _MAX_ nodes as _OR_ nodes and _MIN_ nodes as _AND_ nodes.\n",
    "`and_or_graph_search` can then be used to find the optimal solution.\n",
    "Standard algorithms like `minimax` and `expectiminimax` (for belief states) can also be applied on it with a few modifications."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here's how `and_or_graph_search` can be applied to a simple vacuum-world example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "vacuum_world = GraphProblemStochastic('State_1', ['State_7', 'State_8'], vacuum_world)\n",
    "plan = and_or_graph_search(vacuum_world)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Suck',\n",
       " {'State_5': ['Right', {'State_6': ['Suck', {'State_8': []}]}], 'State_7': []}]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_plan(state, problem, plan):\n",
    "    if problem.goal_test(state):\n",
    "        return True\n",
    "    if len(plan) is not 2:\n",
    "        return False\n",
    "    predicate = lambda x: run_plan(x, problem, plan[1][x])\n",
    "    return all(predicate(r) for r in problem.result(state, plan[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "run_plan('State_1', vacuum_world, plan)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ONLINE DFS AGENT\n",
    "So far, we have seen agents that use __offline search__ algorithms,\n",
    "which is a class of algorithms that compute a complete solution before executing it.\n",
    "In contrast, an __online search__ agent interleaves computation and action.\n",
    "Online search is better for most dynamic environments and necessary for unknown environments.\n",
    "<br>\n",
    "Online search problems are solved by an agent executing actions, rather than just by pure computation.\n",
    "For a fully observable environment, an online agent cycles through three steps: taking an action, computing the step cost and checking if the goal has been reached.\n",
    "<br>\n",
    "For online algorithms in partially-observable environments, there is usually a tradeoff between exploration and exploitation to be taken care of.\n",
    "<br>\n",
    "<br>\n",
    "Whenever an online agent takes an action, it receives a _percept_ or an observation that tells it something about its immediate environment.\n",
    "Using this percept, the agent can augment its map of the current environment.\n",
    "For a partially observable environment, this is called the belief state.\n",
    "<br>\n",
    "Online algorithms expand nodes in a _local_ order, just like _depth-first search_ as it does not have the option of observing farther nodes like _A* search_.\n",
    "Whenever an action from the current state has not been explored, the agent tries that action.\n",
    "<br>\n",
    "Difficulty arises when the agent has tried all actions in a particular state.\n",
    "An offline search algorithm would simply drop the state from the queue in this scenario whereas an online search agent has to physically move back to the previous state.\n",
    "To do this, the agent needs to maintain a table where it stores the order of nodes it has been to.\n",
    "This is how our implementation of _Online DFS-Agent_ works.\n",
    "This agent works only in state spaces where the action is reversible, because of the use of backtracking.\n",
    "<br>\n",
    "Let's have a look at the `OnlineDFSAgent` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "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\">OnlineDFSAgent</span><span class=\"p\">:</span>\n",
       "\n",
       "    <span class=\"sd\">&quot;&quot;&quot;[Figure 4.21] The abstract class for an OnlineDFSAgent. Override</span>\n",
       "<span class=\"sd\">    update_state method to convert percept to state. While initializing</span>\n",
       "<span class=\"sd\">    the subclass a problem needs to be provided which is an instance of</span>\n",
       "<span class=\"sd\">    a subclass of the Problem 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\">problem</span><span class=\"p\">):</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span> <span class=\"o\">=</span> <span class=\"n\">problem</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"bp\">None</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"bp\">None</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">untried</span> <span class=\"o\">=</span> <span class=\"nb\">dict</span><span class=\"p\">()</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">unbacktracked</span> <span class=\"o\">=</span> <span class=\"nb\">dict</span><span class=\"p\">()</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">result</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=\"n\">s1</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=\"n\">percept</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">goal_test</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">):</span>\n",
       "            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"bp\">None</span>\n",
       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">if</span> <span class=\"n\">s1</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">untried</span><span class=\"o\">.</span><span class=\"n\">keys</span><span class=\"p\">():</span>\n",
       "                <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">untried</span><span class=\"p\">[</span><span class=\"n\">s1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">actions</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">)</span>\n",
       "            <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "                <span class=\"k\">if</span> <span class=\"n\">s1</span> <span class=\"o\">!=</span> <span class=\"bp\">self</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\">s</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span><span class=\"p\">)]:</span>\n",
       "                    <span class=\"bp\">self</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\">s</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span><span class=\"p\">)]</span> <span class=\"o\">=</span> <span class=\"n\">s1</span>\n",
       "                    <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">unbacktracked</span><span class=\"p\">[</span><span class=\"n\">s1</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">insert</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span><span class=\"p\">)</span>\n",
       "            <span class=\"k\">if</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">untried</span><span class=\"p\">[</span><span class=\"n\">s1</span><span class=\"p\">])</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n",
       "                <span class=\"k\">if</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">unbacktracked</span><span class=\"p\">[</span><span class=\"n\">s1</span><span class=\"p\">])</span> <span class=\"o\">==</span> <span class=\"mi\">0</span><span class=\"p\">:</span>\n",
       "                    <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"bp\">None</span>\n",
       "                <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "                    <span class=\"c1\"># else a &lt;- an action b such that result[s&#39;, b] = POP(unbacktracked[s&#39;])</span>\n",
       "                    <span class=\"n\">unbacktracked_pop</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">unbacktracked</span><span class=\"o\">.</span><span class=\"n\">pop</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">)</span>\n",
       "                    <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">)</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">result</span><span class=\"o\">.</span><span class=\"n\">keys</span><span class=\"p\">():</span>\n",
       "                        <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">result</span><span class=\"p\">[(</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">)]</span> <span class=\"o\">==</span> <span class=\"n\">unbacktracked_pop</span><span class=\"p\">:</span>\n",
       "                            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"n\">b</span>\n",
       "                            <span class=\"k\">break</span>\n",
       "            <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "                <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">untried</span><span class=\"o\">.</span><span class=\"n\">pop</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">)</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"n\">s1</span>\n",
       "        <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</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=\"sd\">&quot;&quot;&quot;To be overridden in most cases. The default case</span>\n",
       "<span class=\"sd\">        assumes the percept to be of type state.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">percept</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(OnlineDFSAgent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It maintains two dictionaries `untried` and `unbacktracked`.\n",
    "`untried` contains nodes that have not been visited yet.\n",
    "`unbacktracked` contains the sequence of nodes that the agent has visited so it can backtrack to it later, if required.\n",
    "`s` and `a` store the state and the action respectively and `result` stores the final path or solution of the problem.\n",
    "<br>\n",
    "Let's look at another online search algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LRTA* AGENT\n",
    "We can infer now that hill-climbing is an online search algorithm, but it is not very useful natively because for complicated search spaces, it might converge to the local minima and indefinitely stay there.\n",
    "In such a case, we can choose to randomly restart it a few times with different starting conditions and return the result with the lowest total cost.\n",
    "Sometimes, it is better to use random walks instead of random restarts depending on the problem, but progress can still be very slow.\n",
    "<br>\n",
    "A better improvement would be to give hill-climbing a memory element.\n",
    "We store the current best heuristic estimate and it is updated as the agent gains experience in the state space.\n",
    "The estimated optimal cost is made more and more accurate as time passes and each time the the local minima is \"flattened out\" until we escape it.\n",
    "<br>\n",
    "This learning scheme is a simple improvement upon traditional hill-climbing and is called _learning real-time A*_ or __LRTA*__.\n",
    "Similar to _Online DFS-Agent_, it builds a map of the environment and chooses the best possible move according to its current heuristic estimates.\n",
    "<br>\n",
    "Actions that haven't been tried yet are assumed to lead immediately to the goal with the least possible cost.\n",
    "This is called __optimism under uncertainty__ and encourages the agent to explore new promising paths.\n",
    "This algorithm might not terminate if the state space is infinite, unlike A* search.\n",
    "<br>\n",
    "Let's have a look at the `LRTAStarAgent` class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "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\">LRTAStarAgent</span><span class=\"p\">:</span>\n",
       "\n",
       "    <span class=\"sd\">&quot;&quot;&quot; [Figure 4.24]</span>\n",
       "<span class=\"sd\">    Abstract class for LRTA*-Agent. A problem needs to be</span>\n",
       "<span class=\"sd\">    provided which is an instance of a subclass of Problem Class.</span>\n",
       "\n",
       "<span class=\"sd\">    Takes a OnlineSearchProblem [Figure 4.23] as a problem.</span>\n",
       "<span class=\"sd\">    &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\">problem</span><span class=\"p\">):</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span> <span class=\"o\">=</span> <span class=\"n\">problem</span>\n",
       "        <span class=\"c1\"># self.result = {}      # no need as we are using problem.result</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">H</span> <span class=\"o\">=</span> <span class=\"p\">{}</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"bp\">None</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"bp\">None</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\">s1</span><span class=\"p\">):</span>     <span class=\"c1\"># as of now s1 is a state rather than a percept</span>\n",
       "        <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">goal_test</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">):</span>\n",
       "            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"bp\">None</span>\n",
       "            <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span>\n",
       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">if</span> <span class=\"n\">s1</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">H</span><span class=\"p\">:</span>\n",
       "                <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">H</span><span class=\"p\">[</span><span class=\"n\">s1</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">h</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">)</span>\n",
       "            <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "                <span class=\"c1\"># self.result[(self.s, self.a)] = s1    # no need as we are using problem.output</span>\n",
       "\n",
       "                <span class=\"c1\"># minimum cost for action b in problem.actions(s)</span>\n",
       "                <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">H</span><span class=\"p\">[</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"nb\">min</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">LRTA_cost</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">output</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">),</span>\n",
       "                                     <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">H</span><span class=\"p\">)</span> <span class=\"k\">for</span> <span class=\"n\">b</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</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\">s</span><span class=\"p\">))</span>\n",
       "\n",
       "            <span class=\"c1\"># an action b in problem.actions(s1) that minimizes costs</span>\n",
       "            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span> <span class=\"o\">=</span> <span class=\"n\">argmin</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">actions</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">),</span>\n",
       "                            <span class=\"n\">key</span><span class=\"o\">=</span><span class=\"k\">lambda</span> <span class=\"n\">b</span><span class=\"p\">:</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">LRTA_cost</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">output</span><span class=\"p\">(</span><span class=\"n\">s1</span><span class=\"p\">,</span> <span class=\"n\">b</span><span class=\"p\">),</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">H</span><span class=\"p\">))</span>\n",
       "\n",
       "            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">s</span> <span class=\"o\">=</span> <span class=\"n\">s1</span>\n",
       "            <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">a</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">LRTA_cost</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">s1</span><span class=\"p\">,</span> <span class=\"n\">H</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Returns cost to move from state &#39;s&#39; to state &#39;s1&#39; plus</span>\n",
       "<span class=\"sd\">        estimated cost to get to goal from s1.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">s1</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">s1</span> <span class=\"ow\">is</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">h</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "            <span class=\"c1\"># sometimes we need to get H[s1] which we haven&#39;t yet added to H</span>\n",
       "            <span class=\"c1\"># to replace this try, except: we can initialize H with values from problem.h</span>\n",
       "            <span class=\"k\">try</span><span class=\"p\">:</span>\n",
       "                <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">c</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">s1</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">H</span><span class=\"p\">[</span><span class=\"n\">s1</span><span class=\"p\">]</span>\n",
       "            <span class=\"k\">except</span><span class=\"p\">:</span>\n",
       "                <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">c</span><span class=\"p\">(</span><span class=\"n\">s</span><span class=\"p\">,</span> <span class=\"n\">a</span><span class=\"p\">,</span> <span class=\"n\">s1</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">problem</span><span class=\"o\">.</span><span class=\"n\">h</span><span class=\"p\">(</span><span class=\"n\">s1</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"
    }
   ],
   "source": [
    "psource(LRTAStarAgent)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`H` stores the heuristic cost of the paths the agent may travel to.\n",
    "<br>\n",
    "`s` and `a` store the state and the action respectively.\n",
    "<br>\n",
    "`problem` stores the problem definition and the current map of the environment is stored in `problem.result`.\n",
    "<br>\n",
    "The `LRTA_cost` method computes the cost of a new path given the current state `s`, the action `a`, the next state `s1` and the estimated cost to get from `s` to `s1` is extracted from `H`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's use `LRTAStarAgent` to solve a simple problem.\n",
    "We'll define a new `LRTA_problem` instance based on our `one_dim_state_space`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<search.Graph at 0x1eddaa35ef0>"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_dim_state_space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define an instance of `OnlineSearchProblem`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "LRTA_problem = OnlineSearchProblem('State_3', 'State_5', one_dim_state_space)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we initialize a `LRTAStarAgent` object for the problem we just defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "lrta_agent = LRTAStarAgent(LRTA_problem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll pass the percepts `[State_3, State_4, State_3, State_4, State_5]` one-by-one to our agent to see what action it comes up with at each timestep."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State_3 Right State_4\n",
      "State_3 Left State_2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Right'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lrta_agent('State_3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State_3 Right State_4\n",
      "State_3 Left State_2\n",
      "State_4 Right State_5\n",
      "State_4 Left State_3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Left'"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lrta_agent('State_4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State_4 Right State_5\n",
      "State_4 Left State_3\n",
      "State_3 Right State_4\n",
      "State_3 Left State_2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Right'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lrta_agent('State_3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State_3 Right State_4\n",
      "State_3 Left State_2\n",
      "State_4 Right State_5\n",
      "State_4 Left State_3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Right'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lrta_agent('State_4')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you manually try to see what the optimal action should be at each step, the outputs of the `lrta_agent` will start to make sense if it doesn't already."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "lrta_agent('State_5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is no possible action for this state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "This concludes the notebook.\n",
    "Hope you learned something new!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  },
  "widgets": {
   "state": {
    "1516e2501ddd4a2e8e3250bffc0164db": {
     "views": [
      {
       "cell_index": 59
      }
     ]
    },
    "17be64c89a9a4a43b3272cb018df0970": {
     "views": [
      {
       "cell_index": 59
      }
     ]
    },
    "ac05040009a340b0af81b0ee69161fbc": {
     "views": [
      {
       "cell_index": 59
      }
     ]
    },
    "d9735ffe77c24f13ae4ad3620ce84334": {
     "views": [
      {
       "cell_index": 59
      }
     ]
    }
   },
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}