MIN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Managing the Improvement News"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook was designed to tell you quickly and easily which options are permissible according to the decision theory proposed in [\"The Causal Decision Theorist's Guide to Managing the News\"](https://philpapers.org/rec/GALTCD-3).\n",
    "\n",
    "First, you'll have to run the line below.  Just click on it, hold down Shift, and hit Enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desires"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, you'll have to enter in your desires, by recording them in an array like the following:\n",
    "\n",
    "|             | State 1 |  State 2 | ... | State N |\n",
    "| :-----------: | :-----------: | :-----:|:-----:|:---------:|\n",
    "| Act 1       | des(Act 1 & State 1)       |des(Act 1 & State 2) | ... | des(Act 1 & State N) | \n",
    "| Act 2       | des(Act 2 & State 1)       |des(Act 2 & State 2) | ... | des(Act 2 & State N) | \n",
    "|     ...        |                      |                     | |    |\n",
    "| Act M       |  des(Act M & State 1)      | des(Act M & State 2)| ... | des(Act M & State N) |\n",
    "\n",
    "To do this, first type ```des=numpy.array(``` to signal that you're entering a matrix.  Next put an open bracket ```[``` to begin the matrix, and then another open bracket ```[``` to begin the first row.  At that point, you enter in the values from the first row the table, separated by commas, and follow up with a closed bracket ```]``` to finish off the row.  A comma followed by another open bracket begins the next row, and you proceed from there.  At the end, you'll need to close off all your brackets and parentheses.\n",
    "\n",
    "For instance, consider the following desires:\n",
    "\n",
    "|      |  Predicted Black  |  Predicted White  |\n",
    "|:----:|:------------------:|:------------------:|\n",
    "| Black Left    |       0            |        100         |\n",
    "| White Left    |    100             |        0           |\n",
    "| Black Right    |     -1             |       99           |\n",
    "| White Right    |     99             |       -1           |\n",
    "\n",
    "These desires come from a decision called *Semi-Frustrator* by [Jack Sencer & Ian Wells](https://philpapers.org/rec/SPEWTB).  I'll use it as my running example here.  In the decision, you know that a reliable predictor, known as 'The Frustrator', has made a prediction about whether you'd choose to take the contents of the black box or the white box, and they left \\$100 in whichever box they predicted you would *not* choose.  These predictions are incredibly reliable if you point to your chosen box with your left hand.  If, however, you point with your right hand, the predictions are are no better than chance.  It's free to point with your left hand, but it costs \\$1 to point with your right hand.\n",
    "\n",
    "To enter your desires information as a matrix, just type:\n",
    "\n",
    "```\n",
    "des = numpy.array([[0,100],[100,0],[-1,99],[99,-1]])\n",
    "```\n",
    "And then press Shift+Enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "des = numpy.array([[0,100],[100,0],[-1,99],[99,-1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, you'll enter in your conditional probabilities for each state, given that you select each act, in the following format:\n",
    "\n",
    "|      |    Act 1   |   Act 2  |   ...   |  Act M   |\n",
    "|:----:|:----------:|:--------:|:-------:|:--------:|\n",
    "|State 1| Pr(State 1 $|$ Act 1) | Pr(State 1 $|$ Act 2) | ... | Pr(State 1 $|$ Act M) |\n",
    "|State 2| Pr(State 2 $|$ Act 1) | Pr(State 2 $|$ Act 2) | ... | Pr(State 2 $|$ Act M) |\n",
    "| |   |   | ... |   |\n",
    "|State N| Pr(State N $|$ Act 1) | Pr(State N $|$ Act 2) | ... | Pr(State N $|$ Act M) |\n",
    "\n",
    "For instance, in our example, we can use these conditional probabilities:\n",
    "\n",
    "|                  |    Black Left    |    White Left  |   Black Right   |   White Right   |\n",
    "|:---------------: |:-------:|:------:|:-----:|:------:|\n",
    "| Predicted Black |   100%  |   0%   |  50%  |   50%  |\n",
    "| Predicted White |    0%   |   100% |  50%  |   50%  |\n",
    "\n",
    "We enter this in as follows:\n",
    "\n",
    "```\n",
    "probs = numpy.array([[1,0,0.5,0.5],[0,1,0.5,0.5]])\n",
    "```\n",
    "After you've entered in the probabilities, press Shift+Enter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "probs = numpy.array([[1,0,0.5,0.5],[0,1,0.5,0.5]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Permissible Choices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, to see which of the available acts MIN says are permissible, just run the line of code ```%run MIN_functions.ipynb``` below.\n",
    "\n",
    "To start, you'll have to tell the algorithm which names you'd like to give to the available acts.  For our example decision, we can use \"BL\", \"WL\", \"BR\", and \"WR\" for the acts Black Left, White Left, Black Right, and White Right, respectively. (Or, if you find it easier, just use \"A\", \"B\", \"C\", and \"D\".  It's up to you.)\n",
    "\n",
    "If there are 'ties' that need to be broken, then you'll be asked to provide a 'tie-breaking' preference ordering.  According to the theory, an act is permissible iff this algorithm says that it is permissible given *some* way of breaking ties.  \n",
    "\n",
    "In our example decision, to see that BR is permissible, place WL above BL in your 'tie-breaking' preferences.  And to see that WR is permissible, place BL above WL in the 'tie-breaking' preferences."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What name would you like to give to the act in the first row of the desire matrix?BL\n",
      "What name would you like to give to the act in the next row?WL\n",
      "What name would you like to give to the act in the next row?BR\n",
      "What name would you like to give to the act in the next row?WR\n",
      "\n",
      "Because there are ties in the strengths of your reasons, this decision requires the use of the tie-breaking algorithm.\n",
      "You should enter some arbitrary preference between options which we will use to break ties.\n",
      "Be sure to use the same names for the acts that you entered above.\n",
      "\n",
      "What is your most preferred option?BL\n",
      "What is your next most preferred option?WL\n",
      "What is your next most preferred option?BR\n",
      "What is your next most preferred option?WR\n",
      "\n",
      "Here is the list of preferences which you have pro tanto reason to hold, ordered by the strength of the reason you have to hold them.\n",
      "\n",
      "BR  >  WL    [98.0]\n",
      "WR  >  BL    [98.0]\n",
      "BL  >  BR    [2.0]\n",
      "WL  >  WR    [2.0]\n",
      "WL  =  BL    [0.0]\n",
      "WR  =  BR    [0.0]\n",
      "\n",
      "\n",
      "We start at the top of this list, and work our way down, striking any preferences which lead to cycles when\n",
      "combined with the (unstruck) preferences above them.  When we reach the bottom, the following preferences are\n",
      "left unstruck:\n",
      "\n",
      "BR  >  WL\n",
      "WR  >  BL\n",
      "BL  >  BR\n",
      "\n",
      "\n",
      "Therefore, the following options are permissible:\n",
      "\n",
      "WR\n"
     ]
    }
   ],
   "source": [
    "%run MIN_functions.ipynb"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}