CSPs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Constraint Satisfaction Problems\n",
    "\n",
    "This notebook presents, in an interactive way, the lecture notes of MIT's 16.413 course **Principles of Autonomy and Decision Making** for the chapter on **Constraint Satisfaction**.\n",
    "\n",
    "The material below is highly influenced as well by **Chapter 6 Constraint Satisfaction Problems** of the book *Artificial Intelligence: A Modern Approach*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first import necessary modules and helper functions. Run the cell below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "from lib.notebook import psource, pseudocode\n",
    "from lib.n_queens_csp import NQueensCSP, queen_constraint\n",
    "from lib.backtracking import *\n",
    "from lib.csp import CSP\n",
    "\n",
    "import sys\n",
    "import time\n",
    "\n",
    "import lib.csp\n",
    "from lib.sudoku.sudoku_csp  import Sudoku, text2problem\n",
    "from lib.constraint_propagation import AC3, AC1, implementAC1, implementAC3\n",
    "\n",
    "from lib.search import NQueensProblem, depth_first_tree_search\n",
    "\n",
    "# For visualization of intermediate steps.\n",
    "from lib.visualization import *\n",
    "\n",
    "import time\n",
    "\n",
    "# For plotting\n",
    "%matplotlib inline\n",
    "\n",
    "# Delete after development\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CONTENTS\n",
    "\n",
    " 1. [**Introduction to Constraint Propagation Problems (L13 & L14)**](#Intro):\n",
    "    1. *Definition*\n",
    "    2. *Examples*\n",
    "\n",
    " 2. [**Solving CSPs (L14 & L15)**](#solving_csps) :\n",
    "    1. [*Constraint Propagation in CSPs*](#Constraint_Propagation):\n",
    "        1. [AC-1](#ac1):\n",
    "            * [Definition](#ac1_definition)\n",
    "            * [Complexity analysis](#ac1_complexity)\n",
    "            * [Example: solving Sudoku with AC-1](#ac1_example)\n",
    "        2. [AC-3](#ac3):\n",
    "            * [Definition](#ac3_definition)\n",
    "            * [Complexity analysis](#ac3_complexity)\n",
    "            * [Example: solving Sudoku with AC-3](#ac3_example)\n",
    "    2. *[Search in CSPs](#search_in_csps)*:\n",
    "        1. [Generic Search](#generic_search):\n",
    "            * [Formulating CSPs as a state space search problem](#generic_search_definition)\n",
    "            * [Complexity](#generic_search_complexity)\n",
    "            * [Example: NQueens with generic search (5 Queens)](#generic_search_example)\n",
    "        2. [Backtracking Search (BT)](#backtracking):\n",
    "            * [Definition](#backtracking_definition)\n",
    "            * [Complexity](#backtracking_complexity)\n",
    "            * [Example: solving NQueens (15 Queens)](#backtracking_example)\n",
    "        3. [Backtracking Search with Forward Checking (BT-FC)](#backtracking_w_fc):\n",
    "            * [Definition](#bt_fc_definition)\n",
    "            * [Complexity](#bt_fc_complexity)\n",
    "            * [Example: solving NQueens (20 Queens)](#bt_fc_example)         \n",
    "        4. [**Backtracking while Maintaining Arc Consistency (BT-MAC)**](#backtracking_w_mac):\n",
    "            * [Definition](#bt_mac_definition)\n",
    "            * [Complexity](#bt_mac_complexity)\n",
    "            * [Example: solving NQueens (20 Queens)](#bt_mac_example)\n",
    "        5. [Backtracking with Dynamic Variable Ordering](#bt_dvo):\n",
    "            * [Definition](#bt_dvo_definition)\n",
    "            * [Complexity](#bt_dvo_complexity)\n",
    "            * [Example: solving NQueens (40 Queens)](#bt_dvo_example)\n",
    "            * [Example: solving hard Sudokus](#bt_dvo_example_2)\n",
    "        6. [Empirical-runtime-comparison-between-Forward-Checking-and-Maintaining-Arc-Consistency](#experiments)\n",
    "\n",
    "    3. *Elimination for Constraints in CSPs*:\n",
    "        1. Variable Elimination for Constraints:\n",
    "            * Definition: join and project\n",
    "            * Example\n",
    "        2. Bucket elimination (Adaptive Consistency):\n",
    "            * Definition\n",
    "            * Example\n",
    "\n",
    " 3. **Appendix**:\n",
    "    1. Constraint Optimization Problem:\n",
    "        1. Branch-and-Bound\n",
    "        2. Example: using Map Coloring problem with cost added to the colors to use.\n",
    "    2. Incremental Repair / Iterative Repair / Min-Conflict Heuristic\n",
    "        * Definition\n",
    "        * Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction <a name=\"Intro\"></a>\n",
    "\n",
    "In first half of the course, we looked at state space search where our task was to reach a goal node from a given start node connected by a graph. However, many real life problems don't specify the goal node before hand instead we know the desired properties of the goal node. Hence we have to perform the state space search and then check if the node satisfies the properties for all the leaf nodes in the tree. Consider a problem with state space dimensionality $N$ and let each dimension take $p$ values - the total number of possible end states are $N^p$. For a simple Sudoku problem where 40 out of 81 boxes are unfilled - this number is $40^9 \\sim 200$ trillion! This is not consistent with the observed behaviour in human beings - we don't check for all the 200 trillion states before arriving at the solution. Instead, we exploit the fact that there are many constraints or desired properties of the solution to eliminate or prune parts of the tree even before reaching the leaf node. This structured exploitation is possible if we incorporate these desired properties along with the state space. Constraint Satisfaction problem is a mathematical framework that does exactly this.\n",
    "\n",
    "Constraint satisfaction problem represents state using a variable that can take assignments from a list of values called the domain of the variable. The desired properties are specified as constraints which are relations on one or many of the variables. This allows us to treat the state space with structure contrary to the black box view used in state space search problems.\n",
    "\n",
    "Formally, a constraint satisfaction problem (CSP) can be defined as a triple of $\\langle$ V, D, C $\\rangle$ where V is a set of variables, D is the domain of each of the variables in V and C is the set of constraints\n",
    "defining the problem. Each constraint in C can be thought of as a pair of scope S which is a\n",
    "subset of V and a relation R between variables in S. \n",
    "\n",
    "Consider a problem where we are required to construct a set which contains one instance of a variable (say A) and two instances of another variable (say B). This problem can be formulated using a CSP := $\\langle$ V, D, C $\\rangle$ as follows\n",
    "1. $V = \\{A, B\\}$\n",
    "2. $D = \\{1, 2\\}$ \n",
    "3. $C = \\{[\\{A, B\\}, \\{\\{1, 2\\}, \\{1, 1\\}\\}],  [\\{A, B\\}, \\{\\{1, 2\\}, \\{2, 2\\}\\}]\\}$ \n",
    "\n",
    "The first constraint in C forces that the solution must have exactly one A and the second constraint imposes the fact that there must be exactly two B’s. Hence, the solution to the problem is obtained when both the constraints are satisfied which is possible only when the assignment is (A = 1,B = 2).\n",
    "\n",
    "Constraints involving just a single variable is called a unary constraint and those that involve two variables are called binary constraints. Constraints could also involve any arbitrary number of variables which are termed as global constraints. \n",
    "\n",
    "CSPs can be visualized using constraint graphs where the nodes represent the variables and the\n",
    "edges represent the constraint between the variables connected by it. Any CSP can be represented\n",
    "using a constraint graph because any constraint involving multiple variables can be converted to\n",
    "binary constraints by adding additional variables to the problem."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solving CSPs <a name=\"solving_csps\"></a>\n",
    "\n",
    "## Constraint Propagation <a name=\"Constraint_Propagation\"></a>\n",
    "\n",
    "Apart from searching the state space, constraint programming allows us to perform specific\n",
    "type of inference called constraint Propagation which helps in eliminating unwanted parts of the\n",
    "state space based on constraint satisfaction.\n",
    "\n",
    "A network is node-consistent if all the variables in it are also node consistent i.e unary constraints on all the variables are satisfied. We could also extend the same definition for binary constraints in which case the network would be called arc-consistent. \n",
    "\n",
    "Before starting any type of search, we would like to first delete all the values from the domain of a variable that don't satisfy the constraints. We already know that any global constraint involving more than two variables can be converted to a binary constraint. So if we devise an algorithm that prunes the domain of the variable by checking only unary and binary constraints, that would be sufficient. \n",
    "\n",
    "Algorithm 1 shown below describes a Revise procedure that takes two variables as input and deletes all the values from the domain of the first variable that doesn't satisfy the binary constraint between the two variables. Therefore at the end of the revise algorithm the first variable will be arc-consistent with respect to the second variable but the vice versa is not true!\n",
    "\n",
    "<img src=\"images/Algorithm_1.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AC-1 <a name=\"ac1\"></a>\n",
    "\n",
    "### Definition <a name=\"ac1_definition\"></a>\n",
    "\n",
    "AC-1 is a constraint propagation algorithm that repeatedly checks for arc-consistency between two nodes and removes those values in the domain of each of the two variables that are not consistent and continues this until all the variables are consistent. The algorithm is described below:\n",
    "\n",
    "<img src=\"images/Algorithm_2.png\">\n",
    "The code snippet below shows two initial cases of sudoku problem - one of which is easy and can be solved just by constraint propagation (AC-1). Try giving different initial states by modifying the first line to see if it can be solved by AC-1\n",
    "\n",
    "The harder problem proves that any solution that is arc-consistent need not be solution but all solutions are arc-consistent i.e arc-consistent is incomplete but sound. This is one of the drawbacks of arc-consistency methods. Most of the time one would have to perform additional algorithms to arrive at the solution. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complexity analysis of Revise and AC-1 <a name=\"ac1_complexity\"></a>\n",
    "\n",
    "Terminology:\n",
    "\n",
    "$k$ - maximum number of values that any variable in CSP can take\n",
    "\n",
    "$e$ - total number of binary constraints in the set C\n",
    "\n",
    "$n$ - total number of variables in the CSP\n",
    "\n",
    "\n",
    "In the revise algorithm, we check for consistency of every combination of values that the two variables can take which is $k^{2}$ in the worst case. Therefore the complexity of revise algorithm is $\\mathcal{O}(k^{2})$.\n",
    "\n",
    "Now let's analyze the AC-1 algorithm. For every constraint in the set C we call the revise procedure twice. Therefore we perform $e*(k^{2}+k^{2})$ operations. On top of this we run this loop until all the values taken by the variables don't change. In the worst case we will have to perform this for $n*k$ steps. Therefore putting all of this together we get a worst case time complexity for AC-1 to be $\\mathcal{O}(enk^{3})$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: solving Sudoku with AC-1 <a name=\"ac1_example\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAGKCAYAAAASfgYQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3XtUVXXex/E3IHjtCIEhjxeEVFBCEUSjREXNREvLWypgimFemNQ000IdFUEktSYrTXEczUuK6HjJEc0SLyGKNjnlLaeshDSRm4KHy5znD5M8gluaJ85vn2d9X2uxam9r/T5ru+Gzf7+9OdvGZDIhhBBC3I+t6gBCCCH0TYpCCCGEJikKIYQQmqQohBBCaJKiEEIIoamW1h/a2tiY6taubaks/zWTrfX0nc1//qM6QrXcKi2lthX83VvL8QTrOU+NxlvUsXdQHeOBrOV4gvWcp0VG4zWTydTo3v2aRVG3dm3yt26suVR/kOKuvVRHqLa6aftVR6iWTrPmc/DgQdUxHshajidYz3na3b8Dx95OVB3jgazleIL1nKf2zwy8VNV+66lkIYQQSkhRCCGE0CRFIYQQQpMUhRBCCE1SFEIIITRJUQghhNAkRSGEEEKTFIUQQghNUhRCCCE0SVEIIYTQJEUhhBBCkxSFEEIITVIUQgghNFm8KC5fy8Fx8AjsnxnIjeJiSw//QMnJyQQHB+Pm5oaXlxdjx44lOztbdSwzWw8fJXjaTFyHj6TB8y/g83I0cZu2UFJaqjpaJbt27SIoKAgXFxd8fX1ZtmyZ6khVSj58lOfnxeE+8iUcB4+g06RpbDp4SHWsKl28eJFJkyYRFBSEo6Mjffv2VR2pSmXl5SzakkKbqInUf24oLV58iakrV6uOVcn69esxGAyVvpKSklRHM9NzxizsnxlY5dcXZ87V6NiaHzNeE2b8dS0N6tTh5q1blh76gT755BMiIyOJiopi/vz5/Pzzz8TGxjJkyBDS0tKw1cnn3+cUFhLS3pepAwfg2KA+x89fYN6Gzfycm8dfxkepjlchPT2dsLAwIiIiiI2N5cSJE8yePRsbGxsmTpyoOp6Zt7ftwKOxK29FjcbFYGDPiUwiEpdyraCA6Gf7qY5n5uzZs6SmphIYGEipDi8O7ohc+i6ff3WamOFD8W7alB+vXePMDz+qjnVfu3btok6dOhXbHh4eCtNU9u6EsRQUFZntm7t+E19e/I7A1i1rdGyLFsWhf33N3sxTzBg6kNdXr7Xk0NWyefNm/Pz8WLx4ccU+g8HAsGHDuHDhAl5eXgrT/WZs6NNm293b+VJQVMwHu/fwzriXsLGxUZTM3MKFC3n88ccrZhE9e/YkPz+fhIQEoqKicHDQz8txts9+A5eGhortkPa+ZF/P5Z3tO3VXFKGhofTrdztTREQEOTk5ihNVtjfzJFsOHSHz3SW0bd5MdZxq8ff3p0GDBqpj3Ne9x7GktJTMCxcZEvwktezsanRsi10il5eXM2n5Kt4cPgRng+HB/4MCZWVlGO7J1rBhQwBMJpOKSNX28EMPUVJWpjqGmdOnTxMSEmK2r0ePHuTl5ZGRkaEoVdXuLok7/Dw9yMq5riCNNr3MbLWs2XeAkHa+VlMS1mjvyVPk3rjBsG5danwsi51xK/akUlJWxoR+oZYa8ncLDw/n6NGjbNiwgYKCAi5cuMD8+fPp1q0b3t7equNVUl5eTtEtI4e/PsN7O3fzcujTuplNABiNxkqzhjvb587V7JrqHyH97DlaNfkf1TGsUsa587Rq4sYrH6zk4SFhGAYNY8iCBF0W7x3t27fHyckJf39/Vq/W372Ue21OO0JTF2e6+LSt8bEssvSUU1DInz/ayN+mTsK+lsVvi1Rbnz59+OCDD4iOjmbcuHEAdO7cmU2bNilOVrWGg0dg/HWNOrxHdxIiX1Qb6B6enp6cPHnSbF9mZiYAubm5KiJV24Evv+Lv6RmsnKSveynW4ufcPNZ++hntPFqwfvqrFBYXM/Ovaxm8IIEjixfq6oLG1dWVmJgYAgICKC8vZ+vWrUyePJmioiKio6NVx6tS0S0jO48dJ6rPUxY5lhb5qT1r7Xo6e7UmNDDAEsP919LS0pgyZQrjx4/nqaee4urVq8THxxMWFsaOHTuwq+F1wN8rLTGOImMJx89fYMGmzbyyfCXLJrysOlaFyMhIJk+ezJo1axgwYACZmZkV9yv0vHzy/ZWrRLy1lP6dA3mxVw/VcaySCTCZICVmJs6GhwBwe9iJHjNm8dk/T9PDr53agHfp1asXvXr99v7t3r17YzQaSUxMZMKECbo8V3dlHOfmrVu80C3YIuPV+BH4+tIPrNl/gDeHDyHvxk3ybtykyGgEIP9mEcW//rsevPnmm4SGhjJv3jyCg4MZNGgQGzdu5NChQ+zevVt1vEr8Wz5KF582THm+P0vHjmHFJ3u5mP2z6lgVIiIiGDNmDFOmTMHd3Z3w8HCmT58O3L6K06PrhYU8O2c+zRs1Yu20KarjWC2nBvV5zL15RUkAPNm2DQ61avHNj/p98umOAQMGkJuby6VLl1RHqdLmtMO0dHOjY6uafdrpjhqfUXyblU1pWRnB02ZW+rMWo6IY3bsnH76ij+n9+fPnGTx4sNm+Vq1aUbduXb777jtFqaqnw6OeAHx/5QqPujVWnOY2Ozs7Fi9eTExMDFlZWbi7u3P+/HkAAgMDFaerrOiWkQFz4ygpK+Pvc96gXp3aqiNZLe+mTblVWlJpvwmwtdHfFfq97izn6GmJ7I78mzf5R+Yppg16zmJj1nhRPNm2Dfvj5pnt23vyFInJ29j55xg8GuvnyrJZs2Z8+eWXZvvOnTtHcXExzZs3V5Sqeo6eOQtACx1eqTs5OeHk5ATAqlWr6Ny5M61bt1acylxZeTnDFibybVY2aYlxPOLoqDqSVevXKYC56z/mWn5BxRNlh/71DaVlZbTzaKE0W3Vs374dZ2dnXX7fb//iGMbSUostO4EFisKloYFu7R4z2/f91asAdPFpQ4O6dWs6QrVFRkYyc+ZM3NzcKu5RJCQk4O7uTu/evVXHq9Bv9jx6+rWjbfPm2NnacvTMWZZu28HQ4Cd1M5sAyMjIID09HV9fXwoLC0lOTubTTz9l7969qqNVEv3+h+w5cZIlY8eQU1hIztnfnsrq8Kgnte3tFaYzV1RURGpqKgBZWVkUFhayfft24Pb6er169VTGA+ClPr1ZtvMTnpsXx4yhgygsLuaNNevo6deOLj5tVMczEx4eTkBAAD4+PpSXl5OSkkJKSgqLFi3S5f2JzWmHaefRgjbNmlpsTP0+gqTA+PHjcXBwICkpidWrV9OwYUOCgoKYM2cO9evXVx2vQsdWLVm7/zO+v/oLtexs8WjsSuyLYbx8zy/iqWZvb8/WrVuJj4/H1taWoKAgUlNT8fHxUR2tkv2nbs8kX/2w8sc2XEhaTgvXRywd6b5++eUXRo4cabbvzvbp06dxd3dXEcuMoV49UhfMZcqKJMIWLcGhVi2efbwTi6NGq45WSatWrVi3bh2XL1/GZDLh7e3NihUrGD58uOpolVzLL+DAP08zN9yy2Wy0fpGsfp06pvytGy0Y579T3LXXg/8jnaibtl91hGrpNGs+Bw8eVB3jgazleIL1nKfd/Ttw7O1E1TEeyFqOJ1jPeWr/zMBMk8nU8d79+ptXCSGE0BUpCiGEEJqkKIQQQmiSohBCCKFJikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJikKIYQQmqQohBBCaJKiEEIIoUmKQgghhCYpCiGEEJo030dhsrW1io/ytZaP8AXr+Whkm8LXrOK4WsvxBOs5T00PGaziuFrL8QTrOk+rIjMKIYQQmqQohBBCaJKiEEIIoUmKQgghhCYpCiGEEJqkKIQQQmiSohBCCKFJikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJikKIYQQmqQohBBCaLJYUezatYugoCBcXFzw9fVl2bJllhr6dykrL2fRlhTaRE2k/nNDafHiS0xduVp1LDN9+/bFYDBU+XXs2DHV8cxsPXyU4GkzcR0+kgbPv4DPy9HEbdpCSWmp6mj3lZWVhZubGwaDgRs3bqiOY+Zv+w9g/8zASl8rPtmrOlolycnJBAcH4+bmhpeXF2PHjiU7O1t1rEqSDx/l+XlxuI98CcfBI+g0aRqbDh5SHatKFy9eZNKkSQQFBeHo6Ejfvn0tMq7m+yj+KOnp6YSFhREREUFsbCwnTpxg9uzZ2NjYMHHiREtEqLbIpe/y+VeniRk+FO+mTfnx2jXO/PCj6lhmlixZQkFBgdm+BQsW8NVXXxEQEKAoVdVyCgsJae/L1IEDcGxQn+PnLzBvw2Z+zs3jL+OjVMerUkxMDPXr1+fmzZuqo9zXvri51HFwqNj2bOyqME1ln3zyCZGRkURFRTF//nx+/vlnYmNjGTJkCGlpadja6mcx4+1tO/Bo7MpbUaNxMRjYcyKTiMSlXCsoIPrZfqrjmTl79iypqakEBgZSasGLLYsUxcKFC3n88ccrZhE9e/YkPz+fhIQEoqKicLjrhFdpb+ZJthw6Qua7S2jbvJnqOPfl7e1ttl1SUsKpU6cYNGgQtWpZ5K+02saGPm223b2dLwVFxXywew/vjHsJGxsbRcmqduTIEfbv38+0adOIiYlRHee+OrZqSYO6dVXHuK/Nmzfj5+fH4sWLK/YZDAaGDRvGhQsX8PLyUpjO3PbZb+DS0FCxHdLel+zrubyzfafuiiI0NJR+/W5nioiIICcnxyLjWqTWT58+TUhIiNm+Hj16kJeXR0ZGhiUiVMuafQcIaeer65Koyv79+8nLy2Pw4MGqo1TLww89RElZmeoYlZSXl/Paa6/x+uuv4+zsrDqOVSsrK8NgMJjta9iwIQAmk0lFpPu6uyTu8PP0ICvnuoI02lTNxCwyqtForDRruLN97tw5S0Soloxz52nVxI1XPljJw0PCMAwaxpAFCbo8Ye6WnJxMkyZNeOKJJ1RHua/y8nKKbhk5/PUZ3tu5m5dDn9bdbCIpKQmj0cjYsWNVR3kgr6gJ1Ok/GJ+Xo/lwj/7uT4SHh3P06FE2bNhAQUEBFy5cYP78+XTr1q3SjFiP0s+eo1WT/1EdQzcssk7h6enJyZMnzfZlZmYCkJuba4kI1fJzbh5rP/2Mdh4tWD/9VQqLi5n517UMXpDAkcULdfeDDaCoqIg9e/YwevRoXea7o+HgERh/XVMN79GdhMgX1Qa6R05ODrGxsaxcuRJ7e3vVce7LzcmJueHDCWzdivL//IeP0w4z8b0VFBlLmPzcs6rjVejTpw8ffPAB0dHRjBs3DoDOnTuzadMmxcke7MCXX/H39AxWTtLX/VOVLFIUkZGRTJ48mTVr1jBgwAAyMzMr7lfo6aaWCTCZICVmJs6GhwBwe9iJHjNm8dk/T9PDr53agFXYs2cPN2/e1P2yU1piHEXGEo6fv8CCTZt5ZflKlk14WXWsCvPnzycwMJCnn376wf+xQr0DOtA7oEPFdp+O/hhLS4j/eAuv9O+nm++ntLQ0pkyZwvjx43nqqae4evUq8fHxhIWFsWPHDuzs7FRHrNL3V64S8dZS+ncO5MVePVTH0Q2LFEVERASnT59mypQpvPLKK9SrV4+5c+fy2muv4eqqn6c1nBrUx8PVtaIkAJ5s2waHWrX45scfdVkUW7duxdPTE39/f9VRNPm3fBSALj5tcDE8ROTSd5ny/AAedWusOBmcOXOGdevWsWfPHvLy8oDbMzWAgoIC7OzsqKvjG8cDn3yCLYeO8v3Vq3g2Vn88Ad58801CQ0OZN29exb527doREBDA7t276d+/v8J0VbteWMizc+bTvFEj1k6bojqOrljk8sPOzo7Fixfz73//my+++IJvv/2WwMBAgIp/6oF306aYqHyjzQTY2ujjSu1u+fn57Nu3T/eziXt1eNQTgO+vXFGc5LaLFy9SWlpKr169aN68Oc2bN2fq1KnA7SfMXnvtNcUJtdlU/FM/S4/nz5+nXTvzC6tWrVpRt25dvvvuO0Wp7q/olpEBc+MoKSvj73PeoF6d2qoj6YpFn6V0cnLCyckJgFWrVtG5c2dat25tyQia+nUKYO76j7mWX1DxJMShf31DaVkZ7TxaKM1WlV27dmE0GhkyZIjqKL/L0TNnAWihk9lkUFAQu3fvNtu3f/9+li5dSnJyMh4eHoqSVU/KkS9wMRhwf6SR6igVmjVrxpdffmm279y5cxQXF9O8eXNFqapWVl7OsIWJfJuVTVpiHI84OqqOpDsWKYqMjAzS09Px9fWlsLCQ5ORkPv30U/bu1dfTGi/16c2ynZ/w3Lw4ZgwdRGFxMW+sWUdPv3Z08WmjOl4lycnJ+Pr66uqZ9Hv1mz2Pnn7taNu8OXa2thw9c5al23YwNPhJXSw7ATg7OxMcHGy274cffgDgiSeeoEGDBipiVWlo3CICW7fEt0ULyv/zHzYfOsLmQ0dY+vIY3dyfgNv3JWfOnImbm1vFPYqEhATc3d3p3bu36nhmot//kD0nTrJk7BhyCgvJOfvbk5gdHvWkto4ebigqKiI1NRW4/QkChYWFbN++HYDevXtTr169GhnXIkVhb2/P1q1biY+Px9bWlqCgIFJTU/Hx8bHE8NVmqFeP1AVzmbIiibBFS3CoVYtnH+/E4qjRqqNVkpOTw8GDB3X9S2Fw+xfD1u7/jO+v/kItO1s8GrsS+2IYL4fq+6axXrVu8j+s2XeAH69dw2SCNs2a8tdXXyG8R3fV0cyMHz8eBwcHkpKSWL16NQ0bNiQoKIg5c+ZQv3591fHM7D91e+bz6odJlf7sQtJyWrg+YulI9/XLL78wcuRIs313tk+fPo27u3uNjGuj9csv9erVM13RyTqylrpp+1VHqLbirr1UR6iW7v4dOPZ2ouoYD2QtxxOs5zztNGs+Bw8eVB3jgazleIL1nKcGgyHTZDJ1vHe/fuaqQgghdEmKQgghhCYpCiGEEJqkKIQQQmiSohBCCKFJikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJikKIYQQmqQohBBCaJKiEEIIoUmKQgghhCYpCiGEEJo0X1xk85//WMVnvlvLZ72D9XyGvukhg1UcV2s5nmA956lN4WtWcVyt5XiCdZ2nVZEZhRBCCE1SFEIIITRJUQghhNAkRSGEEEKTFIUQQghNUhRCCCE0SVEIIYTQJEUhhBBCkxSFEEIITVIUQgghNElRCCGE0CRFIYQQQpMUhRBCCE0WKYrkw0d5fl4c7iNfwnHwCDpNmsamg4csMfTvsn79egwGQ6WvpKQk1dEq+TYrm/HLPqBD9BRq9x9MzxmzVEeqUnJyMsHBwbi5ueHl5cXYsWPJzs5WHauSnjNmYf/MwCq/vjhzTnU8M2VlZSxZsgQ/Pz9cXFzw9vZmxowZqmNpunwtB8fBI7B/ZiA3iotVx6lk165dBAUF4eLigq+vL8uWLVMdqZKth48SPG0mrsNH0uD5F/B5OZq4TVsoKS2t8bE1P2b8j/L2th14NHblrajRuBgM7DmRSUTiUq4VFBD9bD9LRPhddu3aRZ06dSq2PTw8FKap2jc//Mg/Tpyks1drysrKVMep0ieffEJkZCRRUVHMnz+fn3/+mdjYWIYMGUJaWhq2tvqZ0L47YSwFRUVm++au38SXF78jsHVLRamqNm7cONLS0pgxYwatW7fmp59+4tw5fZXZvWb8dS0N6tTh5q1bqqNUkp6eTlhYGBEREcTGxnLixAlmz56NjY0NEydOVB2vQk5hISHtfZk6cACODepz/PwF5m3YzM+5efxlfFSNjm2Rotg++w1cGhoqtkPa+5J9PZd3tu/UZVH4+/vToEED1TE0PdOpI/0f7wTAC3GLuFZQqDhRZZs3b8bPz4/FixdX7DMYDAwbNowLFy7g5eWlMJ25ts2bmW2XlJaSeeEiQ4KfpJadnaJUle3bt4+UlBSOHj2Kt7e36jjVcuhfX7M38xQzhg7k9dVrVcepZOHChTz++OMVs4iePXuSn59PQkICUVFRODg4KE5429jQp822u7fzpaComA927+GdcS9hY2NTY2Nb5JLu7pK4w8/Tg6yc65YY/v8lPV2N309ZWRkGg/nffcOGDQEwmUwqIlXb3pOnyL1xg2HduqiOYuajjz6ia9euVlMS5eXlTFq+ijeHD8HZUPnngB6cPn2akJAQs309evQgLy+PjIwMRamq5+GHHqLEAisKyn7apJ89R6sm/6NqeE3t27fHyckJf39/Vq9erTqO1QoPD+fo0aNs2LCBgoICLly4wPz58+nWrZvuf9BtTjtCUxdnuvi0VR3FzIkTJ2jZsiVTp06lSZMmuLq6EhYWpsv7PgAr9qRSUlbGhH6hqqPcl9ForDRruLOtxyW98vJyim4ZOfz1Gd7buZuXQ5+u0dkEWGjp6V4HvvyKv6dnsHKSftb/AFxdXYmJiSEgIIDy8nK2bt3K5MmTKSoqIjo6WnU8q9OnTx8++OADoqOjGTduHACdO3dm06ZNipNpK7plZOex40T1earGvwF/rytXrrBhwwYee+wxVq9ezY0bN5g9ezYjRozgwIEDusqbU1DInz/ayN+mTsK+lpIfNdXi6enJyZMnzfZlZmYCkJubqyKSpoaDR2D89QZ2eI/uJES+WONjWvxv7/srV4l4ayn9OwfyYq8elh5eU69evejV67f38Pbu3Ruj0UhiYiITJkywiuUePUlLS2PKlCmMHz+ep556iqtXrxIfH09YWBg7duzATkdr/3fblXGcm7du8UK3YNVRKjGZTJhMJjZu3IizszMAjRs3JjQ0lIMHD9K9e3e1Ae8ya+16Onu1JjQwQHUUTZGRkUyePJk1a9YwYMAAMjMzK+5X6PF7Pi0xjiJjCcfPX2DBps28snwlyya8XKNjWvQoXC8s5Nk582neqBFrp02x5ND/tQEDBpCbm8ulS5dUR7E6b775JqGhocybN4/g4GAGDRrExo0bOXToELt371Yd7742px2mpZsbHVvp62knAEdHR9q2bVtREgBBQUE4ODhw9uxZhcnMfX3pB9bsP8Cbw4eQd+MmeTduUmQ0ApB/s4jiX/9dDyIiIhgzZgxTpkzB3d2d8PBwpk+fDtxeZdAb/5aP0sWnDVOe78/SsWNY8cleLmb/XKNjWmxGUXTLyIC5cZSUlfH3OW9Qr05tSw39f3JnKq+nKb21OH/+PIMHDzbb16pVK+rWrct3332nKJW2/Js3+UfmKaYNek51lCp5eXlxq4pHTE0mk66ufr/Nyqa0rIzgaTMr/VmLUVGM7t2TD1/Rx9KznZ0dixcvJiYmhqysLNzd3Tl//jwAgYGBitNp6/CoJwDfX7nCo26Na2wcixRFWXk5wxYm8m1WNmmJcTzi6GiJYf8Q27dvx9nZmebNm6uOYnWaNWvGl19+abbv3LlzFBcX6/Z4bv/iGMbSUl0uO8Ht+z5xcXHk5ORUzCqOHDlCaWkpvr6+itP95sm2bdgfN89s396Tp0hM3sbOP8fg0Vh/V+pOTk44OTkBsGrVKjp37kzr1q0Vp9J29MztWWSLGp75WKQoot//kD0nTrJk7BhyCgvJOfvbkwQdHvWktr29JWI8UHh4OAEBAfj4+FBeXk5KSgopKSksWrRIV1drcHuGtufE7Rtul3OuU1hczNbDRwEI7RigixlbZGQkM2fOxM3NreIeRUJCAu7u7vTu3Vt1vCptTjtMO48WtGnWVHWUKo0aNYrly5czdOhQpk2bRmFhIXPmzCEkJISgoCDV8Sq4NDTQrd1jZvu+v3oVgC4+bWhQt66KWFXKyMggPT0dX19fCgsLSU5O5tNPP2Xv3r2qo5npN3sePf3a0bZ5c+xsbTl65ixLt+1gaPCTNTqbAAsVxf5Tt68qX/2w8kdhXEhaTgvXRywR44FatWrFunXruHz5MiaTCW9vb1asWMHw4cNVR6vkan4+wxa+ZbbvzvaFpOW0qKP+mI4fPx4HBweSkpJYvXo1DRs2JCgoiDlz5lC/fn3V8Sq5ll/AgX+eZm64/v6+7zAYDOzcuZPp06czevRoHBwc6Nu3L/Hx8aqjWS17e3u2bt1KfHw8tra2BAUFkZqaio+Pj+poZjq2asna/Z/x/dVfqGVni0djV2JfDOPle34RrybYaP3iU/06dUz5WzfWeIj/q+KuvR78H+lE3bT9qiNUS6dZ8zl48KDqGA9kLccTrOc87e7fgWNvJ6qO8UDWcjzBes5T+2cGZppMpo737tfXeooQQgjdkaIQQgihSYpCCCGEJikKIYQQmqQohBBCaJKiEEIIoUmKQgghhCYpCiGEEJqkKIQQQmiSohBCCKFJikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJs33UdjZ2Znat29vwTj/HZvCAtURqs30kEF1hGo59803eOv0LW93s5bjCdZznp65nIW3t7fqGA9kLccTrOc8PXXqVJXvo9Asinr16pmuXLlSo8H+CNbyUhCwnpetyMtr/njWcp7KS6v+eNZynhoMBnlxkRBCiN9PikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJikKIYQQmqQohBBCaJKiEEIIoUmKQgghhCYpCiGEEJqkKIQQQmiSohBCCKHJIkWxfv16DAZDpa+kpCRLDP9fu3wtB8fBI7B/ZiA3iotVxzGTnJxMcHAwbm5ueHl5MXbsWLKzs1XHquTbrGzGL/uADtFTqN1/MD1nzFIdqUrbt2+nV69euLu706hRI/z9/Vm0aBElJSWqo5lJPnyU5+fF4T7yJRwHj6DTpGlsOnhIdawq7dq1i6CgIFxcXPD19WXZsmWqI1Wp54xZ2D8zsMqvL86cUx3PTFlZGUuWLMHPzw8XFxe8vb2ZMWNGjY9bq8ZHuMuuXbuoU6dOxbaHh4clh//dZvx1LQ3q1OHmrVuqo5j55JNPiIyMJCoqivnz5/Pzzz8TGxvLkCFDSEtLw9ZWPxPFb374kX+cOElnr9aUlZWpjnNf169fp2vXrkyaNImGDRuSmZlJfHw8V65cYfHixarjVXh72w48GrvyVtRoXAwG9pzIJCJxKdcKCoiwrZjuAAAgAElEQVR+tp/qeBXS09MJCwsjIiKC2NhYTpw4wezZs7GxsWHixImq45l5d8JYCoqKzPbNXb+JLy9+R2DrlopSVW3cuHGkpaUxY8YMWrduzU8//cS5czVfZhYtCn9/fxo0aGDJIf9rh/71NXszTzFj6EBeX71WdRwzmzdvxs/Pz+wHmMFgYNiwYVy4cAEvLy+F6cw906kj/R/vBMALcYu4VlCoOFHVIiMjzba7du1KYWEhK1eu5K233sLGxkZRMnPbZ7+BS8PfXoIT0t6X7Ou5vLN9p66KYuHChTz++OMVs4iePXuSn59PQkICUVFRODg4KE74m7bNm5ltl5SWknnhIkOCn6SWnZ2iVJXt27ePlJQUjh49avEXS+nn0lNHysvLmbR8FW8OH4KzQX9vpiorK8NwT66GDRsCoPUiKhX0NLv5vR5++GHdLT3dXRJ3+Hl6kJVzXUGa+zt9+jQhISFm+3r06EFeXh4ZGRmKUlXP3pOnyL1xg2HduqiOYuajjz6ia9euSt4+aNHv4vbt2+Pk5IS/vz+rV6+25NC/y4o9qZSUlTGhX6jqKFUKDw/n6NGjbNiwgYKCAi5cuMD8+fPp1q2bVbzCUs/Ky8spKiriiy++YPny5YwZM0Y3s4n7ST97jlZN/kd1DDNGo7HSrOHOtiWWSv4vNqcdoamLM1182qqOYubEiRO0bNmSqVOn0qRJE1xdXQkLC7PIvUmLLD25uroSExNDQEAA5eXlbN26lcmTJ1NUVER0dLQlIlRbTkEhf/5oI3+bOgn7WhZdmau2Pn368MEHHxAdHc24ceMA6Ny5M5s2bVKczPo1btwYo9EIwPDhw4mNjVWcSNuBL7/i7+kZrJykr3V/T09PTp48abYvMzMTgNzcXBWRqqXolpGdx44T1ecp3V0gXLlyhQ0bNvDYY4+xevVqbty4wezZsxkxYgQHDhyo0bwW+UnYq1cvevX67Z2xvXv3xmg0kpiYyIQJE3S1PDFr7Xo6e7UmNDBAdZT7SktLY8qUKYwfP56nnnqKq1evEh8fT1hYGDt27MBOR+uq1mbfvn0UFxeTmZlJQkICU6dOZenSpapjVen7K1eJeGsp/TsH8mKvHqrjmImMjGTy5MmsWbOGAQMGkJmZWXG/Qk/f7/falXGcm7du8UK3YNVRKjGZTJhMJjZu3IizszNw+8ImNDSUgwcP0r179xobW9nf2IABA8jNzeXSpUuqIlTy9aUfWLP/AG8OH0LejZvk3bhJ0a9Xl/k3iyj+9d9Ve/PNNwkNDWXevHkEBwczaNAgNm7cyKFDh9i9e7fqeFbNz8+PoKAgoqOjSUhIICkpiX//+9+qY1VyvbCQZ+fMp3mjRqydNkV1nEoiIiIYM2YMU6ZMwd3dnfDwcKZPnw7cXmHQq81ph2np5kbHVvp62gnA0dGRtm3bVpQEQFBQEA4ODpw9e7ZGx1a2tnJnmqSn6d23WdmUlpURPG1mpT9rMSqK0b178uEr6qf458+fZ/DgwWb7WrVqRd26dfnuu+8Upfr/x8/PD4BLly7h6empOM1vim4ZGTA3jpKyMv4+5w3q1amtOlIldnZ2LF68mJiYGLKysnB3d+f8+fMABAYGKk5XtfybN/lH5immDXpOdZQqeXl5cauKR/VNJlONz9KUFcX27dtxdnamefPmqiJU8mTbNuyPm2e2b+/JUyQmb2Pnn2PwaKyPK6FmzZrx5Zdfmu07d+4cxcXFujqe1i49PR0Ad3d3xUl+U1ZezrCFiXyblU1aYhyPODqqjqTJyckJJycnAFatWkXnzp1p3bq14lRV2/7FMYylpbpcdoLb9ybj4uLIycmpmFUcOXKE0tJSfH19a3RsixRFeHg4AQEB+Pj4UF5eTkpKCikpKSxatEhX65UuDQ10a/eY2b7vr14FoItPGxrUrasiViWRkZHMnDkTNze3insUCQkJuLu707t3b9XxzBTdMrLnxO2bmJdzrlNYXMzWw0cBCO0YoJur4eeff56QkBC8vb2xs7MjPT2dZcuWMXDgQF3NJqLf/5A9J06yZOwYcgoLyTn72xNEHR71pLa9vcJ0v8nIyCA9PR1fX18KCwtJTk7m008/Ze/evaqj3dfmtMO082hBm2ZNVUep0qhRo1i+fDlDhw5l2rRpFBYWMmfOHEJCQggKCqrRsS1SFK1atWLdunVcvnwZk8mEt7c3K1asYPjw4ZYY/v+d8ePH4+DgQFJSEqtXr6Zhw4YEBQUxZ84c6tevrzqemav5+Qxb+JbZvjvbF5KW06LOIypiVeLv78/69ev54YcfqFWrFi1atGDOnDmMGTNGdTQz+0/dnkm++mHlj7+5kLScFq76OJ729vZs3bqV+Ph4bG1tCQoKIjU1FR8fH9XRqnQtv4AD/zzN3HD9/kwyGAzs3LmT6dOnM3r0aBwcHOjbty/x8fE1PraN1i9o1atXz3TlypUaD/F/VTdtv+oI1VbctdeD/yMd6O7fgWNvJ6qO8UDWcjzBes7TTrPmc/DgQdUxHshajidYz3lqMBgyTSZTx3v362fdRwghhC5JUQghhNAkRSGEEEKTFIUQQghNUhRCCCE0SVEIIYTQJEUhhBBCkxSFEEIITVIUQgghNElRCCGE0CRFIYQQQpMUhRBCCE1SFEIIITRJUQghhNCk+T4Km//8xyo+ytdaPsIXrOejkU0PGaziuFrL8QTrOU9tCl+ziuNqLccTrOs8rYrMKIQQQmiSohBCCKFJikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJikKIYQQmqQohBBCaJKiEEIIoUmKQgghhCYpCiGEEJqkKIQQQmiSohBCCKHJIkXRc8Ys7J8ZWOXXF2fOWSJCtWzbto0XXngBLy8v3Nzc6Nq1K1u2bFEdq0p//+IYHaKnUP+5obQaM46l23aojlSl9evXYzAYKn0lJSWpjlZJWXk5i7ak0CZqIvWfG0qLF19i6srVqmNpysrKws3NDYPBwI0bN1THMfNtVjbjl31Ah+gp1O4/mJ4zZqmOVKXt27fTq1cv3N3dadSoEf7+/ixatIiSkhLV0Sr5+OBhAidNxXHwCNxHvsSoxe+QlXO9xsfVfB/FH+XdCWMpKCoy2zd3/Sa+vPgdga1bWiJCtSxbtgx3d3fi4+NxdnYmNTWVMWPGkJOTw7hx41THq3DkmzMMiVvEqKd6sCjyRTLOneeNNeuwtbVh0oBnVcer0q5du6hTp07FtoeHh8I0VYtc+i6ff3WamOFD8W7alB+vXePMDz+qjqUpJiaG+vXrc/PmTdVRKvnmhx/5x4mTdPZqTVlZmeo493X9+nW6du3KpEmTaNiwIZmZmcTHx3PlyhUWL16sOl6FnccyCE9cwvh+oSSMfpHs3FzmrNtA/7kLyHg7EVvbmrvut0hRtG3ezGy7pLSUzAsXGRL8JLXs7CwRoVo2b96Ms7NzxXa3bt3Izs7mvffe01VRLNi4hSfaePPhKxMBeMrfj7ybN1mwcQvj+/bBwd5eccLK/P39adCggeoY97U38yRbDh0h890llc5XvTpy5Aj79+9n2rRpxMTEqI5TyTOdOtL/8U4AvBC3iGsFhYoTVS0yMtJsu2vXrhQWFrJy5UreeustbGxsFCUzt+nzQ3R41JO/jI+q2GeoV5eB8xdy7nIWbZo1rbGxldyj2HvyFLk3bjCsWxcVw9/X3SVxR/v27cnOzlaQ5v7++d139OrQ3mzfUx38yL1xg/Sz5xWlsm5r9h0gpJ2v1ZREeXk5r732Gq+//nqV560e1OQVbk17+OGHdbf0VFpeTsP69cz2OdavD4DJZKrRsZX8TW5OO0JTF2e6+LRVMfzvkpGRQcuW+lkeA7hVUopDLfPJoIP97e0zP/6kItIDtW/fHicnJ/z9/Vm9Wn/r/hnnztOqiRuvfLCSh4eEYRg0jCELEiyy/vvfSEpKwmg0MnbsWNVR/t8oLy+nqKiIL774guXLlzNmzBjdzCYARj3Vg8Nfn2Hdp59RUFTE+ctZzF630SIXOBZZerpb0S0jO48dJ6rPU7r6S6jK559/zq5du3j//fdVRzHzqFtjTlz41mzf8fMXAMi9oa/pvaurKzExMQQEBFBeXs7WrVuZPHkyRUVFREdHq45X4efcPNZ++hntPFqwfvqrFBYXM/Ovaxm8IIEjixfq6lzNyckhNjaWlStXYq/DZUZr1bhxY4xGIwDDhw8nNjZWcSJzfQM7kjQ5mrF/eZ/Ipe8CENTGi22zZtb42BYvil0Zx7l56xYvdAu29NC/y6VLlxgzZgz9+vUjLCxMdRwzY0OfZuL7K1j1j30M6hLE8XMXeHv7TgBsbfQ13e/Vqxe9evWq2O7duzdGo5HExEQmTJigm+UJE2AyQUrMTJwNDwHg9rATPWbM4rN/nqaHXzu1Ae8yf/58AgMDefrpp1VH+X9l3759FBcXk5mZSUJCAlOnTmXp0qWqY1X4/KvTTHx/BX/q348+Af5cyctj/oaPGbwggb2xc7Crwfu9Fi+KzWmHaenmRsdW+lrOudv169cZNGgQzZo1Y9WqVarjVDL6qR589d33RL+/gvHLPqBe7drEjYpg8opVuDo5qo73QAMGDCAlJYVLly7p5uknpwb18XB1rSgJgCfbtsGhVi2++fFH3RTFmTNnWLduHXv27CEvLw+Aol+fKCwoKMDOzo66deuqjGi1/Pz8AAgKCuLhhx9m3Lhx/OlPf8LT01NxstteS1rDM50CiR89smJfe08PHhv3J3YcO87zTzxeY2NbtCjyb97kH5mnmDboOUsO+7sUFRUxdOhQSkpK2LJlC/Xq1Xvw/2RhdnZ2/GV8FHMjhvPTtRw8XB/h7E+XAejs1Vpxuge7s4yjp+Uc76ZNuVVa+ealCX3N0i5evEhpaanZLO0Ob29vRo4cybJlyxQk+//lTmlcunRJN0Vx7qfLDOtqvhLj1bQJdWs78O/sn2t0bIsWxfYvjmEsLdXtslNZWRkjR47k4sWL7Nu3j0aNGqmOpMmpQQOcfn3kdPnufxDUxgvvGnxE7o+yfft2nJ2dad68ueooFfp1CmDu+o+5ll+AS0MDAIf+9Q2lZWW082ihNNvdgoKC2L17t9m+/fv3s3TpUpKTk3UzQ7N26enpALi7uytO8hv3Ro04dfHfZvvO/PgTxcYS3F0fqdGxLVoUm9MO086jRY0+7/t/8eqrr5KamkpCQgLXr18nIyOj4s/at29P7dq1Fab7TfrZcxz95gztPT0oKCrm44OHSD35JZ8vWqA6WiXh4eEEBATg4+NDeXk5KSkppKSksGjRIt3cnwB4qU9vlu38hOfmxTFj6CAKi4t5Y806evq1o4tPG9XxKjg7OxMcbH6h9cMPPwDwxBNP6Op3VYpuGdlzIhOAyznXKSwuZuvhowCEdgygXh19fD89//zzhISE4O3tjZ2dHenp6SxbtoyBAwfqZjYBEBX6NNNW/RW3h53o09GfK7l5LNi0hRaujxDa0b9Gx7ZYUVzLL+DAP08zN3y4pYb83Q4cOADA66+/XunPTp8+rZurC/tatdh86AjzNmzG1saGLj5tOJgYh28LfeS7W6tWrVi3bh2XL1/GZDLh7e3NihUrGD5cX+eBoV49UhfMZcqKJMIWLcGhVi2efbwTi6NGq45mta7m5zNs4Vtm++5sX0haTos6NXsVXF3+/v6sX7+eH374gVq1atGiRQvmzJnDmDFjVEcz86f+/XCwr8WKT/by4Z5UHOvX50kfb2JfDKf+XZ96UBNstH5Ro36dOqb8rRtrNMAfobhr5fVavaqbtl91hGrpNGs+Bw8eVB3jgazleIL1nKfd/Ttw7O1E1TEeyFqOJ1jPeWr/zMBMk8nU8d79+pn7CyGE0CUpCiGEEJqkKIQQQmiSohBCCKFJikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJikKIYQQmqQohBBCaJKiEEIIoUmKQgghhCYpCiGEEJqkKIQQQmjSfHGRydbWKj7z3Vo+6x2s5zP0bQpfs4rjai3HE6znPDU9ZLCK42otxxOs6zytiswohBBCaJKiEEIIoUmKQgghhCYpCiGEEJqkKIQQQmiSohBCCKFJikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJikKIYQQmqQohBBCaLJIUVy8eJFJkyYRFBSEo6Mjffv2tcSwv9vWw0cJnjYT1+EjafD8C/i8HE3cpi2UlJaqjlZJWVkZS5Yswc/PDxcXF7y9vZkxY4bqWJX0nDEL+2cGVvn1xZlzquOZ2bVrF0FBQbi4uODr68uyZctUR6rSxwcPEzhpKo6DR+A+8iVGLX6HrJzrqmOZ2bZtGy+88AJeXl64ubnRtWtXtmzZojrWA12+loPj4BHYPzOQG8XFquOYWb9+PQaDodJXUlJSjY+t+THjf5SzZ8+SmppKYGAgpTr8oXtHTmEhIe19mTpwAI4N6nP8/AXmbdjMz7l5/GV8lOp4ZsaNG0daWhozZsygdevW/PTTT5w7p68fvADvThhLQVGR2b656zfx5cXvCGzdUlGqytLT0wkLCyMiIoLY2FhOnDjB7NmzsbGxYeLEiarjVdh5LIPwxCWM7xdKwugXyc7NZc66DfSfu4CMtxOxtdXHIsGyZctwd3cnPj4eZ2dnUlNTGTNmDDk5OYwbN051vPua8de1NKhTh5u3bqmOcl+7du2iTp06FdseHh41PqZFiiI0NJR+/foBEBERQU5OjiWG/d3Ghj5ttt29nS8FRcV8sHsP74x7CRsbG0XJzO3bt4+UlBSOHj2Kt7e36jia2jZvZrZdUlpK5oWLDAl+klp2dopSVbZw4UIef/zxillEz549yc/PJyEhgaioKBwcHBQnvG3T54fo8Kin2YWLoV5dBs5fyLnLWbRp1lRhut9s3rwZZ2fniu1u3bqRnZ3Ne++9p9uiOPSvr9mbeYoZQwfy+uq1quPcl7+/Pw0aNLDomBa5/NDLVc5/4+GHHqKkrEx1DDMfffQRXbt21X1JVGXvyVPk3rjBsG5dVEcxc/r0aUJCQsz29ejRg7y8PDIyMhSlqqy0vJyG9euZ7XOsXx8Ak8mkIlKV7i6JO9q3b092draCNA9WXl7OpOWreHP4EJwNBtVxdMd6f4LXoPLycopuGTn89Rne27mbl0Of1s1sAuDEiRO0bNmSqVOn0qRJE1xdXQkLC9PtN+HdNqcdoamLM1182qqOYsZoNFaaNdzZ1tOS3qinenD46zOs+/QzCoqKOH85i9nrNhLSzrfS7E1vMjIyaNlSP8uNd1uxJ5WSsjIm9AtVHeWB2rdvj5OTE/7+/qxevdoiY1pk6cnaNBw8AuOv91LCe3QnIfJFtYHuceXKFTZs2MBjjz3G6tWruXHjBrNnz2bEiBEcOHBAV6V2t6JbRnYeO05Un6d0l9HT05OTJ0+a7cvMzAQgNzdXRaQq9Q3sSNLkaMb+5X0il74LQFAbL7bNmqk4mbbPP/+cXbt28f7776uOUklOQSF//mgjf5s6Cfta+v2R6OrqSkxMDAEBAZSXl7N161YmT55MUVER0dHRNTq2fo+KQmmJcRQZSzh+/gILNm3mleUrWTbhZdWxKphMJkwmExs3bqyY4jdu3JjQ0FAOHjxI9+7d1Qa8j10Zx7l56xYvdAtWHaWSyMhIJk+ezJo1axgwYACZmZkV9yv0tHT6+Venmfj+Cv7Uvx99Avy5kpfH/A0fM3hBAntj52Cno/s+d1y6dIkxY8bQr18/wsLCVMepZNba9XT2ak1oYIDqKJp69epFr16/vXu7d+/eGI1GEhMTmTBhQo2ep/r5DtAR/5aP0sWnDVOe78/SsWNY8cleLmb/rDpWBUdHR9q2bWu2DhwUFISDgwNnz55VmEzb5rTDtHRzo2Mr/S0/REREMGbMGKZMmYK7uzvh4eFMnz4duH0lpxevJa3hmU6BxI8eSbd2jzG0axeSY2Zw8PS/2HHsuOp4lVy/fp1BgwbRrFkzVq1apTpOJV9f+oE1+w/w5vAh5N24Sd6NmxQZjQDk3yyi+Nd/16sBAwaQm5vLpUuXanQcmVE8QIdHPQH4/soVHnVrrDjNbV5eXtyq4vE9k8mkq6vfu+XfvMk/Mk8xbdBzqqNUyc7OjsWLFxMTE0NWVhbu7u6cP38egMDAQMXpfnPup8sM62o+I/Nq2oS6tR34t44uZgCKiooYOnQoJSUlbNmyhXr16j34f7Kwb7OyKS0rI3ha5aW7FqOiGN27Jx++op/Ho+91Zwm3ppdypSge4OiZ21foLXR0VdmnTx/i4uLIycmpmFUcOXKE0tJSfH19Faer2vYvjmEsLdXlstPdnJyccHJyAmDVqlV07tyZ1q1bK071G/dGjTh18d9m+878+BPFxhLcXR9RlKqysrIyRo4cycWLF9m3bx+NGjVSHalKT7Ztw/64eWb79p48RWLyNnb+OQaPxvr5vq/K9u3bcXZ2pnnz5jU6jkWKoqioiNTUVACysrIoLCxk+/btwO11Nr1cafSbPY+efu1o27w5dra2HD1zlqXbdjA0+EndzCYARo0axfLlyxk6dCjTpk2jsLCQOXPmEBISQlBQkOp4Vdqcdph2Hi1085z/vTIyMkhPT8fX15fCwkKSk5P59NNP2bt3r+poZqJCn2baqr/i9rATfTr6cyU3jwWbttDC9RFCO/qrjlfh1VdfJTU1lYSEBK5fv272iHH79u2pXbu2wnS/cWlooFu7x8z2fX/1KgBdfNrQoG5dFbGqFB4eTkBAAD4+PpSXl5OSkkJKSgqLFi2q8ZUEixTFL7/8wsiRI8323dk+ffo07u7ulojxQB1btWTt/s/4/uov1LKzxaOxK7EvhvHyPb+Ip5rBYGDnzp1Mnz6d0aNH4+DgQN++fYmPj1cdrUrX8gs48M/TzA0frjrKfdnb27N161bi4+OxtbUlKCiI1NRUfHx8VEcz86f+/XCwr8WKT/by4Z5UHOvX50kfb2JfDKf+Xb+tq9qBAwcAeP311yv9mZ6+561Jq1atWLduHZcvX8ZkMuHt7c2KFSsYPrzmv69stH5Jp169eqYrV67UeIj/q7pp+1VHqLbirr0e/B/pQHf/Dhx7O1F1jAeyluMJ1nOedpo1n4MHD6qO8UDWcjzBes5Tg8GQaTKZOt67X593PoUQQuiGFIUQQghNUhRCCCE0SVEIIYTQJEUhhBBCkxSFEEIITVIUQgghNElRCCGE0CRFIYQQQpMUhRBCCE1SFEIIITRJUQghhNAkRSGEEEKTFIUQQghNUhRCCCE0ab6Pws7O1uTn6WnBOP8d00MG1RGqzaawQHWEajlzOQtvb2/VMR7IWo4nWM95eu6bb/DW6ZsI72YtxxOs5zw9+e3FKt9HofmGuzr2DvLymj+YtbxsRV5e88ezlvNUXlr1x7OW89T+mYFV7pelJyGEEJqkKIQQQmiSohBCCKFJikIIIYQmKQohhBCapCiEEEJokqIQQgihSYpCCCGEJikKIYQQmqQohBBCaJKiEEIIoUmKQgghhCYpCiGEEJosUhRbDx8leNpMXIePpMHzL+DzcjRxm7ZQUlpqieGrrW/fvhgMhiq/jh07pjpeheTDR3l+XhzuI1/CcfAIOk2axqaDh1THqlJZWRlLlizBz88PFxcXvL29mTFjhupYVfr44GECJ03FcfAI3Ee+xKjF75CVc111rEp27dpFUFAQLi4u+Pr6smzZMtWRKvnb/gPYPzOw0teKT/aqjlbJxYsXmTRpEkFBQTg6OtK3b1/Vkarl8rUcHAePwP6ZgdwoLq7RsTQ/ZvyPklNYSEh7X6YOHIBjg/ocP3+BeRs283NuHn8ZH2WJCNWyZMkSCgrMPzd+wYIFfPXVVwQEBChKVdnb23bg0diVt6JG42IwsOdEJhGJS7lWUED0s/1UxzMzbtw40tLSmDFjBq1bt+ann37i3LlzqmNVsvNYBuGJSxjfL5SE0S+SnZvLnHUb6D93ARlvJ2Jrq4/Jd3p6OmFhYURERBAbG8uJEyeYPXs2NjY2TJw4UXW8SvbFzaWOg0PFtmdjV4Vpqnb27FlSU1MJDAykVGcXr1pm/HUtDerU4eatWzU+lkWKYmzo02bb3dv5UlBUzAe79/DOuJewsbGxRIwHuvdFPSUlJZw6dYpBgwZRq5ZFDlW1bJ/9Bi4Nf3tpS0h7X7Kv5/LO9p26Kop9+/aRkpLC0aNHdf8SpE2fH6LDo55mFy6GenUZOH8h5y5n0UYnL/JZuHAhjz/+eMUsomfPnuTn55OQkEBUVBQOd/1Q1oOOrVrSoG5d1TE0hYaG0q/f7e+biIgIcnJyFCd6sEP/+pq9maeYMXQgr69eW+PjKbtMevihhygpK1M1fLXs37+fvLw8Bg8erDqKmbtL4g4/Tw/dLZN89NFHdO3aVfclAVBaXk7D+vXM9jnWrw+A1lsgLe306dOEhISY7evRowd5eXlkZGQoSmXd9DJbrK7y8nImLV/Fm8OH4GywzFv+LHqEysvLKbpl5PDXZ3hv525eDn1aN7OJqiQnJ9OkSROeeOIJ1VEeKP3sOVo1+R/VMcycOHGCli1bMnXqVJo0aYKrqythYWFkZ2erjlbJqKd6cPjrM6z79DMKioo4fzmL2es2EtLOl7bNm6mOV8FoNFaaNdzZ1uOSnlfUBOr0H4zPy9F8uEd/9yes0Yo9qZSUlTGhX6jFxrToekrDwSMw/roGGN6jOwmRL1py+N+lqKiIPXv2MHr0aF2XGcCBL7/i7+kZrJykrzXqK1eusGHDBh577DFWr17NjRs3mD17NiNGjODAgQO6Oq59AzuSNDmasX95n8il7wIQ1MaLbbNmKk5mztPTk5MnT5rty8zMBCA3N1dFpCq5OTkxN3w4ga1bUf6f//Bx2mEmvreCImMJk597VnU8q5VTUMifP9rI36ZOwt6Cy+EWLYq0xDiKjCUcP3+BBZs288rylSyb8LIlI54iXosAABjFSURBVFTbnj17uHnzpu6Wne71/ZWrRLy1lP6dA3mxVw/VccyYTCZMJhMbN27E2dkZgMaNGxMaGsrBgwfp3r272oB3+fyr00x8fwV/6t+PPgH+XMnLY/6Gjxm8IIG9sXOws7NTHRGAyMhIJk+ezJo1axgwYACZmZkV9yv0tITSO6ADvQM6VGz36eiPsbSE+I+38Er/frrKak1mrV1PZ6/WhAZa9uEai/5t+bd8lC4+bZjyfH+Wjh3Dik/2cjH7Z0tGqLatW7fi6emJv7+/6ij3db2wkGfnzKd5o0asnTZFdZxKHB0dadu2bUVJAAQFBeHg4MDZs2cVJqvstaQ1PNMpkPjRI+nW7jGGdu1CcswMDp7+FzuOHVcdr0JERARjxoxhypQpuLu7Ex4ezvTp0wFwddXfE0V3G/jkE1wvvMH3V6+qjmKVvr70A2v2H+DN4UPIu3GTvBs3KTIaAci/WUTxr/9eE5Q9ytPhUU8Avr9yhUfdGquKUaX8/Hz27dvHpEmTVEe5r6JbRgbMjaOkrIy/z3mDenVqq45UiZeXF7eqeHTPZDLp7ory3E+XGdY12GyfV9Mm1K3twL91dDFjZ2fH4sWLiYmJISsrC3d3d86fPw9AYGCg4nTabCr+qZ8lR2vybVY2pWVlBE+rvBzaYlQUo3v35MNXamb5WVlRHD1z+4qyhQ6vgnbt2oXRaGTIkCGqo1SprLycYQsT+TYrm7TEOB5xdFQdqUp9+vQhLi6OnJycilnFkSNHKC0txdfXV3E6c+6NGnHq4r/N9p358SeKjSW4uz6iKNX9OTk54eTkBMCqVavo3LkzrVu3VpxKW8qRL3AxGHB/pJHqKFbpybZt2B83z2zf3pOnSEzexs4/x+BRg7+jYpGi6Dd7Hj392tG2eXPsbG05euYsS7ftYGjwk7qbTcDtp518fX3x8vJSHaVK0e9/yJ4TJ1kydgw5hYXknP3taZcOj3pS295eYbrfjBo1iuXLlzN06FCmTZtGYWEhc+bMISQkhKCgINXxzESFPs20VX/F7WEn+nT050puHgs2baGF6yOEdtTP8mNGRgbp6en4+vpSWFhIcnIyn376KXv36uuJov9t7/6DqqrzP44/+ZmCXiQsJBUBxR/xhRRExGJTJPxVWimmITmSoCRfk5TKIh0FQTSkNnfNDPOrk2t6MVORVbEWVEISdWU3RaxMJzUT5UdCF6H7/cOVuoEHapZ7znXejxmGOR9xPi/PHHmdzznn3js5dQWBffvg6+FB488/s/XgYbYePEzmrOc1t5qsra1l3759AFy8eJGamhp27NgBQHh4OA4ODkp/3Wy6Oul41O9/TMZuX8Z7xGdAu75exSxFMdi7DxvzPuPclR+wtbHGs5srKdMjmfWbF+JpQUVFBfn5+SQlJakd5Y7yjp8A4KX3spr9WXnWu3ho5AxYp9Oxa9cuXn75ZWbMmIG9vT1jx44lLS1N7WjN/O/4cdjb2bJ2z17ey91HF0dHHvbpT8r0aTh26KB2vCZ2dnZkZ2eTlpaGtbU1wcHB7Nu3Dx8fH7Wjmejb/QE27P+UC1evYjTCgJ49+OCluUwLHa52tGZ++OEHnnvuOZOx29ulpaX06tVLjViaYqX0YiLHDh2MVdl/M2OcP6buT2FqR2izjgV5akdokyFvJJOfn692jFZZyv4EyzlOh/sP4shbK9WO0SpL2Z9gOcep3eNPlxiNxsG/HdfWGlAIIYTmSFEIIYRQJEUhhBBCkRSFEEIIRVIUQgghFElRCCGEUCRFIYQQQpEUhRBCCEVSFEIIIRRJUQghhFAkRSGEEEKRFIUQQghFUhRCCCEUSVEIIYRQpPh5FEZra4t4K19LeQtfsJy3RraqSbSI/Wop+xMs5zg1dtZZxH61lP0JlnWctkRWFEIIIRRJUQghhFAkRSGEEEKRFIUQQghFUhRCCCEUSVEIIYRQJEUhhBBCkRSFEEIIRVIUQgghFElRCCGEUCRFIYQQQpEUhRBCCEVSFEIIIRRJUQghhFBktqLQ6/WEhITg5uZGv379iI2N5dKlS+aavs3OXrxE3Oo1DIpP4J7xkxj56htqR2rVxYsXcXNzQ6fT8eOPP6odp4n+UCFPLU2l13Mz6TLpWYa8uIAt+QfVjtWiDz/8EJ1O1+wrKytL7Wgmsg8VErJgIa5Tn6PTU8/gMyue1C3bqL95U+1ozYwdO7bFfarT6Thy5Ija8Uw0NDayYtt2BsTMwfHJyXhMn8n8devVjtXM7t27CQ4OpmvXrvj6+rJ69WqzzKv4eRT/LXv27CE6OpqYmBiSk5O5fPkyKSkpREREUFBQgLW1dhY2X56/wN+PHiOoX18aGhrUjtMmSUlJODo6cuPGDbWjmHjr4514dnPlzZgZdNXpyD1aQtTKTK5WVxP/xDi147Vo9+7ddOjQoWnb09NTxTTNVdTUMOIhX+Y/PYEunRz54kw5Szdv5fL1Sv4cF6N2PBOrVq2iurraZGzZsmWcPHmSgIAAlVK1LDrzHf5xspSkqZPp36MHF65e5dT5C2rHMlFUVERkZCRRUVGkpKRw9OhRFi1ahJWVFXPmzGnXuc1SFFu3bmXgwIFkZGQ0jel0OqZMmUJ5eTn9+vUzR4w2eXzIYMYPHQLAM6kruFpdo3IiZYcPHyYvL48FCxaQlJSkdhwTOxa9RlcnXdP2iId8uXTtOm/v2KXZovD396dTp05qx7ij2DGjTLaH+/lSXVvHmpxc3p49EysrK5WSNde/f3+T7fr6eo4fP87EiROxtTXLr5422VtyjG0HD1PyzioedO+pdpw7Wr58OUOHDm1aRYwcOZKqqirS09OJiYnB3t6+3eY2y6l8Q0MDOp3OZMzJyQkAo9FojghtpqXVTWsaGxtJTEzklVdewcXFRe04zfy6JG4b6OXJxYprKqS5e93buTP1FrD6zcvLo7KykkmTJqkdxcSG/Z8yws9X0yUBUFpayogRI0zGQkNDqayspLi4uF3nNstvxWnTplFYWMjmzZuprq6mvLyc5ORkHn300WZnHaLtsrKyMBgMxMbGqh2lzYpOl+Hd/QG1Y9zRQw89hLOzM/7+/qxfr71r1Lc1NjZS+5OBQ/8+xV925TBrzChNrSZaotfr6d69O8OGDVM7ionisjN4d3dj7pp13BsRiW7iFCKWpWvuhMZgMDRbNdzeLisra9e5zbL+Gz16NGvWrCE+Pp7Zs2cDEBQUxJYtW8wx/V2poqKClJQU1q1bh52dndpx2uTTEyf5pKiYdS+27/XUP8LV1ZWkpCQCAgJobGwkOzubefPmUVtbS3x8vNrxmnGa9CyG/9zAnhY6nPTo6eoGakVtbS25ubnMmDFDc4V2+XolGw98hp+nBx++/BI1dXUs/GAjk5alczhjuWbyenl5cezYMZOxkpISAK5fv96uc5ulKAoKCkhISCAuLo7HHnuMK1eukJaWRmRkJDt37sTGxsYcMe4qycnJBAYGMmrUqNZ/WAPOfX+FqDczGR8UyPSwULXjNBMWFkZYWFjTdnh4OAaDgZUrV/LCCy9o7pJkwcpUag31fHGmnGVbtjL33XWsfmGW2rHuKDc3lxs3bmjushOAETAaYXvSQlx0nQFwu9eZ0Fff4LN/lhI60E/dgP8RHR3NvHnz2LBhAxMmTKCkpKTpfkV7H59mKYrXX3+dMWPGsHTp0qYxPz8/AgICyMnJYfz48eaIcdc4deoUmzZtIjc3l8rKSuDWGRtAdXU1NjY2dOzYUc2IJq7V1PDE4mTc77uPjQsS1I7TZhMmTGD79u18++23mnv6yb9PbwAe8RlAV11nojPfIeGpCfR266ZyspZlZ2fj5eWFv7+/2lGace7kiKera1NJADz84ADsbW358sIFzRRFVFQUpaWlJCQkMHfuXBwcHFiyZAmJiYm4urq269xmOU06c+YMfn6mO9vb25uOHTvyzTffmCPCXeWrr77i5s2bhIWF4e7ujru7O/PnzwduPWmSmJiocsJf1P5kYMKSVOobGvhk8Ws4dLhH7UhtdvuSg1YuPdzJoN5eAJz7/nuVk7SsqqqK/fv3a3I1AdC/Rw+MNH+oxghYW2lnJWljY0NGRgZff/01n3/+OWfPniUwMBCg6Xt7McuKomfPnpw4ccJkrKysjLq6Otzd3c0R4a4SHBxMTk6OyVheXh6ZmZno9XrNnP02NDYyZflKzl68RMHKVO7v0kXtSL/Ljh07cHFx0fwxWnjqNAAe7XxW+Uft3r0bg8FARESE2lFaNG5IAEs+/IirVdVNT+od/NeX3GxowM/TQ9VsLXF2dsbZ2RmA999/n6CgIPr27duuc5qlKKKjo1m4cCFubm5N9yjS09Pp1asX4eHh5ojQZrU/Gcg9eusG0XcV16ipqyP7UCEAYwYHaOKM2MXFhZCQEJOx8+fPAzBs2DDNvA4g/q/vkXv0GKtin6eipoaK0788mTGotxf3aOgm/LRp0wgICMDHx4fGxka2b9/O9u3bWbFihabuT4xbtJSRA/140N0dG2trCk+dJvPjnUwOeVizl530ej2+vr6aer3Ur80cHc7qXXt4cmkqr06eSE1dHa9t2MTIgX484jNA7XhNiouLKSoqwtfXl5qaGvR6PQcOHGDv3r3tPrdZiiIuLg57e3uysrJYv349Tk5OBAcHs3jxYhwdHc0Roc2uVFUxZfmbJmO3t8uz3sWjw/1qxLJIecdvrSJfeq/522CUZ72Lh6t29qW3tzebNm3iu+++w2g00r9/f9auXcvUqVPVjmZisHcfNuZ9xrkrP2BrY41nN1dSpkcya4w2H2qoqKggPz9fcy8G/TWdgwP7li0hYW0WkStWYW9ryxNDh5ARM0PtaCbs7OzIzs4mLS0Na2trgoOD2bdvHz4+Pu0+t5XSC94cHByM32v0uuevdSzIUztCm9X9Kaz1H9KA4f6DOPLWSrVjtMpS9idYznE65I1k8vPz1Y7RKkvZn2A5x6lOpysxGo2DfzuunTW1EEIITZKiEEIIoUiKQgghhCIpCiGEEIqkKIQQQiiSohBCCKFIikIIIYQiKQohhBCKpCiEEEIokqIQQgihSIpCCCGEIikKIYQQiqQohBBCKJKiEEIIoUiKQgghhCLFDy6y+vlni3jPd0t5r3ewnPfQN3bWWcR+tZT9CZZznFrVJFrEfrWU/QmWdZy2RFYUQgghFElRCCGEUCRFIYQQQpEUhRBCCEVSFEIIIRRJUQghhFAkRSGEEEKRFIUQQghFUhRCCCEUSVEIIYRQJEUhhBBCkRSFEEIIRVIUQgghFJmtKBoaG1mxbTsDYubg+ORkPKbPZP669eaavs12795NcHAwXbt2xdfXl9WrV6sdqZn/y/sUu8efbva1ds9etaMpunjxIm5ubuh0On788Ue145g4e/EScavXMCg+gXvGT2Lkq2+oHalFY8eORafTtfh15MgRteM1yT5USMiChbhOfY5OTz2Dz6x4Urdso/7mTbWjtUiv1xMSEoKbmxv9+vUjNjaWS5cuqR3LhP5QIU8tTaXXczPpMulZhry4gC35B80yt+LbjP83RWe+wz9OlpI0dTL9e/TgwtWrnDp/wVzTt0lRURGRkZFERUWRkpLC0aNHWbRoEVZWVsyZM0fteM3sT11CB3v7pm2vbq4qpmldUlISjo6O3LhxQ+0ozXx5/gJ/P3qMoH59aWhoUDvOHa1atYrq6mqTsWXLlnHy5EkCAgJUStVcRU0NIx7yZf7TE+jSyZEvzpSzdPNWLl+v5M9xMWrHM7Fnzx6io6OJiYkhOTmZy5cvk5KSQkREBAUFBVhba+PCy1sf78Szmytvxsygq05H7tESolZmcrW6mvgnxrXr3GYpir0lx9h28DAl76ziQfee5pjyD1m+fDlDhw5tWkWMHDmSqqoq0tPTiYmJwf5Xv5S1YLB3Hzp17Kh2jDY5fPgweXl5LFiwgKSkJLXjNPP4kMGMHzoEgGdSV3C1ukblRC3r37+/yXZ9fT3Hjx9n4sSJ2Nqa7byvVbFjRplsD/fzpbq2jjU5ubw9eyZWVlYqJWtu69atDBw4kIyMjKYxnU7HlClTKC8vp1+/fiqm+8WORa/R1UnXtD3iIV8uXbvO2zt2tXtRmKUqN+z/lBF+vpouCYDS0lJGjBhhMhYaGkplZSXFxcUqpbJ8jY2NJCYm8sorr+Di4qJ2nBZp5azx98rLy6OyspJJkyapHaVV93buTL0GV2sNDQ3odDqTMScnJwCMRqMakVr065K4baCXJxcrrrX73Gb531Fcdgbv7m7MXbOOeyMi0U2cQsSydLP8A38Pg8HQbNVwe7usrEyNSIr6xbxAh/GT8JkVz3u52r0/kZWVhcFgIDY2Vu0odx29Xk/37t0ZNmyY2lFa1NjYSO1PBg79+xR/2ZXDrDGjNLWaAJg2bRqFhYVs3ryZ6upqysvLSU5O5tFHH222gtOaotNleHd/oN3nMcta9fL1SjYe+Aw/Tw8+fPklaurqWPjBRiYtS+dwxnLNHDheXl4cO3bMZKykpASA69evqxGpRW7OziyZNpXAvt40/vwzHxUcYs5f1lJrqGfek0+oHc9ERUUFKSkprFu3Djs7O7Xj3FVqa2vJzc1lxowZmvk/9FtOk57F8J8b2NNCh5MePV3dQC0YPXo0a9asIT4+ntmzZwMQFBTEli1bVE6m7NMTJ/mkqJh1L7b//VOzFIURMBphe9JCXHSdAXC715nQV9/gs3+WEjrQzxwxWhUdHc28efPYsGEDEyZMoKSkpOl+hZYuTYQHDCI8YFDT9ujB/hhu1pP20Tbmjh+nqazJyckEBgYyatSo1n9Y/C65ubncuHFD05edClamUmuo54sz5SzbspW5765j9Quz1I5loqCggISEBOLi4njssce4cuUKaWlpREZGsnPnTmxsbNSO2My5768Q9WYm44MCmR4W2u7zmaUonDs54unq2lQSAA8/OAB7W1u+vHBBM0URFRVFaWkpCQkJzJ07FwcHB5YsWUJiYiKurtp+oujph4ex7WAh565cwatbN7XjAHDq1Ck2bdpEbm4ulZWVwK2zYIDq6mpsbGzoaCE347UoOzsbLy8v/P391Y5yR/59egPwiM8Auuo6E535DglPTaC3mzaOUYDXX3+dMWPGsHTp0qYxPz8/AgICyMnJYfz48Sqma+5aTQ1PLE7G/b772LggwSxzmuXUs3+PHhhpflPICFhbaefs18bGhoyMDL7++ms+//xzzp49S2BgIEDTd62yavqunUsQX331FTdv3iQsLAx3d3fc3d2ZP38+cOvpncTERJUTWq6qqir279+v6dXEbw3q7QXAue+/VzmJqTNnzuDnZ3qy6u3tTceOHfnmm29UStWy2p8MTFiSSn1DA58sfg2HDveYZV6zrCjGDQlgyYcfcbWquunO/cF/fcnNhgb8PD3MEeF3cXZ2xtnZGYD333+foKAg+vbtq3IqZdsPf05XnY5e99+ndpQmwcHB5OTkmIzl5eWRmZmJXq/H09NTpWSWb/fu3RgMBiIiItSO0maFp04D4KGx1XnPnj05ceKEyVhZWRl1dXW4u7urlKq5hsZGpixfydmLlyhYmcr9XbqYbW6zFMXM0eGs3rWHJ5em8urkidTU1fHahk2MHOjHIz4DzBGhTYqLiykqKsLX15eamhr0ej0HDhxg715tPVE0OXUFgX374OvhQePPP7P14GG2HjxM5qznNXV/wsXFhZCQEJOx8+fPAzBs2DA6deqkRqwW1f5kIPforQcXvqu4Rk1dHdmHCgEYMzjAbGdubaXX6/H19dXMM/6/NW7RUkYO9ONBd3dsrK0pPHWazI93MjnkYU1ddoJb9yYXLlyIm5tb0z2K9PR0evXqRXh4uNrxmsT/9T1yjx5jVezzVNTUUHH6lycxB/X24p52fFjELEWhc3Bg37IlJKzNInLFKuxtbXli6BAyYmaYY/o2s7OzIzs7m7S0NKytrQkODmbfvn34+PioHc1E3+4PsGH/p1y4ehWjEQb07MEHL81lWuhwtaNZrCtVVUxZ/qbJ2O3t8qx38ehwvxqxWlRRUUF+fr4mX7h422DvPmzM+4xzV37A1sYaz26upEyPZNYY7T3UEBcXh729PVlZWaxfvx4nJyeCg4NZvHgxjo6Oasdrknf81qrnpfeymv1Zeda7eLi23zFqpfSCEscOHYxV2X9rt8n/W+r+FKZ2hDbrWJCndoQ2GfJGMvn5+WrHaJWl7E+wnON0uP8gjry1Uu0YrbKU/QmWc5zaPf50idFoHPzbce1cpxBCCKFJUhRCCCEUSVEIIYRQJEUhhBBCkRSFEEIIRVIUQgghFElRCCGEUCRFIYQQQpEUhRBCCEVSFEIIIRRJUQghhFAkRSGEEEKRFIUQQghFUhRCCCEUSVEIIYRQpPh5FFZWVj8A35ovjhBCCBX1MhqNzT5PWbEohBBCCLn0JIQQQpEUhRBCCEVSFEIIIRRJUQghhFAkRSGEEELR/wNJB1JEkGID+AAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Solution found in 4 iterations\n",
      "time taken to solve is 0.022329 seconds\n",
      "\n",
      "Harder problem\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Solution not found after 2 iterations\n",
      "time taken is 0.022656 seconds\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.022655963897705078, False)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "easy1 = '..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3..'\n",
    "harder1 = '4173698.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......'\n",
    "e = Sudoku(easy1)\n",
    "e.display(e.infer_assignment())\n",
    "\n",
    "implementAC1(e,pr=True)\n",
    "\n",
    "print('\\nHarder problem\\n')\n",
    "e = Sudoku(harder1)\n",
    "e.display(e.infer_assignment())\n",
    "\n",
    "implementAC1(e,pr=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## AC-3 <a name=\"ac3\"></a>\n",
    "\n",
    "### Definition <a name=\"ac3_definition\"></a>\n",
    "In AC-1, the domain of a variable is changed by deleting the values in the variable’s domain that are arc inconsistent with another variable. We notice that every time the domain of the variable shrinks, some equivalent values in other variables can now potentially become inconsistent. AC-1 doesn’t take advantage of this and hence it must be run iteratively until the domain of all the variables don’t change. AC-3, on the contrary, tries to take advantage of this fact by using a queue that has information about the next arcs to be checked based on the modifications made in the current iteration. This leads to a much faster constraint propagation. The algorithm is described below\n",
    "\n",
    "<img src=\"images/Algorithm_3.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complexity analysis of AC-3 <a name=\"ac3_complexity\"></a>\n",
    "\n",
    "Using the same notation as above, we can see that the size of the queue is $2*e$. Now for every element in the queue we apply the revise procedure which involves $k^{2}$ operations. Also in the worst case, everytime we perform a revise we might have to add k more values back to the queue. Therefore, in the worst case, we might have to perform $2*e*k^{2}*k$ steps in total. Therefore the worst case time complexity of AC-3 algorithm is $\\mathcal{O}(ek^{3})$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: solving Sudoku with AC-3 <a name=\"ac3_example\"></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "time taken to solve is 0.028530 seconds\n",
      "\n",
      "Harder problem\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Solution not found\n",
      "time taken is 0.035846 seconds\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.03584599494934082, False)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "easy1 = '..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3..'\n",
    "harder1 = '4173698.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......'\n",
    "e = Sudoku(easy1)\n",
    "e.display(e.infer_assignment())\n",
    "\n",
    "implementAC3(e,pr=True)\n",
    "\n",
    "print('\\nHarder problem\\n')\n",
    "e = Sudoku(harder1)\n",
    "e.display(e.infer_assignment())\n",
    "\n",
    "implementAC3(e,pr=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's compare the average time complexity of AC-1 and AC-3\n",
    "\n",
    "We have a file named easy50.txt which contains some 50 easy sudoku problems not all of which can be completely solved by constraint propagation. Let's measure the average time taken by both AC-1 and AC-3 on those problems that can be completely solved.\n",
    "\n",
    "It can be seen from the previous two code blocks that AC-1 performs faster than AC-3 but we also proved that AC-3 has better worst case time complexity than AC-1. To understand this, observe that the average time taken by AC-3 is higher but the worst case time is better for AC-3. We repeat the experiment 10 times to smooth the variability in the worst case time from one run to another. The following snippet takes about 20 seconds to run. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120 problems out of 500 were solved\n",
      "\n",
      "The average time taken by AC-1 algorithm is 0.023781 seconds\n",
      "The average time taken by AC-3 algorithm is 0.029730 seconds\n",
      "\n",
      "The worst case performance for AC-1 algorithm was 0.046707 seconds\n",
      "The worst case performance for AC-3 algorithm was 0.041716 seconds\n"
     ]
    }
   ],
   "source": [
    "fname = './sudoku_files/easy50.txt'\n",
    "problems = text2problem(fname)\n",
    "length = len(problems)*10\n",
    "t_1 = 0\n",
    "t_2 = 0\n",
    "in_1 = 0\n",
    "in_2 = 0\n",
    "max1 = 0\n",
    "max2 = 0\n",
    "for repeat in range(10):\n",
    "    for i in problems:\n",
    "        t1, done1 = implementAC1(Sudoku(i),pr=False)\n",
    "        t2, done2 = implementAC3(Sudoku(i),pr=False)\n",
    "        if done1 == True:\n",
    "            if max1 < t1:\n",
    "                max1 = t1\n",
    "            t_1 += t1\n",
    "            in_1 += 1\n",
    "        if done2 == True:\n",
    "            if max2 < t2:\n",
    "                max2 = t2\n",
    "            t_2 += t2\n",
    "            in_2 += 1\n",
    "        \n",
    "print('%d problems out of %d were solved'%(in_1,length))\n",
    "print()\n",
    "print('The average time taken by AC-1 algorithm is %f seconds' %(t_1/in_1))\n",
    "print('The average time taken by AC-3 algorithm is %f seconds' %(t_2/in_2))\n",
    "print()\n",
    "print('The worst case performance for AC-1 algorithm was %f seconds' %max1)\n",
    "print('The worst case performance for AC-3 algorithm was %f seconds' %max2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <a name=\"search_in_csps\"></a>2. Search in CSPs\n",
    "\n",
    "Constraint propagation alone is not sufficient to solve many CSPs. In this case, a solution must be found using **search algorithms**.\n",
    "\n",
    "In this section, we will explain different search algorithms used to solve CSPs.\n",
    "The section is organized as follows:\n",
    "\n",
    "a. [Generic Search](#generic_search):\n",
    "    * Formulating CSPs as a state space search problem\n",
    "    * Complexity\n",
    "    * Example: NQueens with generic search (5 Queens)\n",
    "b. [Backtracking Search (BT)](#backtracking):\n",
    "    * Definition\n",
    "    * Complexity\n",
    "    * Example: solving NQueens (15 Queens)\n",
    "c. [Backtracking Search with Forward Checking (BT-FC)](#backtracking_w_fc):\n",
    "    * Definition\n",
    "    * Complexity\n",
    "    * Example: solving NQueens (30 Queens)              \n",
    "d. [**Backtracking while Maintaining Arc Consistency (BT-MAC)**](#backtracking_w_mac):\n",
    "    * Definition\n",
    "    * Complexity\n",
    "    * Example: solving NQueens (30 Queens)\n",
    "    \n",
    "e. [Backtracking with Dynamic Variable Ordering](#bt_dvo):\n",
    "    * [Definition](#bt_dvo_definition)\n",
    "    * [Complexity](#bt_dvo_complexity)\n",
    "    * [Example: solving NQueens (40 Queens)](#bt_dvo_example)\n",
    "    * [Example: solving hard Sudokus](#bt_dvo_example_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"generic_search\"></a> a. Generic Search\n",
    "\n",
    "#### Formulating CSPs as a state space search problem <a name=\"generic_search_definition\"></a> \n",
    "\n",
    "CSPs can be formulated using the State Space search representation.\n",
    "In particular, we can express a CSP as follows:\n",
    "* **State**:\n",
    "    - We can define as state a **partial assignment** to variables made thus far.\n",
    "    For example, if we have variables $A$, $B$ and $C$ whith respective domains $[a_1, a_2]$, $[b_1, b_2]$, and  $[c_1, c_2]$ a partial assignment would be for example $\\{A=a_2, C=c_1\\}$, another one could be $\\{B=b_2, C=c_2\\}$. In contrast, we consider a **complete assignment** one where all variables would be assigned, such as $\\{A=a_2, B=b_1, C=c_1\\}$. Note that a complete assignment is still a (kind-of) partial assignment.\n",
    "* **Initial State**:\n",
    "    - Initially the state would be **no assignment**, which we can represent as the empty set $\\{\\}$.\n",
    "* **Operator/Action**:\n",
    "    - We also need to define an action/operator to frame a CSP into a State Space search problem.\n",
    "    In our case, this would correspond to the fact of **adding a new assignment**.\n",
    "    In other words, our operator corresponds to the action of assigning a value to a yet unassigned variable $X=x$, which expands the State by one element. For example, if we start from the initial state $\\{\\}$, and we proceed with the action $X=x,$ we end up with a new state $\\{X=x\\}$, which is itself a partial assignment.\n",
    "* **Goal Test**:\n",
    "    - As in all State Space search problems, we need to define what is our goal state.\n",
    "    In our case, this is achieved when all variables are assigned (meaning we have a **complete assignment**) and all constraints are satisfied (which we refer to as a **consistent assignment**).\n",
    "\n",
    "Once the problem is formulated as a State Space search problem, we can use standard search algorithms such as:\n",
    "* Breadth first search\n",
    "* Depth first search\n",
    "* Depth-limited search\n",
    "\n",
    "to solve the given problem.\n",
    "\n",
    "#### Complexity <a name=\"generic_search_complexity\"></a>\n",
    "\n",
    "Unfortunately, given a CSP with $n$ variables with a domain size of $d$, results in a branching factor at the top level of $nd$.\n",
    "This is because any of the $n$ variables can be assigned any of $d$ values.\n",
    "Once a variable has been assigned a value, we are still left with $n − 1$ variables which can be assigned $d$ values. By induction, we end up with a tree having $n!d^n ∼ \\mathcal{O}((nd)^n)$ leaves, which is even larger than the possible $d^n$ complete assignments!\n",
    "\n",
    "Nevertheless, we can observe than in a CSP **the order when assigning variables does not influence the solution**. This property is known as **commutativity**. More specifically, a problem is commutative if the order of application of any given set of actions does no effect on the outcome. Therefore, there is no need to consider all variables at each level of the search tree, but just one at a time. \n",
    "\n",
    "This makes sense intuitvely, for example, if we consider the coloring map problem, we might decide whether to color a certain region red or blue, but we would not decide between coloring one region red or another region blue. Therefore, the number of leaves is reduced to $d^n$, where we just have to decide on an assignment for each variable at a time.\n",
    "\n",
    "#### Example: NQueens with generic search (5 Queens) <a name=\"generic_search_example\"></a>\n",
    "\n",
    "The N-queens puzzle is the problem of placing N chess queens on an N×N chessboard in a way such that no two queens threaten each other. Here N is a natural number. \n",
    "\n",
    "Thus, no two queens can share a common row, column, or diagonal. We will use the following representation in this problem.\n",
    "- Each variable specifies the row on which a particular queen is placed. Each queen is identified (indexed) with a column of the board. This automatically ensures that the queens will not share columns.\n",
    "- The variable domains are the available row indices.\n",
    "- The constraints between the variables specify that the corresponding queens do not share a row or diagonal.\n",
    "\n",
    "Using the State Space search formulation, we express the NQueens Problem as follows:\n",
    "* **State**:\n",
    "    - We can define as state a **partial assignment** of Queens (variables) made thus far.\n",
    "* **Initial State**:\n",
    "    - Initially the state would be **no assignment**, which, in our case, we represent as a value of -1 for all variables.\n",
    "* **Operator/Action**:\n",
    "    - Our action consists in **adding a new Queen** to the board."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01//EN\"\n",
       "   \"http://www.w3.org/TR/html4/strict.dtd\">\n",
       "\n",
       "<html>\n",
       "<head>\n",
       "  <title></title>\n",
       "  <meta http-equiv=\"content-type\" content=\"text/html; charset=None\">\n",
       "  <style type=\"text/css\">\n",
       "td.linenos { background-color: #f0f0f0; padding-right: 10px; }\n",
       "span.lineno { background-color: #f0f0f0; padding: 0 5px 0 5px; }\n",
       "pre { line-height: 125%; }\n",
       "body .hll { background-color: #ffffcc }\n",
       "body  { background: #f8f8f8; }\n",
       "body .c { color: #408080; font-style: italic } /* Comment */\n",
       "body .err { border: 1px solid #FF0000 } /* Error */\n",
       "body .k { color: #008000; font-weight: bold } /* Keyword */\n",
       "body .o { color: #666666 } /* Operator */\n",
       "body .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n",
       "body .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n",
       "body .cp { color: #BC7A00 } /* Comment.Preproc */\n",
       "body .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n",
       "body .c1 { color: #408080; font-style: italic } /* Comment.Single */\n",
       "body .cs { color: #408080; font-style: italic } /* Comment.Special */\n",
       "body .gd { color: #A00000 } /* Generic.Deleted */\n",
       "body .ge { font-style: italic } /* Generic.Emph */\n",
       "body .gr { color: #FF0000 } /* Generic.Error */\n",
       "body .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
       "body .gi { color: #00A000 } /* Generic.Inserted */\n",
       "body .go { color: #888888 } /* Generic.Output */\n",
       "body .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
       "body .gs { font-weight: bold } /* Generic.Strong */\n",
       "body .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
       "body .gt { color: #0044DD } /* Generic.Traceback */\n",
       "body .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
       "body .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
       "body .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
       "body .kp { color: #008000 } /* Keyword.Pseudo */\n",
       "body .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
       "body .kt { color: #B00040 } /* Keyword.Type */\n",
       "body .m { color: #666666 } /* Literal.Number */\n",
       "body .s { color: #BA2121 } /* Literal.String */\n",
       "body .na { color: #7D9029 } /* Name.Attribute */\n",
       "body .nb { color: #008000 } /* Name.Builtin */\n",
       "body .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
       "body .no { color: #880000 } /* Name.Constant */\n",
       "body .nd { color: #AA22FF } /* Name.Decorator */\n",
       "body .ni { color: #999999; font-weight: bold } /* Name.Entity */\n",
       "body .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n",
       "body .nf { color: #0000FF } /* Name.Function */\n",
       "body .nl { color: #A0A000 } /* Name.Label */\n",
       "body .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
       "body .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
       "body .nv { color: #19177C } /* Name.Variable */\n",
       "body .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
       "body .w { color: #bbbbbb } /* Text.Whitespace */\n",
       "body .mb { color: #666666 } /* Literal.Number.Bin */\n",
       "body .mf { color: #666666 } /* Literal.Number.Float */\n",
       "body .mh { color: #666666 } /* Literal.Number.Hex */\n",
       "body .mi { color: #666666 } /* Literal.Number.Integer */\n",
       "body .mo { color: #666666 } /* Literal.Number.Oct */\n",
       "body .sa { color: #BA2121 } /* Literal.String.Affix */\n",
       "body .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
       "body .sc { color: #BA2121 } /* Literal.String.Char */\n",
       "body .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
       "body .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
       "body .s2 { color: #BA2121 } /* Literal.String.Double */\n",
       "body .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n",
       "body .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
       "body .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n",
       "body .sx { color: #008000 } /* Literal.String.Other */\n",
       "body .sr { color: #BB6688 } /* Literal.String.Regex */\n",
       "body .s1 { color: #BA2121 } /* Literal.String.Single */\n",
       "body .ss { color: #19177C } /* Literal.String.Symbol */\n",
       "body .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
       "body .fm { color: #0000FF } /* Name.Function.Magic */\n",
       "body .vc { color: #19177C } /* Name.Variable.Class */\n",
       "body .vg { color: #19177C } /* Name.Variable.Global */\n",
       "body .vi { color: #19177C } /* Name.Variable.Instance */\n",
       "body .vm { color: #19177C } /* Name.Variable.Magic */\n",
       "body .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
       "\n",
       "  </style>\n",
       "</head>\n",
       "<body>\n",
       "<h2></h2>\n",
       "\n",
       "<div class=\"highlight\"><pre><span></span>    <span class=\"k\">def</span> <span class=\"nf\">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> <span class=\"k\">if</span> <span class=\"ow\">not</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">pruning</span> <span class=\"ow\">or</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",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NQueensProblem.actions)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Goal Test**:\n",
    "    - This state is achieved when all variables are assigned (meaning we have a **complete assignment**) and all constraints are satisfied.\n",
    "\n",
    "Below you can actually see the NQueens Problem coded as a State Search Problem:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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\">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",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NQueensProblem.goal_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us apply a generic search algorithm to the NQueens problem.\n",
    "For example, let us use Depth First Search to find a solution.\n",
    "Note that we are already applying the commutativity property of CSPs that we discussed previously.\n",
    "Therefore, we are avoiding $n!$ redundant paths, thereby making the depth first search faster.\n",
    "\n",
    "Feel free to change the number of queens used, but be aware that depth first search will start struggling with numbers larger than 7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken to solve 5 Queens problem using Backtracking: 0.003018 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 5\n",
    "\n",
    "n_queens_problem = NQueensProblem(N, pruning=False)\n",
    "\n",
    "start_time = time.time()\n",
    "solution = depth_first_tree_search(n_queens_problem).solution()\n",
    "end_time = time.time()\n",
    "print(\"Time taken to solve %s Queens problem using Backtracking: %f seconds\"% (N, end_time - start_time))\n",
    "\n",
    "plot_NQueens(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the previous call to depth first search retrieved an answer in less than 5ms.\n",
    "Check out what happens when N is higher!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken to solve 7 Queens problem using Backtracking: 0.331491 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 7\n",
    "\n",
    "n_queens_problem = NQueensProblem(N, pruning=False)\n",
    "\n",
    "start_time = time.time()\n",
    "solution = depth_first_tree_search(n_queens_problem).solution()\n",
    "end_time = time.time()\n",
    "print(\"Time taken to solve %s Queens problem using Backtracking: %f seconds\"% (N, end_time - start_time))\n",
    "\n",
    "plot_NQueens(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is starting to take some time to solve the problem. The reader can convince itself that with 8 or more Queens, it will take a long time to retrieve the solution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"backtracking\"></a> b. Backtracking\n",
    "\n",
    "#### Definition <a name=\"backtracking_definition\"></a> \n",
    "\n",
    "Backtracking search suits the commutative property of CSPs, as it consists on a depth-first search that chooses one variable at a time. \n",
    "\n",
    "Moreover, it makes use of another property of CSPs that is: **extensions to inconsistent partial assignments are always inconsistent**.\n",
    "The backtracking search **backtracks** when an inconsistent partial assignment is reached. \n",
    "\n",
    "We show below the actual backtracking search algorithm (pseudo-code), as presented in Chapter 6 Constraint Satisfaction Problems of the book _Artificial Intelligence: A Modern Approach_. \n",
    "\n",
    "<a name=\"backtracking_algorithm\"></a>\n",
    "<img src=\"images/backtracking_algorithm.png\" alt=\"drawing\" width=\"600\">\n",
    "\n",
    "In plain words, the algorithm first chooses an unassigned variable, and loops over its domain by picking one value at\n",
    "a time. Every time a value is taken, if it is consistent, then the algorithm continues to look for a\n",
    "solution. If it is not consistent, then the algorithm backtracks by trying with another value instead.\n",
    "\n",
    "The backtracking algorithm presented above makes use of a set of sub-functions that we detail\n",
    "below:\n",
    "* **Select-Unassigned-Variable(csp, assignment)**:\n",
    "    - Decides which variable should be assigned next.\n",
    "* **Order-Domain-Values(var, assignment, csp)**:\n",
    "    - Decides the order in which the values of the variable should be tried. We will see in section 2.3.4 how modifications of this and the previous function result in different general purpose heuristics.\n",
    "* **Inference(csp, var, assignment)**:\n",
    "    - Every time a variable has been assigned a value, there is the opportunity to further reduce the domains of the rest of unassigned variables using inference, such as checking for arcconsistency. While the call to this function is not strictly necessary, we will see in section 2.3.3 that interleaving search and inference results in a more efficient algorithm.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    \n",
    "The source code to implement this pseudo-code is actually fairly close to the actual implementation.\n",
    "Find below the actual source code in python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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\">backtracking_search</span><span class=\"p\">(</span><span class=\"n\">csp</span><span class=\"p\">,</span> <span class=\"n\">select_unassigned_variable</span> <span class=\"o\">=</span> <span class=\"n\">first_unassigned_variable</span><span class=\"p\">,</span>\n",
       "                        <span class=\"n\">order_domain_values</span> <span class=\"o\">=</span> <span class=\"n\">unordered_domain_values</span><span class=\"p\">,</span>\n",
       "                        <span class=\"n\">inference</span> <span class=\"o\">=</span> <span class=\"n\">no_inference</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot; Backtracking search as detailed in Fig. 6.5 of AIMA book. &quot;&quot;&quot;</span>\n",
       "    \n",
       "    <span class=\"k\">def</span> <span class=\"nf\">backtrack</span><span class=\"p\">(</span><span class=\"n\">assignment</span><span class=\"p\">,</span> <span class=\"n\">csp</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Search for a consistent assignment for the csp.</span>\n",
       "<span class=\"sd\">        Each recursive call chooses a variable, and considers values for it.&quot;&quot;&quot;</span>\n",
       "        <span class=\"c1\"># If assignment is complete then return assignment.</span>\n",
       "        <span class=\"k\">if</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">assignment</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">variables</span><span class=\"p\">):</span>\n",
       "            <span class=\"k\">return</span> <span class=\"n\">assignment</span>\n",
       "        <span class=\"c1\"># Select an unassigned variable.</span>\n",
       "        <span class=\"n\">var</span> <span class=\"o\">=</span> <span class=\"n\">select_unassigned_variable</span><span class=\"p\">(</span><span class=\"n\">assignment</span><span class=\"p\">,</span> <span class=\"n\">csp</span><span class=\"p\">)</span>\n",
       "        <span class=\"c1\"># Loop over the domain of the current variable.</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">val</span> <span class=\"ow\">in</span> <span class=\"n\">order_domain_values</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">,</span> <span class=\"n\">csp</span><span class=\"p\">):</span>\n",
       "            <span class=\"c1\"># If value is consistent with assignment, continue.</span>\n",
       "            <span class=\"k\">if</span> <span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">is_consistent</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">):</span>\n",
       "                <span class=\"c1\"># Assign the value to the variable.</span>\n",
       "                <span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">assign</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">)</span>\n",
       "                <span class=\"c1\"># If we do not use forward checking, we are good!</span>\n",
       "                <span class=\"c1\"># If we do forward checking, prune domains, and continue only if no domain is empty.</span>\n",
       "                <span class=\"n\">removals</span> <span class=\"o\">=</span> <span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">suppose</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">)</span>\n",
       "                <span class=\"n\">infer</span> <span class=\"o\">=</span> <span class=\"n\">inference</span><span class=\"p\">(</span><span class=\"n\">csp</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">,</span> <span class=\"n\">removals</span><span class=\"p\">)</span>\n",
       "                <span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">track_pruned_domain_for_display</span><span class=\"p\">()</span>\n",
       "                <span class=\"k\">if</span> <span class=\"n\">infer</span><span class=\"p\">:</span>\n",
       "                    <span class=\"c1\"># Calculate next result (recursive call).</span>\n",
       "                    <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">backtrack</span><span class=\"p\">(</span><span class=\"n\">assignment</span><span class=\"p\">,</span> <span class=\"n\">csp</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>\n",
       "                <span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">restore</span><span class=\"p\">(</span><span class=\"n\">removals</span><span class=\"p\">)</span>\n",
       "                <span class=\"c1\"># If we have a conflict, unassign.</span>\n",
       "                <span class=\"c1\"># If we use forward checking, restore domains pruned by this assignment var=val.</span>\n",
       "                <span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">unassign</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">)</span> <span class=\"c1\"># could be done outside the for loop...</span>\n",
       "        <span class=\"k\">return</span> <span class=\"bp\">None</span>\n",
       "    \n",
       "    <span class=\"c1\"># Start backtracking</span>\n",
       "    <span class=\"n\">result</span> <span class=\"o\">=</span> <span class=\"n\">backtrack</span><span class=\"p\">({},</span> <span class=\"n\">csp</span><span class=\"p\">)</span>\n",
       "    <span class=\"k\">assert</span> <span class=\"n\">result</span> <span class=\"ow\">is</span> <span class=\"bp\">None</span> <span class=\"ow\">or</span> <span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">goal_test</span><span class=\"p\">(</span><span class=\"n\">result</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(backtracking_search)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a name=\"backtrack_pseudo\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: solving NQueens using simple backtracking algorithm <a name=\"backtracking_example\"></a> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can encode the NQueens problem as follows, for a N×N board:\n",
    "* **Variables**:\n",
    "    * Each of the Queen's positions on the board: $X_i = \\text{row of queen in column i}$\n",
    "* **Domains**:\n",
    "    * The domain of each variable is just the number of rows on the board: $X_i \\in \\mathcal{X} = \\{0, ..., N-1\\}$\n",
    "* **Constraints**:\n",
    "    * Queens do not share rows. This is equivalent to requiring all variables $X_i$ to be of different value: $AllDiff(X_i)$\n",
    "    * Only one queen in a column. This is satisfied by default because of the variable encoding.\n",
    "    * No two queens can share a common diagonal. This can be encoded as follows:\n",
    "         - Assume we have a variable $X_i$, or, in other words, a queen in the row given by the value of $X_i$ and column given by the index $i$.\n",
    "         Then, no queen can be represented by $X_k$ if the following condition holds: $X_k = X_i - (k - i)$.\n",
    "         This is only for diagonals going _down_ from left to right.\n",
    "         What about the other diagonal? The one going _up_ from left to right can be similarly encoded changing just one sign: $X_k = X_i + (k - i)$. Since we need to check this constraint for all the queens on the board, we have:\n",
    "             ```pseudo\n",
    "                for all X_i:\n",
    "                    for 0:k, k != i, k < N:\n",
    "                       X_k != X_i - (k - i)\n",
    "                       X_k != X_i + (k - i)\n",
    "            ```\n",
    "\n",
    "            But this is actually equivalent to check that the value of $X_k - k$ is different for all $k$ (same for  $X_k + k$)! Therefore, we can use the $AllDiff(\\cdot)$ function to encode this constraint as well.\n",
    "        \n",
    " Below you can find the actual NQueens problem formulated as explained here.\n",
    " Note that we define the variables and domains.\n",
    " Also, the constraints are encoded in the method `is_consistent` below.\n",
    "This method checks that an assignment is consistent given the constraints, as required by the function `csp.is_consistent(var, val, assignment)` in the [backtrack code](#backtrack_pseudo)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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\">NQueensCSP</span><span class=\"p\">(</span><span class=\"n\">CSP</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;Make a CSP for the nQueens problem for search with backtracking &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=\"sd\">&quot;&quot;&quot;Initialize data structures for n Queens.&quot;&quot;&quot;</span>\n",
       "        <span class=\"c1\"># Indices of variables in the problem.</span>\n",
       "        <span class=\"n\">variables</span> <span class=\"o\">=</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"p\">))</span>\n",
       "        <span class=\"c1\"># Initial domains of the variables.</span>\n",
       "        <span class=\"n\">domains</span> <span class=\"o\">=</span> <span class=\"p\">{</span><span class=\"n\">var</span><span class=\"p\">:</span><span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"p\">))</span> <span class=\"k\">for</span> <span class=\"n\">var</span> <span class=\"ow\">in</span> <span class=\"n\">variables</span><span class=\"p\">}</span>\n",
       "        <span class=\"c1\"># What are the neighbors of a given var, can include itself.</span>\n",
       "        <span class=\"n\">neighbors</span> <span class=\"o\">=</span> <span class=\"p\">{</span><span class=\"n\">var</span><span class=\"p\">:</span><span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"n\">n</span><span class=\"p\">))</span> <span class=\"k\">for</span> <span class=\"n\">var</span> <span class=\"ow\">in</span> <span class=\"n\">variables</span><span class=\"p\">}</span>\n",
       "        \n",
       "        <span class=\"n\">CSP</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\">variables</span><span class=\"p\">,</span> <span class=\"n\">domains</span><span class=\"p\">,</span> <span class=\"n\">neighbors</span><span class=\"p\">,</span> <span class=\"n\">queen_constraint</span><span class=\"p\">)</span>\n",
       "    \n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">is_consistent</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot; Check if the attempted var = val assignment is consistent with current assignment &quot;&quot;&quot;</span>\n",
       "        <span class=\"c1\"># Add var = val in the list of assignments as a first attempt.</span>\n",
       "        <span class=\"c1\"># Slow because we are copying, but perfect for pedagogical purposes.</span>\n",
       "        <span class=\"n\">attempt_assignment</span> <span class=\"o\">=</span> <span class=\"n\">copy</span><span class=\"o\">.</span><span class=\"n\">deepcopy</span><span class=\"p\">(</span><span class=\"n\">assignment</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">var</span> <span class=\"o\">!=</span> <span class=\"bp\">None</span> <span class=\"ow\">and</span> <span class=\"n\">val</span> <span class=\"o\">!=</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">attempt_assignment</span><span class=\"o\">.</span><span class=\"n\">update</span><span class=\"p\">({</span><span class=\"n\">var</span><span class=\"p\">:</span> <span class=\"n\">val</span><span class=\"p\">})</span>\n",
       "        <span class=\"c1\"># Check for same column constraint is implicit in formulation.</span>\n",
       "        <span class=\"c1\"># Check for same row constraint:</span>\n",
       "        <span class=\"n\">c_row</span> <span class=\"o\">=</span> <span class=\"n\">all_different</span><span class=\"p\">(</span><span class=\"n\">attempt_assignment</span><span class=\"o\">.</span><span class=\"n\">values</span><span class=\"p\">())</span>\n",
       "        <span class=\"c1\"># Check for same diagonal constraint:</span>\n",
       "        <span class=\"n\">diag_1</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">key</span> <span class=\"o\">+</span> <span class=\"n\">value</span> <span class=\"k\">for</span> <span class=\"n\">key</span><span class=\"p\">,</span> <span class=\"n\">value</span> <span class=\"ow\">in</span> <span class=\"n\">attempt_assignment</span><span class=\"o\">.</span><span class=\"n\">items</span><span class=\"p\">()]</span>\n",
       "        <span class=\"n\">diag_2</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">key</span> <span class=\"o\">-</span> <span class=\"n\">value</span> <span class=\"k\">for</span> <span class=\"n\">key</span><span class=\"p\">,</span> <span class=\"n\">value</span> <span class=\"ow\">in</span> <span class=\"n\">attempt_assignment</span><span class=\"o\">.</span><span class=\"n\">items</span><span class=\"p\">()]</span>\n",
       "        <span class=\"n\">c_diag_1</span> <span class=\"o\">=</span> <span class=\"n\">all_different</span><span class=\"p\">(</span><span class=\"n\">diag_1</span><span class=\"p\">)</span>\n",
       "        <span class=\"n\">c_diag_2</span> <span class=\"o\">=</span> <span class=\"n\">all_different</span><span class=\"p\">(</span><span class=\"n\">diag_2</span><span class=\"p\">)</span>\n",
       "\n",
       "        <span class=\"k\">return</span> <span class=\"n\">c_row</span> <span class=\"ow\">and</span> <span class=\"n\">c_diag_1</span> <span class=\"ow\">and</span> <span class=\"n\">c_diag_2</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(NQueensCSP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the NQueensCSP inherits from a CSP."
   ]
  },
  {
   "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\">CSP</span><span class=\"p\">(</span><span class=\"n\">search</span><span class=\"o\">.</span><span class=\"n\">Problem</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;This class describes finite-domain Constraint Satisfaction Problems.</span>\n",
       "<span class=\"sd\">    A CSP is specified by the following inputs:</span>\n",
       "<span class=\"sd\">        variables   A list of variables; each is atomic (e.g. int or string).</span>\n",
       "<span class=\"sd\">        domains     A dict of {var:[possible_value, ...]} entries.</span>\n",
       "<span class=\"sd\">        neighbors   A dict of {var:[var,...]} that for each variable lists</span>\n",
       "<span class=\"sd\">                    the other variables that participate in constraints.</span>\n",
       "<span class=\"sd\">        constraints A function f(A, a, B, b) that returns true if neighbors</span>\n",
       "<span class=\"sd\">                    A, B satisfy the constraint when they have values A=a, B=b</span>\n",
       "\n",
       "<span class=\"sd\">    In the textbook and in most mathematical definitions, the</span>\n",
       "<span class=\"sd\">    constraints are specified as explicit pairs of allowable values,</span>\n",
       "<span class=\"sd\">    but the formulation here is easier to express and more compact for</span>\n",
       "<span class=\"sd\">    most cases. (For example, the n-Queens problem can be represented</span>\n",
       "<span class=\"sd\">    in O(n) space using this notation, instead of O(N^4) for the</span>\n",
       "<span class=\"sd\">    explicit representation.) In terms of describing the CSP as a</span>\n",
       "<span class=\"sd\">    problem, that&#39;s all there is.</span>\n",
       "\n",
       "<span class=\"sd\">    However, the class also supports data structures and methods that help you</span>\n",
       "<span class=\"sd\">    solve CSPs by calling a search function on the CSP. Methods and slots are</span>\n",
       "<span class=\"sd\">    as follows, where the argument &#39;a&#39; represents an assignment, which is a</span>\n",
       "<span class=\"sd\">    dict of {var:val} entries:</span>\n",
       "<span class=\"sd\">        assign(var, val, a)     Assign a[var] = val; do other bookkeeping</span>\n",
       "<span class=\"sd\">        unassign(var, a)        Do del a[var], plus other bookkeeping</span>\n",
       "<span class=\"sd\">        nconflicts(var, val, a) Return the number of other variables that</span>\n",
       "<span class=\"sd\">                                conflict with var=val</span>\n",
       "<span class=\"sd\">        curr_domains[var]       Slot: remaining consistent values for var</span>\n",
       "<span class=\"sd\">                                Used by constraint propagation routines.</span>\n",
       "<span class=\"sd\">    The following methods are used only by graph_search and tree_search:</span>\n",
       "<span class=\"sd\">        actions(state)          Return a list of actions</span>\n",
       "<span class=\"sd\">        result(state, action)   Return a successor of state</span>\n",
       "<span class=\"sd\">        goal_test(state)        Return true if all constraints satisfied</span>\n",
       "<span class=\"sd\">    The following are just for debugging purposes:</span>\n",
       "<span class=\"sd\">        nassigns                Slot: tracks the number of assignments made</span>\n",
       "<span class=\"sd\">        display(a)              Print a human-readable representation</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\">variables</span><span class=\"p\">,</span> <span class=\"n\">domains</span><span class=\"p\">,</span> <span class=\"n\">neighbors</span><span class=\"p\">,</span> <span class=\"n\">constraints</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Construct a CSP problem. If variables is empty, it becomes domains.keys().&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">variables</span> <span class=\"o\">=</span> <span class=\"n\">variables</span> <span class=\"ow\">or</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"n\">domains</span><span class=\"o\">.</span><span class=\"n\">keys</span><span class=\"p\">())</span>\n",
       "\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">variables</span> <span class=\"o\">=</span> <span class=\"n\">variables</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">domains</span> <span class=\"o\">=</span> <span class=\"n\">domains</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">neighbors</span> <span class=\"o\">=</span> <span class=\"n\">neighbors</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">constraints</span> <span class=\"o\">=</span> <span class=\"n\">constraints</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">initial</span> <span class=\"o\">=</span> <span class=\"p\">()</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span> <span class=\"o\">=</span> <span class=\"bp\">None</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">nassigns</span> <span class=\"o\">=</span> <span class=\"mi\">0</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">assign</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Add {var: val} to assignment; Discard the old value if any.&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">assignment</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">val</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">nassigns</span> <span class=\"o\">+=</span> <span class=\"mi\">1</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">unassign</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Remove {var: val} from assignment.</span>\n",
       "<span class=\"sd\">        DO NOT call this if you are changing a variable to a new value;</span>\n",
       "<span class=\"sd\">        just call assign for that.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">var</span> <span class=\"ow\">in</span> <span class=\"n\">assignment</span><span class=\"p\">:</span>\n",
       "            <span class=\"k\">del</span> <span class=\"n\">assignment</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">]</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">is_consistent</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Return if var=val conflicts with other variables.&quot;&quot;&quot;</span>\n",
       "        <span class=\"c1\"># Subclasses may implement this more efficiently</span>\n",
       "        <span class=\"k\">return</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">nconflicts</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"mi\">0</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">nconflicts</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Return the number of conflicts var=val has with other variables.&quot;&quot;&quot;</span>\n",
       "        <span class=\"c1\"># Subclasses may implement this more efficiently</span>\n",
       "        <span class=\"k\">def</span> <span class=\"nf\">conflict</span><span class=\"p\">(</span><span class=\"n\">var2</span><span class=\"p\">):</span>\n",
       "            <span class=\"k\">return</span> <span class=\"p\">(</span><span class=\"n\">var2</span> <span class=\"ow\">in</span> <span class=\"n\">assignment</span> <span class=\"ow\">and</span>\n",
       "                    <span class=\"ow\">not</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">constraints</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">var2</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">[</span><span class=\"n\">var2</span><span class=\"p\">]))</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">count</span><span class=\"p\">(</span><span class=\"n\">conflict</span><span class=\"p\">(</span><span class=\"n\">v</span><span class=\"p\">)</span> <span class=\"k\">for</span> <span class=\"n\">v</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">neighbors</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">])</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">display</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Show a human-readable representation of the CSP.&quot;&quot;&quot;</span>\n",
       "        <span class=\"c1\"># Subclasses can print in a prettier way, or display with a GUI</span>\n",
       "        <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s1\">&#39;CSP:&#39;</span><span class=\"p\">,</span> <span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"s1\">&#39;with assignment:&#39;</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"c1\"># These methods are for the tree and graph-search interface:</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 a list of applicable actions: nonconflicting</span>\n",
       "<span class=\"sd\">        assignments to an unassigned variable.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">if</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">variables</span><span class=\"p\">):</span>\n",
       "            <span class=\"k\">return</span> <span class=\"p\">[]</span>\n",
       "        <span class=\"k\">else</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">assignment</span> <span class=\"o\">=</span> <span class=\"nb\">dict</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">)</span>\n",
       "            <span class=\"n\">var</span> <span class=\"o\">=</span> <span class=\"n\">first</span><span class=\"p\">([</span><span class=\"n\">v</span> <span class=\"k\">for</span> <span class=\"n\">v</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">variables</span> <span class=\"k\">if</span> <span class=\"n\">v</span> <span class=\"ow\">not</span> <span class=\"ow\">in</span> <span class=\"n\">assignment</span><span class=\"p\">])</span>\n",
       "            <span class=\"k\">return</span> <span class=\"p\">[(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">)</span> <span class=\"k\">for</span> <span class=\"n\">val</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">domains</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">]</span>\n",
       "                    <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">nconflicts</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"mi\">0</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;Perform an action and return the new state.&quot;&quot;&quot;</span>\n",
       "        <span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">)</span> <span class=\"o\">=</span> <span class=\"n\">action</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">state</span> <span class=\"o\">+</span> <span class=\"p\">((</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">val</span><span class=\"p\">),)</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;The goal is to assign all variables, with all constraints satisfied.&quot;&quot;&quot;</span>\n",
       "        <span class=\"n\">assignment</span> <span class=\"o\">=</span> <span class=\"nb\">dict</span><span class=\"p\">(</span><span class=\"n\">state</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">return</span> <span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">assignment</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">variables</span><span class=\"p\">)</span>\n",
       "                <span class=\"ow\">and</span> <span class=\"nb\">all</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">nconflicts</span><span class=\"p\">(</span><span class=\"n\">variables</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">[</span><span class=\"n\">variables</span><span class=\"p\">],</span> <span class=\"n\">assignment</span><span class=\"p\">)</span> <span class=\"o\">==</span> <span class=\"mi\">0</span>\n",
       "                        <span class=\"k\">for</span> <span class=\"n\">variables</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">variables</span><span class=\"p\">))</span>\n",
       "\n",
       "    <span class=\"c1\"># These are for constraint propagation</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">support_pruning</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Make sure we can prune values from domains. (We want to pay</span>\n",
       "<span class=\"sd\">        for this only if we use it.)&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span> <span class=\"ow\">is</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span> <span class=\"o\">=</span> <span class=\"p\">{</span><span class=\"n\">v</span><span class=\"p\">:</span> <span class=\"nb\">list</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">domains</span><span class=\"p\">[</span><span class=\"n\">v</span><span class=\"p\">])</span> <span class=\"k\">for</span> <span class=\"n\">v</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">variables</span><span class=\"p\">}</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">suppose</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">value</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Start accumulating inferences from assuming var=value.&quot;&quot;&quot;</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">support_pruning</span><span class=\"p\">()</span>\n",
       "        <span class=\"n\">removals</span> <span class=\"o\">=</span> <span class=\"p\">[(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">a</span><span class=\"p\">)</span> <span class=\"k\">for</span> <span class=\"n\">a</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">]</span> <span class=\"k\">if</span> <span class=\"n\">a</span> <span class=\"o\">!=</span> <span class=\"n\">value</span><span class=\"p\">]</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">[</span><span class=\"n\">value</span><span class=\"p\">]</span>\n",
       "        <span class=\"k\">return</span> <span class=\"n\">removals</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">prune</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">value</span><span class=\"p\">,</span> <span class=\"n\">removals</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Rule out var=value.&quot;&quot;&quot;</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">remove</span><span class=\"p\">(</span><span class=\"n\">value</span><span class=\"p\">)</span>\n",
       "        <span class=\"k\">if</span> <span class=\"n\">removals</span> <span class=\"ow\">is</span> <span class=\"ow\">not</span> <span class=\"bp\">None</span><span class=\"p\">:</span>\n",
       "            <span class=\"n\">removals</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">((</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">value</span><span class=\"p\">))</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">choices</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Return all values for var that aren&#39;t currently ruled out.&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\">curr_domains</span> <span class=\"ow\">or</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">domains</span><span class=\"p\">)[</span><span class=\"n\">var</span><span class=\"p\">]</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">infer_assignment</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Return the partial assignment implied by the current inferences.&quot;&quot;&quot;</span>\n",
       "        <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">support_pruning</span><span class=\"p\">()</span>\n",
       "        <span class=\"k\">return</span> <span class=\"p\">{</span><span class=\"n\">v</span><span class=\"p\">:</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span><span class=\"p\">[</span><span class=\"n\">v</span><span class=\"p\">][</span><span class=\"mi\">0</span><span class=\"p\">]</span>\n",
       "                <span class=\"k\">for</span> <span class=\"n\">v</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">variables</span> <span class=\"k\">if</span> <span class=\"mi\">1</span> <span class=\"o\">==</span> <span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span><span class=\"p\">[</span><span class=\"n\">v</span><span class=\"p\">])}</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">restore</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">removals</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Undo a supposition and all inferences from it.&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">for</span> <span class=\"n\">B</span><span class=\"p\">,</span> <span class=\"n\">b</span> <span class=\"ow\">in</span> <span class=\"n\">removals</span><span class=\"p\">:</span>\n",
       "            <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">curr_domains</span><span class=\"p\">[</span><span class=\"n\">B</span><span class=\"p\">]</span><span class=\"o\">.</span><span class=\"n\">append</span><span class=\"p\">(</span><span class=\"n\">b</span><span class=\"p\">)</span>\n",
       "\n",
       "    <span class=\"c1\"># This is for min_conflicts search</span>\n",
       "\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">conflicted_vars</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">,</span> <span class=\"n\">current</span><span class=\"p\">):</span>\n",
       "        <span class=\"sd\">&quot;&quot;&quot;Return a list of variables in current assignment that are in conflict&quot;&quot;&quot;</span>\n",
       "        <span class=\"k\">return</span> <span class=\"p\">[</span><span class=\"n\">var</span> <span class=\"k\">for</span> <span class=\"n\">var</span> <span class=\"ow\">in</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">variables</span>\n",
       "                <span class=\"k\">if</span> <span class=\"bp\">self</span><span class=\"o\">.</span><span class=\"n\">nconflicts</span><span class=\"p\">(</span><span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">current</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">],</span> <span class=\"n\">current</span><span class=\"p\">)</span> <span class=\"o\">&gt;</span> <span class=\"mi\">0</span><span class=\"p\">]</span>\n",
       "\n",
       "    <span class=\"c1\"># Only used for tracking pruned domains for visualization.</span>\n",
       "    <span class=\"k\">def</span> <span class=\"nf\">track_pruned_domain_for_display</span><span class=\"p\">(</span><span class=\"bp\">self</span><span class=\"p\">):</span>\n",
       "        <span class=\"k\">return</span>\n",
       "</pre></div>\n",
       "</body>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "psource(CSP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let us solve the problem using backtracking!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken to solve 10 Queens problem using Backtracking: 0.013008 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create NQueens problem.\n",
    "N = 10\n",
    "n_queens_backtracking = NQueensCSP(N)\n",
    "\n",
    "# Solve the problem using Backtracking. Display timing.\n",
    "start_time = time.time()\n",
    "solution = backtracking_search(n_queens_backtracking)\n",
    "end_time = time.time()\n",
    "print(\"Time taken to solve %s Queens problem using Backtracking: %f seconds\"% (N, end_time - start_time))\n",
    "plot_NQueens(solution)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Backtracking is solving the problem way faster than Depth First Search (DFS)!\n",
    "In particular for the 7 queens problem, DFS took $0.311423$ seconds to solve the problem.\n",
    "Instead, backtracking only takes $0.000920$ seconds! Quite an improvement right?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the snippet below to have an insight on how backtracking actually proceeds:\n",
    "- We display with **red crosses** the domains that are not considered by the algorithm anymore (while this is not used for backtracking explicitly, we will see that for backtracking with forward checking we actually preemptively prune domains).\n",
    "- Below we represent **any intermediate queen assignment by actually putting a queen on the board**. Note that every backtracking is just shown by removing a previously placed queen!\n",
    "- When an assigned queen conflicts with a previously placed queen, we color the **square of the conflicting queens in red**.\n",
    "\n",
    "**Use the ```iteration``` slider to see the intermediate steps that backtracking takes**. Mind that, due to visualization lag, you might need to leave the slider at a certain value for a minimum time in order to refresh the screen, so we do not recommend using the mouse, but you should rather **use left/right arrow keys**.\n",
    "\n",
    "> If you see the board displaying things without responding to the slider, just interrupt the kernel (black square in the toolbar, next to the Run command) and run the cell again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d9b4e66c16fb46ac9510a6c7baa8a37e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='iteration', max=927), Output()), _dom_classes=('widget-i…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create NQueens problem.\n",
    "N = 10\n",
    "n_queens_backtracking = NQueensCSP(N)\n",
    "backtracking_instru_queen = make_instru(n_queens_backtracking)\n",
    "result = backtracking_search(backtracking_instru_queen)\n",
    "\n",
    "# Displaying\n",
    "display_nqueens(backtracking_instru_queen, result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"backtracking_w_fc\"></a> c. Backtracking with Forward Checking\n",
    "\n",
    "#### Definition <a name=\"bt_fc_definition\"></a>\n",
    "\n",
    "By modifying the call to the function _Inference_ in the backtracking algorithm presented [above](#backtracking_algorithm), we can interleave search with inference to reduce the domain of yet unassigned variables, thereby reducing the search space. \n",
    "\n",
    "A simple form of inference is **forward checking**, which consists in establishing arc-consistency for the recently assigned variable with respect to all connected, yet unassigned, variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Complexity <a name=\"bt_fc_complexity\"></a>\n",
    "\n",
    "Forward checking only checks arc-consistency for arcs that terminate on the new assignment.\n",
    "Therefore, it has a $\\mathcal{O}(ek)$ complexity, where $k$ is the domain's size and $e$ are the number of binary constraints."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: NQueens <a name=\"bt_fc_example\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking arc-consistency for the NQueens problem is simple, as we just need to define a function \n",
    "The constraint that needs to be passed to the CSP is defined in the **queen_constraint** function. \n",
    "The constraint is satisfied (true) if A, B are really the same variable, or if they are not in the same row (equivalent to having the same value), down diagonal, or up diagonal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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\">queen_constraint</span><span class=\"p\">(</span><span class=\"n\">A</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=\"n\">b</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;Constraint is satisfied (true) if A, B are really the same variable,</span>\n",
       "<span class=\"sd\">    or if they are not in the same row, down diagonal, or up diagonal.&quot;&quot;&quot;</span>\n",
       "    <span class=\"k\">return</span> <span class=\"n\">A</span> <span class=\"o\">==</span> <span class=\"n\">B</span> <span class=\"ow\">or</span> <span class=\"p\">(</span><span class=\"n\">a</span> <span class=\"o\">!=</span> <span class=\"n\">b</span> <span class=\"ow\">and</span> <span class=\"n\">A</span> <span class=\"o\">+</span> <span class=\"n\">a</span> <span class=\"o\">!=</span> <span class=\"n\">B</span> <span class=\"o\">+</span> <span class=\"n\">b</span> <span class=\"ow\">and</span> <span class=\"n\">A</span> <span class=\"o\">-</span> <span class=\"n\">a</span> <span class=\"o\">!=</span> <span class=\"n\">B</span> <span class=\"o\">-</span> <span class=\"n\">b</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(queen_constraint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Time taken to solve 15 Queens problem using Backtracking with Forward Checking: 0.044742 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create NQueens problem.\n",
    "N = 15\n",
    "n_queens = NQueensCSP(N)\n",
    "\n",
    "# Solve the problem using Backtracking with Forward Checking (fc flag set to True). Store timing.\n",
    "start_time = time.time()\n",
    "solution = backtracking_search(n_queens, inference = forward_checking)\n",
    "end_time = time.time()\n",
    "print(\" Time taken to solve %s Queens problem using Backtracking with Forward Checking: %f seconds\"% (N, end_time - start_time))\n",
    "plot_NQueens(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the snippet below to have an insight on how backtracking with forward checking actually proceeds:\n",
    "As before:\n",
    "- We display with **red crosses** the domains that are not considered by the algorithm anymore (while this is not used for backtracking explicitly, we will see that for backtracking with forward checking we actually preemptively prune domains).\n",
    "- Below we represent **any intermediate queen assignment by actually putting a queen on the board**. Note that every backtracking is just shown by removing a previously placed queen!\n",
    "- When an assigned queen conflicts with a previously placed queen, we color the **square of the conflicting queens in red**.\n",
    "\n",
    "On top of this, **we now display if a domain is pruned to the point where there is no possible values by coloring the column of the offending variable in _yellow_**.\n",
    "\n",
    "**Use the ```iteration``` slider to see the intermediate steps that backtracking with forward checking takes**. Mind that, due to visualization lag, you might need to leave the slider at a certain value for a minimum time in order to refresh the screen.\n",
    "\n",
    "> If you see the board displaying things without responding to the slider, just interrupt the kernel (black square in the toolbar, next to the Run command) and run the cell again.\n",
    "\n",
    "Here we use a small N because it is easier to observe the actual behaviour of the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9d9df5d3ec27462cb3dd84bd5ec6a28f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='iteration', max=135), Output()), _dom_classes=('widget-i…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create small NQueens problem.\n",
    "N = 10\n",
    "n_queens = NQueensCSP(N)\n",
    "\n",
    "# This is to store the intermediate steps.\n",
    "backtracking_instru_queen = make_instru(n_queens)\n",
    "\n",
    "# Solve it using backtracking with forward checking.\n",
    "result = backtracking_search(backtracking_instru_queen, inference = forward_checking)\n",
    "\n",
    "# Displaying\n",
    "display_nqueens(backtracking_instru_queen, result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <a name=\"backtracking_w_mac\"></a>d. Backtracking while Maintaining Arc Consistency (BT-MAC)\n",
    "\n",
    "#### Definition <a name=\"bt_mac_definition\"></a>\n",
    "\n",
    "We have seen that forward checking allows us to prune domains of variables that otherwise would be in conflict with the newly added queen. Nevertheless, forward checking does not actually ensure arc-consistency for all the variables.\n",
    "\n",
    "The idea of the inference algorithm _Maintaining Arc Consistency_ (MAC) is to run the AC3 algorithm we discussed [here](#AC-3-) every time we assign a new queen. This ensures that we do not continue down a possible partial assignment which will lead to a dead end. Effectively, the search space gets reduced!\n",
    "\n",
    "We can observe this behaviour very clearly by using the interactive slider to visualize intermediate steps.\n",
    "Below we show both boards at iteration number 3 for both algorithms.\n",
    "We can see that, while forward checking is unable to see that this partial assigment is actually not arc-consistent, _Maintaining Arc Consistency_ infers that we should already backtrack as this partial assignment will lead us to a dead-end.\n",
    "\n",
    "| <p align=\"center\">Forward Checking: | <p align=\"center\">Maintaining Arc Consistency:|\n",
    "|:-------------------------:|:-------------------------:|\n",
    "|![alt-text-1](images/bt-fc.png \"title-1\") | ![alt-text-2](images/bt-mac.png \"title-2\")|"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is the actual code for MAC:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "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\">mac</span><span class=\"p\">(</span><span class=\"n\">csp</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">,</span> <span class=\"n\">assignment</span><span class=\"p\">,</span> <span class=\"n\">removals</span><span class=\"p\">):</span>\n",
       "    <span class=\"sd\">&quot;&quot;&quot;Maintain arc consistency.&quot;&quot;&quot;</span>\n",
       "    <span class=\"k\">return</span> <span class=\"n\">AC3</span><span class=\"p\">(</span><span class=\"n\">csp</span><span class=\"p\">,</span> <span class=\"p\">[(</span><span class=\"n\">X</span><span class=\"p\">,</span> <span class=\"n\">var</span><span class=\"p\">)</span> <span class=\"k\">for</span> <span class=\"n\">X</span> <span class=\"ow\">in</span> <span class=\"n\">csp</span><span class=\"o\">.</span><span class=\"n\">neighbors</span><span class=\"p\">[</span><span class=\"n\">var</span><span class=\"p\">]],</span> <span class=\"n\">removals</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(mac)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Complexity <a name=\"bt_mac_complexity\"></a>\n",
    "By ensuring full arc-consistency between all variables each time a queen is placed on the board, MAC is strictly more computationally demanding than Forward Checking.\n",
    "While Forward Checking has a complexity of $\\mathcal{O}(ek)$, full AC3 propagation is $\\mathcal{O}(ek^3)$, where $k$ is the domain's size and $e$ are the number of binary constraints.\n",
    "Yet, by pruning the search tree further than Forward Checking, MAC uses less iterations to arrive to a solution.\n",
    "\n",
    "Therefore, whether MAC has a better or worst runtime performance than Forward Checking depends on the actual cost of doing constraint propagation versus search.\n",
    "That is why backtracking with Forward Checking, or even simple backtracking, are still used in applications.\n",
    "\n",
    "In our case, we actually observe that MAC takes about $0.10$ seconds to solve the 15 queens problem, while Forward Checking only takes half of this: $0.05$ seconds. For reference, simple backtracking takes $0.50$ seconds instead for the same problem.\n",
    "\n",
    "In terms of actual iterations (and we refer to an iteration as any assignment or unassignment of a variable), we observe the following for the N = 15 queens problem:\n",
    "- Backtracking with Forward Checking: $135$ iterations\n",
    "- Backtracking with MAC: $41$ iterations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: solving NQueens (20 Queens) <a name=\"bt_mac_example\"></a>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Time taken to solve 15 Queens problem using Backtracking with MAC: 0.115248 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create NQueens problem.\n",
    "N = 15\n",
    "n_queens = NQueensCSP(N)\n",
    "\n",
    "# Solve the problem using Backtracking with Forward Checking. Store timing.\n",
    "start_time = time.time()\n",
    "solution = backtracking_search(n_queens, inference = mac)\n",
    "end_time = time.time()\n",
    "print(\" Time taken to solve %s Queens problem using Backtracking with MAC: %f seconds\"% (N, end_time - start_time))\n",
    "plot_NQueens(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run the snippet below to have an insight on how backtracking with Maintaining Arc Consistency actually proceeds:\n",
    "We use below the same legend as before to represent pruned domains, partial assignments and empty domains.\n",
    "\n",
    "**Use the ```iteration``` slider to see the intermediate steps that backtracking with Maintaining Arc Consistency takes**. Mind that, due to visualization lag, you might need to leave the slider at a certain value for a minimum time in order to refresh the screen.\n",
    "\n",
    "> If you see the board displaying things without responding to the slider, just interrupt the kernel (black square in the toolbar, next to the Run command) and run the cell again.\n",
    "\n",
    "Here we use a small N because it is easier to observe the actual behaviour of the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4f5d28c8f9884cc58be087433e7f2af7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='iteration', max=41), Output()), _dom_classes=('widget-in…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create small NQueens problem.\n",
    "N = 10\n",
    "n_queens = NQueensCSP(N)\n",
    "\n",
    "# This is to store the intermediate steps.\n",
    "backtracking_instru_queen = make_instru(n_queens)\n",
    "\n",
    "# Solve it using backtracking with forward checking.\n",
    "result = backtracking_search(backtracking_instru_queen, inference = mac)\n",
    "\n",
    "# Displaying\n",
    "display_nqueens(backtracking_instru_queen, result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### e. Backtracking with Dynamic Variable Ordering <a name=\"bt_dvo\"></a>\n",
    "#### Definition  <a name=\"bt_dvo_definition\"></a>\n",
    "So far we have used the backtracking algorithm presented [before](#backtracking_algorithm) using as function for ```Selected-Unassigned-Variable``` a static variable ordering where we pick variables in order.\n",
    "For the NQueens problem, we were picking first the first column, then the second, etc.\n",
    "\n",
    "An alternative approach is to dynamically pick the next variable to assign using heuristics.\n",
    "Here we present the **Minimum-Remaining-Values (MRV)** heuristic which picks as next variable the one for which its domain is the smallest. This heuristic has also been called the \"most constrained variable\" or the \"fail-first\" heuristic.\n",
    "\n",
    "#### Complexity <a name=\"bt_dvo_complexity\"></a>\n",
    "\n",
    "The MRV heuristic can perform better than a random or static ordering, but results vary wieldly depending on the problem.\n",
    "\n",
    "#### Example: solving NQueens (40 Queens) <a name=\"bt_dvo_example\"></a>\n",
    "\n",
    "For the NQueens problem, using the MRV heuristic allows us to solve much larger problems than with a static ordering.\n",
    "We can, for example, solve a 40 Queens problem (or even 80 Queens problem) in \"real-time\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Time taken to solve 40 Queens problem using Backtracking with MAC: 0.521760 seconds\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create NQueens problem.\n",
    "N = 40\n",
    "n_queens = NQueensCSP(N)\n",
    "\n",
    "# Solve the problem using Backtracking with Forward Checking. Store timing.\n",
    "start_time = time.time()\n",
    "solution = backtracking_search(n_queens, select_unassigned_variable=mrv, inference = mac)\n",
    "end_time = time.time()\n",
    "print(\" Time taken to solve %s Queens problem using Backtracking with MAC: %f seconds\"% (N, end_time - start_time))\n",
    "plot_NQueens(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Run the snippet below to have an insight on how backtracking with MAC and MRC works:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "202442601325450481de7770f0fc2820",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=0, description='iteration', max=37), Output()), _dom_classes=('widget-in…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create small NQueens problem.\n",
    "N = 10\n",
    "n_queens = NQueensCSP(N)\n",
    "\n",
    "# This is to store the intermediate steps.\n",
    "backtracking_instru_queen = make_instru(n_queens)\n",
    "\n",
    "# Solve it using backtracking with forward checking.\n",
    "result = backtracking_search(backtracking_instru_queen,select_unassigned_variable=mrv, inference = mac)\n",
    "\n",
    "# Displaying\n",
    "display_nqueens(backtracking_instru_queen, result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: solving hard Sudokus <a name=\"bt_dvo_example_2\"></a>\n",
    "We saw before that we cannot solve hard Sudokus by just using [AC3]().\n",
    "Here we show that combining MAC inference with MRV variable ordering we can easily solve the Sudoku we had issues with at the beginning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAGKCAYAAAASfgYQAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAH9lJREFUeJzt3XuYjfXC//HPGuMwDss4DpEZUxg0DuNQk5rCbBmKHH8JOWWnUirqUZsk53N752mTyKN0RNo8ex5jUoNqyNCmHIp2lLGVcZiVGXOyfn/snQzT11Brfdc93q/rctXcc3Wtz3V3m7d7rTHL5fV6BQDArwmyPQAAENgIBQDAiFAAAIwIBQDAiFAAAIyCTZ8Mcrm8IWXL+mvLFfMGOad3rrNnbU8oljN5eSrrgP/3TjmfknOu05ycMypXuoztGZfklPMpOec6zcrJOeb1emtceNwYipCyZXVq5Zu+W/U7yY6Ltz2h2EI2JtueUCxtx09SSkqK7RmX5JTzKTnnOr09pqW2vDDL9oxLcsr5lJxznZa+s+fBoo47J8kAACsIBQDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIz8HorDxzIU2vtelb6zp37Kzvb3w1/SgQMHNGrUKMXGxio0NFRdunSxPekiHceOV+k7exb569M9+2zPK2T16tWKj49XeHi4atSooZiYGM2cOVO5ubm2p10kv6BAM99dpcbDH1aFu/sqYtD9Gr1oie1ZF1m7dq1iY2NVvXp1RUdHa/78+bYnFentlM1qM2q0Qnvfq/D77tfgOX9WesZx27Mc63+SNxT5e37h39f5/LGNP2bcF8a+ukwVy5XT6TNn/P3QxbJ3714lJSWpTZs2ysvLsz2nSC8+9EdlZmUVOjZx+Vv6/MA/1abh9ZZWFe348eOKi4vTqFGjVLlyZaWlpWnatGk6evSo5syZY3teIUPnvaiPdu7SuH59FVW3rr47dkx7Dn1ne1Yhqamp6t+/vwYOHKjJkydr27ZtevbZZ+VyufTwww/bnnfOmi1bNWDWXD3YNUEzhgzSkRMnNOG1N9Rt4hRtfWGWghz0XhKBZv3UiSpX5pf3C4msFebzx/RrKDZ98aXWpe3Q2L499V9LlvnzoYstISFBXbt2lSQNHDhQGRkZlhddrEm9awt9nJuXp7SvD6jPre0UXKqUpVVFGzp0aKGP4+Li5PF4tGjRIs2ePVsul8vSssLWpW3Xu5s+VtqLcy86v4Fk+vTpuummm87dRXTs2FGnTp3SjBkzNHz4cJUpExhvOPTWR5vU8rpI/eXB4eeOucuHqOek6dp3OF2Nr61rcZ2ztW5wvSqGhPj1Mf2W9YKCAo1a8Ir+1K+Pqrnd/nrYy+bEP+ms275DJ376SffcdovtKcVStWrVgHvqaen6DWrfLDqgIyFJu3btUvv27Qsd69Chg06ePKmtW7daWnWxvIICVa5QvtCx0AoVJEler9fGJPwGfvuquDAxSbn5+Xqoa4K/HvKq8c7Gj1W3ejXd0rSJ7Sm/qqCgQFlZWfr000+1YMECDRs2LGDuJiRp676v1KBObT3610Wq2qe/3L3uUZ8pMwLuOfWcnJyL7hp+/njfvsB5fWrwHzpo85d79NoHHyozK0tfHU7Xs6+96YgYB7pGwx9SuW691fSBkXo50fevT0h+euopI9Oj515/U/8zepRKB/v9ZZESLetMjtZs+UzDO/8hoL7wXqhWrVrKycmRJPXr10+TJ0+2vKiwf504qWUffKhm9SO0/Kkn5MnO1tOvLlPvKTP08ZzpAXNuIyMjtX379kLH0tLSJEknTpywMalIXdq01uLHRuqPf3lJQ+e9KEmKbdxI741/2vIy56pdpYomDuinNg0bqODsWb29cbMe/u+FysrJ1WN33+XTx/bLV+3xy5brxkYNldCmlT8e7qqydutnOn3mjP7fbbfanmK0fv16ZWdnKy0tTTNmzNDo0aM1b94827PO8UryeqVV455WNXclSVLtqlXUYex4ffiPXerQopndgf8xdOhQPfbYY1q6dKm6d++utLS0c69XBNLTph/t3KWHX1qoR7p1VedWMTp68qQmvfG2ek+ZoXWTJ6hUgL2W5gSdWrVUp1Ytz33cuXWMcvJyNe3td/Vot64+/f/v8yvry4OHtDR5g/7Ur49O/nRaJ386raz//Mny1OksZf/n33Fl3tm4WdfXrq3WDQLru50u1KJFC8XGxmrkyJGaMWOGFi9erG+++cb2rHOqVKygG8LrnYuEJLVr0lhlgoO1+7vA+c6ngQMHatiwYXr88ccVHh6uAQMG6KmnnpIkhYX5/rtfiuvJxUt1Z9s2mjbkPt3W7Ab1jbtFK8aNVcquL/S3LZ/Znldi9Gx3s457ftK3P/zg08fx+R3F/vQjysvP161jLr7ljBg8XEM6ddTLjwbOt/U5yanTp/V/aTs0ptfdtqdclhYtWkiSDh48qMjISMtr/i2qbl2dybv4BXavpCBX4PxJvVSpUpozZ47GjRun9PR0hYeH66uvvpIktWnTxvK6X+z7/rDuiSt8l9uobh2FlC2jb478y9Kqksd17p++fWrU56Fo16Sxkqc+X+jYuu07NGvFe1rz3DjV98P3AJdUqz/dopy8vIB/2ulCqampkqTw8HDLS37RtW0rTVz+to6dylT1yv/+rrxNX+xWXn6+mtWPsLqtKFWqVFGVKlUkSa+88opuvPFGNWzY0PKqX4TXqKEdBwrfMe757ntl5+QqPKympVUlz6qPP1V1t1vhNWv49HF8Horqld26rdkNhY79fJt0S9PGfv9+4EvJyspSUlKSJCk9PV0ej0erV6+WJHXq1Enly5c3/ed+9c7GzWpWPyKgvye9R48eat++vaKiolSqVCmlpqZq/vz56tmzZ8DcTUjS/Z07af6av+vu56dqbN9e8mRn65mlr6lji2a6pWlj2/PO2bp1q1JTUxUdHS2Px6MVK1bogw8+0Lp1/vnul+IannCHxrzyqmpXraLOrWN09MRJTXnrXUWE1VRC6xjb8xyp79SZatPwekVHRKjg7Fm9s+ljvbPpY817YJjPX5/iW5Au8OOPP+q+++4rdOznj3ft2hUwfwo+dipTG/6xSxMH9LM9xSgmJkbLly/XoUOHFBwcrIiICE2YMEHDhg2zPa0Qd/nySpoyUY8vXKz+M+eqTHCw7rqpreYMH2J7WiGlS5fWypUrNW3aNAUFBSk2NlZJSUlq2rSp7WmFPNKtq8qUDtbCv6/Ty4lJCq1QQe2aRmnyoAGqUK6c7XmO1LDONVq6foO+O3ZMXq/U+Nq6evWJRzWgw+0+f2yX6S+/VChXzntq5Zs+H/FbZcfF255QbCEbk21PKJa24ycpJSXF9oxLcsr5lJxznd4e01JbXphle8YlOeV8Ss65Tkvf2TPN6/W2vvB44LxKBwAISIQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBkfD8Kb1CQI36Ur1N+hK/knB+N7PI86Yjz6pTzKTnnOvVWcjvivDrlfErOuk6Lwh0FAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjIw/Zvxqs3LzJ3ph9Rp9dfiwTp/JUXjNGurf/jaN6XW3ypQubXseAFhBKM6T4fGoffNoje7ZXaEVK+izr77W82+8o3+dOKm/PDjc9jwAsIJQnOePCXcU+vj2ZtHKzMrWX/83UX8ecb9cLpelZQBgD69RXELVSpWUm59vewYAWMMdRREKCgqUk5ev7Qe+0X+v+V89kHAHdxMArlqEogiVe9+rnLw8SdKADrdrxtBBdgcBgEWEoggbZ01VVk6uPvvqa0156x09umCR5j/0gO1ZAGAFoShCzPXXSZJuadpY1d2VNHTei3q8R3ddV7uW5WUA4H+8mH0JLa+LlCR9e/So5SUAYAehuIRP9uyVJEWEhVleAgB28NTTebo++7w6tmimJvXqqVRQkD7Zs1fz3vub+t7ajqedAFy1CMV5Wje4XsuSP9S3P/yo4FJBql8rTJMH9dcDF/xFPAC4mhCK80wceK8mDrzX9gwACCi8RgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMDK+H4Xr7FmFbEz215Yrlh0Xb3tCsTnhfEqSt5LbEefVKedTcs516vI86Yjz6pTzKTnrOi0KdxQAACNCAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACNCAZ/q0qWL3G53kb+2bNliex6AYjD+mHHgt5o7d64yMzMLHZsyZYp27typVq1aWVoF4HIQCvhUVFRUoY9zc3O1Y8cO9erVS8HBXH6AE/DUE/wqOTlZJ0+eVO/evW1PAVBMhAJ+tWLFCtWpU0c333yz7SkAiolQwG+ysrKUmJioHj16yOVy2Z4DoJgIBfwmMTFRp0+f5mknwGEIBfxm5cqVioyMVExMjO0pAC4DoYBfnDp1SuvXr+duAnAgQgG/WLt2rXJyctSnTx/bUwBcJkIBv1ixYoWio6PVqFEj21MAXCZCAZ/LyMhQSkqKevXqZXsKgCvAX42Fz1WrVk3Hjx+3PQPAFeKOAgBgRCgAAEaEAgBgRCgAAEaEAgBgRCgAAEaEAgBgRCgAAEaEAgBgRCgAAEaEAgBgRCgAAEaEAgBgRCgAAEaEAgBg5PJ6vb/6yVKlSnmbN2/uxzlXxuXJtD2h2LyV3LYnFMu+3bsVdW1d2zMuySnnU3LOdbrncLqioqJsz7gkp5xPyTnX6Y4dO9K8Xm/rC48bQ1G+fHnv0aNHfTrs9xCyMdn2hGLLjou3PaFYbo9pqS0vzLI945Kccj4l51ynbcdPUkpKiu0Zl+SU8yk55zp1u91FhoKnngAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARsG2BwSSFZs/0fINH2n7/m90KitLDetcoyd6dtc9t91qexoAH8ovKNDcVe/r1aQPdOjHH1Wjslu9brlZc4YPtT0tIBCK87zw3t9Uv1aYZg8fouputxK3pWngrHk6lpmpkXd1tT0PgI8MnfeiPtq5S+P69VVU3br67tgx7Tn0ne1ZAYNQnGf1s8+oeuVf3mCkffNoHTl+Qn9evYZQACXUurTtenfTx0p7ca6a1LvW9pyAxGsU5zk/Ej9rEVlf6RnHLawB4A9L129Q+2bRRMKAUFxC6t59alDnGtszAPjI1n1fqUGd2nr0r4tUtU9/uXvdoz5TZvAHxPMQCoMNn+/U+6lb9XiPbranAPCRf504qWUffKh//POfWv7UE3pl1Eht339AvafMkOmtoq8mvEbxK749+oMGzp6nbje20aD4DrbnAPARrySvV1o17mlVc1eSJNWuWkUdxo7Xh//YpQ4tmtkdGAC4oyjCcY9Hd02YpHo1amjZmMdtzwHgQ1UqVtAN4fXORUKS2jVprDLBwdr9Hd/5JBGKi2SdyVH3iVOVm5+v9yc8o/LlytqeBMCHourWlVcXP8XklRTk4kukRCgKyS8o0D3TZ2l/+hGtnTheNUNDbU8C4GNd27bSF98e0rFTmeeObfpit/Ly89WsfoS1XYGE1yjOM/Kll5W4bbvm/nGYMjweZezdd+5zLa+LVNnSpS2uA+AL93fupPlr/q67n5+qsX17yZOdrWeWvqaOLZrplqaNbc8LCITiPMk7PpckPfHy4os+9/XiBYoIq+nvSQB8zF2+vJKmTNTjCxer/8y5KhMcrLtuaqs5w4fYnhYwCMV59i9ZaHsCAAuuv6a21kwcZ3tGwOI1CgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgZf8y46+xZhWxM9teWK5YdF297QrE54XxKkreS2xHn1SnnU3LOderyPOmI8+qU8yk56zotCncUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAjQgEAMDL+mHHgavJ2ymbNXvWevj58RJXLl1f75tGaOnigrqlW1fY0xzt8LENNRzyi02fO6MS7y1UxJMT2JFwG7igASWu2bNWAWXMVGxWlVePGauqQgdr85W51mzhFZ8+etT3P8ca+ukwVy5WzPQNXiDsKQNJbH21Sy+si9ZcHh5875i4fop6Tpmvf4XQ1vrauxXXOtumLL7UubYfG9u2p/1qyzPYcXAFCAUjKKyhQ5QrlCx0LrVBBkuT1em1MKhEKCgo0asEr+lO/PufOJ5yHp54ASYP/0EGbv9yj1z74UJlZWfrqcLqefe1NtW8WrSb1rrU9z7EWJiYpNz9fD3VNsD0FvwGhACR1adNaix8bqQfnL1C1vgPU9IGRKjhboHeeecr2NMfKyPToudff1Kxhg1U6mCcvnIxQAJI+2rlLD7+0UI9066rkqc9r+VNP6ITnJ/WeMkMFBQW25znS+GXLdWOjhkpo08r2FPxGZB6Q9OTipbqzbRtNG3LfuWPNI+vrhhGP6G9bPlOPm2+yuM55vjx4SEuTN2jD9Ek6+dNpSVJWTo4k6dTpLJUKClJI2bI2J+IyEApA0r7vD+ueuFsLHWtUt45CypbRN0f+ZWmVc+1PP6K8/HzdOubpiz4XMXi4hnTqqJcffdjCMlwJQgFICq9RQzsOfFPo2J7vvld2Tq7Cw2paWuVc7Zo0VvLU5wsdW7d9h2ateE9rnhun+rXCLC3DlSAUgKThCXdozCuvqnbVKurcOkZHT5zUlLfeVURYTSW0jrE9z3GqV3brtmY3FDr27Q8/SJJuadqYv5ntMIQCkPRIt64qUzpYC/++Ti8nJim0QgW1axqlyYMGqAJ/oxhXOUIBSHK5XBrRpbNGdOlse0qJNSi+gwbFd7A9A1eAb48FABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgZ34/CGxSk7Lh4f225YiEbk21PKDYnnE9JcnmedMR5dcr5lJxznXoruR1xXp1yPiVnXadF4Y4CAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKAAARoQCAGBEKABJBw4c0KhRoxQbG6vQ0FB16dLF9iQgYBh/zDhwtdi7d6+SkpLUpk0b5eXl2Z4DBBTuKABJCQkJ2rNnj5YtW6bGjRvbngMEFEIBSAoK4rcC8Gv43QEAMCIUAAAjQgEAMCIUAAAjQgEAMCIUAAAj/sIdICkrK0tJSUmSpPT0dHk8Hq1evVqS1KlTJ5UvX97mPMAqQgFI+vHHH3XfffcVOvbzx7t27VJ4eLiNWUBAIBSApPDwcGVmZtqeAQQkXqMAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABi5vF7vr36yVKkgb4vISD/OuTLeSm7bE4rN5XHGex7sOZyuqKgo2zMuySnnU3LOdbpv925FXVvX9oxLcsr5lJxznW7ffyDN6/W2vvC48Y2LypUuoy0vzPLdqt9Jdly87QnFFrIx2faEYmk7fpJSUlJsz7gkp5xPyTnX6e0xLfl9/ztzynVa+s6eRR7nqScAgBGhAAAYEQoAgBGhAAAYEQoAgBGhAAAYEQoAgBGhAAAYEQoAgBGhAAAYEQoAgBGhAAAYEQoAgBGhgE/l5+dr7ty5atGihapXr66oqCiNHTvW9izHWr16teLj4xUeHq4aNWooJiZGM2fOVG5uru1pjtWlSxe53e4if23ZssX2vIBg/DHjwG81YsQIbdy4UWPHjlXDhg31/fffa9++fbZnOdbx48cVFxenUaNGqXLlykpLS9O0adN09OhRzZkzx/Y8R5o7d64yMwu/X8SUKVO0c+dOtWrVytKqwEIo4DPr16/XqlWr9MknnzjiTZCcYOjQoYU+jouLk8fj0aJFizR79my5XC5Ly5zrwmszNzdXO3bsUK9evRQczJdIiaee4EOvv/664uLiiISPVa1alaeefkfJyck6efKkevfubXtKwCAU8Jlt27bp+uuv1+jRo1WnTh2FhYWpf//+OnLkiO1pjldQUKCsrCx9+umnWrBggYYNG8bdxO9kxYoVqlOnjm6++WbbUwIGoYDPHD16VG+88YZ27dqlJUuW6KWXXtLnn3+ue++9V6b3asel1apVS7Vq1dIdd9yhdu3aafLkybYnlQhZWVlKTExUjx49CO95eAIOPuP1euX1evXmm2+qWrVqkv79BS4hIUEpKSm6/fbb7Q50sPXr1ys7O1tpaWmaMWOGRo8erXnz5tme5XiJiYk6ffo0TztdgFDAZ0JDQxUREXEuEpIUGxurMmXKaO/evYTiN2jRooWkf5/PqlWrasSIEXrkkUcUGRlpeZmzrVy5UpGRkYqJibE9JaDw1BN8plGjRkU+xeT1ehUUxKX3e/k5GgcPHrS8xNlOnTql9evXczdRBH63wmc6d+6s3bt3KyMj49yxjz/+WHl5eYqOjra4rGRJTU2VJIWHh1te4mxr165VTk6O+vTpY3tKwOGpJ/jM4MGDtWDBAvXt21djxoyRx+PRhAkT1L59e8XGxtqe50g9evRQ+/btFRUVpVKlSik1NVXz589Xz549edrpN1qxYoWio6PVqFEj21MCDqGAz7jdbq1Zs0ZPPfWUhgwZojJlyqhLly6aNm2a7WmOFRMTo+XLl+vQoUMKDg5WRESEJkyYoGHDhtme5mgZGRlKSUnRuHHjbE8JSIQCPnXddddp5cqVtmeUGOPHj9f48eNtzyhxqlWrpuPHj9ueEbB4jQIAYEQoAABGhAIAYEQoAABGhAIAYEQoAABGhAIAYEQoAABGhAIAYEQoAABGhAIAYEQoAABGhAIAYEQoAABGxh8z7g0KUnZcvL+2XLGQjcm2JxSbE86nJLk8TzrivDrlfErOuU69ldyOOK9OOZ+Ss67TonBHAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACNCAQAwIhQAACO/hGL58uVyu90X/Vq8eLE/Hh6WrNj8iXo8P1Xh992v0N73qu2oMXorZZPtWQAuk/H9KH5va9euVbly5c59XL9+fX8+PPzshff+pvq1wjR7+BBVd7uVuC1NA2fN07HMTI28q6vteQCKya+hiImJUcWKFf35kLBo9bPPqHpl97mP2zeP1pHjJ/Tn1WsIBeAgvEYBnzk/Ej9rEVlf6RnHLawBcKX8GormzZurSpUqiomJ0ZIlS/z50AgQqXv3qUGda2zPAHAZ/PLUU1hYmMaNG6dWrVqpoKBAK1eu1GOPPaasrCyNHDnSHxMQADZ8vlPvp27VolEP254C4DL4JRTx8fGKj//lzcU7deqknJwczZo1Sw899JCCgngGrKT79ugPGjh7nrrd2EaD4jvYngPgMlj7Ct29e3edOHFCBw8etDUBfnLc49FdEyapXo0aWjbmcdtzAFwma6FwuVyF/omSKetMjrpPnKrc/Hy9P+EZlS9X1vYkAJfJr98ee77Vq1erWrVqqlevnq0J8LH8ggLdM32W9qcf0cZZU1UzNNT2JABXwC+hGDBggFq1aqWmTZuqoKBAq1at0qpVqzRz5kxenyjBRr70shK3bdfcPw5ThsejjL37zn2u5XWRKlu6tMV1AIrLL6Fo0KCBXnvtNR0+fFher1dRUVFauHCh+vXr54+HhyXJOz6XJD3x8sU/quXrxQsUEVbT35MAXAG/hGLChAmaMGGCPx4KAWT/koW2JwD4HfC8DwDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIwIBQDAiFAAAIwIBQDAyPh+FK6zZxWyMdlfW65Ydly87QnF5oTzKUneSm5HnFennE/JOdepy/OkI86rU86n5KzrtCjcUQAAjAgFAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjAgFAMCIUAAAjPwSiv3pR/Tg/L+q5cjHVbZbb3UcO94fD3vVOHwsQ6G971XpO3vqp+xs23MAlDDGHzP+e9l96Dv937bturFRQ+Xn5/vjIa8qY19dporlyun0mTO2pwAogfxyR3Fn29b659JFeuvpJ9Wk3rX+eMirxqYvvtS6tB16omc321MAlFB+uaMICuKlEF8oKCjQqAWv6E/9+ii0QgXbcwCUUHwFd7CFiUnKzc/XQ10TbE8BUIIRCofKyPToudff1Kxhg1U62C83hgCuUoTCocYvW64bGzVUQptWtqcAKOH4o6gDfXnwkJYmb9CG6ZN08qfTkqSsnBxJ0qnTWSoVFKSQsmVtTgRQghAKB9qffkR5+fm6dczTF30uYvBwDenUUS8/+rCFZQBKIkLhQO2aNFby1OcLHVu3fYdmrXhPa54bp/q1wiwtA1AS+SUUWWdylLgtTZJ0OOO4PNnZWrn5E0lSQutWKl+Op0kuR/XKbt3W7IZCx7794QdJ0i1NG6tiSIiNWQBKKL+E4odTp3TP9NmFjv388deLFyiiXE1/zAAAXAG/hCIirKby1q7yx0NdtQbFd9Cg+A62ZwAogfj2WACAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAEaEAABgRCgCAkcvr9f76J12uHyUd9N8cAIBF4V6vt8aFB42hAACAp54AAEaEAgBgRCgAAEaEAgBgRCgAAEb/H3CoPCpoXOy0AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "harder1 = '4173698.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......'\n",
    "h = Sudoku(harder1)\n",
    "h.display(h.infer_assignment())\n",
    "print()\n",
    "solution = backtracking_search(h, select_unassigned_variable=mrv, inference=forward_checking)\n",
    "h.display(solution)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### d. Empirical runtime comparison between Forward Checking and Maintaining Arc Consistency <a name=\"experiments\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have mentioned before, MAC is slightly slower per node than Forward Checking, yet it can often perform reasoning steps which remove large parts of the search space.\n",
    "\n",
    "Experimentally, we observe the following results for the NQueens and Sudoku problems (using the MRV heuristic as variable ordering):\n",
    "\n",
    "- 60 Queens :\n",
    "\n",
    "| Algorithm| Runtime (s)|\n",
    "|:-------|-------|\n",
    "|FC| 0.345 |\n",
    "|MAC|2.926 |\n",
    "    \n",
    "\n",
    "- Hard Sudoku :\n",
    "\n",
    "| Algorithm |Runtime (s)|\n",
    "|:-------|-------|\n",
    "|FC| 0.013|\n",
    "|MAC|0.066|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Time taken to solve 60 Queens problem using Backtracking with FC: 0.106117 seconds\n"
     ]
    }
   ],
   "source": [
    "# Create NQueens problem.\n",
    "N = 60\n",
    "n_queens = NQueensCSP(N)\n",
    "\n",
    "# Solve the problem using Backtracking with Forward Checking. Store timing.\n",
    "start_time = time.time()\n",
    "solution = backtracking_search(n_queens, select_unassigned_variable=mrv, inference = forward_checking)\n",
    "end_time = time.time()\n",
    "print(\" Time taken to solve %s Queens problem using Backtracking with FC: %f seconds\"% (N, end_time - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Time taken to solve 60 Queens problem using Backtracking with MAC: 2.400822 seconds\n"
     ]
    }
   ],
   "source": [
    "# Create NQueens problem.\n",
    "N = 60\n",
    "n_queens = NQueensCSP(N)\n",
    "\n",
    "# Solve the problem using Backtracking with MAC. Store timing.\n",
    "start_time = time.time()\n",
    "solution = backtracking_search(n_queens, select_unassigned_variable=mrv, inference = mac)\n",
    "end_time = time.time()\n",
    "print(\" Time taken to solve %s Queens problem using Backtracking with MAC: %f seconds\"% (N, end_time - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Time taken to solve hard Sudoku problem using Backtracking with FC: 0.011625 seconds\n"
     ]
    }
   ],
   "source": [
    "harder1 = '4173698.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......'\n",
    "h = Sudoku(harder1)\n",
    "start_time = time.time()\n",
    "\n",
    "# Solve the problem using Backtracking with Forward Checking. Store timing.\n",
    "solution = backtracking_search(h, select_unassigned_variable=mrv, inference=forward_checking)\n",
    "end_time = time.time()\n",
    "print(\" Time taken to solve hard Sudoku problem using Backtracking with FC: %f seconds\"% (end_time - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Time taken to solve hard Sudoku problem using Backtracking with MAC: 0.079388 seconds\n"
     ]
    }
   ],
   "source": [
    "harder1 = '4173698.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......'\n",
    "h = Sudoku(harder1)\n",
    "start_time = time.time()\n",
    "\n",
    "# Solve the problem using Backtracking with MAC. Store timing.\n",
    "solution = backtracking_search(h, select_unassigned_variable=mrv, inference=mac)\n",
    "end_time = time.time()\n",
    "print(\" Time taken to solve hard Sudoku problem using Backtracking with MAC: %f seconds\"% (end_time - start_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bucket Elimination\n",
    "\n",
    "The idea of join and project used to eliminate variables when solving system of linear equation can be extended to constraints. This is made possible by bucket elimination. The two operations are explained below.\n",
    "\n",
    "$\\textbf{Join Operation}$ for constraints is shown below:\n",
    "<img src=\"images/pic_1.png\" alt=\"drawing\" width=\"600\">\n",
    "\n",
    "\n",
    "$\\textbf{Project Operation}:$ C2 = $\\pi_{2}C_{21}$\n",
    "<img src=\"images/pic_2.png\" alt=\"drawing\" width=\"600\">\n",
    "\n",
    "- First, we assume an ordering of the variables in the problem and assign the constraints in the bucket of the variable that has higher preference (according to the ordering) among the two variables involved in the binary constraint.\n",
    "\n",
    "- Now, in each bucket we use the join operation to combine all the constraints and project out the corresponding variable of the bucket\n",
    "\n",
    "- We use this combined constraint in the next bucket along with all the existing buckets. Propagating this forward, we would end up with the solution to the single variable corresponding to the last bucket. Now we use this value of the variable to infer the values of all the other variables in the higher buckets."
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}