diff --git a/ipynb/flipping.ipynb b/ipynb/flipping.ipynb index dbcc883..dfab59c 100644 --- a/ipynb/flipping.ipynb +++ b/ipynb/flipping.ipynb @@ -15,11 +15,13 @@ "> Take a standard deck of cards, and pull out the numbered cards from one suit (the nine cards 2 through 10). Shuffle them, and then lay them face down in a row. Flip over the first card so it is face up. Now guess whether the next card in the row (the first down card) is higher or lower. If you’re right, keep going. If you play this game optimally, what’s the probability that you can get to the end without making any mistakes?

\n", "> *Extra credit:* What if there were more cards — 2 through 20, or 2 through 100? How do your chances of getting to the end change?\n", " \n", - "First, let's define \"*play this game optimally.*\" The optimal policy is to look at the current flipped-up card and, remembering what cards have already been flipped and thus knowing what cards remain face-down, count how many of the remaining down cards are higher than the up card, and how many are lower. Guess according to the majority. (*Details*: In case of a tie in the counts, guessing either \"higher\" or \"lower\" is equally optimal. When there are only two cards left (one up, one down) you know for sure what the down card is, so you can always guess right.)\n", + "First, let's define \"*play this game optimally.*\" The optimal policy is to look at the current flipped-up card and, remembering what cards have already been flipped and thus knowing what cards remain face-down, guess that the first down card will be \"higher\" if the majority of the down cards are higher than the up card, otherwise guess that it will be \"lower\". (*Details*: In case of a tie in the counts, guessing either \"higher\" or \"lower\" is equally optimal. When there are only two cards left (one up, one down) you know for sure what the down card is, so you can always guess right.)\n", " \n", - "We can solve the problem with brute force: define `guess_all(cards)` to take a specific sequence of cards and return true only if the optimal policy guesses all the cards correctly. Then we can apply `guess_all` to every permutation of cards and count how often it guesses correctly. Assuming every permutation is equally likely, the ratio is the probability of guessing right all the way to the end.\n", + "# Brute Force Algorithm\n", " \n", - "(*Python Trivia*: `True` is equal to `1` and `False` is equal to `0`, so `sum([True, False, True])` is 2; `mean([True, False, True])` is 2/3, and the expression `(b and x)` where `b` is a Boolean and `x` is a number is equivalent to `(x if b else 0)`. In other languages you would be required or at least encouraged to explicitly cast Booleans to integers, but in Python it is considered good style to do without explicit casts.)\n", + "We can solve the problem with brute force: for every permutation of the cards, call `guess_all` to determine if the optimal policy guesses right on that sequence of cards. Assuming every permutation is equally likely (that is, the cards were shuffled fairly), the overall probability of guessing right is the proportion of `True` results.\n", + " \n", + "> *Python Trivia*: `True` is equal to `1` and `False` is equal to `0`, so `sum([True, False, True])` is 2; `mean([True, False, True])` is 2/3, and when `b` is a Boolean and `x` is a number, the expression `(b and x)` is equivalent to `(x if b else 0)` and the expression `(x - b)` is equivalent to `((x - 1) if b else x)`. In other languages you would be required (or at least encouraged) to explicitly cast Booleans to integers, but in Python `bool` is a subclass of `int` and it is considered good style to do without casts.\n", " \n", "I can implement `guess_all` as follows:" ] @@ -30,6 +32,8 @@ "metadata": {}, "outputs": [], "source": [ + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", "from itertools import permutations\n", "from statistics import mean\n", "from functools import lru_cache" @@ -46,9 +50,8 @@ " return len(cards) <= 2 or guess_first(cards) and guess_all(cards[1:])\n", "\n", "def guess_first(cards) -> bool:\n", - " \"\"\"Given a sequence of cards, guess that the down card will be \"higher\" or \"lower\" \n", - " according to majority counts of the down cards; return True if the guess \n", - " matches the actual relation between the up card and the first down card.\"\"\"\n", + " \"\"\"Guess that the first down card will be \"higher\" or \"lower\" according to majority \n", + " counts of the down cards; return True if the guess is correct.\"\"\"\n", " up, *down = cards\n", " higher = sum(d > up for d in down)\n", " lower = sum(d < up for d in down)\n", @@ -79,7 +82,8 @@ } ], "source": [ - " # On this sequence, the optimal policy always guesses \"higher\"; that's right. \n", + "# On this sequence, the optimal policy always guesses \"higher\"; \n", + "# and it turns out that's always right. \n", "guess_all((2, 3, 4, 5, 6))" ] }, @@ -102,7 +106,7 @@ "source": [ "# On this sequence, the optimal policy guesses \"higher\" first; that's wrong.\n", "# There is a 3/4 chance that a down card is higher than 3, but it turns\n", - "# out that the 2 is actually lower.\n", + "# out that the first down card, 2, is the one lower card.\n", "guess_all((3, 2, 4, 5, 6)) " ] }, @@ -132,7 +136,7 @@ "source": [ "# The Answer\n", "\n", - "What's the probability that we can guess all nine cards right? We get that by averaging over all possible permutations of the cards:" + "The probability that we can guess all nine cards right is the average over all possible permutations of the cards:" ] }, { @@ -163,51 +167,21 @@ "source": [ "That's the correct answer ([per 538](https://fivethirtyeight.com/features/how-many-hoops-will-kids-jump-through-to-play-rock-paper-scissors/)): about 17% chance of guessing all nine cards right.\n", "\n", - "# Extra Credit\n", + "# Extra Credit: Efficient Algorithm\n", "\n", - "The extra credit problem asks about 19 and 99 cards. But there are 19! permutations of 19 cards; that's over $10^{17}$ (and don't even think about 99!). So my brute force solution won't work. We will need a more efficient way of looking at the space of possible sequences of cards. \n", + "The extra credit problem asks about 19 and 99 cards. But there are $19! \\approx 10^{17}$ permutations of 19 cards and a whopping $99! \\approx 10^{156}$ permutations of 99 cards. So my brute force algorithm won't work. \n", "\n", - "I note that two things are true when we are deciding whether to guess \"higher\" or \"lower\" in `guess_first(cards)`: \n", + "(*Note*: since we are now dealing with the general case of $n$ cards, I'll represent them as `range(n)`, that is, starting at `0` rather than `2`.)\n", "\n", - "**First**, the **order** of the `down` cards doesn't matter. The optimal policy makes the same guess whether `down` is `(2, 3, 4, 5)` or a permutation such as `(4, 2, 5, 3)`. So we could represent cards as a set: `{2, 3, 4, 5}`. As we flip over cards the set of remaining cards becomes smaller; altogether there are $2^n$ subsets to consider, a significant reduction from the $n!$ permutations we had to consider in the brute force approach, and good enough to handle $n=19$ (but not yet good enough for $n=99$).\n", + "# Efficient Algorithm: Analysis\n", "\n", - "**Second**, the **identity** of the `down` cards doesn't matter (if we're careful).\n", - "For example, when the up card is `3` it doesn't matter if the remaining cards are `{2, 3, 6}` or `{1, 3, 4}` or `{0, 3, 5}` or any other set of three cards in which the `3` is the middle card. For any such set, the chance of guessing right is 50%. Note that I can't just summarize these situations as \"*there are 3 cards remaining and the up card is 3*\" but I can summarize them as \"*there are 3 cards remaining and the up card is the second lowest*\". In other words, I describe the up card by **renumbering** it to be its index into the list of sorted cards. For each of the three sets described here, the index of `3` is `1`: it is the second element of the sorted list of cards. Some examples:\n", + "We will need a more efficient way of representing cards, so that we don't need to consider $n!$ possibilities. I see two ideas that will help. Consider what happens when we are deciding whether to guess \"higher\" or \"lower\" in `guess_first(cards)`: \n", "\n", - " - [Remaining: `{2, 3, 6}` Up card: `3`] with renumbering becomes [Remaining: `range(3)` Up index: `1`] (i.e., second lowest)\n", - " - [Remaining: `{1, 3, 4}` Up card: `3`] with renumbering becomes [Remaining: `range(3)` Up index: `1`] (i.e., second lowest)\n", - " - [Remaining: `{0, 3, 5}` Up card: `3`] with renumbering becomes [Remaining: `range(3)` Up index: `1`] (i.e., second lowest)\n", - " - [Remaining: `{3, 4, 7}` Up card: `3`] with renumbering becomes [Remaining: `range(3)` Up index: `0`] (i.e., lowest)\n", - " - [Remaining: `{0, 2, 3}` Up card: `3`] with renumbering becomes [Remaining: `range(3)` Up index: `2`] (i.e., third lowest)\n", + "**First**, the **order** of the `down` cards doesn't matter. The optimal policy makes the same guess whether `down` is `(2, 3, 4, 5)` or a permutation such as `(4, 2, 5, 3)`. So we could represent cards as a set: `{2, 3, 4, 5}`. As we discard flipped cards, we must consider subsets. Since there are $n!$ permutations but only $2^n$ subsets of $n$ cards, this is a nice improvement, good enough to handle $n=19$ (but not good enough for $n=99$).\n", "\n", - " \n", - "Renumbering the up card as an index number won't alter the probabilities, but it will allow me to describe any situation with just two integers, the number of cards remaining and the index of the up card. That means there are only $O(n^2)$ situations to describe, which should be good enough to handle $n=99$. \n", + "**Second**, the **identity** of the `down` cards doesn't matter. What does matter is how many down cards are higher or lower than the up card. For example, when the up card is `3` it doesn't matter if the remaining cards are `{2, 3, 6}` or `{1, 3, 4}` or `{0, 3, 5}` or any other set of three cards in which the `3` is the middle card. For any such set, there is one card higher and one card lower than the up card, so the chance of guessing right is 50%. Note that I can't represent all these situations as \"*there are 3 cards remaining and the up card is 3*\" but I can represent them as \"*there are 3 cards remaining and the up card is the second lowest*\". \n", "\n", - "In other words, what I have done is gone from a **concrete** representation of the cards as explicit permutations to an **abstract** representation that says how many cards remain and what the index number of the up card is, but doesn't say exactly what the cards are nor what order they are in. Abstraction is often a good way to fight against combinatorial explosion.\n", - "\n", - "\n", - "\n", - "\n", - "# First Try at Extra Credit\n", - "\n", - "I thought I could define a function, `P_all(n)`, that told me the probability of guessing all `n` cards right. I wrote down a first try at a definition:\n", - "\n", - " def P_all(n) -> float:\n", - " return 1 if n <= 2 else P_first(n) * P_all(n - 1)\n", - " \n", - "Could it really be as simple as that? All I have to do is define `P_first(n)` (the probability of guessing the first of `n` cards right) and I'm done? My immediate reaction was that this feels *too* easy. I was suspicious of this definition for three reasons:\n", - "\n", - "1. It is rare (but not unheard of) for an efficient solution to be simpler than the brute force solution.\n", - "- I said there should be renumbering, but this code doesn't appear to do any renumbering.\n", - "- Yes, the probability of getting all the cards right can be described as the probability of getting the first card right and then getting the rest right. But the joint probability of two events is equal to the product of their probabilities *only when the two events are independent*. And in this problem, the two events are *not* independent, because they both depend on the card that is the first down card in `P_first(n)` and becomes the up card in `P_all(n - 1)`. For example, suppose the first down card is 0, the lowest possible card. That certainly has a big effect on `P_first(n)`, because it means a guess of \"higher\" will always be wrong and a guess of \"lower\" will always be right. And it also has a big effect on guessing the rest of the sequence, because it means that the second guess should always be \"higher\" (than 0), which is guaranteed to be right. \n", - "\n", - "My suspicions were well-founded; I'll need something a bit more complicated.\n", - "\n", - "# Second Try at Extra Credit\n", - "\n", - "I need to break down the problem in a way that shares the information about the first down card (that becomes the next up card). One way to do that is to define `P_given(up, n)` to be the probability of guessing all the cards right *given* that the flipped-up card has index `up` in the sorted list of `n` remaining cards (including the `up` card).\n", - "\n", - "I will still define `P_all(n)`, but it won't call itself recursively, rather it calls `P_given(up, n)` for every possible `up` card, and averages the results:" + "In other words, I can describe the up card by **renumbering** it to be its index into the sorted list of remaining cards (up and down). For each of the three sets described here, the index of the `3` card is `1`; it is the second element of the sorted list of cards:" ] }, { @@ -216,17 +190,50 @@ "metadata": {}, "outputs": [], "source": [ - "def P_all(n) -> float:\n", - " \"\"\"Probability of guessing all n cards right.\"\"\"\n", - " return mean(P_given(up, n) for up in range(n))" + "for cards in ({2, 3, 6}, {1, 3, 4}, {0, 3, 5}):\n", + " assert sorted(cards).index(3) == 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "`P_given(up, n)` works by considering each possible first down card, computing if we would guess the first down card right given the up card (by calling `first_right(up, down, n)`), and if right, calling `P_given` recursively with the old first down card (renumbered) being the new up card, and the deck size, `n`, being one card smaller. \n", - "When this is all done, we take the average probability value over all the down cards. We also arrange for `P_given` to cache its values so that we don't repeat computations; this is crucial for efficiency." + "Some further examples of renumbering:\n", + "\n", + " - [Cards: `{2, 3, 6}` Up: `3`] *renumbered to* [Cards: `range(3)` Up: `1`] (i.e., second lowest)\n", + " - [Cards: `{1, 3, 4}` Up: `3`] *renumbered to* [Cards: `range(3)` Up: `1`] (i.e., second lowest)\n", + " - [Cards: `{0, 3, 5}` Up: `3`] *renumbered to* [Cards: `range(3)` Up: `1`] (i.e., second lowest)\n", + " - [Cards: `{3, 5, 7}` Up: `3`] *renumbered to* [Cards: `range(3)` Up: `0`] (i.e., lowest)\n", + " - [Cards: `{0, 1, 3}` Up: `3`] *renumbered to* [Cards: `range(3)` Up: `2`] (i.e., third lowest)\n", + "\n", + " \n", + "Now I can describe any situation with just two integers, the number of cards and the index of the up card. That means there are only $n^2$ possible situations to describe, which should be good enough to handle $n=99$ and beyond. \n", + "\n", + "What I have done is gone from a **concrete** representation of the cards as explicit permutations to an **abstract** representation that says how many cards remain and what the index number of the up card is, but doesn't say exactly what the cards are nor what order they are in. This kind of abstraction is often a good way to fight against combinatorial explosion.\n", + "\n", + "\n", + "\n", + "\n", + "# Efficient Algorithm: First Try\n", + "\n", + "I wanted to define a function, `P_all(n)`, that tells me the probability of guessing all `n` cards right. I wrote down a first try at a definition:\n", + "\n", + " def P_all(n) -> float:\n", + " return 1 if n <= 2 else P_first(n) * P_all(n - 1)\n", + " \n", + "Could it really be as simple as that? All I have to do is define `P_first(n)` (the probability of guessing the first of `n` cards right) and I'm done? My immediate reaction was that this feels *too* easy. I was suspicious of this definition for three reasons:\n", + "\n", + "1. It is rare (but not unheard of) for an efficient algorithm to be simpler than the brute force algorithm.\n", + "- I said there should be renumbering, but this code doesn't do any renumbering.\n", + "- This code says the joint probability of getting the first card right and then getting the rest right is the product of their probabilities. But that's true *only when the two events are independent*. And in flipping cards, the two events are *not* independent, because both events depend on the card that is the first down card in `P_first(n)` and becomes the up card in `P_all(n - 1)`. \n", + "\n", + "My suspicions were well-founded: this code won't work.\n", + "\n", + "# Efficient Algorithm: Second Try\n", + "\n", + "I need to capture the fact that the card that is the first down card for the current guess becomes the up card for the next guess. One way to do that is to define `P_all_given(up, n)` to be the probability of guessing all the cards right given that the flipped-up card has index `up` in the sorted list of `n` remaining cards (including the `up` card).\n", + "\n", + "Now `P_all(n)` is defined to call `P_all_given(up, n)` for each possible `up` card and average the results:" ] }, { @@ -235,22 +242,17 @@ "metadata": {}, "outputs": [], "source": [ - "@lru_cache(None)\n", - "def P_given(up, n) -> float:\n", - " \"\"\"Probability of guessing all n cards right, given the up card.\"\"\"\n", - " return (1 if n <= 2 else\n", - " mean(first_right(up, down, n) \n", - " and P_given(renumber(down, up), n - 1)\n", - " for down in range(n) if down != up))" + "def P_all(n) -> float:\n", + " \"\"\"Probability of guessing all n cards right.\"\"\"\n", + " return mean(P_all_given(up, n) for up in range(n))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "`first_right(up, down, n)` returns true if we would correctly guess the down card given the up card. The optimal policy is to guess that the down card will be higher than the up card when the up card is in the lower half of `range(n)`. \n", - "\n", - "And finally, `renumber` renumbers a down card by decrementing it by one if the up card is lower (meaning that removing the up card from the deck makes the down card one closer to the lowest possible card). " + "`P_all_given(up, n)` works by considering each possible first down card (`down1`), computing if we would guess the first down card right given the up card (`guess_first_given(up, down1, n)`), and if right, calling `P_all_given` recursively with the old first down card (renumbered) being the new up card, and the deck size, `n`, being one card smaller. \n", + "When this is all done, we take the average probability value over all the down cards. We also arrange for `P_all_given` to cache its values so that we don't repeat computations; this is crucial for efficiency." ] }, { @@ -259,39 +261,42 @@ "metadata": {}, "outputs": [], "source": [ - "def first_right(up, down, n) -> bool:\n", - " \"\"\"Do we guess right given these up and down cards, \n", - " when the set of cards (including up and down) is range(n)?\"\"\"\n", - " return (up > down) == (up > (n - 1) / 2)\n", - "\n", - "def renumber(down, up) -> int: return down - (up < down)" + "@lru_cache(None)\n", + "def P_all_given(up, n) -> float:\n", + " \"\"\"Probability of guessing all n cards right, given the index of the up card.\"\"\"\n", + " return (1 if n <= 2 else\n", + " mean(guess_first_given(up, down1, n) and P_all_given(renumber(down1, up), n - 1)\n", + " for down1 in range(n) if down1 != up))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "We can see that `P_all(n)` differs from the old brute-force result only in the 17th decimal place (due to round-off error):" + "The function `guess_first_given(up, down1, n)`, defined below, returns true if we would correctly guess the first down card given the up card. The optimal policy is to guess that the first down card will be higher than the renumbered up card when the up card is in the lower half of `range(n)`. \n", + "\n", + "And finally, `renumber` renumbers a card by decrementing it by one if the card we are discarding (the up card) is lower (meaning that the card we are keeping becomes one closer to the lowest possible card). Otherwise the card's number is unchanged." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.17085537918871255" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "P_all(9)" + "def guess_first_given(up, down1, n) -> bool:\n", + " \"\"\"Do we guess the first down card right given the up card, \n", + " when the set of cards (including up and down) is range(n)?\"\"\"\n", + " return (up < n / 2) == (down1 > up)\n", + "\n", + "def renumber(card, discard) -> int: return card - (discard < card)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that `P_all(n)` agrees with the old brute-force result (except for round-off in the 17th decimal place):" ] }, { @@ -302,7 +307,7 @@ { "data": { "text/plain": [ - "0.17085537918871252" + "0.17085537918871255" ] }, "execution_count": 11, @@ -311,14 +316,7 @@ } ], "source": [ - "mean(map(guess_all, permutations(cards)))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can now efficiently answer the extra credit questions:" + "P_all(9)" ] }, { @@ -329,7 +327,7 @@ { "data": { "text/plain": [ - "0.008419397002884993" + "0.17085537918871252" ] }, "execution_count": 12, @@ -338,7 +336,16 @@ } ], "source": [ - "P_all(19)" + "mean(map(guess_all, permutations(range(2, 11))))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The Extra Credit Answers\n", + "\n", + "We can now efficiently answer the extra credit questions:" ] }, { @@ -349,7 +356,7 @@ { "data": { "text/plain": [ - "6.67213407124781e-14" + "0.008419397002884993" ] }, "execution_count": 13, @@ -357,6 +364,26 @@ "output_type": "execute_result" } ], + "source": [ + "P_all(19)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.67213407124781e-14" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "P_all(99)" ] @@ -365,64 +392,121 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The moral is: don't expect to ever guess 99 cards all right, and allocate at least about 100 tries to guess 19 cards right.\n", + "The moral is: give yourself at least about 100 tries to guess 19 cards right, and don't expect to *ever* guess 99 cards right.\n", "\n", - "# Computational Complexity\n", + "# Closed Form Formula?\n", "\n", - "My first approach, with `guess_all`, is $O(n!)$ because it considers every permutation of $n$ cards.\n", + "I would like to come up with a closed-form formula for `P_all(n)` as a function of $n$. I don't see how to define an *exact* formula, but I can see that:\n", + "- When the up card is the very middle of the remaining cards, we have a 50% chance of guessing right.\n", + "- When the up card is the very highest or very lowest of the remaining cards, we have a 100% chance of guessing right.\n", + "- So on average (very roughly speaking), we should have about a 75% chance of guessing right on each card.\n", + "- In a full deck we make $n - 2$ guesses (we don't have to guess the first card, and we will know the last for sure).\n", + "- Therefore, the chance of guessing all the cards right is roughly $0.75^{(n-2)}$\n", "\n", - "For my second approach, `first_right` and `renumber` do only a constant amount of work each call. `P_all` makes $n$ calls to `P_given`, and `P_given` considers $n$ down cards and makes recursive calls only when `first_guess(up, down, n)` returns true. It seems difficult to analyze how often that happens. But we can put an upper bound on the work `P_given` does. It is memoized (with `lru_cache`) and both of its arguments are restricted to $n$ possible values, so we can say that `P_given(up, n)` is $O(n^2)$ as an upper bound, and therefore `P_all(n)` is $O(n^3)$ as an upper bound.\n", - "\n", - "However, experimental evidence suggests a stricter bound of $O(n^2)$ for `P_all(n)` (although I haven't proved it).\n", - "\n", - "In the table below, `n` is the number of cards, `s` is the size of the cache for `P_given` (that is, the number of computations `P_given` performed and cached during the computation of `P_all(n)`), and we see that, for all values of $n$ tested, `s` is *exactly* equal to $c = n \\times (n + 1) / 2 - 1$. " + "To see if this theory makes sense, let's make a logarithmic plot (see below) in which `base ** (n-2)` (in blue) is an exponential function, which means it is a perfectly straight line on a log plot. We see that the `P_all(n)` curve (in red) matches the exponential function at the start and end, but bows a tiny bit above the exponential in the middle. It must be a more complex function than just a simple exponential. After playing around a bit, I found that `base = 0.7256`, not `base = 0.7500`, gave the best fit to `P_all(n=299)`, out of any four-decimal-place value." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "base = 0.7256\n", + "\n", + "X = range(2, 300, 4)\n", + "Y = [P_all(n) for n in X]\n", + "E = [base ** (n - 2) for n in X]\n", + "\n", + "plt.figure(figsize=(9, 9))\n", + "plt.yscale('log')\n", + "plt.xlabel(\"Number of Cards, n\")\n", + "plt.ylabel(\"Probability of Guessing All Right (log scale)\")\n", + "plt.plot(X, Y, 'rs', alpha=0.5, label='P_all(n)')\n", + "plt.plot(X, E, 'bs', alpha=0.5, label=f'{base} ** (n-2)')\n", + "plt.legend();" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Computational Complexity: O(n) Notation \n", + "\n", + "The brute force algorithm, with `guess_all(n)`, requires $O(n!)$ computation time because it considers every permutation of $n$ cards.\n", + "\n", + "In the efficient algorithm, `P_all(n)` makes $n$ calls to `P_all_given`, and each call to `P_all_given` considers $n$ down cards and makes recursive calls only when `guess_first_given(up, down1, n)` returns true. Some of those calls have already been computed and are cached. It seems complicated to do an exact analysis. \n", + "\n", + "However, if we assume that the majority of the work done by `P_all` is inside a call to `P_all_given`, and note that both of `P_all_given`'s arguments are restricted to $n$ possible values, then we can conclude that only $O(n^2)$ unique calls can be made. Repeated calls will fetch results from the cache in constant time. Therefore `P_all` is $O(n^2)$.\n", + "\n", + "Experimental evidence shows that for every value of `n` tested so far, a call to `P_all(n)` does *exactly* $n \\times (n + 1) / 2 - 1$ unique calls to `P_all_given`. We can determine this by looking at the number of elements in the function's cache.\n", + "\n", + "In the table below, `n` is the number of cards, `s` is the size of the cache, and we see that `s` is always equal to $c = n \\times (n + 1) / 2 - 1$. \n", + "\n", + "The last three columns of the table don't deal with computational complexity. They give the value of `P_all(n)`, the approximation `base ** (n - 2)`, and the percentage difference between the true value and the approximation." + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "| n | s | s==c | P_all(n) |\n", - "|—————|————————|——————|——————————|\n", - "| 3 | 5 | True | 8.33e-01 |\n", - "| 4 | 9 | True | 6.67e-01 |\n", - "| 5 | 14 | True | 5.17e-01 |\n", - "| 6 | 20 | True | 3.97e-01 |\n", - "| 7 | 27 | True | 3.01e-01 |\n", - "| 8 | 35 | True | 2.28e-01 |\n", - "| 9 | 44 | True | 1.71e-01 |\n", - "| 10 | 54 | True | 1.28e-01 |\n", - "| 20 | 209 | True | 6.18e-03 |\n", - "| 30 | 464 | True | 2.71e-04 |\n", - "| 40 | 819 | True | 1.14e-05 |\n", - "| 50 | 1,274 | True | 4.71e-07 |\n", - "| 60 | 1,829 | True | 1.91e-08 |\n", - "| 70 | 2,484 | True | 7.69e-10 |\n", - "| 80 | 3,239 | True | 3.07e-11 |\n", - "| 90 | 4,094 | True | 1.22e-12 |\n", - "| 100 | 5,049 | True | 4.83e-14 |\n", - "| 110 | 6,104 | True | 1.90e-15 |\n", - "| 120 | 7,259 | True | 7.49e-17 |\n", - "| 130 | 8,514 | True | 2.94e-18 |\n", - "| 140 | 9,869 | True | 1.15e-19 |\n", - "| 150 | 11,324 | True | 4.49e-21 |\n" + " n | s | s==c || P_all(n) | base**(n-2) | diff (base=0.7256)\n", + "—————|————————|——————||——————————|—————————————|———————\n", + " 2 | 2 | True || 1.0e+00 | 1.0e+00 | 0%\n", + " 3 | 5 | True || 8.3e-01 | 7.3e-01 | 13%\n", + " 4 | 9 | True || 6.7e-01 | 5.3e-01 | 21%\n", + " 5 | 14 | True || 5.2e-01 | 3.8e-01 | 26%\n", + " 6 | 20 | True || 4.0e-01 | 2.8e-01 | 30%\n", + " 7 | 27 | True || 3.0e-01 | 2.0e-01 | 33%\n", + " 8 | 35 | True || 2.3e-01 | 1.5e-01 | 36%\n", + " 9 | 44 | True || 1.7e-01 | 1.1e-01 | 38%\n", + " 19 | 189 | True || 8.4e-03 | 4.3e-03 | 49%\n", + " 39 | 779 | True || 1.6e-05 | 7.0e-06 | 55%\n", + " 59 | 1,769 | True || 2.6e-08 | 1.1e-08 | 56%\n", + " 79 | 3,159 | True || 4.2e-11 | 1.9e-11 | 56%\n", + " 99 | 4,949 | True || 6.7e-14 | 3.1e-14 | 54%\n", + " 119 | 7,139 | True || 1.0e-16 | 5.0e-17 | 51%\n", + " 139 | 9,729 | True || 1.6e-19 | 8.2e-20 | 48%\n", + " 159 | 12,719 | True || 2.4e-22 | 1.3e-22 | 44%\n", + " 179 | 16,109 | True || 3.7e-25 | 2.2e-25 | 40%\n", + " 199 | 19,899 | True || 5.5e-28 | 3.6e-28 | 35%\n", + " 219 | 24,089 | True || 8.3e-31 | 5.9e-31 | 29%\n", + " 239 | 28,679 | True || 1.3e-33 | 9.7e-34 | 23%\n", + " 259 | 33,669 | True || 1.9e-36 | 1.6e-36 | 15%\n", + " 279 | 39,059 | True || 2.8e-39 | 2.6e-39 | 7%\n", + " 299 | 44,849 | True || 4.2e-42 | 4.2e-42 | 2%\n" ] } ], "source": [ - "print('| n | s | s==c | P_all(n) |')\n", - "print('|—————|————————|——————|——————————|')\n", - "for n in list(range(3, 10)) + list(range(10, 151, 10)):\n", - " P_given.cache_clear()\n", + "P_all_given.cache_clear()\n", + "print(f' n | s | s==c || P_all(n) | base**(n-2) | diff (base={base})')\n", + "print(f'—————|————————|——————||——————————|—————————————|———————')\n", + "for n in list(range(2, 10)) + list(range(19, 300, 20)):\n", " p = P_all(n)\n", - " s = P_given.cache_info().currsize\n", + " s = P_all_given.cache_info().currsize\n", " c = n * (n + 1) / 2 - 1\n", - " print(f'|{n:4d} | {s:6,d} | {s == c} | {p:.2e} |')" + " e = base ** (n - 2)\n", + " diff = abs(p - e) / p\n", + " print(f'{n:4d} | {s:6,d} | {s == c} || {p:8.1e} | {e:8.1e} | {diff:3.0%}')" ] } ],