From a021a08fbc02ff97b1485072e02163b1958dc7c4 Mon Sep 17 00:00:00 2001 From: jrtechs Date: Sun, 7 Oct 2018 12:26:58 -0400 Subject: [PATCH] Final updates and revisions to the fibonacci post. --- .../posts/programming/everything-fibonacci.md | 80 ++++++++++--------- 1 file changed, 41 insertions(+), 39 deletions(-) diff --git a/blogContent/posts/programming/everything-fibonacci.md b/blogContent/posts/programming/everything-fibonacci.md index a34f14d..2ff26eb 100644 --- a/blogContent/posts/programming/everything-fibonacci.md +++ b/blogContent/posts/programming/everything-fibonacci.md @@ -3,11 +3,11 @@ know what the fibonacci sequence is and how to calculate it. For those who don't know: [Fibonacci](https://en.wikipedia.org/wiki/Fibonacci) is a sequence of numbers starting with 0,1 whose next number is the sum of the two previous numbers. After having multiple of my CS classes -gave lectures and multiple homework on the Fibonacci sequence; I decided -that it would be a great idea to write a blog post going over +give lectures and homeworks on the Fibonacci sequence; I decided + to write a blog post going over the 4 main ways of calculating the nth term of the Fibonacci sequence. -In addition to providing python code for calculating the nth perm of the sequence, a proof for their validity -and analysis of their time complexities both mathematically and empirically will +In addition to providing the python code for calculating the nth perm of the sequence, a proof for their validity +and an analysis of their time complexities both mathematically and empirically will be examined. # Slow Recursive Definition @@ -25,28 +25,26 @@ def fib(n): ##Time Complexity Observing that each call has two recursive calls we can place an upper bound on this -function as $O(2^n)$. However, if we solve this recurrence we can compute the exact value -and place a tight bound for time complexity. +function as $O(2^n)$. However, if we solve this recurrence we can place a tight bound for time complexity. We can write a recurrence for the number of times fib is called: $$ - F(0) = 0\\ F(1) = 1\\ F(n) = F(n-1) + F(n-2)\\ $$ -Next we replace each instance of F(n) with $a^n$ since we want to solve for the roots since that -will allow us to put a tight asymptotic limit on the growth. +Next, we replace F(n) with $a^n$ since we want to find rate of exponential growth. $$ a^n = a^{n-1} + a^{n-2}\\ \frac{a^n}{a^{n-2}} = \frac{a^{n-1} + a^{n-2}}{a^{n-2}}\\ a^2 = a + 1\\ - a = \frac{1 + sqrt(5)}{2}\\ + a = \frac{1 \pm sqrt(5)}{2}\\ $$ -From this calculation we can conclude that F(n) $\in \Theta 1.681^n$ +From this calculation we can conclude that F(n) $\in \Theta 1.681^n$. We don't have to worry about +the negative root since it would not be asymptotically relevant by the definition of $\Theta$. @@ -57,14 +55,13 @@ Here is a graph of the actual performance that I observed from this recursive de ![Recursive Definition](media/fibonacci/RecursiveDefinition.png) - - # Accumulation Solution The problem with the previous recursive solution is that you had to recalculate certain terms of fibonacci a ton of times. A summation variable would help us avoid this problem. -You could write this using a simple loop, however, it is still possible to do this with -recursion. +You could write this solution using a simple loop or dynamic programming +, however, I chose to use recursion to demonstrate that it's recursion which made the first +problem slow. ```Python @@ -80,9 +77,11 @@ def fibIterative(n): return fibHelper(n, 0, 1) ``` -In this code example fibHelper is a method which accumulates the previous two terms. +In this code example, fibHelper is a method which accumulates the previous two terms. The fibIterative is a wrapper method which sets the two initial terms equal to 0 and 1 -representing the fibonacci sequence. +representing the fibonacci sequence. At first it may not be obvious that fibIterative(n) +is equivalent to fib(n). To demonstrate that these two are in fact equivalent, I broke this +into two inductive proofs. ## Proof for Fib Helper **Lemma:** For any n $\epsilon$ N if n $>$ 1 then @@ -90,7 +89,7 @@ representing the fibonacci sequence. **Proof via Induction** -Base Case: n = 2: +**Base Case**: n = 2: $$ LHS = fibHelper(2, a, b)\\ = fibHelper(1, b, a + b) = a + b\\ @@ -98,7 +97,7 @@ $$ = a + b\\ $$ -Inductive Step: +**Inductive Step:** Assume proposition is true for all n and show n+1 follows. @@ -118,19 +117,19 @@ $\Box$ **Proof via Strong Induction** -Base Case: n = 0: +**Base Case**: n = 0: $$ fibIterative(0, 0, 0) = 0\\ = fib(0) $$ -Base Case: n = 1: +**Base Case**: n = 1: $$ fibIterative(1, 0, 0) = 1\\ = fib(1) $$ -Inductive Step: +**Inductive Step:** Assume proposition is true for all n and show n+1 follows. @@ -145,9 +144,9 @@ $\Box$ ## Time Complexity -Suppose that we wish to solve for time complexity in terms of the number of additions needed to be -computed. By observing the algorithm for fibHelper we can see that we perform one addition every time -which we have a recursive call. We can now form a recurrence for time complexity and solve for it. +Suppose that we wish to solve for the time complexity in terms of the number of additions needed to be +computed. Based on fibHelper we can see that it performs one addition every recursive call. +We can now form a recurrence for time complexity. $$ T(0) = 0\\ @@ -169,8 +168,8 @@ Fibonacci. # Matrix Solution -We can actually get better than linear time for performance while calculating -the Fibonacci sequence recursively using this fact: +We can actually get better than linear for performance for Fibonacci while still using +recursion. However, to do so we need to know this fact: $$ \begin{bmatrix} @@ -183,10 +182,11 @@ F_n & F{n-1} \end{bmatrix}^n $$ -Without any other tricks, raising a matrix to a power n times would not get +Without any tricks, raising a matrix to a power n times would not get us better than linear performance. However, if we use the [Exponentiation by Squaring](https://en.wikipedia.org/wiki/Exponentiation_by_squaring) method, we can expect to see logarithmic time. Since two spots in the matrix are always equal, -I represented the matrix as an array with only three elements. +I represented the matrix as an array with only three elements to reduce the space and +computations required. ```Python @@ -216,9 +216,9 @@ def fibPower(n): ## Time Complexity -For this algorythem lets solve for the time complexity as the number of additions and multiplications. +For this algorithm, lets solve for the time complexity as the number of additions and multiplications required. -Since we are always multiplying two 2x2 matrices, that is constant time. +Since we are always multiplying two 2x2 matrices, that operation is constant time. $$ T_{multiply} = 9 @@ -246,11 +246,14 @@ $$ T_{fibPower}(n) = T_{power}(n)\\ $$ +Now we can state that $fibPower(n) \in \Theta(log(n))$. ## Inductive Proof for Matrix Method +I would like to now prove that this matrix identity is valid since it is not at first obvious. + **Lemma:** For any n $\epsilon$ N if n $>$ 0 then $$ \begin{bmatrix} @@ -314,20 +317,20 @@ $\Box$ ![FibPower Performance](media/fibonacci/FibPower.png) -As expected by our mathmatical calcuations, the algorthem appears to be running in +As expected by our mathematical calculations, the algorithm appears to be running in logarithmic time. ## Measured Performance With Large Numbers ![FibPower Performance](media/fibonacci/FibPowerBigPicture.png) -When calculating the fibonacci term for extremely large numbers dispite having a polynomial -time complexity, the space required to compute Fibonacci grows exponentially. Since our +When calculating the fibonacci term for extremely large numbers despite having a polynomial +time complexity, the space required to compute each Fibonacci term grows exponentially. Since our performance is only pseudo-polynomial we see a degrade in our performance when calculating large terms of the fibonacci sequence. The one amazing thing to point out here is that despite calculating the 10,000 term of Fibonacci, -this algorithm is nearly 400 times faster than the recursive algorithm when it was calculating +this algorithm is nearly 400 times faster than the recursive algorithm when calculating the 30th term of Fibonacci. @@ -346,10 +349,10 @@ def fibClosedFormula(n): return (p-v)/math.sqrt(5) ``` -## Derivation of Formula +## Derivation of Binet's Formula -Similar to when we were calculating for the time complexity, we want to start by finding the -two roots of the equation. +Similar to when we were calculating the time complexity of the basic recursive definition +, we want to start by finding the two roots of the equation in terms of exponents. $$ a^n = a^{n-1} + a^{n-2}\\ @@ -385,7 +388,6 @@ $$ ## Time Complexity - Since we managed to find the closed form of the fibonacci sequence we can expect to see constant performance. ## Measured Performance