Prime_Factorials_for_Euler's_Number (1).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XFgA6hNQWIQj"
      },
      "outputs": [],
      "source": [
        "from collections import Counter\n",
        "\n",
        "def factorial(n):\n",
        "    if n == 0 or n == 1:\n",
        "        return 1\n",
        "    fact = 1\n",
        "    for i in range(2, n + 1):\n",
        "        fact *= i\n",
        "    return fact\n",
        "\n",
        "def convert_to_base(n, base):\n",
        "    if n == 0:\n",
        "        return [0]\n",
        "    digits = []\n",
        "    while n:\n",
        "        digits.append(n % base)\n",
        "        n = n // base\n",
        "    return digits[::-1]  # Reverse to get the correct order\n",
        "\n",
        "def count_digit_occurrences(n, base):\n",
        "    fact_n = factorial(n)\n",
        "    digits = convert_to_base(fact_n, base)\n",
        "    counter = Counter(digits)\n",
        "    return counter\n",
        "\n",
        "# Example usage:\n",
        "base = 100\n",
        "for i in range(1, 100):\n",
        "    occurrence = count_digit_occurrences(i, base)\n",
        "    subscript_digit = i\n",
        "    result = occurrence.get(subscript_digit, 0)\n",
        "    print(f\"The digit {subscript_digit} appears {result} times in the factorial {i}! in base {base}\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from ipywidgets import interact, IntSlider\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "from collections import Counter\n",
        "\n",
        "def factorial(n):\n",
        "    if n == 0 or n == 1:\n",
        "        return 1\n",
        "    fact = 1\n",
        "    for i in range(2, n + 1):\n",
        "        fact *= i\n",
        "    return fact\n",
        "\n",
        "def convert_to_base(n, base):\n",
        "    if n == 0:\n",
        "        return [0]\n",
        "    digits = []\n",
        "    while n:\n",
        "        digits.append(n % base)\n",
        "        n = n // base\n",
        "    return digits[::-1]\n",
        "\n",
        "def count_digit_occurrences(n, base):\n",
        "    fact_n = factorial(n)\n",
        "    digits = convert_to_base(fact_n, base)\n",
        "    counter = Counter(digits)\n",
        "    return counter\n",
        "\n",
        "def compute_occurrences(max_range, base):\n",
        "    occurrences_matrix = np.zeros((max_range, base))\n",
        "    for i in range(1, max_range + 1):\n",
        "        occurrence = count_digit_occurrences(i, base)\n",
        "        for digit in range(base):\n",
        "            occurrences_matrix[i - 1, digit] = occurrence.get(digit, 0)\n",
        "    return occurrences_matrix\n",
        "\n",
        "def plot_occurrences(max_range, base):\n",
        "    occurrences_matrix = compute_occurrences(max_range, base)\n",
        "    fig = plt.figure()\n",
        "    ax = fig.add_subplot(111, projection='3d')\n",
        "    x_data, y_data = np.meshgrid(range(1, max_range + 1), range(base))\n",
        "    x_data = x_data.flatten()\n",
        "    y_data = y_data.flatten()\n",
        "    z_data = occurrences_matrix.flatten()\n",
        "\n",
        "    ax.bar3d(x_data, y_data, np.zeros_like(z_data), 1, 1, z_data, shade=True)\n",
        "\n",
        "    ax.set_xlabel('Number (n)')\n",
        "    ax.set_ylabel(f'Base-{base} Digit')\n",
        "    ax.set_zlabel('Occurrences')\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "def interactive_plot():\n",
        "    interact(\n",
        "        plot_occurrences,\n",
        "        max_range=IntSlider(min=2, max=500, step=1, value=10, description='Max Range'),\n",
        "        base=IntSlider(min=2, max=500, step=1, value=10, description='Base')\n",
        "    )\n",
        "\n",
        "# Run the interactive plot\n",
        "interactive_plot()"
      ],
      "metadata": {
        "id": "fOq6kZ-HWKhN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import Counter\n",
        "import sys\n",
        "\n",
        "def factorial(n):\n",
        "    if n < 0:\n",
        "        print(\"Error: Factorial of negative numbers is undefined\")\n",
        "        sys.exit()\n",
        "    elif n == 0 or n == 1:\n",
        "        return 1\n",
        "    fact = 1\n",
        "    for i in range(2, n + 1):\n",
        "        fact *= i\n",
        "    return fact\n",
        "\n",
        "def convert_to_base(n, base):\n",
        "    if n == 0:\n",
        "        return [0]\n",
        "    digits = []\n",
        "    while n:\n",
        "        digits.append(n % base)\n",
        "        n = n // base\n",
        "    return digits[::-1]\n",
        "\n",
        "def count_digit_occurrences(n, base):\n",
        "    fact_n = factorial(n)\n",
        "    digits = convert_to_base(fact_n, base)\n",
        "    counter = Counter(digits)\n",
        "    return counter\n",
        "\n",
        "def calculate_product_occurrences(n1, n2, base):\n",
        "    product_occurrences = Counter()\n",
        "    for i in range(n1, n2 + 1):\n",
        "        occurrence = count_digit_occurrences(i, base)\n",
        "        for key, value in occurrence.items():\n",
        "            product_occurrences[key] += value\n",
        "    return product_occurrences\n",
        "\n",
        "# Example usage:\n",
        "base = 16\n",
        "n1 = 10\n",
        "n2 = 20\n",
        "result = calculate_product_occurrences(n1, n2, base)\n",
        "print(f\"For the range {n1}-{n2}, the product of factorials has the following digit occurrences in base {base}:\\n\")\n",
        "for key, value in result.items():\n",
        "    print(f\"The digit {key} appears {value} times\")"
      ],
      "metadata": {
        "id": "4z956Zh_WNDd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "from collections import Counter\n",
        "\n",
        "def factorial(n):\n",
        "    if n == 0 or n == 1:\n",
        "        return 1\n",
        "    fact = 1\n",
        "    for i in range(2, n + 1):\n",
        "        fact *= i\n",
        "    return fact\n",
        "\n",
        "def convert_to_base(n, base):\n",
        "    if n == 0:\n",
        "        return [0]\n",
        "    digits = []\n",
        "    while n:\n",
        "        digits.append(n % base)\n",
        "        n = n // base\n",
        "    return digits[::-1]  # Reverse to get the correct order\n",
        "\n",
        "def count_digit_occurrences(n, base):\n",
        "    fact_n = factorial(n)\n",
        "    digits = convert_to_base(fact_n, base)\n",
        "    counter = Counter(digits)\n",
        "    return counter\n",
        "\n",
        "# Collect data\n",
        "max_n = 100\n",
        "max_base = 100\n",
        "\n",
        "# Prepare data for 3D plot\n",
        "data = []\n",
        "for base in range(2, max_base + 1):  # Base cannot be 1, starting from 2\n",
        "    for n in range(1, max_n):\n",
        "        occurrence = count_digit_occurrences(n, base)\n",
        "        subscript_digit = n\n",
        "        result = occurrence.get(subscript_digit, 0)\n",
        "        data.append((n, base, result))\n",
        "\n",
        "# Convert to numpy array for easy handling\n",
        "data = np.array(data)\n",
        "\n",
        "# Create 3D plot\n",
        "fig = plt.figure(figsize=(10, 7))\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "# Scatter plot\n",
        "ax.scatter(data[:, 0], data[:, 1], data[:, 2], c=data[:, 2], cmap='viridis', marker='o')\n",
        "\n",
        "# Add labels\n",
        "ax.set_xlabel('Number (n)')\n",
        "ax.set_ylabel('Base')\n",
        "ax.set_zlabel('Occurrence of n in n! (Factorial)')\n",
        "\n",
        "# Show plot\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "bkK5MuwcWS6N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To produce the program and approach the approximation of Euler's number \\( e \\) through digit frequencies in factorials, we use a set of mathematical steps and equations. Here, I will outline those equations and the rationale behind each step.\n",
        "\n",
        "### Fundamental Equations and Steps:\n",
        "\n",
        "1. **Factorial Calculation**:\n",
        "   The factorial of a number \\( n \\) is given by:\n",
        "   \\[\n",
        "   n! = 1 \\cdot 2 \\cdot 3 \\cdot \\cdots \\cdot n\n",
        "   \\]\n",
        "   For \\( n = 0 \\) or \\( n = 1 \\), \\( n! = 1 \\).\n",
        "\n",
        "2. **Digit Conversion**:\n",
        "   To convert a number \\( x \\) to a given base \\( b \\), we repeatedly divide the number by the base, collecting remainders:\n",
        "   \\[\n",
        "   x = \\sum_{k=0}^{m} d_k \\cdot b^k\n",
        "   \\]\n",
        "   where \\( d_k \\) are the digits of \\( x \\) in base \\( b \\), and \\( m \\) is such that \\( b^m \\) is the highest power of \\( b \\) less than or equal to \\( x \\).\n",
        "\n",
        "3. **Digit Frequency Calculation**:\n",
        "   For each factorial \\( n! \\), we determine the frequency of each digit \\( d \\) in its base \\( b \\) representation. We count how often each digit appears and then calculate the relative frequency:\n",
        "   \\[\n",
        "   \\text{freq}_d(n!) = \\frac{\\text{count of } d \\text{ in } n!}{\\text{total number of digits in } n!}\n",
        "   \\]\n",
        "\n",
        "4. **Weighted Sum for Approximation**:\n",
        "   Using the digit frequencies, we create a weighted sum to approximate \\( e \\). For each term \\( n \\), the contribution of its digit frequency is weighted by \\( \\frac{1}{n!} \\):\n",
        "   \\[\n",
        "   E(N) = 1 + \\sum_{n=1}^{N} \\left( \\frac{\\sum_{d=0}^{b-1} \\text{freq}_d(n!) \\cdot \\frac{1}{n!}}{1} \\right)\n",
        "   \\]\n",
        "   where \\( \\text{freq}_d(n!) \\) is the frequency of digit \\( d \\) in \\( n! \\).\n",
        "\n",
        "### Summary of Computational Steps in the Program:\n",
        "\n",
        "1. **Factorial Calculation**:\n",
        "   The factorial for any \\( n \\) is directly calculated using:\n",
        "   \\[\n",
        "   \\text{factorial}(n) = \\begin{cases}\n",
        "   1 & \\text{if } n = 0 \\\\\n",
        "   n \\cdot \\text{factorial}(n-1) & \\text{if } n > 0\n",
        "   \\end{cases}\n",
        "   \\]\n",
        "\n",
        "2. **Convert Number to Base**:\n",
        "   For a number \\( x \\):\n",
        "   \\[\n",
        "   \\text{convert\\_to\\_base}(x, b) \\Rightarrow [d_m, d_{m-1}, \\ldots, d_1, d_0]\n",
        "   \\]\n",
        "   where \\( d_k = x \\mod b \\) and \\( x = x // b \\) iteratively.\n",
        "\n",
        "3. **Digit Frequency Calculation in Factorials**:\n",
        "   For each \\( n! \\) in a set range, the frequency of each digit \\( d \\) is summed up:\n",
        "   \\[\n",
        "   \\text{digit\\_frequency\\_in\\_factorials\\_up\\_to\\_n}(n, b) = \\frac{\\text{count of each } d \\text{ in } n!}{\\text{total digits in } n!}\n",
        "   \\]\n",
        "\n",
        "4. **Compute Approximation**:\n",
        "   Aggregate frequencies to form an approximation of \\( e \\):\n",
        "   \\[\n",
        "   e_{\\text{approx}}(N) = 1 + \\sum_{n=1}^{N} \\sum_{d=0}^{b-1} \\left( \\text{freq}_d(n!) \\cdot \\frac{1}{n!} \\right)\n",
        "   \\]\n",
        "\n",
        "### Equations Represented in Python Functions:\n",
        "\n",
        "1. **Factorial Calculation**:\n",
        "   ```python\n",
        "   def factorial(n):\n",
        "       return math.factorial(n)\n",
        "   ```\n",
        "\n",
        "2. **Convert to Base**:\n",
        "   ```python\n",
        "   def convert_to_base(n, base):\n",
        "       digits = []\n",
        "       while n:\n",
        "           digits.append(n % base)\n",
        "           n //= base\n",
        "       return digits[::-1]\n",
        "   ```\n",
        "\n",
        "3. **Digit Frequency Calculation**:\n",
        "   ```python\n",
        "   def digit_frequency_in_factorials_up_to_n(n, base):\n",
        "       digit_counts = Counter()\n",
        "       total_digits = 0\n",
        "       for i in range(1, n + 1):\n",
        "           fact_digits = convert_to_base(factorial(i), base)\n",
        "           digit_counts.update(fact_digits)\n",
        "           total_digits += len(fact_digits)\n",
        "       frequencies = {digit: count / total_digits for digit, count in digit_counts.items()}\n",
        "       return frequencies\n",
        "   ```\n",
        "\n",
        "4. **Compute Approximation for \\( e \\)**:\n",
        "   ```python\n",
        "   def approximate_e_via_digit_frequency(N, base):\n",
        "       E_N = 1\n",
        "       for n in range(1, N + 1):\n",
        "           frequencies = digit_frequency_in_factorials_up_to_n(n, base)\n",
        "           weighted_sum = sum(frequencies[d] * (1 / factorial(n)) for d in frequencies)\n",
        "           E_N += weighted_sum\n",
        "       return E_N\n",
        "   ```\n",
        "\n",
        "By combining these steps, the program successfully approximates Euler's number \\( e \\) through the digit frequency approach, illustrating the intriguing connection between digit patterns in factorials and the mathematical constant \\( e \\)."
      ],
      "metadata": {
        "id": "K3jFUXMzn0as"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "from collections import Counter\n",
        "\n",
        "def convert_to_base(n, base):\n",
        "    \"\"\"Convert number `n` to any given `base` and return the digits in a list.\"\"\"\n",
        "    if n == 0:\n",
        "        return [0]\n",
        "    digits = []\n",
        "    while n:\n",
        "        digits.append(n % base)\n",
        "        n //= base\n",
        "    return digits[::-1]  # Reverse to get the correct order\n",
        "\n",
        "def digit_frequency_in_factorials_up_to_n(n, base):\n",
        "    \"\"\"Calculate the average frequency of each digit in factorials up to `n` in given `base`.\"\"\"\n",
        "    digit_counts = Counter()\n",
        "    total_digits = 0\n",
        "\n",
        "    for i in range(1, n + 1):\n",
        "        fact_digits = convert_to_base(math.factorial(i), base)\n",
        "        digit_counts.update(fact_digits)\n",
        "        total_digits += len(fact_digits)\n",
        "\n",
        "    frequencies = {digit: count / total_digits for digit, count in digit_counts.items()}\n",
        "    return frequencies\n",
        "\n",
        "def approximate_e_via_digit_frequency(N, base):\n",
        "    \"\"\"Approximate the value of `e` through digit frequency in factorial series up to `N`.\"\"\"\n",
        "    E_N = 1  # Start with the initial term corresponding to 1/0! which is 1\n",
        "    for n in range(1, N + 1):\n",
        "        frequencies = digit_frequency_in_factorials_up_to_n(n, base)\n",
        "        weighted_sum = sum(frequencies[d] * (1 / math.factorial(n)) for d in frequencies)\n",
        "        E_N += weighted_sum\n",
        "    return E_N\n",
        "\n",
        "# Example usage:\n",
        "base = int(input(\"Enter the base system you want to use: \"))\n",
        "N = int(input(\"Calculate up to factorial of: \"))\n",
        "\n",
        "approx_e = approximate_e_via_digit_frequency(N, base)\n",
        "print(f\"Approximation of e using digit frequency up to {N}! in base {base}: {approx_e:.10f}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2vxP0qegniC5",
        "outputId": "5c097d2c-0381-4ebe-cc95-c341c9c46769"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the base system you want to use: 8\n",
            "Calculate up to factorial of: 40\n",
            "Approximation of e using digit frequency up to 40! in base 8: 2.7182818285\n"
          ]
        }
      ]
    }
  ]
}