{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Another Phi Identity\n", "\n", "Developed from an email from D. B. Koski.\n", "\n", "David writes, referring to his stumbling across the Fibonaccis left of zero:\n", "\n", "\n", "> Not sure if I ever explained how I found this out on my own. The Fibonnaci before zero. It had to do with UVW tetrahedra.\n", "\n", "> Setting the U at $2\\phi^{0} + 0\\phi^{-3}$, the next step up for the V was $3\\phi^{0} + 1\\phi^{-3}$ and the larger W at $5\\phi^{0} + 1\\phi^{3}$. This made the prior, lessor phi scaled W at $1\\phi^{0} + 1\\phi^{-3}$.\n", "\n", ">This made no sense since the U at $2\\phi^{0} + 0\\phi^{-3}$ had coefficients of 2 and 0; F[3] and F[0].\n", "How could the lessor W have coefficients of F[2] and F[?] unless of course the Fibonnaci series had to be going on, \"left of zero\". The lessor W had coefficients of F[2] and F[-1]\n", "\n", "[ $\\LaTeX$ added]\n", "\n", "Here's one way to express the identity I'm studying:\n", "\n", "$$\n", "2\\left( n-i+1 \\right) = \\\\\n", "\\sum_{i}^{n} \\left( F(i)\\phi^{3-i} + F(i-3)\\phi^{-i} \\right)\n", "$$\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Where ...F(-3) = 2, F(-2) = -1, F(-1) = 1, F(0) = 0, F(1) = 1, F(2) = 1... F(i) i.e. [the Fibonacci numbers](http://oeis.org/A147316) F(i) where i can be a negative integer. \n", "\n", "Index i ranges up to n inclusive, i.e. i and n set lower and upper bounds for consecutive enumeration. The two-term expression after the sigma ($\\sum$) always yields 2. The difference between i and n therefore determines what multiple of 2 we have reached.\n", "\n", "For example, if i = -5, n = -5\n", "\n", "$$F(-5)\\phi^{8} + F(-8)\\phi^{5} == $$\n", "$$5\\phi^{8} + -21\\phi^{5} == 2 $$\n", "\n", "The video, embedded at the end, is incorrect in neglecting to make the 2nd exponent -i instead of i. The video is part 4 of 4. I provide links to the other three as well, which take us step by step through the development of this Notebook, starting with an email from David Koski.\n", "\n", "David works with phi-scaled volumes, meaning edges will stretch or shrink by the golden mean and volumes will change accordingly, as a plus or minus 3rd power of phi.\n", "\n", "What we aim to accomplish, in this exercise, is showing how the above equality might be treated as a claim, the sense of which needs to be established, followed by its truth or untruth. Instead of looking for a formal proof, we go with extended precision verification, which does not constitute a proof so much as the *sense* of what is claimed.\n", "\n", "That sense would come before truth is part of our grammar, in the sameway that what is meaningless cannot be proved or disproved.\n", "\n", "Anyway, our equality is far from meaningless and involves two terms always summing to make two, no matter the value of i. As i travels from its starting value to n, inclusive, it contributes that many 2s, i.e. (n - i + 1) of them. If i runs from 0 to 1, that's 2 + 2 = 4 and so on.\n", "\n", "Winding the Fibonacci Numbers back to start them with 2, -1 reminds us the Fibonacci Numbers [extend in both directions](https://oeis.org/A147316)." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SEQ1: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n", "SEQ2: [2, -1, 1, 0, 1, 1, 2, 3, 5, 8]\n", " 2 == 0 * Ø**( 3) + 2 * Ø**( 0) --> 2.000000000000000000\n", " 2 == 1 * Ø**( 2) + -1 * Ø**( -1) --> 2.000000000000000000\n", " 2 == 1 * Ø**( 1) + 1 * Ø**( -2) --> 2.000000000000000000\n", " 2 == 2 * Ø**( 0) + 0 * Ø**( -3) --> 2.000000000000000000\n", " 2 == 3 * Ø**( -1) + 1 * Ø**( -4) --> 2.000000000000000000\n", " 2 == 5 * Ø**( -2) + 1 * Ø**( -5) --> 2.000000000000000000\n", " 2 == 8 * Ø**( -3) + 2 * Ø**( -6) --> 2.000000000000000000\n", " 2 == 13 * Ø**( -4) + 3 * Ø**( -7) --> 2.000000000000000000\n", " 2 == 21 * Ø**( -5) + 5 * Ø**( -8) --> 2.000000000000000000\n", " 2 == 34 * Ø**( -6) + 8 * Ø**( -9) --> 2.000000000000000000\n" ] } ], "source": [ "import math\n", "import gmpy2\n", "\n", "gmpy2.get_context().precision=200\n", "\n", "def fibo(a=0, b=1):\n", " while True:\n", " yield a\n", " a, b = b, a + b\n", " \n", "fib_gen = fibo()\n", "print(\"SEQ1:\",[next(fib_gen) for _ in range(10)])\n", "\n", "fib_gen = fibo(2, -1)\n", "print(\"SEQ2:\",[next(fib_gen) for _ in range(10)])\n", "\n", "coeff0 = fibo()\n", "coeff1 = fibo(2, -1)\n", "Ø = (gmpy2.sqrt(5) + 1)/2\n", "\n", "template = \" 2 == {coeff0:>4} * Ø**({a:>3}) + {coeff1:>4} * Ø**({b:>3}) \"\n", "expr = \"{coeff0:>3} * Ø**({a:>3}) + {coeff1:>3} * Ø**({b:>3})\"\n", "args = {}\n", "\n", "for i in range(10):\n", " args[\"a\"] = 3 - i\n", " args[\"b\"] = -i\n", " args[\"coeff0\"] = next(coeff0)\n", " args[\"coeff1\"] = next(coeff1)\n", " identity = template.format(**args)\n", " print(identity, end=\" --> \")\n", " print(\"{:>20.18f}\".format(eval(expr.format(**args))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets evaluate the individual terms on either side of the + symbol. They're not both equal to 1 are they? That would mean we're just writing 1 + 1 == 2 every time. But we already know either term may be 0, so clearly we can't expect the same terms in each row." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 0.000000000 + 2.000000000 --> 2.000000000\n", " 2.618033989 + -0.618033989 --> 2.000000000\n", " 1.618033989 + 0.381966011 --> 2.000000000\n", " 2.000000000 + 0.000000000 --> 2.000000000\n", " 1.854101966 + 0.145898034 --> 2.000000000\n", " 1.909830056 + 0.090169944 --> 2.000000000\n", " 1.888543820 + 0.111456180 --> 2.000000000\n", " 1.896674439 + 0.103325561 --> 2.000000000\n", " 1.893568819 + 0.106431181 --> 2.000000000\n", " 1.894755060 + 0.105244940 --> 2.000000000\n" ] } ], "source": [ "term1 = \"{coeff0:>3} * Ø**({a:>3})\"\n", "term2 = \"{coeff1:>3} * Ø**({b:>3})\"\n", "terms = \"{t1:>12.9f} + {t2:>12.9f}\"\n", "args = {}\n", "coeff0 = fibo()\n", "coeff1 = fibo(2, -1)\n", "\n", "for i in range(10):\n", " args[\"a\"] = 3 - i\n", " args[\"b\"] = -i\n", " args[\"coeff0\"] = next(coeff0)\n", " args[\"coeff1\"] = next(coeff1)\n", " t1 = eval(term1.format(**args))\n", " t2 = eval(term2.format(**args))\n", " print(terms.format(t1=t1, t2=t2), end=\" --> \")\n", " print(\"{:>12.9f}\".format(eval(expr.format(**args))))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def sequence(n):\n", " coeff0 = fibo()\n", " coeff1 = fibo(2, -1)\n", " total = 0\n", " for i in range(n+1):\n", " args[\"a\"] = 3 - i\n", " args[\"b\"] = -i\n", " args[\"coeff0\"] = next(coeff0)\n", " args[\"coeff1\"] = next(coeff1)\n", " total += eval(expr.format(**args))\n", " return total" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "mpfr('2.0',200)" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sequence(0)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[mpfr('2.0',200),\n", " mpfr('4.0',200),\n", " mpfr('6.0',200),\n", " mpfr('8.0',200),\n", " mpfr('10.0',200),\n", " mpfr('12.0',200),\n", " mpfr('14.0',200),\n", " mpfr('16.0',200),\n", " mpfr('18.0',200),\n", " mpfr('20.0',200)]" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[sequence(n) for n in range(10)]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Lets generalize by rewinding further back in the Fibonacci Numbers, starting with coefficients 610 and -144 respectively, and going forward from there. The printout below overlaps the one above, while showing that, indeed, we're free to press this identity in both directions. \n", "\n", "Two terms with Fibonacci coefficients, three apart (the first ahead), and exponents of phi three apart (the first three higher), always add to give the number 2, starting with anchoring relationships such as:\n", "\n", "$$\n", "2 = fibo(i)\\phi^{3-i} + fibo(i-3)\\phi^{-i}\n", "$$\n", "\n", "We could rewrite the Sigma expression accordingly." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SEQ1: [-144, 89, -55, 34, -21, 13, -8, 5, -3, 2]\n", "SEQ2: [610, -377, 233, -144, 89, -55, 34, -21, 13, -8]\n", " 2 == -144 * Ø**( 15) + 610 * Ø**( 12) --> 2.000000000000000000\n", " 2 == 89 * Ø**( 14) + -377 * Ø**( 11) --> 2.000000000000000000\n", " 2 == -55 * Ø**( 13) + 233 * Ø**( 10) --> 2.000000000000000000\n", " 2 == 34 * Ø**( 12) + -144 * Ø**( 9) --> 2.000000000000000000\n", " 2 == -21 * Ø**( 11) + 89 * Ø**( 8) --> 2.000000000000000000\n", " 2 == 13 * Ø**( 10) + -55 * Ø**( 7) --> 2.000000000000000000\n", " 2 == -8 * Ø**( 9) + 34 * Ø**( 6) --> 2.000000000000000000\n", " 2 == 5 * Ø**( 8) + -21 * Ø**( 5) --> 2.000000000000000000\n", " 2 == -3 * Ø**( 7) + 13 * Ø**( 4) --> 2.000000000000000000\n", " 2 == 2 * Ø**( 6) + -8 * Ø**( 3) --> 2.000000000000000000\n", " 2 == -1 * Ø**( 5) + 5 * Ø**( 2) --> 2.000000000000000000\n", " 2 == 1 * Ø**( 4) + -3 * Ø**( 1) --> 2.000000000000000000\n", " 2 == 0 * Ø**( 3) + 2 * Ø**( 0) --> 2.000000000000000000\n", " 2 == 1 * Ø**( 2) + -1 * Ø**( -1) --> 2.000000000000000000\n", " 2 == 1 * Ø**( 1) + 1 * Ø**( -2) --> 2.000000000000000000\n", " 2 == 2 * Ø**( 0) + 0 * Ø**( -3) --> 2.000000000000000000\n", " 2 == 3 * Ø**( -1) + 1 * Ø**( -4) --> 2.000000000000000000\n", " 2 == 5 * Ø**( -2) + 1 * Ø**( -5) --> 2.000000000000000000\n", " 2 == 8 * Ø**( -3) + 2 * Ø**( -6) --> 2.000000000000000000\n", " 2 == 13 * Ø**( -4) + 3 * Ø**( -7) --> 2.000000000000000000\n" ] } ], "source": [ "fib_gen = fibo(-144, 89)\n", "print(\"SEQ1:\",[next(fib_gen) for _ in range(10)])\n", "\n", "fib_gen = fibo(610, -377)\n", "print(\"SEQ2:\",[next(fib_gen) for _ in range(10)])\n", "\n", "coeff0 = fibo(-144, 89)\n", "coeff1 = fibo(610, -377)\n", "for i in range(-12,8):\n", " args[\"a\"] = 3 - i\n", " args[\"b\"] = -i\n", " args[\"coeff0\"] = next(coeff0)\n", " args[\"coeff1\"] = next(coeff1)\n", " identity = template.format(**args)\n", " print(identity, end=\" --> \")\n", " print(\"{:>20.18f}\".format(eval(expr.format(**args))))" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " -196416.105571791 + 196418.105571791 --> 2.000000000\n", " 75026.894424525 + -75024.894424525 --> 2.000000000\n", " -28655.105565830 + 28657.105565830 --> 2.000000000\n", " 10947.894408919 + -10945.894408919 --> 2.000000000\n", " -4179.105524974 + 4181.105524974 --> 2.000000000\n", " 1598.894301956 + -1596.894301956 --> 2.000000000\n", " -608.105244940 + 610.105244940 --> 2.000000000\n", " 234.893568819 + -232.893568819 --> 2.000000000\n", " -87.103325561 + 89.103325561 --> 2.000000000\n", " 35.888543820 + -33.888543820 --> 2.000000000\n", " -11.090169944 + 13.090169944 --> 2.000000000\n", " 6.854101966 + -4.854101966 --> 2.000000000\n", " 0.000000000 + 2.000000000 --> 2.000000000\n", " 2.618033989 + -0.618033989 --> 2.000000000\n", " 1.618033989 + 0.381966011 --> 2.000000000\n", " 2.000000000 + 0.000000000 --> 2.000000000\n", " 1.854101966 + 0.145898034 --> 2.000000000\n", " 1.909830056 + 0.090169944 --> 2.000000000\n", " 1.888543820 + 0.111456180 --> 2.000000000\n", " 1.896674439 + 0.103325561 --> 2.000000000\n" ] } ], "source": [ "terms = \"{t1:>18.9f} + {t2:>18.9f}\"\n", "coeff0 = fibo(-144, 89)\n", "coeff1 = fibo(610, -377)\n", "for i in range(-12,8):\n", " args[\"a\"] = 3 - i\n", " args[\"b\"] = -i\n", " args[\"coeff0\"] = next(coeff0)\n", " args[\"coeff1\"] = next(coeff1)\n", " t1 = eval(term1.format(**args))\n", " t2 = eval(term2.format(**args))\n", " print(terms.format(t1=t1, t2=t2), end=\" --> \")\n", " print(\"{:>12.9f}\".format(eval(expr.format(**args))))" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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\n", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "YouTubeVideo(\"kXn-cvynsoE\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The [nbviewer view](https://nbviewer.jupyter.org/github/4dsolutions/Python5/blob/master/Phi_identity.ipynb) of this Notebook will show the embedded Youtube. The above is Part 4 of 4. Here are links to the previous three in first to last order:\n", "\n", "* [Part 1: Python Syntax](https://youtu.be/lkGsi9uwMlo)\n", "* [Part 2: Fun with Phi and Fibonaccis](https://youtu.be/3pJ-WhvmRFI)\n", "* [Part 3: More Fun with Phi](https://youtu.be/xlyKfG_5s4E)\n", "* [Part 4: Phi Identity](https://youtu.be/kXn-cvynsoE)" ] } ], "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.6.8" } }, "nbformat": 4, "nbformat_minor": 2 }