MIN_functions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function takes a square matrix and sets the new value of (row, col) to the old value of (col, col) - (row, col).\n",
    "# So, when you feed it the matrix Utility(row | col), it gives you back the matrix Improvement(col,row | col)\n",
    "def improve(m):\n",
    "    blank = numpy.zeros(shape=(m.shape[0],m.shape[1]))\n",
    "    for i in range(0,m.shape[0]):\n",
    "        for j in range(0,m.shape[1]):\n",
    "            blank[i][j] = m[j][j]-m[i][j]\n",
    "    return blank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function takes a square matrix and sets the new value of (row, col) to the old value of (row, col) - (col, row).\n",
    "# So, when you feed it the matrix Improvement(col, row | col), it gives you back the matrix News(col, row)\n",
    "def newsify(m):\n",
    "    blank = numpy.zeros(shape=m.shape)\n",
    "    for row in range(0,m.shape[0]):\n",
    "        for col in range(0,m.shape[1]):\n",
    "            blank[row][col] = m[row][col] - m[col][row]\n",
    "    return blank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here, I generate the matrix News(col, row) from the user-provided desires and probability matrices\n",
    "News = newsify(improve(des.dot(probs)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Later, I need to know how many acts there are.  So I store the number of rows in News as \"num_acts\"\n",
    "num_acts = News.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function generates a list of ordered triples, where the first member of the triple is the column of News(col, row), \n",
    "# the second member is the row of News(col,row), and the third member is the value at (row, col).\n",
    "# Because News(col, row) = - News(row, col), I only look at the upper triangle\n",
    "def pairs(m):\n",
    "    blist = []\n",
    "    for row in range(0,m.shape[0]):\n",
    "        for col in range(row+1,m.shape[1]):\n",
    "            blist.append((col, row, m[row][col]))\n",
    "    return blist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Running the function \"pairs\" on the matrix \"News\" to get the list \"pairs\"\n",
    "pairs = pairs(News)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function replaces numbers with the user-provided names for the acts.\n",
    "def name_acts(l):\n",
    "    first = input('What name would you like to give to the act in the first row of the desire matrix?')\n",
    "    key_dict = { 0: first }\n",
    "    count = 1\n",
    "    for num in range(1,num_acts):\n",
    "        next = input('What name would you like to give to the act in the next row?')\n",
    "        key_dict[count] = next\n",
    "        count += 1\n",
    "    blist = []\n",
    "    for row in range(0,len(l)):\n",
    "        blist.append((key_dict[l[row][0]], key_dict[l[row][1]], l[row][2]))\n",
    "    return blist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Init_list is the result of replacing each row number with the user-provided names for acts\n",
    "init_list = name_acts(pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The 'positivise' function makes all strengths positive by swapping the position of options if the strength is negative and \n",
    "# replacing strength with its absolute value\n",
    "def positivise(l):\n",
    "    blist = []\n",
    "    for row in range(0,len(l)):\n",
    "        if l[row][2] >0:\n",
    "            blist.append((l[row][0], l[row][1],l[row][2]))\n",
    "        elif l[row][2]<0:\n",
    "            blist.append((l[row][1], l[row][0],abs(l[row][2])))\n",
    "        elif l[row][2]==0:\n",
    "            blist.append((l[row][0],l[row][1],l[row][2]))\n",
    "    return blist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The list 'positive_pairs' gives the 'positivised' init_list\n",
    "positive_pairs = positivise(init_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function checks to see whether there are ties in the \"strength\" of reasons \n",
    "def check_for_ties(l):\n",
    "    answer = 0\n",
    "    for i in range(0,len(l)):\n",
    "        for j in range(i+1,len(l)):\n",
    "            if abs(l[i][2])==abs(l[j][2]):\n",
    "                answer = 1\n",
    "                return answer\n",
    "    return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function checks for ties.  If it finds them, then it prompts the user to supply a 'tie-breaking' preference ordering,\n",
    "# which it then uses to break the ties.  It does this in the following way: if X > Y is tied with Z > W, then 'X > Y' is placed\n",
    "# above 'Z > W' iff X comes before Y in the 'tie-breaking' preferences.\n",
    "# If X > Y is tied with X > Z, then X > Y is placed above X > Z iff Z comes before Y in the 'tie-breaking' preferences.\n",
    "# If X = Y is tied with Z = W, then X = Y is placed above Z = W iff X comes before Z in the 'tie-breaking' preferences.\n",
    "# And if X = Y is tied with X = Z, then X = Y comes first iff Y is preferred to Z.\n",
    "# This way of 'breaking ties' will count as 'rationalisable', in the terms from TCDTGTMTN.\n",
    "def break_ties(l):\n",
    "    if check_for_ties(l)==0:\n",
    "        l.sort(key=lambda x:abs(x[2]),reverse=True)\n",
    "    if check_for_ties(l)==1:\n",
    "        print()\n",
    "        print('Because there are ties in the strengths of your reasons, this decision requires the use of the tie-breaking algorithm.')\n",
    "        print('You should enter some arbitrary preference between options which we will use to break ties.')\n",
    "        print('Be sure to use the same names for the acts that you entered above.')\n",
    "        print()\n",
    "        first = input(\"What is your most preferred option?\")\n",
    "        my_dict = { first : 0 }\n",
    "        count=1\n",
    "        for num in range(1,num_acts):\n",
    "            next = input(\"What is your next most preferred option?\")\n",
    "            my_dict[next] = count\n",
    "            count+=1\n",
    "        l.sort(key=lambda x: (-x[2], my_dict[x[0]], -my_dict[x[1]]) if x[2] > 0 else (-x[2], my_dict[x[0]], my_dict[x[1]]))\n",
    "        #l.sort(key=lambda x:abs(x[2]),reverse=True)\n",
    "    return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Running the \"break_ties\" function on the list \"positive_pairs\"\n",
    "break_ties(positive_pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This function displays the preferences and strengths \n",
    "def pref_view_init(l):\n",
    "    for entry in l:\n",
    "        up = entry[0]\n",
    "        down=entry[1]\n",
    "        if entry[2]>0:\n",
    "            print(up+'  >  '+down+'    ['+str(entry[2])+']')\n",
    "        if entry[2]==0:\n",
    "            print(up+'  =  '+down+'    ['+str(entry[2])+']')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This function displays just the preferences\n",
    "def pref_view(l):\n",
    "    for entry in l:\n",
    "        up = entry[0]\n",
    "        down=entry[1]\n",
    "        if entry[2]>0:\n",
    "            print(up+'  >  '+down)\n",
    "        if entry[2]==0:\n",
    "            print(up+'  =  '+down)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here are the tuples, ordered by the strength of the reason you have to prefer option1 to option2\n",
    "print()\n",
    "print(\"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",
    "print()\n",
    "pref_view_init(positive_pairs)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# With this function, we chain together any pairs where the 1st option matches the 2nd or the 2nd matches the first.\n",
    "# Thus, X > Y and Y > Z leads to a pair X > Z\n",
    "# And X > Y and Z = X leads to a pair Z > Y\n",
    "# And X = Y and Y = Z leads to X = Z\n",
    "def chain(l):\n",
    "    blist = []\n",
    "    for row2 in range(0,len(l)):\n",
    "        for row1 in range(0,row2):\n",
    "            if l[row1][2]!=0 or l[row2][2]!=0:\n",
    "                if l[row1][0]==l[row2][1] and not (l[row2][0],l[row1][1],max(l[row1][2],l[row2][2])) in blist:\n",
    "                    blist.append((l[row2][0],l[row1][1],max(l[row1][2],l[row2][2])))\n",
    "                if l[row1][1]==l[row2][0] and not (l[row1][0],l[row2][1],max(l[row1][2],l[row2][2])) in blist:\n",
    "                    blist.append((l[row1][0],l[row2][1],max(l[row1][2],l[row2][2])))\n",
    "        blist.append(l[row2])\n",
    "    return blist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function checks a list of preferences to see whether they form any cycles.\n",
    "# It does this by running the \"chain\" function as many times as their are acts, effectively tracing out every possible path \n",
    "# through the options.  If any of these paths take you back to the option you started with, then the function \n",
    "# returns the answer \"1\".  Otherwise, it returns \"0\".\n",
    "# Additionally, we check any indifferences in the list to see whether they conflict with a strict preference in the list\n",
    "# For instance, X = Y conflicts with X > Y and Y > X\n",
    "def check_for_cycles(l):\n",
    "    blist = l\n",
    "    answer = 0\n",
    "    for num in range(0,num_acts+1):\n",
    "        blist=chain(blist)\n",
    "        for row in blist:\n",
    "            if row[0]==row[1]:\n",
    "                answer = 1\n",
    "                return answer\n",
    "            if row[2]==0:\n",
    "                for row2 in blist:\n",
    "                    if row2[2]>0:\n",
    "                        if (row[0]==row2[0] and row[1]==row2[1]) or (row[0]==row2[1] and row[1]==row2[0]):\n",
    "                            answer = 1\n",
    "                            return answer                    \n",
    "    return answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function decides which strict preferences are kept by adding the strict preferences\n",
    "# from the sorted list iff doing so does not lead to any cycles.  We ignore indifferences.\n",
    "def kept_pairs(l):\n",
    "    keep = []\n",
    "    for row in range(0,len(l)):\n",
    "        if l[row][2]!=0 and check_for_cycles(keep + [l[row]])==0:\n",
    "            keep.append(l[row])\n",
    "        if l[row][2]==0 and check_for_cycles(keep + [l[row]])==0 and check_for_cycles(keep + [[l[row][1],l[row][0],0]])==0:\n",
    "            keep.append(l[row])\n",
    "    return keep "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This list called \"keepers\" is just the preferences which are not struck (i.e., those which do not lead to cycles\n",
    "# when combined with the ones above them)\n",
    "keepers = kept_pairs(positive_pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print()\n",
    "print(\"We start at the top of this list, and work our way down, striking any preferences which lead to cycles when\")\n",
    "print(\"combined with the (unstruck) preferences above them.  When we reach the bottom, the following preferences are\")\n",
    "print(\"left unstruck:\")\n",
    "print()\n",
    "pref_view(keepers)\n",
    "print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function returns the options which are at the top of the preference ordering.  It scans through every pair of distinct\n",
    "# strict preferences in a list and returns options which are strictly preferred to some option and not strictly *dis*preferred\n",
    "# to any other option\n",
    "# It additionally scans through the indifferences to see whether there are \n",
    "def top(l):\n",
    "    tops=[]\n",
    "    for i in l:\n",
    "        dispreferred=0\n",
    "        if i[2]>0:\n",
    "            for j in l:\n",
    "                if i!=j and i[2] != 0 and j[2]!=0 and j[1]==i[0]:\n",
    "                    dispreferred=1\n",
    "            if dispreferred==0:\n",
    "                tops.append(i[0])\n",
    "        if i[2]==0:\n",
    "            for j in l:\n",
    "                if i!=j and j[2] != 0 and (j[1]==i[0] or j[1]==i[1]):\n",
    "                    dispreferred=1\n",
    "            if dispreferred==0:\n",
    "                tops.append(i[0])\n",
    "                tops.append(i[1])\n",
    "    return tops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function removes any duplicates from a list.\n",
    "def remove_duplicates(l):\n",
    "    blist = [] \n",
    "    [blist.append(x) for x in l if x not in blist]\n",
    "    return blist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This function displays every item in a list on its own line\n",
    "def line_by_line(l):\n",
    "    for item in l:\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print()\n",
    "print('Therefore, the following options are permissible:')\n",
    "print()\n",
    "line_by_line(remove_duplicates(top(keepers)))"
   ]
  }
 ],
 "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
}