{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CUdxCOrTmzzq"
      },
      "source": [
        "# CS640 Homework 5: MDP, RL and Adversarial Search\n",
        "\n",
        "This assignment covers three topics shown in the title. There is a problem for each topic.\n",
        "\n",
        "In particular, the MDP problem asks you to implement both the value iteration and the policy iteration, the RL problem asks you to implement the Q-learning algorithm, and in the adversarial search problem, you need to run the min-max algorithm by hand.\n",
        "\n",
        "### Collaboration\n",
        "You must answer all questions **independently**, including the coding ones.\n",
        "\n",
        "## Instructions\n",
        "\n",
        "### General Instructions\n",
        "In an ipython notebook, to run code in a cell or to render [Markdown](https://en.wikipedia.org/wiki/Markdown)+[LaTeX](https://en.wikipedia.org/wiki/LaTeX) press `Ctrl+Enter` or `[>|]`(like \"play\") button above. To edit any code or text cell (double) click on its content. To change cell type, choose \"Markdown\" or \"Code\" in the drop-down menu above.\n",
        "\n",
        "Most of the written questions are followed up a cell for you enter your answers. Please enter your answers in a new line below the **Answer** mark. If you do not see such cell, please insert one by yourself. Your answers and the questions should **not** be in the same cell.\n",
        "\n",
        "### Instructions on Math\n",
        "Some questions require you to enter math expressions. To enter your solutions, put down your derivations into the corresponding cells below using LaTeX. Show all steps when proving statements. If you are not familiar with LaTeX, you should look at some tutorials and at the examples listed below between \\$..\\$. The [OEIS website](https://oeis.org/wiki/List_of_LaTeX_mathematical_symbols) can also be helpful.\n",
        "\n",
        "Alternatively, you can scan your work from paper and insert the image(s) in a text cell.\n",
        "\n",
        "## Submission\n",
        "Once you are ready, save the note book as PDF file (File -> Print -> Save as PDF) and submit via Gradescope.\n",
        "\n",
        "Please select pages to match the questions on Gradescope. **You may be subject to a 5% penalty if you do not do so**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ra3x75Cq0TE9"
      },
      "source": [
        "##Q1: MDP##"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Q1.0: Setups"
      ],
      "metadata": {
        "id": "5va-te6ASat6"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YTCVccBl0bxu"
      },
      "source": [
        "**Packages**\n",
        "\n",
        "The package(s) imported in the following block should be sufficient for this task, but you are free to add more if necessary. However, keep in mind that you **should not** import and use any MDP package."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RIdUg8hh0dTm"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import sys\n",
        "from itertools import product\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XxPSV1lC92Is"
      },
      "source": [
        "**Examples for testing**\n",
        "\n",
        "The following block contains two examples used to test your code. You can create more for debugging, but please add it to a different block."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JUak0AUi90_w"
      },
      "outputs": [],
      "source": [
        "# a small MDP\n",
        "states = [0, 1, 2]\n",
        "actions = [0, 1] # 0 : stay, 1 : jump\n",
        "jump_probabilities = np.matrix([[0.1, 0.2, 0.7],\n",
        "                                [0.5, 0, 0.5],\n",
        "                                [0.6, 0.4, 0]])\n",
        "for i in range(len(states)):\n",
        "    jump_probabilities[i, :] /= jump_probabilities[i, :].sum()\n",
        "\n",
        "rewards_stay = np.array([0, 8, 5])\n",
        "rewards_jump = np.matrix([[-5, 5, 7],\n",
        "                          [2, -4, 0],\n",
        "                          [-3, 3, -3]])\n",
        "\n",
        "T = np.zeros((len(states), len(actions), len(states)))\n",
        "R = np.zeros((len(states), len(actions), len(states)))\n",
        "for s in states:\n",
        "    T[s, 0, s], R[s, 0, s] = 1, rewards_stay[s]\n",
        "    T[s, 1, :], R[s, 1, :] = jump_probabilities[s, :], rewards_jump[s, :]\n",
        "\n",
        "example_1 = (states, actions, T, R)\n",
        "\n",
        "# a larger MDP\n",
        "states = [0, 1, 2, 3, 4, 5, 6, 7]\n",
        "actions = [0, 1, 2, 3, 4]\n",
        "T = np.zeros((len(states), len(actions), len(states)))\n",
        "R = np.zeros((len(states), len(actions), len(states)))\n",
        "for a in actions:\n",
        "    T[:, a, :] = np.random.RandomState(4).uniform(0, 10, (len(states), len(states)))\n",
        "\n",
        "    # randomly delete 20% of the edges\n",
        "    tuples = list(product(states, actions, states))\n",
        "    np.random.RandomState(6).shuffle(tuples)\n",
        "    for t in tuples[:len(tuples) // 5]:\n",
        "        T[t[0], t[1], t[2]] = 0\n",
        "\n",
        "    # normalizing\n",
        "    for s in states:\n",
        "        T[s, a, :] /= T[s, a, :].sum()\n",
        "    R[:, a, :] = np.random.RandomState(8).uniform(-10, 10, (len(states), len(states)))\n",
        "\n",
        "example_2 = (states, actions, T, R)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C61z5yUe_8u0"
      },
      "source": [
        "###Q1.1: Value iteration\n",
        "\n",
        "Implement value iteration by finishing the following function, and then run the cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yjxNKNZ6_9Gj"
      },
      "outputs": [],
      "source": [
        "def value_iteration(states, actions, T, R, gamma = 0.95, tolerance = 1e-2, max_steps = 1000):\n",
        "    Vs = [] # all state values\n",
        "    Vs.append(np.zeros(len(states))) # initial state values\n",
        "    steps, convergent = 0, False\n",
        "    while not convergent and steps < max_steps: # complete this loop\n",
        "        ########################### start of your code #########################\n",
        "        # compute new state values as an array, and append the array to the list Vs\n",
        "\n",
        "        ############################ end of your code ##########################\n",
        "        convergent = np.linalg.norm(Vs[-1] - Vs[-2]) < tolerance\n",
        "        steps += 1\n",
        "    if steps == max_steps:\n",
        "        print(\"Max iterations reached before convergence.\")\n",
        "        sys.exit(1)\n",
        "    ########################### start of your code #########################\n",
        "    # compute Q from the last V array\n",
        "    # extract the optimal policy and name it \"policy\" to return\n",
        "\n",
        "    ############################ end of your code ##########################\n",
        "    return np.array(Vs), policy, steps\n",
        "\n",
        "states, actions, T, R = example_1\n",
        "gamma, tolerance, max_steps = 0.95, 1e-2, 1000\n",
        "Vs_1, policy_1, steps_1 = value_iteration(states, actions, T, R, gamma, tolerance, max_steps)\n",
        "\n",
        "states, actions, T, R = example_2\n",
        "gamma, tolerance, max_steps = 0.95, 1e-2, 1000\n",
        "Vs_2, policy_2, steps_2 = value_iteration(states, actions, T, R, gamma, tolerance, max_steps)\n",
        "\n",
        "fig, axes = plt.subplots(2, 1, figsize = (6, 8))\n",
        "for i in range(Vs_1.shape[1]):\n",
        "    axes[0].plot(Vs_1[:, i], label = \"state \" + str(i))\n",
        "axes[0].set_title(\"Example 1 State Values\", fontsize = 12)\n",
        "axes[0].set_xlabel(\"Step\", fontsize = 8)\n",
        "axes[0].legend()\n",
        "axes[0].grid(True)\n",
        "for i in range(Vs_2.shape[1]):\n",
        "    axes[1].plot(Vs_2[:, i], label = \"state \" + str(i))\n",
        "axes[1].set_title(\"Example 2 State Values\", fontsize = 12)\n",
        "axes[1].set_xlabel(\"Step\", fontsize = 8)\n",
        "axes[1].legend()\n",
        "axes[1].grid(True)\n",
        "fig.tight_layout()\n",
        "plt.show()\n",
        "\n",
        "print(\"Optimal policy for example 1: \" + str(policy_1))\n",
        "print(\"Optimal policy for example 2: \" + str(policy_2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_fKPsi2UBw8n"
      },
      "source": [
        "###Q1.2: Policy iteration\n",
        "\n",
        "Implement policy iteration by finishing the following function, and then run the cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c7byfxgyBye1"
      },
      "outputs": [],
      "source": [
        "def policy_iteration(states, actions, T, R, gamma = 0.95, tolerance = 1e-2, max_steps = 1000):\n",
        "    policy_list = [] # all policies explored\n",
        "    initial_policy = np.array([np.random.choice(actions) for s in states]) # random policy\n",
        "    policy_list.append(initial_policy)\n",
        "    Vs = [] # all state values\n",
        "    Vs = [np.zeros(len(states))] # initial state values\n",
        "    steps, convergent = 0, False\n",
        "    while not convergent and steps < max_steps:\n",
        "        ########################### start of your code #########################\n",
        "        # 1. Evaluate the current policy, and append the new state values as a numpy array to the list Vs\n",
        "        # You can define a function outside of policy_iteration if you want\n",
        "\n",
        "        # 2. Extract the new policy, and append the new policy as a numpy array to the list policy_list\n",
        "\n",
        "        ############################ end of your code ##########################\n",
        "        steps += 1\n",
        "        convergent = (policy_list[-1] == policy_list[-2]).all()\n",
        "    if steps == max_steps:\n",
        "        print(\"Max iterations reached before convergence.\")\n",
        "        sys.exit(1)\n",
        "    return Vs, policy_list, steps\n",
        "\n",
        "print(\"Example MDP 1\")\n",
        "states, actions, T, R = example_1\n",
        "gamma, tolerance, max_steps = 0.95, 1e-2, 1000\n",
        "Vs, policy_list, steps = policy_iteration(states, actions, T, R, gamma, tolerance, max_steps)\n",
        "for i in range(steps):\n",
        "    print(\"Step \" + str(i))\n",
        "    print(\"state values: \" + str(Vs[i]))\n",
        "    print(\"policy: \" + str(policy_list[i]))\n",
        "    print()\n",
        "print()\n",
        "print(\"Example MDP 2\")\n",
        "states, actions, T, R = example_2\n",
        "gamma, tolerance, max_steps = 0.95, 1e-2, 1000\n",
        "Vs, policy_list, steps = policy_iteration(states, actions, T, R, gamma, tolerance, max_steps)\n",
        "for i in range(steps):\n",
        "    print(\"Step \" + str(i))\n",
        "    print(\"state values: \" + str(Vs[i]))\n",
        "    print(\"policy: \" + str(policy_list[i]))\n",
        "    print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rvQqa18rDnwr"
      },
      "source": [
        "##Q1.3: More tests\n",
        "\n",
        "The following block tests both of your implementations with even more random MDPs. Simply run the cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YS1Wr2APDpu2"
      },
      "outputs": [],
      "source": [
        "steps_list_vi, steps_list_pi = [], []\n",
        "for i in range(20):\n",
        "    states = [j for j in range(np.random.randint(5, 40))]\n",
        "    actions = [j for j in range(np.random.randint(2, states[-1]))]\n",
        "    T = np.zeros((len(states), len(actions), len(states)))\n",
        "    R = np.zeros((len(states), len(actions), len(states)))\n",
        "    for a in actions:\n",
        "        T[:, a, :] = np.random.uniform(0, 10, (len(states), len(states)))\n",
        "\n",
        "        # randomly delete 20% of the edges\n",
        "        tuples = list(product(states, actions, states))\n",
        "        np.random.shuffle(tuples)\n",
        "        for t in tuples[:len(tuples) // np.random.randint(2, 20)]:\n",
        "            T[t[0], t[1], t[2]] = 0\n",
        "\n",
        "        for s in states:\n",
        "            T[s, a, :] /= T[s, a, :].sum()\n",
        "        R[:, a, :] = np.random.uniform(-10, 10, (len(states), len(states)))\n",
        "    Vs, policy, steps_v = value_iteration(states, actions, T, R)\n",
        "    Vs, policy_list, steps_p = policy_iteration(states, actions, T, R)\n",
        "    steps_list_vi.append(steps_v)\n",
        "    steps_list_pi.append(steps_p)\n",
        "print(\"Numbers of steps in value iteration: \" + str(steps_list_vi))\n",
        "print(\"Numbers of steps in policy iteration: \" + str(steps_list_pi))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gzXO3gCjDtaB"
      },
      "source": [
        "##Q2: RL"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Q2.0: Setups"
      ],
      "metadata": {
        "id": "_7cG1EA9TIcP"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nkii3z1sDvYX"
      },
      "source": [
        "**Install gym**\n",
        "\n",
        "First, if you have not done this yet, install gym with atari using the following command."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PBwcZiTKDxLo"
      },
      "outputs": [],
      "source": [
        "!pip install cmake 'gym[atari]'\n",
        "!pip install gym[toy_text]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Htahh7JSDyyc"
      },
      "source": [
        "**Setup visualization**\n",
        "\n",
        "The following commands are necessary for viewing the environment on Google Colab. There may be other ways if you run this notebook on your own machine."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-vnWNn6UD0H0"
      },
      "outputs": [],
      "source": [
        "!apt-get install -y xvfb python-opengl > /dev/null 2>&1\n",
        "!pip install gym pyvirtualdisplay > /dev/null 2>&1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ce29LoLPD4C7"
      },
      "source": [
        "**Packages**\n",
        "\n",
        "Again, the package(s) imported in the following block should be sufficient for this task, but you are free to add more if necessary. However, keep in mind that you **should not** import and use any RL package."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "noAJSYWCD-IH"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import scipy as sp\n",
        "import sys\n",
        "import gym"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CFlYjJqMD8A9"
      },
      "source": [
        "The following block sets up visualization on Google Colab. If you see errors, try ignoring them."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Gi-TpT79D7GJ"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from IPython import display as ipythondisplay\n",
        "from pyvirtualdisplay import Display\n",
        "display = Display(visible = 0, size = (400, 300))\n",
        "display.start()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Mx825ecEB2E"
      },
      "source": [
        "**Select environment**\n",
        "\n",
        "We will use the \"Taxi-v3\" environment for this task. In this environment, an agent attempts to pickup a customer and then drive to a specific location. The following block helps you understand a bit more about this environment. Feel free to modify anything inside.\n",
        "\n",
        "It is strongly recommended that you read the description of this environment [here](https://github.com/openai/gym/blob/master/gym/envs/toy_text/taxi.py)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MQG4k638EEZ4"
      },
      "outputs": [],
      "source": [
        "env = gym.make(\"Taxi-v3\", new_step_api = True).env\n",
        "\n",
        "env.reset()\n",
        "\n",
        "# if you run on Google Colab\n",
        "prev_screen = env.render(mode = 'rgb_array')\n",
        "plt.imshow(prev_screen)\n",
        "\n",
        "# if you run on your own machine\n",
        "# env.render()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FrewZkQHEHWP"
      },
      "source": [
        "**Understand the gym environment**\n",
        "\n",
        "As described in the source code, there are 500 states and 6 actions in this environment.\n",
        "\n",
        "Initially, the passenger and the destination can only spawn at two distinct color tiles.\n",
        "\n",
        "Each state is encoded with the following information: taxi coordinate, passenger locations, and destination location.\n",
        "\n",
        "Passenger locations are:\n",
        "- 0: R(ed)\n",
        "- 1: G(reen)\n",
        "- 2: Y(ellow)\n",
        "- 3: B(lue)\n",
        "- 4: in taxi\n",
        "\n",
        "Destination locations are:\n",
        "- 0: R(ed)\n",
        "- 1: G(reen)\n",
        "- 2: Y(ellow)\n",
        "- 3: B(lue)\n",
        "\n",
        "Actions are:\n",
        "- 0: move south\n",
        "- 1: move north\n",
        "- 2: move east\n",
        "- 3: move west\n",
        "- 4: pickup passenger\n",
        "- 5: drop off passenger\n",
        "\n",
        "Rewards are:\n",
        "- -1 per step unless other reward is triggered\n",
        "- +20 delivering passenger\n",
        "- -10  executing \"pickup\" and \"drop-off\" actions illegally\n",
        "\n",
        "The environment includes a dictionary P storing the reward for each (state, action) pair. The information stored in P has the following structure: {state: {action: [(probability, nextstate, reward, done)]}}\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D5F_XsL6EJVD"
      },
      "outputs": [],
      "source": [
        "env.P[10] # shows the rewards in the 10th states"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zr822QA2EK05"
      },
      "source": [
        "Note that all probabilities are 1 in this environment."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YreIrwzsEMXu"
      },
      "source": [
        "###Q2.1: Q-learning"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Implement Q-learning**\n",
        "\n",
        "Implement Q-learning by modifying the specified part in the following block. Currently it is only taking a random action."
      ],
      "metadata": {
        "id": "ptec_LduUL2I"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "htdhwh7VEOO0"
      },
      "outputs": [],
      "source": [
        "def Q_learning(env, episodes = 100000, alpha = 0.1, gamma = 0.6, epsilon = 0.1):\n",
        "    Q_values = np.zeros([env.observation_space.n, env.action_space.n])\n",
        "    rewards_list = [0] * episodes\n",
        "    for episode in range(episodes):\n",
        "        state = env.reset()\n",
        "        done = False\n",
        "        while not done:\n",
        "            ########################################################################\n",
        "            # TO DO: implement Q-learning update\n",
        "            action = env.action_space.sample()\n",
        "            next_state, reward, done, info = env.step(action) # you shouldn't change this line\n",
        "            ############################# End of your code #########################\n",
        "            rewards_list[episode] += reward\n",
        "            state = next_state\n",
        "    return Q_values, rewards_list"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OEfvkG3lEavI"
      },
      "source": [
        "**Train and evaluate**\n",
        "\n",
        "Run the following block to train and evaluate your implementation.\n",
        "\n",
        "You are free to write your own code to debug or to test. For example, you can experiment with some more hyperparameter settings. But please do so in a new code block and delete it before submitting. Furthermore, keep in mind that if the number of episodes of training is too small, your agent may not learn enough information and get stuck during testing forever."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xvSdBhtyEcal"
      },
      "outputs": [],
      "source": [
        "env.reset()\n",
        "Q_values, rewards_list = Q_learning(env)\n",
        "\n",
        "episodes = 1000\n",
        "steps_count, failures_count = 0, 0\n",
        "\n",
        "for episode in range(episodes):\n",
        "    state = env.reset()\n",
        "    done = False\n",
        "    while not done:\n",
        "        action = np.argmax(Q_values[state])\n",
        "        state, reward, done, info = env.step(action)\n",
        "        steps_count += 1\n",
        "        failures_count += reward == -10\n",
        "\n",
        "print(\"Average steps per episode: \" + str(np.round(steps_count / episodes, 2))) # should be less than 20\n",
        "print(\"Number of failures: \" + str(failures_count)) # should be very very low\n",
        "\n",
        "# the curve should be overall increasing\n",
        "fig, ax = plt.subplots()\n",
        "ax.plot(rewards_list)\n",
        "ax.set_title(\"Training Reward Plot\")\n",
        "ax.set_xlabel(\"Episode\")\n",
        "ax.set_ylabel(\"Reward\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Q 3: Adversarial Search##"
      ],
      "metadata": {
        "id": "avI0DjzH9bZM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![AdversarialSearch.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "xQ0lhchv9wRI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Consider an adversarial game with **three** players acting independently and the winner is unique. Suppose we have an AI agent using the minimax algorithm to play this game and it has produced a search tree shown in the figure above. In this search tree,\n",
        "\n",
        "1. the first level (node 0) is the **maximizing** level;\n",
        "2. the second level (node 1 and 2) is the ***minimizing*** level;\n",
        "3. the third level (node 3, 4, 5, and 6) is the ***minimizing*** level;\n",
        "4. the fourth level (node 7 to 14) is the **maximizing** level;\n",
        "5. the fifth level (node 15 to 30) is the leaf level and the number beneath each node is the static evaluator score of the corresponding game state."
      ],
      "metadata": {
        "id": "XHRXbUj29jLR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Q3.1\n",
        "\n",
        "Apply the minimax algorithm without pruning. Enter the returned value for each non-leaf node (node 0 to 14) below in the dictionary M and run the cell."
      ],
      "metadata": {
        "id": "hXngz_S_-Pak"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas\n",
        "\n",
        "M = {0 : 0,\n",
        "     1 : 0,\n",
        "     2 : 0,\n",
        "     3 : 0,\n",
        "     4 : 0,\n",
        "     5 : 0,\n",
        "     6 : 0,\n",
        "     7 : 0,\n",
        "     8 : 0,\n",
        "     9 : 0,\n",
        "     10 : 0,\n",
        "     11 : 0,\n",
        "     12 : 0,\n",
        "     13 : 0,\n",
        "     14 : 0\n",
        "}\n",
        "\n",
        "df = pandas.DataFrame(M, index = [0])\n",
        "df"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 81
        },
        "id": "J3mS0Da5-dOT",
        "outputId": "6c2a47e8-94b2-4cc3-a7e1-a16feee70589"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   0   1   2   3   4   5   6   7   8   9   10  11  12  13  14\n",
              "0   0   0   0   0   0   0   0   0   0   0   0   0   0   0   0"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-586d0c52-f100-4797-99e1-694e088189e5\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>0</th>\n",
              "      <th>1</th>\n",
              "      <th>2</th>\n",
              "      <th>3</th>\n",
              "      <th>4</th>\n",
              "      <th>5</th>\n",
              "      <th>6</th>\n",
              "      <th>7</th>\n",
              "      <th>8</th>\n",
              "      <th>9</th>\n",
              "      <th>10</th>\n",
              "      <th>11</th>\n",
              "      <th>12</th>\n",
              "      <th>13</th>\n",
              "      <th>14</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-586d0c52-f100-4797-99e1-694e088189e5')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-586d0c52-f100-4797-99e1-694e088189e5 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-586d0c52-f100-4797-99e1-694e088189e5');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {},
          "execution_count": 31
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Q3.2\n",
        "\n",
        "Indicate the optimal path as a linked list of nodes (e.g., 0 - 1 - 3 - 7 - 15) the agent will choose."
      ],
      "metadata": {
        "id": "s_HL62ot_tf0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Answer**"
      ],
      "metadata": {
        "id": "mE3yBY8M_1oh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Q3.3\n",
        "\n",
        "Apply the minimax algorithm with alpha-beta pruning. List all of the nodes in ascending index order that will be pruned and run the cell."
      ],
      "metadata": {
        "id": "iQOLh-P4_5SZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "answer = [] # enter your answer in this array\n",
        "answer.sort() # just for easier grading\n",
        "print(answer)"
      ],
      "metadata": {
        "id": "M9P6AA5k__qN"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}