From 952675ffc70f3632e70a77a5c529fec95dc380bc Mon Sep 17 00:00:00 2001 From: Peter Norvig Date: Mon, 3 Jul 2023 13:30:08 -0700 Subject: [PATCH] Add files via upload --- ipynb/StableMatching.ipynb | 426 ++++++++++++++++++++++++------------- 1 file changed, 283 insertions(+), 143 deletions(-) diff --git a/ipynb/StableMatching.ipynb b/ipynb/StableMatching.ipynb index 19ec1e9..49c35dd 100644 --- a/ipynb/StableMatching.ipynb +++ b/ipynb/StableMatching.ipynb @@ -13,13 +13,15 @@ "- Hospitals in turn state which students they prefer. \n", "- An algorithm finds a stable matching.\n", "\n", - "Each actor has **preferences** for who they would prefer to be matched with. In the default way of stating the problem, preferences are expressed as an **ordering**: each actor rates the possible matches on the other side from most preferred to least preferred. But we will go beyond that, allowing each actor to say more: to express their preference for each possible match as a **utility**: a number between 0 and 1. For example actor $A$ on one side could say that they would like to be paired with actor β on the other side with utility 0.9 (meaning a very desireable match) and with actor γ on the other side with utility 0.1 (meaning an undesireable match). The algorithm we present actually pays attention only to the ordering of preferences, but we will use the utilities to analyze how well each side does, on average.\n", + "Each actor has **preferences** for who they would like to be matched with. A matching is **stable** if it is **not** the case that there is an actor from one side and an actor from the other side who both have a higher preference for each other than they have for who they are currently matched with. \n", + "\n", + "In the default way of stating the problem, preferences are expressed as an **ordering**: each actor rates the possible matches on the other side from most preferred to least preferred. But in this notebook we will allow each actor to say more: to express their preference for each possible match as a **utility**: a number between 0 and 1. For example actor $A$ on one side could say that they would like to be paired with actor β on the other side with utility 0.9 (meaning a very desireable match) and with actor γ on the other side with utility 0.1 (meaning an undesireable match). The matching algorithm we present actually pays attention only to the ordering of preferences, but we will use the utilities to analyze how well each side does, on average.\n", + "\n", "\n", - "A matching is **stable** if it is **not** the case that there is an actor from one side and an actor from the other side who both have a higher preference for each other than they have for who they are currently matched with. \n", "\n", "# Gale-Shapley Matching Algorithm\n", "\n", - "The **[Gale-Shapley Stable Matching Algorithm](https://en.wikipedia.org/wiki/Gale%E2%80%93Shapley_algorithm)** (*Note: David Gale was my father's [PhD advisor](https://www.genealogy.math.ndsu.nodak.edu/id.php?id=10282&fChrono=1).*) works as follows: one side is chosen to be the **proposers** and the other side the **acceptors**. Until everyone has been matched the algorithm repeats the following steps:\n", + "The **[Gale-Shapley Stable Matching Algorithm](https://en.wikipedia.org/wiki/Gale%E2%80%93Shapley_algorithm)** (*Note: David Gale was my father's [PhD advisor](https://www.genealogy.math.ndsu.nodak.edu/id.php?id=4381).*) works as follows: one side is chosen to be the **proposers** and the other side the **acceptors**. Until everyone has been matched the algorithm repeats the following steps:\n", "- An unmatched proposer, $p$, proposes a match to the highest-ranked acceptor, $a$, that $p$ has not yet proposed to.\n", "- If $a$ is unmatched, then $a$ tentatively accepts the proposal to be a match.\n", "- If $a$ is matched, but prefers $p$ to their previous match, then $a$ breaks the previous match and tentatively accepts $p$.\n", @@ -42,33 +44,33 @@ "from statistics import mean, stdev\n", "from typing import *\n", "import random\n", - "import itertools \n", - "flatten = itertools.chain.from_iterable\n", "\n", + "# Types\n", + "ID = int # ID number for an actor\n", + "Utility = float # Real number form 0 to 1 indicating degree of preference\n", + "Match = Tuple[ID, ID] # A pair of actors who are matched\n", + "PrefArray = List[List[Utility]] # Preference of each actor on a side for each actor on other side\n", "\n", - "ID = int\n", - "Match = Tuple[ID, ID]\n", - "\n", - "def stable_matching(P, A) -> Set[Match]:\n", + "def stable_matching(P: PrefArray, A: PrefArray) -> Set[Match]:\n", " \"\"\"Compute a stable match, a set of (p, a) pairs.\n", " P and A are square preference arrays: P[p][a] is how much p likes a;\n", " A[a][p] is how much a likes p. Stable means there is no (p, a)\n", " such that both prefer each other over the partner they are matched with.\"\"\"\n", - " ids = range(len(P)) # ID numbers of all actors on (either) side\n", + " ids = range(len(P)) # ID numbers of all actors on either side\n", " unmatched = set(ids) # Members of P that are not yet matched to anyone\n", " matched = {} # {a: p} mapping of who acceptors are matched with\n", " proposals = [sorted(ids, key=lambda a: P[p][a]) \n", " for p in ids] # proposals[p] is an ordered list of who p should propose to\n", " while unmatched:\n", - " p = next(iter(unmatched)) # p is an arbitrary unmatched Proposer\n", + " p = unmatched.pop() # p is an arbitrary unmatched Proposer\n", " a = proposals[p].pop() # a is p's most preferred remaining acceptor\n", - " if a not in matched:\n", - " unmatched.remove(p)\n", + " if a not in matched: # first proposal to a; a tentatively accepts\n", " matched[a] = p\n", - " elif A[a][p] > A[a][matched[a]]:\n", + " elif A[a][p] > A[a][matched[a]]: # a breaks previous engagement and accepts\n", " unmatched.add(matched[a])\n", - " unmatched.remove(p)\n", " matched[a] = p\n", + " else:\n", + " unmatched.add(p) # proposal declined; p remains unmatched\n", " return {(p, a) for (a, p) in matched.items()}" ] }, @@ -86,7 +88,7 @@ "\n", "# Preference Arrays\n", "\n", - "Let's define some preference arrays. `I` is the identity matrix: it says that every proposer number $i$ likes acceptor $i$ best, and dislikes the others equally. `X` is the same as the identity matrix for indexes 0, 1, and 2, but it says that the actor with index 3 would be happy with any of 2, 3, or 4, and actor 4 prefers 3." + "Let's define some preference arrays. `I` is the identity matrix: it says that every proposer number $i$ likes acceptor $i$ best, and dislikes the others equally. " ] }, { @@ -99,37 +101,46 @@ " [0, 1, 0, 0, 0],\n", " [0, 0, 1, 0, 0],\n", " [0, 0, 0, 1, 0],\n", - " [0, 0, 0, 0, 1]]\n", - "\n", - "X = [[1, 0, 0, 0, 0],\n", - " [0, 1, 0, 0, 0],\n", - " [0, 0, 1, 0, 0],\n", - " [0, 0, 1, 0, 0],\n", - " [0, 0, 0, 1, 0]]" + " [0, 0, 0, 0, 1]]" ] }, { - "cell_type": "code", - "execution_count": 42, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "I = [[.9, .4, .3, .2, .1],\n", - " [.1, .9, .4, .3, .2],\n", - " [.2, .1, .9, .4, .3],\n", - " [.3, .2, .1, .9, .4],\n", - " [.4, .3, .2, .1, .9]]\n", - "\n", - "M = [[.9, .4, .3, .2, .1],\n", - " [.1, .9, .4, .3, .2],\n", - " [.2, .1, .9, .4, .3],\n", - " [.1, .2, .3, .4, .9],\n", - " [.9, .4, .3, .2, .1]]" + "If both sides have this same preference array, it should result in a stable matching of (*i*, *i*) pairs:" ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)}" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stable_matching(I, I)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can measure the average utility for both sides:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -141,16 +152,58 @@ " mean(A[a][p] for (p, a) in matching))" ] }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 1)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean_utilities(I, I)" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's see what happens when `I` is the proposing side, and when `X` is the proposing side:" + "Perfect! Both sides achieve the maximum utility, 1.\n", + "\n", + "Next, preference array `X` is almost the same as the identity matrix, except that proposer 3 prefers 4, not 3, and proposer 4 prefers 3, not 4." ] }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "X = [[1, 0, 0, 0, 0],\n", + " [0, 1, 0, 0, 0],\n", + " [0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 1],\n", + " [0, 0, 0, 1, 0]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see that the way that 3 and 4 get matched depends on which side is the proposer:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -159,7 +212,7 @@ "{(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)}" ] }, - "execution_count": 44, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -170,16 +223,43 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(0.9, 0.64)" + "{(0, 0), (1, 1), (2, 2), (3, 4), (4, 3)}" ] }, - "execution_count": 45, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stable_matching(X, I)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The proposers always do better (or no worse than) the acceptors in mean utility:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1, 0.6)" + ] + }, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -190,36 +270,16 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{(0, 0), (1, 1), (2, 2), (3, 4), (4, 3)}" + "(1, 0.6)" ] }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "stable_matching(X, I)" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.76, 0.64)" - ] - }, - "execution_count": 47, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -232,20 +292,106 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "When `I` is the proposing side, every actor in `I` gets their first-choice match.\n", - "\n", - "Likewise, when `X` is the proposer, every actor in `X` gets a first-choice match.\n", - "\n", - "We can measure the average utility to each side for any matching:" + "Similar results hold when we use preference arrays that have utilities that are spread out between 0 and 1; it is still better to be the proposing side:" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 11, "metadata": {}, + "outputs": [], "source": [ - "# Is it Fair?\n", + "A = [[.9, .4, .3, .2, .1],\n", + " [.1, .9, .4, .3, .2],\n", + " [.2, .1, .9, .4, .3],\n", + " [.3, .2, .1, .9, .4],\n", + " [.4, .3, .2, .1, .9]]\n", "\n", - "We see that in both cases, the proposers get 100% of their maximum possible utility, and the acceptors gets only 60% (averaged over all five acceptors). Is this a problem? If the Gale-Shapley algorithm is used in high-stakes applications like matching medical residents to hospitals, does it make a big difference which side is the proposers? I want to address that question with some experiments." + "B = [[.9, .4, .3, .2, .1],\n", + " [.1, .9, .4, .3, .2],\n", + " [.2, .1, .9, .4, .3],\n", + " [.1, .2, .3, .4, .9],\n", + " [.9, .4, .3, .2, .1]]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)}" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stable_matching(A, B)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.9, 0.64)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean_utilities(A, B)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{(0, 0), (1, 1), (2, 2), (3, 4), (4, 3)}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stable_matching(B, A)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.76, 0.64)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean_utilities(B, A)" ] }, { @@ -254,27 +400,29 @@ "source": [ "# Preferences with Common and Private Values\n", "\n", - "I will create a bunch of randomized preference arrays and get a feeling for how they perform. But I don't want them to be completely random; I want them to reflect, in a very abstract way, some properties of the real world:\n", + "If the Gale-Shapley algorithm is used in high-stakes applications like matching medical residents to hospitals, does it make a big difference which side is the proposers? In the toy examples above, it does make a difference; in some cases the acceptors got only 60% of their possible utility, while the proposers got up to 100%. \n", + "\n", + "I will address the question by examining some randomized preference arrays and getting a feeling for how they perform. But I don't want them to be completely random; I want them to reflect, in a very abstract way, some properties of the real world:\n", "- Some choices have intrinsic properties that make them widely popular (or unpopular). For example, Massachusetts General Hospital is considered an excellent choice by many aspiring residents. The amount of utility that is commonly agreed upon is called the **common value** of a choice.\n", - "- Some choices have idiosyncratic properties that appeal only to specific choosers. For example, you might really want to be a resident at your hometown hospital, even if it is not highly-regarded by others. This is the **private value** of a choice.\n", + "- Some choices have idiosyncratic properties that appeal only to specific actors. For example, you might really want to be a resident at your hometown hospital, even if it is not highly-regarded by others. This is the **private value** of a choice.\n", "- In real world situations there is usually a mix of common and private value.\n", "\n", - "The function call `preferences(N, 0.75)`, for example, creates an NxN array of preferences, where each preference is 75% common value and 25% individual value. I implement individual value as being proportional to the ID number (`a` in the code):" + "The function call `preferences(N, 0.75)`, for example, creates an NxN array of preferences, where each preference is 75% common value and 25% individual value. I implement individual value as being proportional to the ID number (`a` in the code); that is equivalent to assuming that the hospitals (say) are sorted in increasing order of quality by ID number." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "def preferences(N=25, c=0.75):\n", " \"\"\"Create an NxN preference array, weighted: c × common + (1 - c) × random.\"\"\"\n", - " return [[round(c * (a + 0.5) / N + (1 - c) * random.uniform(0, 1), 4)\n", - " for a in range(N)] \n", + " return [[round(c * (a + 0.5) / N + (1 - c) * random.uniform(0, 1), 3)\n", + " for a in range(N)] \n", " for p in range(N)]\n", "\n", - "random.seed(42)" + "random.seed(99) # For reproducability" ] }, { @@ -286,22 +434,22 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[[0.3554, 0.1196, 0.3161, 0.3616, 0.6897, 0.7312, 0.9104],\n", - " [0.0792, 0.3181, 0.1935, 0.3593, 0.5741, 0.4061, 0.5637],\n", - " [0.3607, 0.3796, 0.2888, 0.5446, 0.7261, 0.3961, 0.8672],\n", - " [0.3848, 0.2773, 0.2563, 0.7286, 0.4897, 0.4392, 0.5126],\n", - " [0.4595, 0.409, 0.5821, 0.6149, 0.5895, 0.8794, 0.6536],\n", - " [0.3117, 0.5218, 0.4878, 0.6809, 0.6101, 0.7451, 0.4872],\n", - " [0.1497, 0.2518, 0.2185, 0.3664, 0.3719, 0.5318, 0.7821]]" + "[[0.238, 0.207, 0.268, 0.374, 0.701, 0.518, 0.656],\n", + " [0.378, 0.376, 0.648, 0.495, 0.532, 0.699, 0.573],\n", + " [0.487, 0.294, 0.373, 0.591, 0.398, 0.723, 0.889],\n", + " [0.205, 0.581, 0.443, 0.637, 0.556, 0.594, 0.599],\n", + " [0.04, 0.209, 0.673, 0.517, 0.552, 0.843, 0.767],\n", + " [0.524, 0.286, 0.286, 0.71, 0.402, 0.789, 0.762],\n", + " [0.527, 0.579, 0.509, 0.269, 0.333, 0.63, 0.874]]" ] }, - "execution_count": 9, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -319,22 +467,22 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[[0.3648, 0.3702, 0.2095, 0.267, 0.9367, 0.648, 0.6091],\n", - " [0.1711, 0.7291, 0.1634, 0.3795, 0.9895, 0.64, 0.5569],\n", - " [0.6846, 0.8429, 0.776, 0.229, 0.0321, 0.3155, 0.2677],\n", - " [0.211, 0.9429, 0.8764, 0.3147, 0.6554, 0.3956, 0.9145],\n", - " [0.4589, 0.2649, 0.2466, 0.5614, 0.2627, 0.5846, 0.8978],\n", - " [0.3994, 0.2193, 0.9975, 0.5095, 0.0909, 0.0471, 0.1096],\n", - " [0.6274, 0.7921, 0.4222, 0.0635, 0.3816, 0.9961, 0.5291]]" + "[[0.081, 0.425, 0.086, 0.31, 0.006, 0.33, 0.523],\n", + " [0.201, 0.787, 0.055, 0.211, 0.258, 0.404, 0.764],\n", + " [0.354, 0.695, 0.922, 0.131, 0.864, 0.6, 0.747],\n", + " [0.608, 0.408, 0.096, 0.144, 0.174, 0.178, 0.146],\n", + " [0.208, 0.561, 0.771, 0.798, 0.846, 0.117, 0.822],\n", + " [0.186, 0.072, 0.288, 0.586, 0.048, 0.216, 0.399],\n", + " [0.822, 0.399, 0.414, 0.371, 0.093, 0.88, 0.923]]" ] }, - "execution_count": 10, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -352,7 +500,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -365,7 +513,7 @@ " [0.1, 0.3, 0.5, 0.7, 0.9]]" ] }, - "execution_count": 11, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -383,42 +531,42 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.5000444" + "0.4996304" ] }, - "execution_count": 12, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "mean(flatten(preferences(100)))" + "mean(map(mean, preferences(100, c=0.8)))" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.50186629" + "0.5004173" ] }, - "execution_count": 13, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "mean(flatten(preferences(100, c=0.25)))" + "mean(map(mean, preferences(100, c=0.2)))" ] }, { @@ -430,7 +578,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -441,27 +589,19 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[([[0.1692, 0.6815, 0.6931],\n", - " [0.2352, 0.7386, 0.7107],\n", - " [0.2157, 0.6245, 0.7099]],\n", - " [[0.095, 0.6114, 0.6695],\n", - " [0.3564, 0.4007, 0.4181],\n", - " [0.4574, 0.7469, 0.7934]]),\n", - " ([[0.5066, 0.2609, 0.439],\n", - " [0.0884, 0.6074, 0.4683],\n", - " [0.5632, 0.6722, 0.7142]],\n", - " [[0.1663, 0.6358, 0.8687],\n", - " [0.4716, 0.7222, 0.8577],\n", - " [0.2024, 0.2663, 0.5462]])]" + "[([[0.181, 0.736, 0.7], [0.207, 0.734, 0.599], [0.572, 0.745, 0.715]],\n", + " [[0.537, 0.72, 0.784], [0.281, 0.256, 0.582], [0.452, 0.657, 0.554]]),\n", + " ([[0.464, 0.575, 0.662], [0.23, 0.416, 0.821], [0.342, 0.381, 0.658]],\n", + " [[0.471, 0.517, 0.603], [0.201, 0.365, 0.482], [0.102, 0.347, 0.479]])]" ] }, - "execution_count": 15, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -476,12 +616,12 @@ "source": [ "# Histograms of Acceptor/Proposer Utility\n", "\n", - "Now we're readsy to answer the original question: how much worse is it to be an acceptor rather than a proposer? The function `show` displays two overlapping histograms of mean utilities: one for acceptors and one for proposers. " + "Now we're ready to answer the original question: how much worse is it to be an acceptor rather than a proposer? The function `show` displays two overlapping histograms of mean utilities: one for acceptors and one for proposers. " ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -506,7 +646,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -515,12 +655,12 @@ "text": [ "10,000 examples with N = 25 actors, common value ratio c = 0.0\n", " Acceptors: 0.729 ± 0.063\n", - " Proposers: 0.870 ± 0.035\n" + " Proposers: 0.871 ± 0.035\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -546,7 +686,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -560,7 +700,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -577,7 +717,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -586,12 +726,12 @@ "text": [ "10,000 examples with N = 50 actors, common value ratio c = 0.5\n", " Acceptors: 0.647 ± 0.013\n", - " Proposers: 0.661 ± 0.011\n" + " Proposers: 0.661 ± 0.012\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -617,7 +757,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -631,7 +771,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -648,7 +788,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 29, "metadata": {}, "outputs": [ { @@ -662,7 +802,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -681,7 +821,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see that there is very little difference between the two sides. So the conclusion is: when there is a lot of common value, the Gale-Shapley Matching Algorithm is fair. So it is probably okay to use it for matching medical residents, because there is a lot of common value in the perception of the quality of hospitals, and likewise for the quality of students.\n", + "We see that there is very little difference between the two sides. So the conclusion is: when there is a lot of common value, the Gale-Shapley Matching Algorithm is almost fair: the proposers have an advantage, but it is minimal. So it is probably okay to use the algorithm for matching medical residents, because there is a lot of common value in the perception of the quality of hospitals, and likewise for the quality of students.\n", "\n", "But when there is mostly private value, the algorithm is unfair, favoring the proposers over the acceptors." ] @@ -689,7 +829,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -703,9 +843,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.7" + "version": "3.9.12" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }