{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "brNDGX-kvzds"
      },
      "source": [
        "# Template for Notes for CIS 521 Midterm 1\n",
        "\n",
        "The midterm exam for CIS 521 will be **open notes**. No other matierals are allowed for the exam - you may not use the textbook, the internet, a Python envionement, or communicate with anyone during the exam. \n",
        "\n",
        "This python notebook is where you should save all of your notes.  It provides a structured template that allows you to add summaries for each of the textbook sections that are part of the required reading, plus room for lecture notes and definitions.\n",
        "\n",
        "Your summaries must be written in your own words.  Do not copy and paste from the textbook.  Do not share your notes with classmates, or copy any of your classmates' notes.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aPtM8g7R0Pds"
      },
      "source": [
        "# Instructions\n",
        "\n",
        "1. Make a copy of this Google Colab file. From the colab menu, pick **File > Save a copy in Drive**.  That will save a copy of this notebook in your Google drive.\n",
        "2. Go through each section of the notebook, and fill in all the summaries for each chapter and its corresponding sections.  Be sure to save your work frequently!\n",
        "3. Read the notes below about how you can format your summaries.\n",
        "4. In addition to these notes, you are allowed 1 page (both sides) for figures or handwritten notes.\n",
        "5. Submit your version of this notebook to Gradescope before you start the exam.\n",
        "6. If you are taking the exam in person, then you must print a copy of your notes for yourself.   Here's how to print: \n",
        "* Run the last cell of this notebook\n",
        "* Click the \"Mirror cell in tab\" button (this is located in the upper right corner of the cell, immediately to the right of the trash can).  This will open the cell.  \n",
        "* In Chrome, you can then print your notes using the **File > Print** option from the browser's menu.  \n",
        "* In the print options, change the layout from Landscape to Portrait. \n",
        "* Clicking the Save, will save a PDF that you can then print.\n",
        "\n",
        "## Formatting Notes\n",
        "\n",
        "1. The max length for each section's summary is 500 words / 3000 characters.\n",
        "2. You can also write a 2000 word summary of the lectures for each module.\n",
        "3. You may also write definitions of concepts for each module.  The definitions should be written in your own words (not copy and pasted), and they should be no more than 20 words long for each concept. \n",
        "2. You can use Markdown formatting for your summaries. \n",
        "3. You can use Latex formatting for equations. Put two dollar signs before and after your equation like this: \n",
        "$$ \\epsilon = \\frac{1}{mc^2} $$\n",
        "4. When you write python code or psuedocode algorithms, you should surround it with triple backticks like this:\n",
        "```\n",
        "def function():\n",
        "      print('hello world')\n",
        "```\n",
        "5. Write \\ whenever you want to keep writing on the next line without a newline being inserted."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cw5IpDLCZa4W"
      },
      "source": [
        "## Example summary\n",
        "\n",
        "This is a sample summary of [Section 2.1.1](https://web.stanford.edu/~jurafsky/slp3/2.pdf ) of Jurfasky and Martin's Speech and Language Processing's book\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lzaavW96tcxM",
        "outputId": "7dfb0536-267e-48d0-9d68-19940c8aa522"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The example summary is 116 words long, so you could write an additional 384 words.\n"
          ]
        }
      ],
      "source": [
        "chapter_2_1_example = \"\"\"\n",
        "Regular expressions are an algebraic notation for characterizing \\\n",
        "a set of strings that are useful for searching for a pattern or through a corpus.\\\n",
        "Only the first matching result will be shown. The search string is case sensitive, \\\n",
        "but it can consist of a single character or a sequence of characters. \\\n",
        "While square braces specify a disjunction of characters, the dash can more easily look \\\n",
        "for characters over a range. The caret specifies the non-existence of a character. \\\n",
        "Additionally, the (?) is used to for flexibility on a single character, meaning \\\n",
        "\"the preceding character or nothing\". More importantly, the Kleene star means zero or \\\n",
        "more occurrences of the immediately previous character or regular expression in square braces.\\\n",
        "...\n",
        "\"\"\"\n",
        "\n",
        "length = len(chapter_2_1_example.split(\" \"))\n",
        "print(\"The example summary is {len} words long, so you could write an additional \\\n",
        "{remaining} words.\".format(len=length, remaining=(500-length)))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s3Uk9gQTevcj"
      },
      "source": [
        "## Example summary length\n",
        "\n",
        "The maximum summary length for each section is 500 words / 3000 characters.  Hopefully you'll find that to be quite generous. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8DvZ57A-djo1",
        "outputId": "be87c7cf-f489-4a47-e24d-0c0e1972d140"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The length in words is 500\n",
            "The length in characters is 3030\n"
          ]
        }
      ],
      "source": [
        "# This is an example of a 500 word placeholder\n",
        "placeholder = \"\"\"ultrices vitae auctor eu augue ut lectus arcu bibendum at varius \\\n",
        " vel pharetra vel turpis nunc eget lorem dolor sed viverra ipsum nunc aliquet \\\n",
        " bibendum enim facilisis gravida neque convallis a cras semper auctor neque vitae \\\n",
        " tempus quam pellentesque nec nam aliquam sem et tortor consequat id porta nibh \\\n",
        " venenatis cras sed felis eget velit aliquet sagittis id consectetur purus ut \\\n",
        " faucibus pulvinar elementum integer enim neque volutpat ac tincidunt vitae semper \\ \n",
        " quis lectus nulla at volutpat diam ut venenatis tellus in metus vulputate eu \\\n",
        " scelerisque felis imperdiet proin fermentum leo vel orci porta non pulvinar neque \\ \n",
        " laoreet suspendisse interdum consectetur libero id faucibus nisl tincidunt eget \\\n",
        " nullam non nisi est sit amet facilisis magna etiam tempor orci eu lobortis \\\n",
        " elementum nibh tellus molestie nunc non blandit massa enim nec dui nunc mattis \\\n",
        " enim ut tellus elementum sagittis vitae et leo duis ut diam quam nulla porttitor \\\n",
        " massa id neque aliquam vestibulum morbi blandit cursus risus at ultrices mi tempus \\\n",
        " imperdiet nulla malesuada pellentesque elit eget gravida cum sociis natoque \\\n",
        " penatibus et magnis dis parturient montes nascetur ridiculus mus mauris vitae \\\n",
        " ultricies leo integer malesuada nunc vel risus commodo viverra maecenas accumsan \\\n",
        " lacus vel facilisis volutpat est velit egestas dui id ornare arcu odio ut sem nulla \\\n",
        " pharetra diam sit amet nisl suscipit adipiscing bibendum est ultricies integer \\\n",
        " quis auctor elit sed vulputate mi sit amet mauris commodo quis imperdiet massa \\\n",
        " tincidunt nunc pulvinar sapien et ligula ullamcorper malesuada proin libero nunc \\\n",
        " consequat interdum varius sit amet mattis vulputate enim nulla aliquet porttitor \\\n",
        " lacus luctus accumsan tortor posuere ac ut consequat semper viverra nam libero \\\n",
        " justo laoreet sit amet cursus sit amet dictum sit amet justo donec enim diam \\\n",
        " vulputate ut pharetra sit amet aliquam id diam maecenas ultricies mi eget mauris \\\n",
        " pharetra et ultrices neque ornare aenean euismod elementum nisi quis eleifend quam \\\n",
        " adipiscing vitae proin sagittis nisl rhoncus mattis rhoncus urna neque viverra justo \\\n",
        " nec ultrices dui sapien eget mi proin sed libero enim sed faucibus turpis in \\\n",
        " eu mi bibendum neque egestas congue quisque egestas diam in arcu cursus euismod \\\n",
        " quis viverra nibh cras pulvinar mattis nunc sed blandit libero volutpat sed cras \\\n",
        " ornare arcu dui vivamus arcu felis bibendum ut tristique et egestas quis ipsum \\\n",
        " suspendisse ultrices gravida dictum fusce ut placerat orci nulla pellentesque \\\n",
        " dignissim enim sit amet venenatis urna cursus eget nunc scelerisque viverra mauris \\\n",
        " in aliquam sem fringilla ut morbi tincidunt augue interdum velit euismod in \\\n",
        " pellentesque massa placerat duis ultricies lacus sed turpis tincidunt id aliquet \\\n",
        " risus feugiat in ante metus dictum at tempor commodo ullamcorper a lacus vestibulum \\\n",
        " sed arcu non odio euismod lacinia at quis risus sed vulputate odio ut enim blandit \\\n",
        " volutpat maecenas volutpat blandit aliquam etiam erat velit scelerisque in \\\n",
        " dictum non consectetur a erat nam at lectus urna\"\"\"\n",
        "\n",
        "print(\"The length in words is\", len(placeholder.split(' ')))\n",
        "print(\"The length in characters is\", len(placeholder))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5yG3-YncJfTB"
      },
      "source": [
        "# Permissions to use your summaries\n",
        "\n",
        "We'd like to use your summaries to help develop better educational resources like [remember.school](https://remember.school) or a question-answering system about the textbook.  \n",
        "\n",
        "1. Please enter your name.  \n",
        "\n",
        "2. If you grant permission for us to use your summaries under a [Creative Commons License](https://creativecommons.org/licenses/by/4.0/), please set ```permission = True```.  If you do not grant permission, please set it to false. Your answer won't affect your grade.\n",
        "\n",
        "3. If you grant us permission, and you'd like to remain anonymous, set ```anonymous = True```.  We'll remove your name before sharing your summaries with anyone. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2RECnJArJew4"
      },
      "outputs": [],
      "source": [
        "name = \"\"\n",
        "permission = True\n",
        "anonymous = True"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GZZXyrV-xuAp"
      },
      "source": [
        "# Module 1 - Intro to AI"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Y2NfE1CKxzS-"
      },
      "outputs": [],
      "source": [
        "# Russell and Norvig, AIMA 4th Edition, Chapter 1 “Introduction”, Section 1.1 “What is AI”\n",
        "\n",
        "chapter1_1 = \"\"\" \n",
        "AI is the study of intellegence. There have been many different approchaes to this problem throughout history. \\\n",
        "The different disiplines focus on different things. There is this idea of Human vs Rational and Thought vs Behaviour. \\\n",
        "The four combinations of these words have formed different diciplines of studying problem solving and what it means to think. \n",
        " \"\"\" \n",
        "\n",
        "# Russell and Norvig, AIMA 4th Edition, Chapter 27 “Philosophical Foundations”, Sections 27.1 “The Limits of AI” and 27.2 “Can Machines Really Think?”\n",
        "chapter27_1 = \"\"\" \n",
        "John Searle introduced the idea of strong and weak AI. Strong AI is the idea that machines conciously think to solve problems. \\\n",
        "Weak AI is the opposite. Weak AI is the idea that a machine could act as if it is intelligent, howeve, it would just be simulating this intellegence. \\\n",
        "\\\n",
        "Turing made the argument that human behvaiour is far to subtle to be captured in a strict set of rules. This is called the argument from informality. This \\\n",
        "is the idea that there are so many laws that humans follow that are not stricly defined, which would make it impossible to create a set of rules to mimick humanity.\n",
        " \"\"\"\n",
        "chapter27_2 = \"\"\" There has been a lot of debate with regards to the idea of if a machine can think. While this is a heated topic, many in the field do not bother themselves with this thought \\\n",
        "as it is irrelivant at the end of the day. \"\"\"\n",
        "\n",
        "# Russell and Norvig, AIMA 4th Edition, Chapter 2 “Intelligent Agents” (whole chapter)\n",
        "chapter2_1 = \"\"\" An agent is anything that can perceive it's suroundings and act based on that in some enviroment. \\\n",
        "The agent generally depends on it's inbuilt knowlange and its percept sequence to make decitions and act in the environment.\\\n",
        " \"\"\"\n",
        "chapter2_2 = \"\"\" \n",
        "Genearlly, AI has stuck with a measure of correctness called consequentialism. This is the idea that an action's success is measured by it's consequences. \\\n",
        "Mahines, unlike humans, do not have an inate measure of a good and bad outcome. For this reason, we need to expicitly define performance measure to tell the \\\n",
        "AI what is a good outcome and what is a bad outcome. The performance measure can also be implicit depnding on the problem.\"\"\"\n",
        "chapter2_3 = \"\"\" \n",
        "A rational agent is an agent that will make an action based on it's percept sequence and inbuilt knowlage that will maximize the performance measure. \\\n",
        "A rational agent is different from an omniscience agent. An omniscience agent knows with perfect acuracy what the actual outcome of it's action will be.\n",
        " \"\"\"\n",
        "chapter2_4 = \"\"\" Your summary here 170\"\"\" \n",
        "\n",
        "# Lecture notes \n",
        "module1_lecture_notes = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "\n",
        "# Definitions of concepts from Module 1.\n",
        "# You can define any bolded term in the textbook, \n",
        "# but you most use your own words for the definitions.\n",
        "# Each definition should be at most 20 words long.\n",
        "module1_definitions = {\n",
        "\"agent\" : \"anything that can perceive and act in an environment\",\n",
        "\"sensor\" : \"the parts of the agent that allow it to recive information about the world.\",\n",
        "\"actuators\" : \"the parts of the agent that act on the environment. This is the way the agent acts on it's enviroment.\",\n",
        "\"percept\" : \"the content that an agent is reciving via it's sensors\",\n",
        "\"percept sequence\" : \"The total history of every percept that the agent has recived, via its sensors, from it's enviorment.\",\n",
        "\"Agent function\" : \"A function that maps a percept sequence to a set of actions. This is a theoretical model or mathmatical description.\",\n",
        "\"Agent program\" : \"This is the real world implementation of the Agent function. The agent program general be acting in physical system.\",\n",
        "\"chinese room\" : \"A thought experiment that shows how understanding of a topic is not required in order to imitate understanding.\",\n",
        "\"performance measure\" : \"Function that evaluates a given sequence of enviormental states. Used to evaluate desierability of an outcome.\",\n",
        "\"Rational Agent\" : \"RA should select an action based on percept seq and inbuilt knowlage that will maximize it's performance measure\"\n",
        "}\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "elCCgY64spuq"
      },
      "source": [
        "## Preview of your notes for Module 1\n",
        "\n",
        "Here's a preview of your how your notes will be displayed.  At the end of this Python notebook, we'll aggregate your notes for all modules together into a single display.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "gYYeNcdM_maE",
        "outputId": "dfa9b4e8-eeb0-453a-8fb4-b99acff2060e"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "# Module 1: Rational Agents and Task Environments\n",
              "## AIMA Chapter 1.1 What is AI?\n",
              " \n",
              "AI is the study of intellegence. There have been many different approchaes to this problem throughout history. The different disiplines focus on different things. There is this idea of Human vs Rational and Thought vs Behaviour. The four combinations of these words have formed different diciplines of studying problem solving and what it means to think. \n",
              " \n",
              "\n",
              "## AIMA Chapter 27.1 The Limits of AI\n",
              " \n",
              "John Searle introduced the idea of strong and weak AI. Strong AI is the idea that machines conciously think to solve problems. Weak AI is the opposite. Weak AI is the idea that a machine could act as if it is intelligent, howeve, it would just be simulating this intellegence. Turing made the argument that human behvaiour is far to subtle to be captured in a strict set of rules. This is called the argument from informality. This is the idea that there are so many laws that humans follow that are not stricly defined, which would make it impossible to create a set of rules to mimick humanity.\n",
              " \n",
              "\n",
              "## AIMA Chapter 27.1 Can Machines Really Think?\n",
              " There has been a lot of debate with regards to the idea of if a machine can think. While this is a heated topic, many in the field do not bother themselves with this thought as it is irrelivant at the end of the day. \n",
              "\n",
              "## AIMA 2.1 Agents and Environments\n",
              " An agent is anything that can perceive it's suroundings and act based on that in some enviroment. The agent generally depends on it's inbuilt knowlange and its percept sequence to make decitions and act in the environment. \n",
              "\n",
              "## AIMA 2.2 Good Behavior: The Concept of Rationality\n",
              " \n",
              "Genearlly, AI has stuck with a measure of correctness called consequentialism. This is the idea that an action's success is measured by it's consequences. Mahines, unlike humans, do not have an inate measure of a good and bad outcome. For this reason, we need to expicitly define performance measure to tell the AI what is a good outcome and what is a bad outcome. The performance measure can also be implicit depnding on the problem.\n",
              "\n",
              "## AIMA 2.3 The Nature of Environments\n",
              " \n",
              "A rational agent is an agent that will make an action based on it's percept sequence and inbuilt knowlage that will maximize the performance measure. A rational agent is different from an omniscience agent. An omniscience agent knows with perfect acuracy what the actual outcome of it's action will be.\n",
              " \n",
              "\n",
              "## AIMA 2.4 The Structure of Agents\n",
              " Your summary here 170\n",
              "\n",
              "## Module 1 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 1 Definitions\n",
              "* **Agent** - anything that can perceive and act in an environment\n",
              "* **Sensor** - the parts of the agent that allow it to recive information about the world.\n",
              "* **Actuators** - the parts of the agent that act on the environment. This is the way the agent acts on it's enviroment.\n",
              "* **Percept** - the content that an agent is reciving via it's sensors\n",
              "* **Percept sequence** - The total history of every percept that the agent has recived, via its sensors, from it's enviorment.\n",
              "* **Agent function** - A function that maps a percept sequence to a set of actions. This is a theoretical model or mathmatical description.\n",
              "* **Agent program** - This is the real world implementation of the Agent function. The agent program general be acting in physical system.\n",
              "* **Chinese room** - A thought experiment that shows how understanding of a topic is not required in order to imitate understanding.\n",
              "* **Performance measure** - Function that evaluates a given sequence of enviormental states. Used to evaluate desierability of an outcome.\n",
              "* **Rational agent** - RA should select an action based on percept seq and inbuilt knowlage that will maximize it's performance measure\n"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Preview of your summary\n",
        "#@markdown You don't need to modify anything in this cell. Just press play.\n",
        "from IPython.display import display, Markdown, Latex\n",
        "\n",
        "module1_sections = [\n",
        "  (\"AIMA Chapter 1.1 What is AI?\", chapter1_1),\n",
        "  (\"AIMA Chapter 27.1 The Limits of AI\", chapter27_1),\n",
        "  (\"AIMA Chapter 27.1 Can Machines Really Think?\", chapter27_2),\n",
        "  (\"AIMA 2.1 Agents and Environments\", chapter2_1),\n",
        "  (\"AIMA 2.2 Good Behavior: The Concept of Rationality\", chapter2_2),\n",
        "  (\"AIMA 2.3 The Nature of Environments\", chapter2_3),\n",
        "  (\"AIMA 2.4 The Structure of Agents\", chapter2_4),\n",
        "  (\"Module 1 Lecture Notes\", module1_lecture_notes),\n",
        "]\n",
        "\n",
        "\n",
        "def length_check(sections):\n",
        "  warnings = \"\"\n",
        "  for section, summary in sections:\n",
        "    max_word_length = 500\n",
        "    max_character_length = 3000\n",
        "    if \"lecture\" in section.lower():\n",
        "      # It's OK to do longer summaries of the lectures\n",
        "      max_word_length = 2000\n",
        "      max_character_length = 12000  \n",
        "    if (len(summary) > max_character_length or len(summary.split(' ')) > max_word_length):\n",
        "      warnings += \"WARNING: Your summary of '{section}' is too long!\\n\".format(section=section)\n",
        "  return warnings\n",
        "\n",
        "def length_check_definitions(definitions):\n",
        "  warnings = \"\"\n",
        "  for concept, definition in definitions.items():\n",
        "    if(len(definition.split(' ')) > 20):\n",
        "      warnings += \"WARNING: Your definition of '{concept}' is too long!\\n\".format(concept=concept)\n",
        "  return warnings\n",
        "\n",
        "\n",
        "def format_module(module_num, title, sections, definitions, show_placeholder=False):\n",
        "  markdown = \"\"\n",
        "\n",
        "  # Check summary lengths\n",
        "  warnings = length_check(sections)\n",
        "  if warnings != \"\":\n",
        "    markdown += \"## \" + warnings\n",
        "\n",
        "  # Check definition lengths\n",
        "  warnings = length_check_definitions(definitions)\n",
        "  if warnings != \"\":\n",
        "    markdown += \"## \" + warnings\n",
        "\n",
        "  markdown += \"# Module {num}: {title}\\n\".format(num=module_num, title=title)\n",
        "\n",
        "\n",
        "  for section, summary in sections:\n",
        "    if show_placeholder and summary == \" Your summary here \":\n",
        "      summary = placeholder\n",
        "    markdown += \"## {section}\\n{summary}\\n\\n\".format(section=section, summary=summary)\n",
        "  \n",
        "  markdown += \"## Module {num} Definitions\\n\".format(num=module_num)\n",
        "  for concept, definition in definitions.items():\n",
        "    markdown += \"* **{concept}** - {definition}\\n\".format(concept=concept.capitalize(), definition=definition)\n",
        "  return markdown\n",
        "\n",
        "\n",
        "module1_markdown = format_module(1, \"Rational Agents and Task Environments\", module1_sections, module1_definitions)\n",
        "display(Markdown(module1_markdown))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9xRbdqDox2zD"
      },
      "source": [
        "#Module 2 - Python"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DpBvu7EMx7sy"
      },
      "outputs": [],
      "source": [
        "# No readings for this module.  Instead you can summarize the lecture instead.\n",
        "\n",
        "# Lecture notes \n",
        "module2_lecture_notes = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "# Each definition should be at most 20 words long.\n",
        "module2_definitions = {\n",
        "\"mutability\" : \"your definition here\",\n",
        "}"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 209
        },
        "id": "ydOK__lwWgdp",
        "outputId": "29a284ad-fd9a-42a0-ca43-420345ab90ff"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "# Module 2: Python\n",
              "## Module 2 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 2 Definitions\n",
              "* **Mutability** - your definition here\n"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Preview of your summary\n",
        "#@markdown You don't need to modify anything in this cell. Just press play.\n",
        "\n",
        "module2_sections = [\n",
        "  (\"Module 2 Lecture Notes\", module2_lecture_notes),\n",
        "]\n",
        "\n",
        "module2_markdown = format_module(2, \"Python\", module2_sections, module2_definitions)\n",
        "display(Markdown(module2_markdown))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "46MQLR-Gx8dZ"
      },
      "source": [
        "#Module 3 - Search Problems"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 56,
      "metadata": {
        "id": "BN0b1eVYx-nd"
      },
      "outputs": [],
      "source": [
        "# Russell and Norvig, AIMA 4th Edition, AIMA Chapter 3 “Problem Solving by Search” (3.1-3.4)\n",
        "chapter3_1 = \"\"\" \n",
        "In some problems, an agent needs to plan ahead multiple steps. These are called \\\n",
        "problem solving agents. PSA's use atomic reperesentations of the enviorment, \\\n",
        "this means that they are given the state of the world as a whole. It does not \\\n",
        "have any internal structure. Similar agents that get a structured or fractured \\\n",
        "view of the world are called planning agents. Goals are formed to limit the \\\n",
        "objectives and in turn the possible actions, which make the desired outcome clearer. \\\n",
        "\n",
        "\n",
        " \"\"\"\n",
        "chapter3_2 = \"\"\" To design a search problem you need \\\n",
        "initial state, possible actions, a transition model, goal states, and an action \\\n",
        "cost function or a set action cost. \\\n",
        "The sokoban puzzle is an example of a problem that can be modeled as a search \\\n",
        "problem. An example of this from the homework is the sliding tile puzzle problem \\\n",
        "(also known as the 8 puzzle). \\\n",
        "When designing a model, it is key that you identify some abstractions. This \\\n",
        "can involve ignoring intermediate steps like in the 8 puzzle and just focusing on \\\n",
        "whether an action can lead to a goal state or not.\n",
        " \"\"\"\n",
        "chapter3_3 = \"\"\" Your summary here \"\"\"\n",
        "chapter3_4 = \"\"\" BFS, best first search, Uniform cost search, DFS, \\\n",
        "backtracking search (less memory dfs).\\\n",
        "There is also depth limited and iterative deepening search. Depth limited search \\\n",
        "can be incomplete if we choose the wrong l (max depth allowed). Iterative deepening \\\n",
        "search is just multiple applications of depth limited search. In this algo, you\\\n",
        "slowly increase the depth allowed for dfs. \\\n",
        "Iterative deepening search is complete on finite acyclic state spaces! \\\n",
        "Bidirectional search also exists. In this search, you seach from the goal and start \\\n",
        "simultaneously and hope the two will meet. \n",
        "\n",
        "This is helpful: (limits, time, space)\n",
        "\n",
        "\n",
        "BFS: complete and optimal (finite state space, and action costs are identical, $O(b^d),O(b^d)$ ) \n",
        "\n",
        "Uniform cost: Complete and optimal (finite, and all actions are positive $O(b^{C*/e}$, same) \n",
        "\n",
        "DFS: No and No ($O(b^m)$, $O(bm)$), \n",
        "\n",
        "Depth limited: No and No ($O(b^l),O(bl)$)\n",
        "\n",
        "Iterative deepening: complete and optimal (finite, and action costs are identical $O(b^d), O(bd)$) \n",
        "\n",
        "Bidirectional: complete and optimal (finite and both directions are bfs or uniform cost $O(b^{d/2},$ same)\n",
        " \"\"\"\n",
        "\n",
        "\n",
        "# Lecture notes \n",
        "module3_lecture_notes = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "# Definitions of concepts from Module 3.\n",
        "# You can define any bolded term in the textbook, \n",
        "# but you most use your own words for the definitions.\n",
        "# Each definition should be at most 20 words long.\n",
        "module3_definitions = {\n",
        "\"problem-solving agent\" : \"an agent that can formulate a plan via search. plan a sequence of actions instead of a single action response\",  \n",
        "\"informed algo\" : \"an algorithm tha can estimate how far it is from the goal state\",\n",
        "\"uniformed algo\" : \"an algorithm that cannot estimate how far it is from the goal or end state\",\n",
        "\"solution\" : \"a sequence of actions that reach a goal state. also a path of states.\",\n",
        "\"open-loop system\" : \"a problem/enviorment where once a solution is found, the agent can blindly follow the actions\",\n",
        "\"close-loop system\" : \"a problem where the agent checks it's precepts as it goes. This may be nessisary if enviorment nodeterministic\",\n",
        "\"search problem\" : \"this is a set of states that the environment could be in\",\n",
        "\"state space\" : \"same as previous definition\",\n",
        "\"initial state\"  : \"the state that the agent starts at at the beginning of the problem\",\n",
        "\"goal state\" : \"the goal that the search problem is searching for. Like a goal. solution how you got there.\",\n",
        "\"transition model\" : \"takes in a state and an action and outputs a new state\",\n",
        "\"action cost function\" : \"returns a numeric cost of applying an action on a given state\",\n",
        "\"optimal solution\" : \"an optimal solution is a solution that has the lowest path cost among all other solutions\",\n",
        "\"graph\" : \"a search problem can be thought of as a graph. vertices are states and edges are actions\"\n",
        "}\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "lvtN3p7ET3Tx",
        "outputId": "65f2e4d3-3bc8-4c6a-8987-1b298fa6e9ab"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "# Module 3: Search Problems\n",
              "## AIMA Chapter 3.1 Problem-Solving Agents\n",
              " \n",
              "In some problems, an agent needs to plan ahead multiple steps. These are called problem solving agents. PSA's use atomic reperesentations of the enviorment, this means that they are given the state of the world as a whole. It does not have any internal structure. Similar agents that get a structured or fractured view of the world are called planning agents. Goals are formed to limit the objectives and in turn the possible actions, which make the desired outcome clearer. \n",
              "\n",
              " \n",
              "\n",
              "## AIMA Chapter 3.2 Example Problems\n",
              " To design a search problem you need initial state, possible actions, a transition model, goal states, and an action cost function or a set action cost. The sokoban puzzle is an example of a problem that can be modeled as a search problem. An example of this from the homework is the sliding tile puzzle problem (also known as the 8 puzzle). When designing a model, it is key that you identify some abstractions. This can involve ignoring intermediate steps like in the 8 puzzle and just focusing on whether an action can lead to a goal state or not.\n",
              " \n",
              "\n",
              "## AIMA Chapter 3.3 Search Algorithms\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 3.4 Uninformed Search Strategies\n",
              " BFS, best first search, Uniform cost search, DFS, backtracking search (less memory dfs).There is also depth limited and iterative deepening search. Depth limited search can be incomplete if we choose the wrong l (max depth allowed). Iterative deepening search is just multiple applications of depth limited search. In this algo, youslowly increase the depth allowed for dfs. Iterative deepening search is complete on finite acyclic state spaces! Bidirectional search also exists. In this search, you seach from the goal and start simultaneously and hope the two will meet. \n",
              "\n",
              "This is helpful: (limits, time, space)\n",
              "\n",
              "\n",
              "BFS: complete and optimal (finite state space, and action costs are identical, $O(b^d),O(b^d)$ ) \n",
              "\n",
              "Uniform cost: Complete and optimal (finite, and all actions are positive $O(b^{C*/e}$, same) \n",
              "\n",
              "DFS: No and No ($O(b^m)$, $O(bm)$), \n",
              "\n",
              "Depth limited: No and No ($O(b^l),O(bl)$)\n",
              "\n",
              "Iterative deepening: complete and optimal (finite, and action costs are identical $O(b^d), O(bd)$) \n",
              "\n",
              "Bidirectional: complete and optimal (finite and both directions are bfs or uniform cost $O(b^{d/2},$ same)\n",
              " \n",
              "\n",
              "## Module 3 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 3 Definitions\n",
              "* **Problem-solving agent** - an agent that can formulate a plan via search. plan a sequence of actions instead of a single action response\n",
              "* **Informed algo** - an algorithm tha can estimate how far it is from the goal state\n",
              "* **Uniformed algo** - an algorithm that cannot estimate how far it is from the goal or end state\n",
              "* **Solution** - a sequence of actions that reach a goal state. also a path of states.\n",
              "* **Open-loop system** - a problem/enviorment where once a solution is found, the agent can blindly follow the actions\n",
              "* **Close-loop system** - a problem where the agent checks it's precepts as it goes. This may be nessisary if enviorment nodeterministic\n",
              "* **Search problem** - this is a set of states that the environment could be in\n",
              "* **State space** - same as previous definition\n",
              "* **Initial state** - the state that the agent starts at at the beginning of the problem\n",
              "* **Goal state** - the goal that the search problem is searching for. Like a goal. solution how you got there.\n",
              "* **Transition model** - takes in a state and an action and outputs a new state\n",
              "* **Action cost function** - returns a numeric cost of applying an action on a given state\n",
              "* **Optimal solution** - an optimal solution is a solution that has the lowest path cost among all other solutions\n",
              "* **Graph** - a search problem can be thought of as a graph. vertices are states and edges are actions\n"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Preview of your summary\n",
        "#@markdown You don't need to modify anything in this cell. Just press play.\n",
        "module3_sections = [\n",
        "  (\"AIMA Chapter 3.1 Problem-Solving Agents\", chapter3_1),\n",
        "  (\"AIMA Chapter 3.2 Example Problems\", chapter3_2),\n",
        "  (\"AIMA Chapter 3.3 Search Algorithms\", chapter3_3),\n",
        "  (\"AIMA Chapter 3.4 Uninformed Search Strategies\", chapter3_4),\n",
        "  (\"Module 3 Lecture Notes\", module3_lecture_notes),\n",
        "]\n",
        "\n",
        "module3_markdown = format_module(3, \"Search Problems\", module3_sections, module3_definitions)\n",
        "display(Markdown(module3_markdown))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WHREsHSSyA-h"
      },
      "source": [
        "#Module 4 - Informed Search"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {
        "id": "tuFC8w7CyCns"
      },
      "outputs": [],
      "source": [
        "# Russell and Norvig, AIMA Chapter 3 “Problem Solving by Search” (3.5-3.6)\n",
        "chapter3_5 = \"\"\" The chapter is about how informed search can find goals more efficiently than uninformed \n",
        "search by using information about the specific problem. Greedy best first search is complete on finite \n",
        "state spaces O(|V|). A* is the most common informed search algo. It is a best first search \n",
        "that uses the fucntion f(n) = g(n) + h(n). g(n) is the path cost from the initial state to node n. h(n)\n",
        " is the estimated cost of the shortest path from n to the goal. To say that A* is cost optimal depends on the \n",
        " heuristic. If the heuristic is admissible, then A* is cost optimal.\n",
        "f (n) > C* (otherwise n would have been expanded)\n",
        "f (n) = g (n) + h (n) (by definition)\n",
        "f (n) = g∗\n",
        "(n) + h (n) (because n is on an optimal path)\n",
        "f (n) ≤ g∗\n",
        "(n) + h∗\n",
        "(n) (because of admissibility, h (n) ≤ h∗ (n))\n",
        "f (n) ≤ C∗ (by definition, C∗ = g∗ (n) + h∗ (n))\n",
        "\n",
        "\n",
        "With weighted A* , we can focus the countours closer to the goal and end up getting\n",
        "costs between C* and WxC* but the performance is much better as it skews towards the goal.\n",
        " \"\"\"\n",
        "chapter3_6 = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "\n",
        "# Lecture notes \n",
        "module4_lecture_notes = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "# Definitions\n",
        "module4_definitions = {\n",
        "\"heuristic function\" : \"a function that estimates the cost of the cheapest path from a state at node n to a goal state\",  \n",
        "\"greedy best first\" : \"an algo that expands nodes starting with the lowest h(n) aka closest to the goal\",\n",
        "\"admissible heuristic\" : \"a heuristic that will never overestimate the cost from node n to the goal\",\n",
        "\"consistent heuristic\" : \"a heuristic that gives a higher value to a node then to all its successors\",\n",
        "\"contours\" : \"like topology but cost contour bands instead of height\",\n",
        "\n",
        "}\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 534
        },
        "id": "vqtEs0gHs9sO",
        "outputId": "f71f75ee-b359-46ea-eb18-935612c2dd4a"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "# Module 4: Informed Search\n",
              "## AIMA Chapter 3.5 Informed (Heuristic) Search Strategies\n",
              " The chapter is about how informed search can find goals more efficiently than uninformed \n",
              "search by using information about the specific problem. Greedy best first search is complete on finite \n",
              "state spaces O(|V|). A* is the most common informed search algo. It is a best first search \n",
              "that uses the fucntion f(n) = g(n) + h(n). g(n) is the path cost from the initial state to node n. h(n)\n",
              " is the estimated cost of the shortest path from n to the goal. To say that A* is cost optimal depends on the \n",
              " heuristic. If the heuristic is admissible, then A* is cost optimal.\n",
              "f (n) > C* (otherwise n would have been expanded)\n",
              "f (n) = g (n) + h (n) (by definition)\n",
              "f (n) = g∗\n",
              "(n) + h (n) (because n is on an optimal path)\n",
              "f (n) ≤ g∗\n",
              "(n) + h∗\n",
              "(n) (because of admissibility, h (n) ≤ h∗ (n))\n",
              "f (n) ≤ C∗ (by definition, C∗ = g∗ (n) + h∗ (n))\n",
              "\n",
              "\n",
              "With weighted A* , we can focus the countours closer to the goal and end up getting\n",
              "costs between C* and WxC* but the performance is much better as it skews towards the goal.\n",
              " \n",
              "\n",
              "## AIMA Chapter 3.6 Heuristic Functions\n",
              " Your summary here \n",
              "\n",
              "## Module 4 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 4 Definitions\n",
              "* **Heuristic function** - a function that estimates the cost of the cheapest path from a state at node n to a goal state\n",
              "* **Greedy best first** - an algo that expands nodes starting with the lowest h(n) aka closest to the goal\n",
              "* **Admissible heuristic** - a heuristic that will never overestimate the cost from node n to the goal\n",
              "* **Consistent heuristic** - a heuristic that gives a higher value to a node then to all its successors\n",
              "* **Contours** - like topology but cost contour bands instead of height\n"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Preview of your summary\n",
        "#@markdown You don't need to modify anything in this cell. Just press play.\n",
        "module4_sections = [\n",
        "  (\"AIMA Chapter 3.5 Informed (Heuristic) Search Strategies\", chapter3_5),\n",
        "  (\"AIMA Chapter 3.6 Heuristic Functions\", chapter3_6),\n",
        "  (\"Module 4 Lecture Notes\", module4_lecture_notes),\n",
        "]\n",
        "\n",
        "module4_markdown = format_module(4, \"Informed Search\", \n",
        "                         module4_sections, \n",
        "                         module4_definitions)\n",
        "display(Markdown(module4_markdown))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F3FPMzG9yUls"
      },
      "source": [
        "#Module 5 - Adversarial Search and Games"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 75,
      "metadata": {
        "id": "iEIOpL7vyWcc"
      },
      "outputs": [],
      "source": [
        "# Russell and Norvig, AIMA chapter 5 \"Adversarial Search\"”\" (5.1-5.3, and 5.5).\n",
        "chapter5_1 = \"\"\" This chapter is about competivite games where one agent has opposing \n",
        "goals to another agent. Chess go, poker, the economy, are all examples of this.\n",
        "\n",
        "\n",
        " \"\"\"\n",
        "chapter5_2 = \"\"\" Minimax search algoirhtm is an algorithm that finds the best move \n",
        "for max by trying all actions and choosing the one who's state is most desierable. \n",
        "This algo is recursive and goes all the way down the state tree before backing up. This \n",
        "process happens as the search algorithm keeps track of the smallest and largest values\n",
        "it has seen (depending on which level it is at) and passes the information up. This\n",
        "leads to an optimization called alpha beta pruning. Using the information gathered \n",
        "from the successor nodes, you can prune a whole branch of operations if a player would\n",
        "never make that move. Alpha is the value of the best choice we have found so far for max (at least). \n",
        "Beta is the value of the best choice we have found so far on the path for min (at most). \"\"\"\n",
        "chapter5_3 = \"\"\" Heuristic alpha beta tree search is an algorithm that treats non terminal nodes\n",
        "as if they were terminal nodes. This function estimates the nodes utility. These \n",
        "estimations can be made by looking at features of a state. Certain features can \n",
        "strongly corrilate to one agent winning over another.\"\"\"\n",
        "chapter5_5 = \"\"\" alpha beta pruning can be used in games of chance. This can be done\n",
        "mostly the same but has to do with averaging the values of the children. Or at least\n",
        "placing a bound on what that average could be. \"\"\"\n",
        "\n",
        "# Russell and Norvig, AIMA Chapter 16 “Making Simple Decisions” (16.1-16.3)\n",
        "chapter16_1 = \"\"\" Your summary here \"\"\"\n",
        "chapter16_2 = \"\"\" Your summary here \"\"\"\n",
        "chapter16_3 = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "# Lecture notes \n",
        "module5_lecture_notes = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "# Definitions\n",
        "module5_definitions = {\n",
        "\"perfect information\" : \"all information is available to all agents\",\n",
        "\"zero sum\" : \"A move that is good for one agent is bad for the other\",\n",
        "\"features\" : \"these are details of a state. for example number of white peices left.\",\n",
        "\"forward pruning\" : \"pruning moves that appear to be bad moves but could actual be good ones.\"\n",
        "\n",
        "}\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 76,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 878
        },
        "id": "KUc_LgzDvWf-",
        "outputId": "4f915cae-ff44-4ef8-f389-12b7008800a2"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "# Module 5: Adversarial Search and Games\n",
              "## AIMA Chapter 5.1 Game Theory\n",
              " This chapter is about competivite games where one agent has opposing \n",
              "goals to another agent. Chess go, poker, the economy, are all examples of this.\n",
              "\n",
              "\n",
              " \n",
              "\n",
              "## AIMA Chapter 5.2 Optimal Decisions in Games\n",
              " Minimax search algoirhtm is an algorithm that finds the best move \n",
              "for max by trying all actions and choosing the one who's state is most desierable. \n",
              "This algo is recursive and goes all the way down the state tree before backing up. This \n",
              "process happens as the search algorithm keeps track of the smallest and largest values\n",
              "it has seen (depending on which level it is at) and passes the information up. This\n",
              "leads to an optimization called alpha beta pruning. Using the information gathered \n",
              "from the successor nodes, you can prune a whole branch of operations if a player would\n",
              "never make that move. Alpha is the value of the best choice we have found so far for max (at least). \n",
              "Beta is the value of the best choice we have found so far on the path for min (at most). \n",
              "\n",
              "## AIMA Chapter 5.3 Heuristic Alpha–Beta Tree Search\n",
              " Heuristic alpha beta tree search is an algorithm that treats non terminal nodes\n",
              "as if they were terminal nodes. This function estimates the nodes utility. These \n",
              "estimations can be made by looking at features of a state. Certain features can \n",
              "strongly corrilate to one agent winning over another.\n",
              "\n",
              "## AIMA Chapter 5.5 Stochastic Games\n",
              " alpha beta pruning can be used in games of chance. This can be done\n",
              "mostly the same but has to do with averaging the values of the children. Or at least\n",
              "placing a bound on what that average could be. \n",
              "\n",
              "## AIMA Chapter 16.1 Combining Beliefs and Desires under Uncertainty\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 16.2 The Basis of Utility Theory\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 16.3 Utility Functions\n",
              " Your summary here \n",
              "\n",
              "## Module 5 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 5 Definitions\n",
              "* **Perfect information** - all information is available to all agents\n",
              "* **Zero sum** - A move that is good for one agent is bad for the other\n",
              "* **Features** - these are details of a state. for example number of white peices left.\n",
              "* **Forward pruning** - pruning moves that appear to be bad moves but could actual be good ones.\n"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Preview of your summary\n",
        "#@markdown You don't need to modify anything in this cell. Just press play.\n",
        "module5_sections = [\n",
        "  (\"AIMA Chapter 5.1 Game Theory\", chapter5_1),\n",
        "  (\"AIMA Chapter 5.2 Optimal Decisions in Games\", chapter5_2),\n",
        "  (\"AIMA Chapter 5.3 Heuristic Alpha–Beta Tree Search\", chapter5_3),\n",
        "  (\"AIMA Chapter 5.5 Stochastic Games\", chapter5_5),\n",
        "  (\"AIMA Chapter 16.1 Combining Beliefs and Desires under Uncertainty\", chapter16_1),\n",
        "  (\"AIMA Chapter 16.2 The Basis of Utility Theory\", chapter16_2),\n",
        "  (\"AIMA Chapter 16.3 Utility Functions\", chapter16_3),\n",
        "  (\"Module 5 Lecture Notes\", module5_lecture_notes),\n",
        "]\n",
        "\n",
        "module5_markdown = format_module(5, \"Adversarial Search and Games\", \n",
        "                         module5_sections, \n",
        "                         module5_definitions)\n",
        "display(Markdown(module5_markdown))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qVSQhTVSyYYO"
      },
      "source": [
        "#Module 6 - \"Constraint Satisfaction Problems\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 77,
      "metadata": {
        "id": "Wm4mfW82yaRH"
      },
      "outputs": [],
      "source": [
        "# Russell and Norvig, AIMA, Chapter 6 “Constraint Satisfaction Problems” (6.1-6.5)\n",
        "chapter6_1 = \"\"\" Constraint satisfaction problems. These are assignment problems where\n",
        "an assignment of one value limits assignment possibilities for some other variables.\n",
        "The most clear example of this type of problme is sudoku or ken kens. \"\"\"\n",
        "chapter6_2 = \"\"\" Your summary here \"\"\"\n",
        "chapter6_3 = \"\"\" Your summary here \"\"\"\n",
        "chapter6_4 = \"\"\" Your summary here \"\"\"\n",
        "chapter6_5 = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "\n",
        "# Lecture notes \n",
        "module6_lecture_notes = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "# Definitions\n",
        "module6_definitions = {\n",
        "\"binary constraint\" : \"relates 2 vairables \",    \n",
        "\"binary csp\" : \"a problem with only unary and binary constraints or arcs\"\n",
        "\n",
        "}\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 575
        },
        "id": "kKWbCsbfxL3R",
        "outputId": "336e9084-ec6b-4c2a-e6e8-92a30df8dfaa"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "# Module 6: Constraint Satisfaction Problems\n",
              "## AIMA Chapter 6.1 Defining Constraint Satisfaction Problems\n",
              " Constraint satisfaction problems. These are assignment problems where\n",
              "an assignment of one value limits assignment possibilities for some other variables.\n",
              "The most clear example of this type of problme is sudoku or ken kens. \n",
              "\n",
              "## AIMA Chapter 6.2 Constraint Propagation: Inference in CSPs\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 6.3 Backtracking Search for CSPs\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 6.4 Local Search for CSPs\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 6.5 The Structure of Problems\n",
              " Your summary here \n",
              "\n",
              "## Module 6 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 6 Definitions\n",
              "* **Binary constraint** - relates 2 vairables \n",
              "* **Binary csp** - a problem with only unary and binary constraints or arcs\n"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Preview of your summary\n",
        "#@markdown You don't need to modify anything in this cell. Just press play.\n",
        "module6_sections = [\n",
        "  (\"AIMA Chapter 6.1 Defining Constraint Satisfaction Problems\", chapter6_1),\n",
        "  (\"AIMA Chapter 6.2 Constraint Propagation: Inference in CSPs\", chapter6_2),\n",
        "  (\"AIMA Chapter 6.3 Backtracking Search for CSPs\", chapter6_3),\n",
        "  (\"AIMA Chapter 6.4 Local Search for CSPs\", chapter6_4),\n",
        "  (\"AIMA Chapter 6.5 The Structure of Problems\", chapter6_5),\n",
        "  (\"Module 6 Lecture Notes\", module6_lecture_notes),\n",
        "]\n",
        "\n",
        "module6_markdown = format_module(6, \"Constraint Satisfaction Problems\", \n",
        "                         module6_sections, \n",
        "                         module6_definitions)\n",
        "display(Markdown(module6_markdown))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RYESi2kMybL8"
      },
      "source": [
        "#Module 7 - Logical Agents"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "id": "qIRJ4YYCzNHL"
      },
      "outputs": [],
      "source": [
        "# Russell and Norvig, AIMA Chapter 7 “Logical Agents” (Sections 7.1-7.5)\n",
        "\n",
        "chapter7_1 = \"\"\" Your summary here \"\"\"\n",
        "chapter7_2 = \"\"\" Your summary here \"\"\"\n",
        "chapter7_3 = \"\"\" Your summary here \"\"\"\n",
        "chapter7_4 = \"\"\" Your summary here \"\"\"\n",
        "chapter7_5 = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "# Lecture notes \n",
        "module7_lecture_notes = \"\"\" Your summary here \"\"\"\n",
        "\n",
        "# Definitions\n",
        "module7_definitions = {\n",
        "\"concept\" : \"definition\",    \n",
        "}\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 541
        },
        "id": "lXNcHuKjyNXa",
        "outputId": "cdacbdbd-15c1-4228-f792-f63c617f8d16"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "# Module 7: Logical Agents\n",
              "## AIMA Chapter 7.1 Knowledge-Based Agents\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 7.2 The Wumpus World\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 7.3 Logic\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 7.4 Propositional Logic: A Very Simple Logic\n",
              " Your summary here \n",
              "\n",
              "## AIMA 7.5 Propositional Theorem Proving\n",
              " Your summary here \n",
              "\n",
              "## Module 7 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 7 Definitions\n",
              "* **Concept** - definition\n"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "#@title Preview of your summary\n",
        "#@markdown You don't need to modify anything in this cell. Just press play.\n",
        "module7_sections = [\n",
        "  (\"AIMA Chapter 7.1 Knowledge-Based Agents\", chapter7_1),\n",
        "  (\"AIMA Chapter 7.2 The Wumpus World\", chapter7_2),\n",
        "  (\"AIMA Chapter 7.3 Logic\", chapter7_3),\n",
        "  (\"AIMA Chapter 7.4 Propositional Logic: A Very Simple Logic\", chapter7_4),\n",
        "  (\"AIMA 7.5 Propositional Theorem Proving\", chapter7_5),\n",
        "  (\"Module 7 Lecture Notes\", module7_lecture_notes),\n",
        "]\n",
        "\n",
        "module7_markdown = format_module(7, \"Logical Agents\", \n",
        "                         module7_sections, \n",
        "                         module7_definitions)\n",
        "display(Markdown(module7_markdown))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vX7lbnJd4sT5"
      },
      "source": [
        "# Your Exam Notes\n",
        "\n",
        "Here are your full set of exam notes that you can use on your midterm.  Choose **Runtime > Run all**, then your notes will be displayed.\n",
        "\n",
        "If you are taking the exam in person, then you must print a copy of your notes for yourself.   Here's how to print:\n",
        "* Run the cell below. \n",
        "* Click its \"Mirror cell in tab\" button (this is located in the upper right corner of the cell, immediately to the right of the trash can).  This will open the cell.  \n",
        "* In Chrome, you can then print your notes using the **File > Print** option from the browser's menu.  \n",
        "* In the print options, change the layout from Landscape to Portrait. \n",
        "* Clicking the Save, will save a PDF that you can then print.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 80,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "T3cm1WV542_a",
        "outputId": "f8d5476e-019f-4268-9e3b-bfdfb1bb70c7"
      },
      "outputs": [
        {
          "data": {
            "text/markdown": [
              "# Module 1: Rational Agents and Task Environments\n",
              "## AIMA Chapter 1.1 What is AI?\n",
              " \n",
              "AI is the study of intellegence. There have been many different approchaes to this problem throughout history. The different disiplines focus on different things. There is this idea of Human vs Rational and Thought vs Behaviour. The four combinations of these words have formed different diciplines of studying problem solving and what it means to think. \n",
              " \n",
              "\n",
              "## AIMA Chapter 27.1 The Limits of AI\n",
              " \n",
              "John Searle introduced the idea of strong and weak AI. Strong AI is the idea that machines conciously think to solve problems. Weak AI is the opposite. Weak AI is the idea that a machine could act as if it is intelligent, howeve, it would just be simulating this intellegence. Turing made the argument that human behvaiour is far to subtle to be captured in a strict set of rules. This is called the argument from informality. This is the idea that there are so many laws that humans follow that are not stricly defined, which would make it impossible to create a set of rules to mimick humanity.\n",
              " \n",
              "\n",
              "## AIMA Chapter 27.1 Can Machines Really Think?\n",
              " There has been a lot of debate with regards to the idea of if a machine can think. While this is a heated topic, many in the field do not bother themselves with this thought as it is irrelivant at the end of the day. \n",
              "\n",
              "## AIMA 2.1 Agents and Environments\n",
              " An agent is anything that can perceive it's suroundings and act based on that in some enviroment. The agent generally depends on it's inbuilt knowlange and its percept sequence to make decitions and act in the environment. \n",
              "\n",
              "## AIMA 2.2 Good Behavior: The Concept of Rationality\n",
              " \n",
              "Genearlly, AI has stuck with a measure of correctness called consequentialism. This is the idea that an action's success is measured by it's consequences. Mahines, unlike humans, do not have an inate measure of a good and bad outcome. For this reason, we need to expicitly define performance measure to tell the AI what is a good outcome and what is a bad outcome. The performance measure can also be implicit depnding on the problem.\n",
              "\n",
              "## AIMA 2.3 The Nature of Environments\n",
              " \n",
              "A rational agent is an agent that will make an action based on it's percept sequence and inbuilt knowlage that will maximize the performance measure. A rational agent is different from an omniscience agent. An omniscience agent knows with perfect acuracy what the actual outcome of it's action will be.\n",
              " \n",
              "\n",
              "## AIMA 2.4 The Structure of Agents\n",
              " Your summary here 170\n",
              "\n",
              "## Module 1 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 1 Definitions\n",
              "* **Agent** - anything that can perceive and act in an environment\n",
              "* **Sensor** - the parts of the agent that allow it to recive information about the world.\n",
              "* **Actuators** - the parts of the agent that act on the environment. This is the way the agent acts on it's enviroment.\n",
              "* **Percept** - the content that an agent is reciving via it's sensors\n",
              "* **Percept sequence** - The total history of every percept that the agent has recived, via its sensors, from it's enviorment.\n",
              "* **Agent function** - A function that maps a percept sequence to a set of actions. This is a theoretical model or mathmatical description.\n",
              "* **Agent program** - This is the real world implementation of the Agent function. The agent program general be acting in physical system.\n",
              "* **Chinese room** - A thought experiment that shows how understanding of a topic is not required in order to imitate understanding.\n",
              "* **Performance measure** - Function that evaluates a given sequence of enviormental states. Used to evaluate desierability of an outcome.\n",
              "* **Rational agent** - RA should select an action based on percept seq and inbuilt knowlage that will maximize it's performance measure\n",
              "\n",
              "\n",
              "# Module 2: Python\n",
              "## Module 2 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 2 Definitions\n",
              "* **Mutability** - your definition here\n",
              "\n",
              "\n",
              "# Module 3: Search Problems\n",
              "## AIMA Chapter 3.1 Problem-Solving Agents\n",
              " \n",
              "In some problems, an agent needs to plan ahead multiple steps. These are called problem solving agents. PSA's use atomic reperesentations of the enviorment, this means that they are given the state of the world as a whole. It does not have any internal structure. Similar agents that get a structured or fractured view of the world are called planning agents. Goals are formed to limit the objectives and in turn the possible actions, which make the desired outcome clearer. \n",
              "\n",
              " \n",
              "\n",
              "## AIMA Chapter 3.2 Example Problems\n",
              " To design a search problem you need initial state, possible actions, a transition model, goal states, and an action cost function or a set action cost. The sokoban puzzle is an example of a problem that can be modeled as a search problem. An example of this from the homework is the sliding tile puzzle problem (also known as the 8 puzzle). When designing a model, it is key that you identify some abstractions. This can involve ignoring intermediate steps like in the 8 puzzle and just focusing on whether an action can lead to a goal state or not.\n",
              " \n",
              "\n",
              "## AIMA Chapter 3.3 Search Algorithms\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 3.4 Uninformed Search Strategies\n",
              " BFS, best first search, Uniform cost search, DFS, backtracking search (less memory dfs).There is also depth limited and iterative deepening search. Depth limited search can be incomplete if we choose the wrong l (max depth allowed). Iterative deepening search is just multiple applications of depth limited search. In this algo, youslowly increase the depth allowed for dfs. Iterative deepening search is complete on finite acyclic state spaces! Bidirectional search also exists. In this search, you seach from the goal and start simultaneously and hope the two will meet. \n",
              "\n",
              "This is helpful: (limits, time, space)\n",
              "\n",
              "\n",
              "BFS: complete and optimal (finite state space, and action costs are identical, $O(b^d),O(b^d)$ ) \n",
              "\n",
              "Uniform cost: Complete and optimal (finite, and all actions are positive $O(b^{C*/e}$, same) \n",
              "\n",
              "DFS: No and No ($O(b^m)$, $O(bm)$), \n",
              "\n",
              "Depth limited: No and No ($O(b^l),O(bl)$)\n",
              "\n",
              "Iterative deepening: complete and optimal (finite, and action costs are identical $O(b^d), O(bd)$) \n",
              "\n",
              "Bidirectional: complete and optimal (finite and both directions are bfs or uniform cost $O(b^{d/2},$ same)\n",
              " \n",
              "\n",
              "## Module 3 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 3 Definitions\n",
              "* **Problem-solving agent** - an agent that can formulate a plan via search. plan a sequence of actions instead of a single action response\n",
              "* **Informed algo** - an algorithm tha can estimate how far it is from the goal state\n",
              "* **Uniformed algo** - an algorithm that cannot estimate how far it is from the goal or end state\n",
              "* **Solution** - a sequence of actions that reach a goal state. also a path of states.\n",
              "* **Open-loop system** - a problem/enviorment where once a solution is found, the agent can blindly follow the actions\n",
              "* **Close-loop system** - a problem where the agent checks it's precepts as it goes. This may be nessisary if enviorment nodeterministic\n",
              "* **Search problem** - this is a set of states that the environment could be in\n",
              "* **State space** - same as previous definition\n",
              "* **Initial state** - the state that the agent starts at at the beginning of the problem\n",
              "* **Goal state** - the goal that the search problem is searching for. Like a goal. solution how you got there.\n",
              "* **Transition model** - takes in a state and an action and outputs a new state\n",
              "* **Action cost function** - returns a numeric cost of applying an action on a given state\n",
              "* **Optimal solution** - an optimal solution is a solution that has the lowest path cost among all other solutions\n",
              "* **Graph** - a search problem can be thought of as a graph. vertices are states and edges are actions\n",
              "\n",
              "\n",
              "# Module 4: Informed Search\n",
              "## AIMA Chapter 3.5 Informed (Heuristic) Search Strategies\n",
              " The chapter is about how informed search can find goals more efficiently than uninformed \n",
              "search by using information about the specific problem. Greedy best first search is complete on finite \n",
              "state spaces O(|V|). A* is the most common informed search algo. It is a best first search \n",
              "that uses the fucntion f(n) = g(n) + h(n). g(n) is the path cost from the initial state to node n. h(n)\n",
              " is the estimated cost of the shortest path from n to the goal. To say that A* is cost optimal depends on the \n",
              " heuristic. If the heuristic is admissible, then A* is cost optimal.\n",
              "f (n) > C* (otherwise n would have been expanded)\n",
              "f (n) = g (n) + h (n) (by definition)\n",
              "f (n) = g∗\n",
              "(n) + h (n) (because n is on an optimal path)\n",
              "f (n) ≤ g∗\n",
              "(n) + h∗\n",
              "(n) (because of admissibility, h (n) ≤ h∗ (n))\n",
              "f (n) ≤ C∗ (by definition, C∗ = g∗ (n) + h∗ (n))\n",
              "\n",
              "\n",
              "With weighted A* , we can focus the countours closer to the goal and end up getting\n",
              "costs between C* and WxC* but the performance is much better as it skews towards the goal.\n",
              " \n",
              "\n",
              "## AIMA Chapter 3.6 Heuristic Functions\n",
              " Your summary here \n",
              "\n",
              "## Module 4 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 4 Definitions\n",
              "* **Heuristic function** - a function that estimates the cost of the cheapest path from a state at node n to a goal state\n",
              "* **Greedy best first** - an algo that expands nodes starting with the lowest h(n) aka closest to the goal\n",
              "* **Admissible heuristic** - a heuristic that will never overestimate the cost from node n to the goal\n",
              "* **Consistent heuristic** - a heuristic that gives a higher value to a node then to all its successors\n",
              "* **Contours** - like topology but cost contour bands instead of height\n",
              "\n",
              "\n",
              "# Module 5: Adversarial Search and Games\n",
              "## AIMA Chapter 5.1 Game Theory\n",
              " This chapter is about competivite games where one agent has opposing \n",
              "goals to another agent. Chess go, poker, the economy, are all examples of this.\n",
              "\n",
              "\n",
              " \n",
              "\n",
              "## AIMA Chapter 5.2 Optimal Decisions in Games\n",
              " Minimax search algoirhtm is an algorithm that finds the best move \n",
              "for max by trying all actions and choosing the one who's state is most desierable. \n",
              "This algo is recursive and goes all the way down the state tree before backing up. This \n",
              "process happens as the search algorithm keeps track of the smallest and largest values\n",
              "it has seen (depending on which level it is at) and passes the information up. This\n",
              "leads to an optimization called alpha beta pruning. Using the information gathered \n",
              "from the successor nodes, you can prune a whole branch of operations if a player would\n",
              "never make that move. Alpha is the value of the best choice we have found so far for max (at least). \n",
              "Beta is the value of the best choice we have found so far on the path for min (at most). \n",
              "\n",
              "## AIMA Chapter 5.3 Heuristic Alpha–Beta Tree Search\n",
              " Heuristic alpha beta tree search is an algorithm that treats non terminal nodes\n",
              "as if they were terminal nodes. This function estimates the nodes utility. These \n",
              "estimations can be made by looking at features of a state. Certain features can \n",
              "strongly corrilate to one agent winning over another.\n",
              "\n",
              "## AIMA Chapter 5.5 Stochastic Games\n",
              " alpha beta pruning can be used in games of chance. This can be done\n",
              "mostly the same but has to do with averaging the values of the children. Or at least\n",
              "placing a bound on what that average could be. \n",
              "\n",
              "## AIMA Chapter 16.1 Combining Beliefs and Desires under Uncertainty\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 16.2 The Basis of Utility Theory\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 16.3 Utility Functions\n",
              " Your summary here \n",
              "\n",
              "## Module 5 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 5 Definitions\n",
              "* **Perfect information** - all information is available to all agents\n",
              "* **Zero sum** - A move that is good for one agent is bad for the other\n",
              "* **Features** - these are details of a state. for example number of white peices left.\n",
              "* **Forward pruning** - pruning moves that appear to be bad moves but could actual be good ones.\n",
              "\n",
              "\n",
              "# Module 6: Constraint Satisfaction Problems\n",
              "## AIMA Chapter 6.1 Defining Constraint Satisfaction Problems\n",
              " Constraint satisfaction problems. These are assignment problems where\n",
              "an assignment of one value limits assignment possibilities for some other variables.\n",
              "The most clear example of this type of problme is sudoku or ken kens. \n",
              "\n",
              "## AIMA Chapter 6.2 Constraint Propagation: Inference in CSPs\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 6.3 Backtracking Search for CSPs\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 6.4 Local Search for CSPs\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 6.5 The Structure of Problems\n",
              " Your summary here \n",
              "\n",
              "## Module 6 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 6 Definitions\n",
              "* **Binary constraint** - relates 2 vairables \n",
              "* **Binary csp** - a problem with only unary and binary constraints or arcs\n",
              "\n",
              "\n",
              "# Module 7: Logical Agents\n",
              "## AIMA Chapter 7.1 Knowledge-Based Agents\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 7.2 The Wumpus World\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 7.3 Logic\n",
              " Your summary here \n",
              "\n",
              "## AIMA Chapter 7.4 Propositional Logic: A Very Simple Logic\n",
              " Your summary here \n",
              "\n",
              "## AIMA 7.5 Propositional Theorem Proving\n",
              " Your summary here \n",
              "\n",
              "## Module 7 Lecture Notes\n",
              " Your summary here \n",
              "\n",
              "## Module 7 Definitions\n",
              "* **Concept** - definition\n"
            ],
            "text/plain": [
              "<IPython.core.display.Markdown object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# This will generate the full set of notes that you can use for your exam.\n",
        "full_markdown = \"\\n\\n\".join([module1_markdown, \n",
        "                             module2_markdown, \n",
        "                             module3_markdown, \n",
        "                             module4_markdown, \n",
        "                             module5_markdown,\n",
        "                             module6_markdown,\n",
        "                             module7_markdown,]\n",
        "                       )\n",
        "display(Markdown(full_markdown))"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [],
      "name": "Copy of FINAL Template_for CIS521_midterm notes.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
