{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "nt.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "dspYWbEbQAEL",
        "5iUUcT2hRbNN",
        "-dshYwum6Q21",
        "Yo2j-DMS9jh4",
        "0pBRJOOn76qn",
        "QfwvxpW3NUsL",
        "_9PZzyhQ78Xl",
        "EOyoyYmvEiLS",
        "uxoTEmI8zrT6"
      ],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNGRgEq6wtxW3xp0Unh+PYF",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hhboorstein/number-theory/blob/main/nt.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Prime Projects"
      ],
      "metadata": {
        "id": "PJBA7KIoQAbv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Prime Number List\n",
        "\n",
        "Calculates primes up to a user-defined bound. Checks each positive integer for prime divisibility, and appends the candidate if prime."
      ],
      "metadata": {
        "id": "dspYWbEbQAEL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def prime_list(bound):\n",
        "  '''Make a list of prime numbers\n",
        "  up to bound. Requires numpy package.'''\n",
        "  primes=[]\n",
        "  for i in range(2,bound+1):\n",
        "    proceed=True\n",
        "    for p in primes:\n",
        "      if np.sqrt(i)<p:\n",
        "        break\n",
        "      if i%p==0:\n",
        "        proceed=False\n",
        "        break\n",
        "      else:\n",
        "        continue\n",
        "    if proceed==True:\n",
        "      primes.append(i)\n",
        "  return primes"
      ],
      "metadata": {
        "id": "5ENX4y-8QiLs"
      },
      "execution_count": 84,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(prime_list(1000))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8mrziNkNQpjT",
        "outputId": "2939642e-7716-4644-dd83-de7651a08439"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Sieve of Eratosthenes\n",
        "\n",
        "Another technique for calculating prime numbers up to a user-specified bound. The difference here is that all multiples of primes are sieved out at once, and what's left must be prime."
      ],
      "metadata": {
        "id": "5iUUcT2hRbNN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def sieve(bound):\n",
        "  '''Sieves out primes\n",
        "  up to bound.'''\n",
        "  bound +=1\n",
        "  primes=range(2,bound) #this will only contain primes at the end\n",
        "  for i in range(2,bound):\n",
        "    if i**2>bound: #more optimized halting condition\n",
        "      break\n",
        "    if i in primes:\n",
        "      mult_i=[i*j for j in range(i,(bound//i)+1)] #list of prime mults\n",
        "      primes=[n for n in primes if n not in mult_i] #sieve out mult_i\n",
        "  return primes"
      ],
      "metadata": {
        "id": "q8qjPekSQupX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(sieve(100))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "09SK6zgqTBhf",
        "outputId": "f48b4e55-1f18-45fd-a027-052ffb6f2bec"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(sieve(100)==prime_list(100))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qTmts_yKTDUy",
        "outputId": "360bc62d-c4e0-42a1-f59c-b6e78b8d29f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#which is faster?\n",
        "import time\n",
        "\n",
        "a=10000\n",
        "\n",
        "t0=time.time()\n",
        "prime_list(a)\n",
        "t1=time.time()\n",
        "print('prime_list takes',t1-t0,'seconds')\n",
        "\n",
        "t2=time.time()\n",
        "sieve(a)\n",
        "t3=time.time()\n",
        "print('sieve takes', t3-t2,'seconds')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LGuchCPkTKVT",
        "outputId": "0e5c3f79-fb1d-481e-9b64-97af59fea443"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "prime_list takes 0.089752197265625 seconds\n",
            "sieve takes 1.0314862728118896 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "It looks like the prime_list function is faster than the sieve approach. For primes up to 100,000, prime_list took one second and I interrupted sieve after a minute. Huge difference. There are surely ways to further optimize both."
      ],
      "metadata": {
        "id": "AwfWIYZlURxi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Twin Primes\n",
        "\n",
        "Using the prime_list function, the following counts the number of twin prime pairs up to a bound and records the pairs as tuples. (Requires declaration of prime_list.)"
      ],
      "metadata": {
        "id": "-dshYwum6Q21"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"We will be finding the number of twin primes, \\n i.e., primes that differ by 2, \\n up to a given bound.\")\n",
        "b=int(input(\"Input bound: \"))\n",
        "primes=prime_list(b)\n",
        "twins=[]\n",
        "count=0\n",
        "for i in range(len(primes)-1):\n",
        "  if primes[i]+2==primes[i+1]:\n",
        "    count+=1\n",
        "    twins.append((primes[i],primes[i+1]))\n",
        "print(\"There are\", count, \"pairs of twin primes up to\", b)\n",
        "print(\"The twin primes less than\", b, \"are:\")\n",
        "print(twins)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9RVQOZhMTneF",
        "outputId": "359733f4-30a9-44b7-a83c-0f8350086707"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "We will be finding the number of twin primes, \n",
            " i.e., primes that differ by 2, \n",
            " up to a given bound.\n",
            "Input bound: 100\n",
            "There are 8 pairs of twin primes up to 100\n",
            "The twin primes less than 100 are:\n",
            "[(3, 5), (5, 7), (11, 13), (17, 19), (29, 31), (41, 43), (59, 61), (71, 73)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Primality Tests\n",
        "\n",
        "Primality tests are probabilistic tests based in number theory. Such tests determine whether a given positive integer is *likely* to be prime. More precisely, an integer that passes a probable primality test has a property shared by all primes but not most composites. These tests are not guarantees, but the increased sophistication in modern techniques provides high probability of accuracy.\n",
        "\n",
        "Included is also a deterministic test (labelled as such)."
      ],
      "metadata": {
        "id": "IQ0_iJfB72gh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Fermat\n",
        "\n",
        "This test is based on Fermat's Little Theorem. While the test is old, the theorem is still the backbone of many modern tests."
      ],
      "metadata": {
        "id": "Yo2j-DMS9jh4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def fermat(n):\n",
        "  '''Tests a positive integer\n",
        "  n>3 for probable primality.'''\n",
        "  if n <= 3 or n%2==0:\n",
        "    raise Exception('test only valid for odd n>3')\n",
        "  a=0\n",
        "  while not gcd(a,n)==1: #finds random a coprime to n\n",
        "    a=np.random.randint(1,n)\n",
        "  test=pow(a,n-1,n)\n",
        "  if test==1:\n",
        "    print('{} is a probable prime with witness {}.'.format(n,a))\n",
        "  else:\n",
        "    print('{} is composite.'.format(n))"
      ],
      "metadata": {
        "id": "NSfGWUCB99ah"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fermat(29)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q-Es8hqm_-yl",
        "outputId": "e4edf571-112a-4c36-f6f6-152109e4e71c"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "29 is a probable prime with witness 9.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is possible that a number could pass for a given witness, so it is recommended to repeat the test several times with different witnesses. What's worse, there exists infinitely many Carmichael numbers, composite numbers that pass the Fermat primality test for all witnesses. Again, this test is not a guarantee."
      ],
      "metadata": {
        "id": "YGXVlMQf_-BW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 1105 is a Carmichael number\n",
        "fermat(1105)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ydEBbw8EWhLT",
        "outputId": "c3cf72ea-1233-4af7-d5e1-44115e247500"
      },
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1105 is a probable prime with witness 271.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Selfridge Heuristic\n",
        "\n",
        "John Selfridge suggested the following: For an odd integer $p$ such that $p\\equiv\\pm2\\text{ mod }5$, then $p$ is prime if $2^{p-1}\\equiv 1\\text{ mod }p$ and $f_{p+1}\\equiv 0\\text{ mod } p$, where $f_n$ is the $n^{th}$ Fibonacci number. The first condition comes from the Fermat test (see above). This result is entirely conjectural, but there has yet to be a counterexaple. See [here](https://en.wikipedia.org/wiki/Primality_test#Heuristic_tests) and [here](https://en.wikipedia.org/wiki/John_Selfridge#Selfridge's_conjecture_about_primality_testing) for more."
      ],
      "metadata": {
        "id": "ICURShCBnJn_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from numpy import gcd\n",
        "\n",
        "def selfridge(n):\n",
        "  '''Selfridge primality heuristic.'''\n",
        "  if n < 3 or n%2==0:\n",
        "    raise Exception('test only valid for odd n>1')\n",
        "  if not (n%5==2 or n%5==3):\n",
        "    raise Exception('not cong 2,3 mod 5')\n",
        "  if not pow(2,n-1,n)==1:\n",
        "    return False\n",
        "  if fd_fib(n+1)%n==0: \n",
        "    print(\"It's possible...\")\n",
        "    return True\n",
        "  else:\n",
        "    return False"
      ],
      "metadata": {
        "id": "HCyScQDenIgx"
      },
      "execution_count": 124,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "selfridge(37)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "22eMoUMCs-3g",
        "outputId": "decd0ac1-c983-4ded-f980-082bb8da9ebc"
      },
      "execution_count": 122,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It's possible...\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 122
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "selfridge(1567)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CWuny_QftUbe",
        "outputId": "e75a920f-c741-486a-fad9-0becd9be26c2"
      },
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "It's possible...\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Miller-Rabin\n",
        "\n",
        "[See here for more.](https://en.wikipedia.org/wiki/Miller%E2%80%93Rabin_primality_test)"
      ],
      "metadata": {
        "id": "0pBRJOOn76qn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def mr_test(n):\n",
        "  '''Miller-Rabin test for\n",
        "  probable primality.'''\n",
        "  if n<=2 or n%2==0:\n",
        "    raise Exception('test only valid for odd n>2')\n",
        "  # write n=(2**s)*d+1\n",
        "  b=n-1; s=0\n",
        "  while b%2==0:\n",
        "    b=b//2\n",
        "    s+=1\n",
        "  d=b\n",
        "  a=np.random.randint(1,n)\n",
        "  test=pow(a,d,n)\n",
        "  if test==1 or test==(n-1):\n",
        "    print('{} is a probable prime with witness {}.'.format(n,a))\n",
        "    return\n",
        "  for r in range(1,s): # r=0 case above\n",
        "    if pow(a,(2**r)*d,n)==(n-1):\n",
        "      print('{} is a probable prime with witness {}.'.format(n,a))\n",
        "      return\n",
        "  print('{} is composite.'.format(n))"
      ],
      "metadata": {
        "id": "bsJsooVX8AwV"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Note, these test still do fail. 323=17*19, but it passes the test occasionally; see below. "
      ],
      "metadata": {
        "id": "u-AErrbnLLCl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "i=0\n",
        "while i<10:\n",
        "  mr_test(323)\n",
        "  i+=1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kglnv816EkyR",
        "outputId": "6af2f176-6e83-45c2-a53f-fcf1d8afd4c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "323 is composite.\n",
            "323 is a probable prime with witness 1.\n",
            "323 is composite.\n",
            "323 is composite.\n",
            "323 is composite.\n",
            "323 is composite.\n",
            "323 is composite.\n",
            "323 is composite.\n",
            "323 is composite.\n",
            "323 is composite.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This is why it is important to run a test several times with different bases. With the Miller-Rabin test, a composite number cannot produce a false positive to all bases simultaneously (unlike Carmichael numbers with the Fermat test), but testing all bases would be computationally taxing. There are several snazzy improvements to cut down on computation time and make the test deterministic."
      ],
      "metadata": {
        "id": "pVvl8coTMMtr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Deterministic Miller-Rabin\n",
        "\n",
        "A speed enhancement in this test relies on the truth of (part of) the Generalized Riemann Hypothesis."
      ],
      "metadata": {
        "id": "QfwvxpW3NUsL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def det_mr_test(n):\n",
        "  '''Deterministic Miller-Rabin\n",
        "  primality test.'''\n",
        "  if n<=2 or n%2==0:\n",
        "    raise Exception('test only valid for odd n>2')\n",
        "  b=n-1; s=0\n",
        "  while b%2==0:\n",
        "    b=b//2\n",
        "    s+=1\n",
        "  d=b\n",
        "  for a in range(2,min(n-2,int(2*(np.log(n)**2)))+1):\n",
        "    x=pow(a,d,n)\n",
        "    if x==1 or x==(n-1):\n",
        "      continue\n",
        "    flag=False\n",
        "    for r in range(1,s):\n",
        "      if pow(a,(2**r)*d,n)==(n-1):\n",
        "        flag=True\n",
        "        break\n",
        "    if flag==False:\n",
        "      print('{} is composite.'.format(n))\n",
        "      return\n",
        "  print('{} is prime.'.format(n))\n",
        "      \n"
      ],
      "metadata": {
        "id": "aLr1DxOtNUNU"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "det_mr_test(3517)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fq7XkD-9HTIQ",
        "outputId": "1168666c-73c3-44e0-a726-2260da64973a"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3517 is prime.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 1105 is a Carmichael number\n",
        "det_mr_test(1105)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oKSajb4VPr5V",
        "outputId": "0df6a055-10f6-4f1e-9b9a-ae91ac9568f3"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1105 is composite.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Collatz\n",
        "\n",
        "The Collatz conjecture is an open problem in number theory that is simple to state. For a positive integer $n$, we consider the following function: $f(n)=n/2$ if $n$ is even, otherwise $f(n)=3n+1$.\n",
        "\n",
        "It seems that after sufficiently many steps, any positive integer will reach $1$. It is unknown whether this is indeed true for all positive integers. While [experimental evidence](https://en.wikipedia.org/wiki/Collatz_conjecture#Experimental_evidence) shows that all *reasonable* numbers do reach $1$, a max_step halting condition is included for completeness and the practicalities of limited computing resources."
      ],
      "metadata": {
        "id": "_9PZzyhQ78Xl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def collatz(n,max_step):\n",
        "  '''\n",
        "  Runs the Collatz function\n",
        "  on n; returns number of steps to 1.\n",
        "  Will time out after max_step.\n",
        "  '''\n",
        "  #Hardcode n=0 case so it doesn't\n",
        "  #have to loop max_step times to get step=0\n",
        "  if n==0:\n",
        "    return 0\n",
        "  #general logic\n",
        "  step=0\n",
        "  while n!=1:\n",
        "    #timeout condition\n",
        "    if step>max_step:\n",
        "      return 0\n",
        "    #collatz function\n",
        "    if n%2==0:\n",
        "      n=n//2\n",
        "    else:\n",
        "      n=3*n+1\n",
        "    step+=1\n",
        "  return step"
      ],
      "metadata": {
        "id": "ApK27mbX7-KA"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "print(\"This will graph the number of steps it takes \\n for integers to complete the Collatz procedure.\")\n",
        "bound=int(input(\"Calculate for integers up to: \"))\n",
        "u=int(input(\"Upper bound of computation for each integer: \"))\n",
        "\n",
        "#Create step list\n",
        "step_list=[collatz(n,u) for n in range(bound+1)]\n",
        "\n",
        "#generate dataframe\n",
        "#two columns: integers, steps\n",
        "df=pd.DataFrame([[i,step_list[i]] for i in range(bound+1)],columns=['Int','Steps'])\n",
        "\n",
        "#dotsize helps with graph readability\n",
        "dotsize=1000/bound\n",
        "\n",
        "#plot data\n",
        "col=df.plot.scatter('Int','Steps',s=dotsize,c='DarkBlue',title='Number of Collatz steps')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 366
        },
        "id": "GER2BDsw-PXT",
        "outputId": "2327bb74-bcb6-421d-84c8-3309ab894447"
      },
      "execution_count": 2,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "This will graph the number of steps it takes \n",
            " for integers to complete the Collatz procedure.\n",
            "Calculate for integers up to: 100000\n",
            "Upper bound of computation for each integer: 400\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "sns.set_theme()\n",
        "\n",
        "sns.histplot(data=df['Steps'])\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "np5K0933qHqB",
        "outputId": "c1086fed-c628-4d88-a6aa-c02fcc3d577d"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "Jz8CP2OKranw",
        "outputId": "d9ef5f67-9d8b-4683-822f-790b038518c7"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "                 Int          Steps\n",
              "count  100001.000000  100001.000000\n",
              "mean    50000.000000     107.537325\n",
              "std     28867.946472      51.366787\n",
              "min         0.000000       0.000000\n",
              "25%     25000.000000      65.000000\n",
              "50%     50000.000000      99.000000\n",
              "75%     75000.000000     146.000000\n",
              "max    100000.000000     350.000000"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-28fa9f02-fc1c-474c-8693-524da4f25ef6\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Int</th>\n",
              "      <th>Steps</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>100001.000000</td>\n",
              "      <td>100001.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>50000.000000</td>\n",
              "      <td>107.537325</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>28867.946472</td>\n",
              "      <td>51.366787</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>25000.000000</td>\n",
              "      <td>65.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>50000.000000</td>\n",
              "      <td>99.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>75000.000000</td>\n",
              "      <td>146.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>100000.000000</td>\n",
              "      <td>350.000000</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-28fa9f02-fc1c-474c-8693-524da4f25ef6')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-28fa9f02-fc1c-474c-8693-524da4f25ef6 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-28fa9f02-fc1c-474c-8693-524da4f25ef6');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df.mode()['Steps'][0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUAR5wcornfN",
        "outputId": "95c85fdc-3a9a-4b08-8566-eec6df6f35b6"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "71.0"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "df['Parity']=['even' if i%2==0 else 'odd' for i in range(bound+1)]\n",
        "df.head()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 206
        },
        "id": "sCeosYpqsrzW",
        "outputId": "11522535-de6e-4aa1-84b9-0902751716cc"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "   Int  Steps Parity\n",
              "0    0      0   even\n",
              "1    1      0    odd\n",
              "2    2      1   even\n",
              "3    3      7    odd\n",
              "4    4      2   even"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-fb57e990-904f-4af6-aa1f-6ca0d127a17f\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Int</th>\n",
              "      <th>Steps</th>\n",
              "      <th>Parity</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>even</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>odd</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>2</td>\n",
              "      <td>1</td>\n",
              "      <td>even</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>3</td>\n",
              "      <td>7</td>\n",
              "      <td>odd</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>4</td>\n",
              "      <td>2</td>\n",
              "      <td>even</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-fb57e990-904f-4af6-aa1f-6ca0d127a17f')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-fb57e990-904f-4af6-aa1f-6ca0d127a17f button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-fb57e990-904f-4af6-aa1f-6ca0d127a17f');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sns.set_style(\"whitegrid\")\n",
        "sns.relplot(data=df,x='Int',y='Steps',col='Parity',s=5, kind='scatter')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 344
        },
        "id": "wr-RMt6WuGG9",
        "outputId": "324bfc4b-3bae-4ff5-c99f-d117bc9b0cdf"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<seaborn.axisgrid.FacetGrid at 0x7f4784a1a090>"
            ]
          },
          "metadata": {},
          "execution_count": 29
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x360 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Modular Mathematics"
      ],
      "metadata": {
        "id": "b6YmIQbnW-rp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "First, a function that uses the Euclidean algorithm to calculate GCD. This function prints each division step too."
      ],
      "metadata": {
        "id": "dpwqFkqfeT5Y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def egcd_w_print(a,b):\n",
        "  '''Computes GCD(a,b) using the Euclidean algorithm.\n",
        "  Prints formatted division steps.'''\n",
        "  r=max(a,b)%min(a,b)\n",
        "  c=min(a,b)\n",
        "  if r==0:\n",
        "    print('GCD({},{})={}'.format(a,b,c))\n",
        "    return\n",
        "  print('{}={}({})+{}'.format(max(a,b),max(a,b)//c,c,r))\n",
        "  while c%r != 0:\n",
        "    d=c\n",
        "    s=r\n",
        "    r=c%r\n",
        "    c=s\n",
        "    print('{}={}({})+{}'.format(d,d//s,s,r))\n",
        "  print('GCD({},{})={}'.format(a,b,r))\n"
      ],
      "metadata": {
        "id": "DxgEBZabXEdg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "egcd_w_print(133,85)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4jbJxaT-Z39z",
        "outputId": "db4cd424-4d2b-4de2-bdf2-724a3403fc8d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "133=1(85)+48\n",
            "85=1(48)+37\n",
            "48=1(37)+11\n",
            "37=3(11)+4\n",
            "11=2(4)+3\n",
            "4=1(3)+1\n",
            "GCD(133,85)=1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "egcd_w_print(91,49)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gPKvWlp0eMXB",
        "outputId": "57f634fb-44f6-4abb-be94-c1941e79bdea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "91=1(49)+42\n",
            "49=1(42)+7\n",
            "GCD(91,49)=7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "egcd_w_print(121,11)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YA-cq09Ug29w",
        "outputId": "aec3710e-fe8c-4312-ba3d-734eb87397ff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GCD(121,11)=11\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next, the same function without all the extra printing."
      ],
      "metadata": {
        "id": "EsJKBVZEeieg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def gcd(a,b):\n",
        "  '''Computes GCD(a,b) using the Euclidean algorithm.'''\n",
        "  if a==0:\n",
        "    return b\n",
        "  if b==0:\n",
        "    return a\n",
        "  c=min(a,b)\n",
        "  r=max(a,b)%c\n",
        "  if r==0:\n",
        "    return c\n",
        "  while c%r != 0: #while remainder is nonzero\n",
        "    s=r\n",
        "    r=c%r\n",
        "    c=s\n",
        "  return r"
      ],
      "metadata": {
        "id": "UxZC5yCDenO4"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(gcd(171,57),gcd(2,2),gcd(11,121),gcd(91,49))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1JNpjK-DfqxI",
        "outputId": "8d3ab047-c658-4827-89b8-ebeb32d6a0d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "57 2 11 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# RSA Encryption\n",
        "\n",
        "Named for the first researchers to publish the method (Rivest, Shamir, Adleman), RSA is an asymmetric encryption method based on a simple number theoretic result: for $p,q$ large primes, it is computationally difficult to factor $N:=pq$ without knowledge of the factors."
      ],
      "metadata": {
        "id": "EOyoyYmvEiLS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Below code to make RSA work until I write my own mod inverse. (The function pow(a,-1,N) gives the inverse of a mod N, but this requries Python v3.8+)."
      ],
      "metadata": {
        "id": "DxOVtyWsGFDf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# adapted from https://stackoverflow.com/a/9758173\n",
        "\n",
        "def modinv(a, m):\n",
        "  def egcd(a, b):\n",
        "    if a == 0:\n",
        "        return (b, 0, 1)\n",
        "    else:\n",
        "        g, y, x = egcd(b % a, a)\n",
        "        return (g, x - (b // a) * y, y)\n",
        "  ###\n",
        "  g, x, y = egcd(a, m)\n",
        "  if g != 1:\n",
        "      raise Exception('modular inverse does not exist')\n",
        "  else:\n",
        "      return x % m"
      ],
      "metadata": {
        "id": "phWF9dTXf9Tq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Message Encryption"
      ],
      "metadata": {
        "id": "L4VZwN-zJ_67"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# encoding dictionary\n",
        "rsa_alphabet={' ':'00','a':'01','b':'02','c':'03','d':'04','e':'05',\n",
        "              'f':'06','g':'07','h':'08','i':'09','j':'10','k':'11',\n",
        "              'l':'12','m':'13','n':'14','o':'15','p':'16','q':'17',\n",
        "              'r':'18','s':'19','t':'20','u':'21','v':'22','w':'23',\n",
        "              'x':'24','y':'25','z':'26'}\n",
        "# decoding dictionary\n",
        "inv_dict={num:let for let,num in rsa_alphabet.items()}"
      ],
      "metadata": {
        "id": "6N8cq8cfKRaj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# message to digits\n",
        "mess=str(input(\"message:\"))\n",
        "m=''\n",
        "for let in mess:\n",
        "  m+=rsa_alphabet[let]\n",
        "print(m)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f-4tlJOPKo2f",
        "outputId": "a5bcc219-4a58-4f3a-9ecd-04e214e02171"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "message:hello\n",
            "0805121215\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "RSA encryption functions."
      ],
      "metadata": {
        "id": "cXlj6EkgjmWL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def mess_to_int(mess):\n",
        "  '''Translates string to int via RSA dictionary.\n",
        "  Must declare rsa_alphabet first.'''\n",
        "  m=''\n",
        "  for let in mess:\n",
        "    if let not in rsa_alphabet:\n",
        "      raise Exception('invalid character; lower case english and space allowed')\n",
        "    m+=rsa_alphabet[let]\n",
        "  return int(m)\n",
        "  \n",
        "def rsa_encrypt(message,modulus,exponent):\n",
        "  '''Encrypts a string with RSA encryption.\n",
        "  Only lower case characters and spaces allowed.\n",
        "  Limited by size of modulus. \n",
        "  Note: public key=(modulus,exponent).'''\n",
        "  c=pow(mess_to_int(message),exponent,modulus)\n",
        "  return c\n"
      ],
      "metadata": {
        "id": "CyanJhx6Pn7R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# test\n",
        "rsa_encrypt('hi',9167,13)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "id": "4wL80XFBOQQO",
        "outputId": "ad5c728b-75cf-4a34-e505-f8934e2008a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6294"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAADQAAAASCAYAAAAUjf3AAAAABHNCSVQICAgIfAhkiAAAAt5JREFUSInt1l+IV1UQB/CP1WpEVJSGREL6lFGggUpQPSj5UAT9ewiKglpBULIeRBGCHz30x0IUidD+EIb0ElREVPQHsSAKy0jNBLM0WCwXNTLcLXN7mLns7XTv7t2gp/zC5dw73zlzzpw7Z2b4n2ARXsdhDGMA7+Hmms4l6E+9/TiJX/AJHsRZLbYnYQk+wwn8hh1YOsacOu7FSD79XZxZm8o/YjMex/P4MrkKS1NvAFvxBF7C8ZS/lpsvsTX5n9LuBnyTsi3j7G1G2v+1q0NLUvFlTG7g+2rvC3Grf57qdBxKO3cW3O0pP4CpNflkvJXcHS17m4QP8B2e1sGhKfgZB1ucmQjW5IIbC/mWlC9rmDMnuY9abK7AadyInhaHzqm934RpWJ8Tb8HVGMLn+LSLJ4k/cjxVyKfneKBhTiW7QRzo7zVuNp4U4bldREcj6g7Ny3EIO4UzdWzHXTjSZqxm8758f7fgBnOc2TBvVm3+LHxb+35FhPGacdb+G54Tv/EUvsb1OB/XiAw3gm0d7DyTum83cPcktx8X1+R9eNNo9rquxj2GPwtZT4c7tCmVhnBFwZ0nsl65WImHUmdvseEKZ4u/NiJKwiYRRntwVNzfESxI/QXigNcWdjo59FQqtd2VF5Jf0cIvT36P0bvShD6swi5xeMfxBq7E7rQxU4TaPpHSpxQ2ejo49EAqvdPCV6lydQP3cHK7cOlYi4yBc0URr+7oRUZDcLxnfWWknhQ+TPIqUVtOFwtWSeL7Qr5KZKCvRKYc9O9wt8hur+b3MF5s0b0Wc0VXss8YGbi6mI8U8sXCwWO4sCZ/NPV3aL4zTbigQTZH/JmjuKyDjZ4OdYgoeHOxTtShnSKebxOZpl/0a3C/0Qz0sUgIJX4QXUcd74u+b7doYWbnWidF5zHQwaEJYZqo8AdFcRsUDej8Qq9n/Nje1mB/Jb4QyWBYFNRncfkE9lit3ak5PYMz+A/xF2+e1pZeZusNAAAAAElFTkSuQmCC\n",
            "text/latex": "$\\displaystyle 6294$"
          },
          "metadata": {},
          "execution_count": 183
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Message Decryption"
      ],
      "metadata": {
        "id": "zJOqMhSmKG3-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Brief test first. With $N=9167,p=89,q=103,e=13$, encrypting 'hi' yields $c=6294$. (Note 'hi'=0809.)\n",
        "\n",
        "This example comes from: Weissman, Martin H.. An Illustrated Theory of Numbers. United States: American Mathematical Society, 2017. (page 186)"
      ],
      "metadata": {
        "id": "rC7jlChoIF9f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def rsa_test(p,q,e):\n",
        "  '''This is just to test'''\n",
        "  N=p*q\n",
        "  phi_N=(p-1)*(q-1)\n",
        "  d=modinv(e,phi_N)\n",
        "  m=int(input(\"Message:\"))\n",
        "  print(pow(m,d,N))"
      ],
      "metadata": {
        "id": "EFO-W_WmCY2r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rsa_test(89,103,13)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kMzaEfzjWnTH",
        "outputId": "51fbd5f4-9dd5-438e-c913-4375ce2bd3ac"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Message:6294\n",
            "809\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Define functions for initializing RSA keys and decrypting."
      ],
      "metadata": {
        "id": "OVKCxJ_gjZaB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def init_rsa(p,q):\n",
        "  '''Decryption setup. Generates a public key\n",
        "  given the private keys. Returns (N,e,d),\n",
        "  where (N,e) is the public key and\n",
        "  d is the decryption key.'''\n",
        "  fine=False\n",
        "  while not fine:\n",
        "    e=int(input('Suggest exponent:'))\n",
        "    if gcd(e,(p-1)*(q-1))==1:\n",
        "      fine=True\n",
        "  d=modinv(e,(p-1)*(q-1))\n",
        "  return (p*q,e,d)\n",
        "\n",
        "def rsa_decrypt(cipher):\n",
        "  '''Decrypt RSA cypher.'''\n",
        "  m=str(pow(cipher,d,N))\n",
        "  if len(m)%2==1:\n",
        "    m='0'+m\n",
        "  split_list=[m[i:i+2] for i in range(0,len(m),2)]\n",
        "  mess=''\n",
        "  for num in split_list:\n",
        "    mess+=inv_dict[num]\n",
        "  return mess"
      ],
      "metadata": {
        "id": "D882Qf6mW1tM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "rsa_decrypt(6294)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "j_35RiFHaKp9",
        "outputId": "8dbb8341-7023-4a44-809f-2fcf341394b9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hi'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 155
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Working Example"
      ],
      "metadata": {
        "id": "VYr94TpRWhCm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(N,e,d)=init_rsa(101,859)\n",
        "print(N,e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w2hbC0apVHUL",
        "outputId": "a9d0b44b-4746-444b-fade-72094fa6e833"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Suggest exponent:7\n",
            "86759 7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rsa_encrypt('hey',N,e)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "id": "Ujg7-EN-fQp6",
        "outputId": "476bbdc8-ac01-4da5-c290-55b938328952"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "30866"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAEEAAAASCAYAAAAE7bMcAAAABHNCSVQICAgIfAhkiAAAA0ZJREFUWIXt111s32MUB/CPZjPKIl66CROiTDIV8TYTi2hEE8ZCiAsXriziQhBMXHEjdJJlCfEW8ZK4I9aKZNlLEclYSBCRxTQ2Q6petmFsVa26OOff/vbr77e1/bvsN2me9Hu+55znOb/nOc/zZxaT0I0+fI+D2IvP8ChOrvFZhJcxgL/xLdbhxMPkWYFN+CHz7MQbuOII87sG6zGYuQawEdc3oz+q5DSMT7EdP+M4LMOlGWCZKFAD7fgQC9CLr7AUndiBK7GnlKMbq5Pvwa84BysxB3fg9YoFrcFDonAb0q8Nl2BLxmxGP45javjHMYZnS/zG5O8p8WuTf77En4pR8WUWlGyd6bOzIv+qtL2Koyvsc5vUTwkXZtDNBa49uV1oKenn40/8JXZTA5enT29Nnj+wv8TNE7tyt+oFlTFdvTlTEeHGHL8ocJ05bsK/Jf1+bEWXOEJ9yfeLI7cUp4gt2sBVong9pVjXim28LvOsQAeG8DE+alJfW4QHcTxOEP1guSjAkwXNeTl+XROjXxRhsYki7MXD4rhsFwveI3bVSrHT7irFuSzHIdGkO0r2D3ArfpmhvhaDYts2/jZgYUnzYtrurInR6COPVNhuEgUp5ujH7RXa59I+Ij7EcvGBLjDRk95vQn9ELMTNotMP4OKCbaZFWJ0TXIuz0ZpxGxNcU9K/kPwQzirZWsVtNWbiep2ufso4U9yzXxa4pzLYAzU+z6T97gJ3dXJvVehbxXU2KorTQHf6TDrLiZfSfu8M9ZO6eh12izN8vmhoxO4gznwVzs2x2DNuyPG9Cv0B0bhacFGBb+T5rSbPvhyPnaF+ykWA03IczbGxkK6KOPPFQ+kAthX4eTm21eRo8MMFrk98uSU18200vl0z1B+CxeI2KKPFxPneWrJN97F0W/KDOL1ku05caQdNfqL3pt/9Jb4rffaV5j5d/TjuywlsFk3vCfGb4JsM+KOobhHt+CntPenzbv6/o2IxLRl/TDyMXhNn+O2c3CFntYBF+C7tW0Q/elM02H9wS5P6cXSIZva5eMSM4Hd8gsdwUo3fGXhFFGlY9I/D/YCaKwq+TRRiRLzw3hFfqg5teDrjD+cc14uH1/+hn8UsZsF/H4ka/NZxorwAAAAASUVORK5CYII=\n",
            "text/latex": "$\\displaystyle 30866$"
          },
          "metadata": {},
          "execution_count": 166
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rsa_decrypt(30866)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "ocU_aqTIf33o",
        "outputId": "f51c72b5-10ca-4bce-921d-b017ed32910c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hey'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 167
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "(N,e,d)=init_rsa(33533,77977)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BC4_MJlwf8F7",
        "outputId": "281ad5db-5734-47a6-d38d-d9b5fe728543"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Suggest exponent:91\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "rsa_decrypt(rsa_encrypt('hello',N,e))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "to9vAUI-gUYs",
        "outputId": "c9b94d39-30bd-4d80-f75f-5bd133c57ac4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hello'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 179
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Choose bigger primes for longer messages. With $p=335333$ and $q=77977$, we get $N=2614802741$, so we can encode messages of length at most five."
      ],
      "metadata": {
        "id": "Twkb1e5ViwYX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Factorials"
      ],
      "metadata": {
        "id": "uxoTEmI8zrT6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fac(n):\n",
        "  '''The factorial function\n",
        "  for positive integers.'''\n",
        "  if n==1:\n",
        "    return 1\n",
        "  else:\n",
        "    return n*fac(n-1)\n",
        "\n",
        "from sympy import gamma\n",
        "\n",
        "def efac(x):\n",
        "  '''Extended factorial function.\n",
        "  Takes positive real-valued inputs.'''\n",
        "  return gamma(x+1)"
      ],
      "metadata": {
        "id": "nu_vdqdQzsZt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(fac(4),efac(4))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fR-NExh5z0wi",
        "outputId": "5c28bb50-872b-4218-fa6e-a7e1f776ac3a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "24 24\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using the gamma function allows us to extend the classic discrete factorial function to a positive real-valued continuous function. We recover the usual behavior for integers, but we gain continuity. See below.\n",
        "\n",
        "(The gamma function is actually complex-valued, but we just use it for real calculation. [See here for details.](https://en.wikipedia.org/wiki/Gamma_function))"
      ],
      "metadata": {
        "id": "X9Zd744a3j5J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "x_axis=np.linspace(0,6,601)\n",
        "y=[efac(x) for x in x_axis]\n",
        "\n",
        "plt.plot(x,y)\n",
        "plt.title('Continuous x! for 0<=x<=1')\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('extended factorial')\n",
        "plt.show\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 313
        },
        "id": "10wf2230z12j",
        "outputId": "9e8cdd18-4286-4c45-e535-68f8c4108565"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<function matplotlib.pyplot.show>"
            ]
          },
          "metadata": {},
          "execution_count": 25
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fast Fibonacci\n",
        "\n",
        "There are quicker ways to calculate the $n^{th}$ Fibonacci number than simple recursion."
      ],
      "metadata": {
        "id": "316ABiNH7d5m"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Matrix Exponentiation"
      ],
      "metadata": {
        "id": "FPfC5Cza85F1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "# Terrible warning: For some implementation or resource\n",
        "# reason, this function stops working after n=92. See below.\n",
        "\n",
        "def fib_mat_exp(n):\n",
        "  '''Calculates the nth Fibonacci\n",
        "  number using matrix eponentiation.'''\n",
        "  f=np.linalg.matrix_power([[1,1],[1,0]],n-1)\n",
        "  return f[0][0]"
      ],
      "metadata": {
        "id": "5FElLmjq2l-P"
      },
      "execution_count": 65,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fib_mat_exp(17)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t5ttDnMrmThd",
        "outputId": "cb6fd561-2730-4597-d330-8529305569e6"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1597"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# The trouble it seems, is that \n",
        "# the matrix exponentiation method eventually\n",
        "# stops returning the correct answer.\n",
        "# I suspect it's an issue with resources or the \n",
        "# implementation of numpy.linalg.matrix_power.\n",
        "def lazy_fib(n):\n",
        "  '''Classic Fibonacci.'''\n",
        "  a=0;b=1\n",
        "  for i in range(n-1):\n",
        "    c=a+b\n",
        "    a=b\n",
        "    b=c\n",
        "  return c"
      ],
      "metadata": {
        "id": "DhW_qzGp1SVN"
      },
      "execution_count": 46,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a=np.linalg.matrix_power([[1,1],[1,0]],999)[0][0]\n",
        "b=lazy_fib(1000)\n",
        "a==b"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_dMO9OVjm1Lc",
        "outputId": "0b05121d-9677-4808-86a6-7a5b03be298c"
      },
      "execution_count": 125,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 125
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "test_num=100\n",
        "a=np.linalg.matrix_power([[1,1],[1,0]],test_num-1)[0][0]\n",
        "b=lazy_fib(test_num)\n",
        "print(a,b)\n",
        "print(len(str(a)),len(str(b)))\n",
        "print(a==b)\n",
        "while not a==b:\n",
        "  a=np.linalg.matrix_power([[1,1],[1,0]],test_num-1)[0][0]\n",
        "  b=lazy_fib(test_num)\n",
        "  print(a,b)\n",
        "  print(len(str(a)),len(str(b)))\n",
        "  print(a==b,test_num)\n",
        "  test_num=test_num-1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b0utL9Fs11EI",
        "outputId": "d6a92dcd-fb6d-4a78-d19c-e5c42546cd65"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3736710778780434371 354224848179261915075\n",
            "19 21\n",
            "False\n",
            "3736710778780434371 354224848179261915075\n",
            "19 21\n",
            "False 100\n",
            "-2437933049959450366 218922995834555169026\n",
            "20 21\n",
            "False 99\n",
            "6174643828739884737 135301852344706746049\n",
            "19 21\n",
            "False 98\n",
            "-8612576878699335103 83621143489848422977\n",
            "20 20\n",
            "False 97\n",
            "-3659523366270331776 51680708854858323072\n",
            "20 20\n",
            "False 96\n",
            "-4953053512429003327 31940434634990099905\n",
            "20 20\n",
            "False 95\n",
            "1293530146158671551 19740274219868223167\n",
            "19 20\n",
            "False 94\n",
            "-6246583658587674878 12200160415121876738\n",
            "20 20\n",
            "False 93\n",
            "7540113804746346429 7540113804746346429\n",
            "19 19\n",
            "True 92\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "So the matrix exponentiation method stops returning the correct answer after $n=92$. Darn.\n",
        "\n",
        "This seems to be an issue with the practicalities of computing this way, i.e., resources or implementation. The theory is sound, and this *should* work for arbitrarily large $n$."
      ],
      "metadata": {
        "id": "3gHRmHOF3hzn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Fast Doubling"
      ],
      "metadata": {
        "id": "_2jg6OGA885x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# This dictionary increases the working range of fd_fib()\n",
        "fib_dict={0:0,1:1}\n",
        "plist=prime_list(100000)\n",
        "for i in range(2,plist[-1]+1):\n",
        "  fib_dict[i]=fib_dict[i-1]+fib_dict[i-2]\n",
        "for i in range(2,plist[-1]+1):\n",
        "  if i not in plist:\n",
        "    fib_dict.pop(i)"
      ],
      "metadata": {
        "id": "Iqwha65h9BF1"
      },
      "execution_count": 110,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def fd_fib(n):\n",
        "  '''Another Fibonacci algorithm;\n",
        "  this one uses fast doubling.'''\n",
        "  if n in fib_dict:\n",
        "    return fib_dict[n]\n",
        "  if n==1:\n",
        "    return 1\n",
        "  if n%2==0:\n",
        "    f=fd_fib(n//2)\n",
        "    return f*(2*fd_fib((n//2)+1)-f)\n",
        "  else:\n",
        "    k=(n-1)//2\n",
        "    return fd_fib(k+1)**2+fd_fib(k)**2"
      ],
      "metadata": {
        "id": "MqcfvZ702Bs3"
      },
      "execution_count": 111,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fd_fib(42)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "R-TdnUkC7Zw7",
        "outputId": "f33a8940-2a70-4d9b-d970-f8e1f6b9aca8"
      },
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "267914296"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fd_fib(94)==lazy_fib(94)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KwEMbQEZ7zpS",
        "outputId": "54ba2218-27f0-475c-9b9e-404265eb00d0"
      },
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# length of the last entry in dictionary\n",
        "len(str(fib_dict[plist[-1]]))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2Y5TkfxbBZe0",
        "outputId": "f88d2321-f88b-4fb5-cdd9-2f5b7ae002a5"
      },
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "20897"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "With the dictionary of Fibonacci numbers and simpler calculation, fd_fib() will work for any reasonable input. The length of the dictionary is wayyyy overboard, but then I'll never have to worry. With a too-small dictionary, the function times out because the recursion depth is too great."
      ],
      "metadata": {
        "id": "ZBQA6C9uCiZh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('The 10,000th Fibonacci number is:')\n",
        "a=fd_fib(10000)\n",
        "print(a)\n",
        "print(\"That's on the order of 10**{}!!\".format(len(str(a))))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0tlBu_5zDmlJ",
        "outputId": "18d7cb49-b9c7-40dd-faf8-17b02c12922f"
      },
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The 10,000th Fibonacci number is:\n",
            "33644764876431783266621612005107543310302148460680063906564769974680081442166662368155595513633734025582065332680836159373734790483865268263040892463056431887354544369559827491606602099884183933864652731300088830269235673613135117579297437854413752130520504347701602264758318906527890855154366159582987279682987510631200575428783453215515103870818298969791613127856265033195487140214287532698187962046936097879900350962302291026368131493195275630227837628441540360584402572114334961180023091208287046088923962328835461505776583271252546093591128203925285393434620904245248929403901706233888991085841065183173360437470737908552631764325733993712871937587746897479926305837065742830161637408969178426378624212835258112820516370298089332099905707920064367426202389783111470054074998459250360633560933883831923386783056136435351892133279732908133732642652633989763922723407882928177953580570993691049175470808931841056146322338217465637321248226383092103297701648054726243842374862411453093812206564914032751086643394517512161526545361333111314042436854805106765843493523836959653428071768775328348234345557366719731392746273629108210679280784718035329131176778924659089938635459327894523777674406192240337638674004021330343297496902028328145933418826817683893072003634795623117103101291953169794607632737589253530772552375943788434504067715555779056450443016640119462580972216729758615026968443146952034614932291105970676243268515992834709891284706740862008587135016260312071903172086094081298321581077282076353186624611278245537208532365305775956430072517744315051539600905168603220349163222640885248852433158051534849622434848299380905070483482449327453732624567755879089187190803662058009594743150052402532709746995318770724376825907419939632265984147498193609285223945039707165443156421328157688908058783183404917434556270520223564846495196112460268313970975069382648706613264507665074611512677522748621598642530711298441182622661057163515069260029861704945425047491378115154139941550671256271197133252763631939606902895650288268608362241082050562430701794976171121233066073310059947366875\n",
            "That's on the order of 10**2090!!\n"
          ]
        }
      ]
    }
  ]
}