AHartNtkn/difflogclean.ipynb Secret

## difflogclean.ipynb
{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPpkCFUkKoxFzUC2EKJbbem",
      "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/gist/AHartNtkn/a9a3d810824596f44cda2028dc3173e6/difflogclean.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LjVeM_TT6MrL"
      },
      "outputs": [],
      "source": [
        "import jax.numpy as jnp\n",
        "from jax import vmap, grad, random, config, jit\n",
        "from jax.nn import softmax\n",
        "from itertools import product\n",
        "import time\n",
        "import matplotlib.pyplot as plt\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from scipy.linalg import solve\n",
        "\n",
        "config.update('jax_enable_x64', True)\n",
        "# config.update('jax_platform_name', 'gpu')"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def V1(x):\n",
        "    return x**2 * (x - 1)**2\n",
        "\n",
        "def descend(V, x0, dt, n_steps):\n",
        "    x = x0\n",
        "    for _ in range(n_steps):\n",
        "        x -= dt * grad(V)(x)\n",
        "    return x"
      ],
      "metadata": {
        "id": "sQ51ZDrQ6oJz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "descend(V1, 0.55, 0.1, 100).round()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GYZQ02gR6uIF",
        "outputId": "3292b0e2-df4d-4c6c-8b9c-b620c3a28146"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array(1., dtype=float64, weak_type=True)"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def VAnd(v):\n",
        "    x, y, z = v\n",
        "    return (x**2 + y**2 + z**2) * ((x - 1)**2 + y**2 + z**2) * (x**2 + (y - 1)**2 + z**2) * ((x - 1)**2 + (y - 1)**2 + (z - 1)**2)"
      ],
      "metadata": {
        "id": "zfNlKldx6vsu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "descend(VAnd, jnp.array([0.5, 0.5, 0.5]), 0.1, 100).round()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g0Z2VM3q6xSX",
        "outputId": "3cf1f05f-4a2c-476c-e75e-8da321ee4432"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array([0., 0., 0.], dtype=float64)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "descend(lambda v: VAnd(jnp.array([v[0], v[1], 1])), jnp.array([0.5, 0.5]), 0.1, 100).round()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yvpd1ROR6zgK",
        "outputId": "a0905739-fb37-4b45-fab9-27126ff9a631"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array([1., 1.], dtype=float64)"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def VXor(v):\n",
        "    x, y, z = v\n",
        "    return (x**2 + y**2 + z**2) * ((x - 1)**2 + y**2 + (z - 1)**2) * (x**2 + (y - 1)**2 + (z - 1)**2) * ((x - 1)**2 + (y - 1)**2 + z**2)"
      ],
      "metadata": {
        "id": "LdWa4x2f61pL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def VHAddr(v):\n",
        "  i0, i1, s, c = v\n",
        "  return VXor(jnp.array([i0, i1, s])) + VAnd(jnp.array([i0, i1, c]))"
      ],
      "metadata": {
        "id": "gOphA3YK65MT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "descend(lambda v: VHAddr(jnp.array([1, 1, v[0], v[1]])), jnp.array([0.5, 0.5]), 0.1, 100).round()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xz5-Rtw866zI",
        "outputId": "ba202cb0-6eea-4044-b644-43e4bc5831fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array([0., 1.], dtype=float64)"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "descend(lambda v: VHAddr(jnp.array([0, 1, v[0], v[1]])), jnp.array([0.5, 0.5]), 0.1, 100).round()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bwCjBSdL7Ewj",
        "outputId": "779f64fe-3f55-4d8d-be17-11235ce236c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array([1., 0.], dtype=float64)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "descend(lambda v: VHAddr(jnp.array([v[0], v[1], 1, 0])), jnp.array([0.5, 0.5]), 0.1, 100)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P86eaoyj68cq",
        "outputId": "f015c0af-8b83-4db3-839a-bb634efa74cf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array([0.46042582, 0.46043378], dtype=float64)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def VAndL(v):\n",
        "    x, y, z = v\n",
        "    return min(abs(x) + abs(y) + abs(z), abs(x - 1) + abs(y) + abs(z), abs(x) + abs(y - 1) + abs(z), abs(x - 1) + abs(y - 1) + abs(z - 1))"
      ],
      "metadata": {
        "id": "zEdPyxkx6-e2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "descend(lambda v: VAndL(jnp.array([v[0], v[1], 1])), jnp.array([0.5, 0.5]), 0.1, 100).round()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_7ohHvBy7HaE",
        "outputId": "4e480e59-ca93-44f1-a2c3-285fd28f17b3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array([1., 1.], dtype=float64)"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def V2(x):\n",
        "    return -abs(x - 0.5) + 0.5"
      ],
      "metadata": {
        "id": "GKaX_gun7I4h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def descend_w_boundary(V, x0, dt, n_steps, low, high):\n",
        "    x = x0\n",
        "    for _ in range(n_steps):\n",
        "        x = max(low, min(high, x - dt * grad(V)(x)))\n",
        "    return x"
      ],
      "metadata": {
        "id": "e5ilsEFu7LAS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "descend_w_boundary(V2, 0.55, 0.1, 100, 0.0, 1.0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2zmYyYP17MJ7",
        "outputId": "666392b0-cfaa-4a62-97d8-1268061894bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1.0"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "descend_w_boundary(V2, 0.45, 0.1, 100, 0.0, 1.0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gH-x5N3l7OD7",
        "outputId": "8a3828b8-a7ec-4a37-be6d-8f567674cca0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.0"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def find_coefficients(lookup_table):\n",
        "    num_vars = len(lookup_table[0]) - 1\n",
        "    num_equations = len(lookup_table)\n",
        "    num_coefficients = 2 ** num_vars\n",
        "\n",
        "    # Create matrix A for the linear system Ax = b\n",
        "    A = np.zeros((num_equations, num_coefficients))\n",
        "\n",
        "    for i, row in enumerate(lookup_table):\n",
        "        for j in range(num_coefficients):\n",
        "            bits = [int(k) for k in f'{j:0{num_vars}b}']\n",
        "            A[i, j] = np.prod([a if b else 1 for a, b in zip(row[:-1], bits)])\n",
        "\n",
        "    # Create vector b (output values)\n",
        "    b = np.array([row[-1] for row in lookup_table])\n",
        "\n",
        "    # Solve the linear system\n",
        "    coefficients = solve(A, b)\n",
        "    return coefficients"
      ],
      "metadata": {
        "id": "JzMswsiB7Plo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lookup_table = [\n",
        "    (0, 0, 1),\n",
        "    (0, 1, 0),\n",
        "    (1, 0, 0),\n",
        "    (1, 1, 1)\n",
        "]\n",
        "\n",
        "find_coefficients(lookup_table)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mc2DGcpi-b2V",
        "outputId": "fd6ec09d-cf18-4b4d-ef67-c09c624b2b30"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1., -1., -1.,  2.])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lookup_table = [\n",
        "    (-1, -1, 1),\n",
        "    (-1, 1, -1),\n",
        "    (1, -1, -1),\n",
        "    (1, 1, 1)\n",
        "]\n",
        "\n",
        "find_coefficients(lookup_table)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1NE7_NcZ-mz3",
        "outputId": "4ea1eed4-e847-45e7-b7ad-2e22fab2109f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 1.])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lookup_table = [\n",
        "    (-1, -1, -1, -1),\n",
        "    (-1, -1, 1, 1),\n",
        "    (-1, 1, -1, 1),\n",
        "    (-1, 1, 1, -1),\n",
        "    (1, -1, -1, 1),\n",
        "    (1, -1, 1, -1),\n",
        "    (1, 1, -1, -1),\n",
        "    (1, 1, 1, 1)\n",
        "]\n",
        "\n",
        "find_coefficients(lookup_table)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AruRTBtN-dGO",
        "outputId": "c5cbc460-cc76-4b99-b7c3-6d44e669005c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 0., 0., 0., 1.])"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def VLin(v):\n",
        "    x, y, z = v\n",
        "    return (2 * x - 3 * y + 4 * z) ** 2 / (2**2 + (-3)**2 + 4**2)"
      ],
      "metadata": {
        "id": "qEpKO0_P-jlh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "min = descend(VLin, jnp.array([-0.5, -0.5, -0.5]), 0.1, 100)\n",
        "print(min)\n",
        "VLin(min)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5mQ4G4I6-s19",
        "outputId": "95b15672-561c-42d1-cf4d-2e08a172cc87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[-0.39655172 -0.65517241 -0.29310345]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array(3.21945094e-21, dtype=float64)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_lin_eq_pot(coefficients):\n",
        "    *coeffs, D = coefficients\n",
        "    coeffs_array = jnp.array(coeffs)\n",
        "\n",
        "    def f(v):\n",
        "        return (jnp.dot(coeffs_array, v) + D) ** 2 / jnp.dot(coeffs_array, coeffs_array)\n",
        "\n",
        "    return f\n",
        "\n",
        "ex_V = generate_lin_eq_pot(jnp.array([2, -3, 4, 0]))\n",
        "\n",
        "min = descend(ex_V, jnp.array([0.5, 0.5, 0.5]), 0.1, 100)\n",
        "print(min)\n",
        "VLin(min)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sG-AkIPP-uPi",
        "outputId": "c81357b4-f7ee-4d1d-befb-6d5c1b113fe8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0.39655172 0.65517241 0.29310345]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Array(3.21945094e-21, dtype=float64)"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Hyperparameters:\n",
        "    def __init__(self, alpha, beta, gamma, delta, epsilon, zeta):\n",
        "        self.alpha = alpha\n",
        "        self.beta = beta\n",
        "        self.gamma = gamma\n",
        "        self.delta = delta\n",
        "        self.epsilon = epsilon\n",
        "        self.zeta = zeta\n",
        "\n",
        "    def __str__(self):\n",
        "        return (f\"Hyperparameters:\\n\"\n",
        "                f\"  Alpha: {self.alpha}\\n\"\n",
        "                f\"  Beta: {self.beta}\\n\"\n",
        "                f\"  Gamma: {self.gamma}\\n\"\n",
        "                f\"  Delta: {self.delta}\\n\"\n",
        "                f\"  Epsilon: {self.epsilon}\\n\"\n",
        "                f\"  Zeta: {self.zeta}\")\n",
        "\n",
        "def make_euler_step(V_funcs):\n",
        "    grad_V_funcs = [grad(V_m) for V_m in V_funcs]\n",
        "\n",
        "    @jit\n",
        "    def euler_step(y, dt, var_lim, alpha, beta, gamma, delta, epsilon, zeta):\n",
        "        s = y[:len(V_funcs)]\n",
        "        l = y[len(V_funcs):2*len(V_funcs)]\n",
        "        x = y[2*len(V_funcs):]\n",
        "\n",
        "        l_softmax = softmax(l)\n",
        "\n",
        "        V_vals = jnp.array([V_m(x) for V_m in V_funcs])\n",
        "        ds_dt = beta * (s + epsilon) * (V_vals - gamma)\n",
        "        dl_dt = alpha * (V_vals - delta)\n",
        "\n",
        "        grads_V = jnp.array([grad_V_m(x) for grad_V_m in grad_V_funcs])\n",
        "        update_terms = grads_V * (s[:, None] * l_softmax[:, None] + (1 - s[:, None]) * zeta * l_softmax[:, None])\n",
        "        dx_dt = -update_terms.sum(axis=0)\n",
        "\n",
        "        y_updated = y + jnp.concatenate([ds_dt, dl_dt, dx_dt]) * dt\n",
        "        y_updated = y_updated.at[:len(V_funcs)].set(jnp.clip(y_updated[:len(V_funcs)], 0, 1))  # Short-term memory is in [0, 1]\n",
        "        y_updated = y_updated.at[len(V_funcs):2*len(V_funcs)].set(jnp.clip(y_updated[len(V_funcs):2*len(V_funcs)], 0, jnp.inf))  # Long-term memory is > 0\n",
        "        y_updated = y_updated.at[2*len(V_funcs):].set(jnp.mod(y_updated[2*len(V_funcs):], var_lim)) # Variable values\n",
        "\n",
        "        # Check for early stopping condition\n",
        "        stop_condition = jnp.all(V_vals < delta)\n",
        "\n",
        "        return y_updated, stop_condition\n",
        "\n",
        "    return euler_step\n",
        "\n",
        "def euler_integration(y0, num_steps, dt, hyperparams, euler_step_jit, var_lim):\n",
        "    y = y0\n",
        "    stop = False\n",
        "\n",
        "    for _ in range(num_steps):\n",
        "        y, stop = euler_step_jit(y, dt, var_lim, hyperparams.alpha, hyperparams.beta, hyperparams.gamma, hyperparams.delta, hyperparams.epsilon, hyperparams.zeta)\n",
        "        if stop:\n",
        "            break\n",
        "\n",
        "    return y"
      ],
      "metadata": {
        "id": "VxPiR98x-xop"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 1\n",
        "def mod_dist(a, b, mod):\n",
        "    return jnp.abs((a - b + mod / 2) % mod - mod / 2)\n",
        "\n",
        "def pot(x, y):\n",
        "    tuples = list(product([0, 1, 2], repeat=2))\n",
        "    values = [mod_dist(x, i, 3) + mod_dist(y, j, 3) for i, j in tuples if i != j]\n",
        "    return jnp.min(jnp.array(values))\n",
        "\n",
        "def generate_V_funcs_from_graph(graph):\n",
        "    return [lambda x, i=i, j=j: pot(x[i], x[j]) for i, j in graph]\n",
        "\n",
        "# Example usage\n",
        "graph = [(0, 1), (0, 2), (1, 2)]\n",
        "V_funcs = generate_V_funcs_from_graph(graph)\n",
        "\n",
        "def initialize_conditions(n_vars, n_clauses, seed=1):\n",
        "    key = random.PRNGKey(seed)\n",
        "    short_term_memory = jnp.zeros(n_clauses)\n",
        "    long_term_memory = jnp.zeros(n_clauses)\n",
        "    variables = 0.01 * random.uniform(key, (n_vars,))\n",
        "    return jnp.concatenate([short_term_memory, long_term_memory, variables])\n",
        "\n",
        "# Simulation parameters\n",
        "n_vars = 3\n",
        "n_clauses = len(V_funcs)\n",
        "hyperparams = Hyperparameters(alpha=5, beta=20, gamma=0.05, delta=0.2, epsilon=0.001, zeta=0.1)\n",
        "initial_conditions = initialize_conditions(n_vars, n_clauses)\n",
        "var_lim = 3\n",
        "\n",
        "#precompiled simulator\n",
        "euler_step_jit = make_euler_step(V_funcs)"
      ],
      "metadata": {
        "id": "ID2oIYan_OLf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a grid of x and y values\n",
        "x = np.linspace(0, 3, 100)\n",
        "y = np.linspace(0, 3, 100)\n",
        "X, Y = np.meshgrid(x, y)\n",
        "\n",
        "# Compute the potential for each (x, y) pair\n",
        "Z = np.array([jit(pot)(xi, yi) for xi, yi in zip(np.ravel(X), np.ravel(Y))])\n",
        "Z = Z.reshape(X.shape)\n",
        "\n",
        "# Plotting\n",
        "plt.figure(figsize=(8, 6))\n",
        "contour = plt.contourf(X, Y, Z, levels=50, cmap='viridis')\n",
        "plt.colorbar(contour)\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('y')\n",
        "plt.title('Potential Function Contour Plot')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "mGD7Scdc_T-v",
        "outputId": "ac47d5d9-ccf0-4ef6-8b78-57c951cd4313"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Gradient of pot with respect to x\n",
        "grad_pot_x = jit(grad(pot, argnums=0))\n",
        "\n",
        "# Create a grid of x and y values\n",
        "x = np.linspace(0, 3, 100)\n",
        "y = np.linspace(0, 3, 100)\n",
        "X, Y = np.meshgrid(x, y)\n",
        "\n",
        "# Compute the gradient at each (x, y) pair\n",
        "Z = np.array([grad_pot_x(xi, yi) for xi, yi in zip(np.ravel(X), np.ravel(Y))])\n",
        "Z = Z.reshape(X.shape)\n",
        "\n",
        "# Plotting the gradient\n",
        "plt.figure(figsize=(8, 6))\n",
        "contour = plt.contourf(X, Y, Z, levels=50, cmap='viridis')\n",
        "plt.colorbar(contour)\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('y')\n",
        "plt.title('Gradient of Potential Function with Respect to x')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "iqTrB-7J_WNJ",
        "outputId": "f6842060-f09f-4d56-b5f0-aceaa77096de"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Gradient of pot with respect to x\n",
        "grad_pot_x = jit(grad(pot, argnums=1))\n",
        "\n",
        "# Create a grid of x and y values\n",
        "x = np.linspace(0, 3, 100)\n",
        "y = np.linspace(0, 3, 100)\n",
        "X, Y = np.meshgrid(x, y)\n",
        "\n",
        "# Compute the gradient at each (x, y) pair\n",
        "Z = np.array([grad_pot_x(xi, yi) for xi, yi in zip(np.ravel(X), np.ravel(Y))])\n",
        "Z = Z.reshape(X.shape)\n",
        "\n",
        "# Plotting the gradient\n",
        "plt.figure(figsize=(8, 6))\n",
        "contour = plt.contourf(X, Y, Z, levels=50, cmap='viridis')\n",
        "plt.colorbar(contour)\n",
        "plt.xlabel('x')\n",
        "plt.ylabel('y')\n",
        "plt.title('Gradient of Potential Function with Respect to x')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "1zcWO5Na_Ytb",
        "outputId": "8343f39f-e58f-4fe7-88f5-0573953e94a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def display_graph(graph):\n",
        "    \"\"\" Display the graph using networkx and matplotlib. \"\"\"\n",
        "    G = nx.Graph()\n",
        "    G.add_edges_from(graph)\n",
        "\n",
        "    # Draw the graph\n",
        "    nx.draw(G, with_labels=True, node_color='lightblue', edge_color='gray', node_size=800, font_size=16)\n",
        "    plt.show()\n",
        "\n",
        "# Example usage\n",
        "display_graph(graph)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "rW6Xy67w_aXX",
        "outputId": "2f9e0d97-4124-4302-936d-e33a2df83766"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Simulate\n",
        "start_time = time.time()\n",
        "final_state = euler_integration(initial_conditions, 1000, 0.1, hyperparams, euler_step_jit, var_lim)\n",
        "end_time = time.time()\n",
        "time_taken = end_time - start_time\n",
        "print(f\"Time taken for Euler integration: {time_taken} seconds\")\n",
        "print(f\"Final state: {final_state.round().astype(int)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pmRP69Xv_cPI",
        "outputId": "f4458fba-34a8-4251-b358-7a09f68aa521"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time taken for Euler integration: 0.004125118255615234 seconds\n",
            "Final state: [1 1 1 8 5 7 3 2 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def display_graph_colored(graph, node_colors):\n",
        "    \"\"\" Display the graph with colored nodes. \"\"\"\n",
        "    G = nx.Graph()\n",
        "    G.add_edges_from(graph)\n",
        "\n",
        "    color_dict = {node: color for node, color in enumerate(node_colors)}\n",
        "\n",
        "    color_map = {0: 'red', 1: 'green', 2: 'blue'}\n",
        "\n",
        "    node_color_list = [color_map[color_dict[node]] if node in color_dict else 'gray' for node in G.nodes]\n",
        "\n",
        "    nx.draw(G, with_labels=True, node_color=node_color_list, edge_color='gray', node_size=800, font_size=16)\n",
        "    plt.show()\n",
        "\n",
        "display_graph_colored(graph, (final_state[2*n_clauses:].round() % 3).astype(int).tolist())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "kL9jgPxJ_fd1",
        "outputId": "5013e110-2100-4004-a846-46d59f4c2855"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Example 2\n",
        "graph = [(0, 4), (0, 5), (0, 6), (0, 7), (0, 9), (1, 2), (1, 3), (1, 6), (1, 9), (2, 5), (2, 7), (2, 9), (3, 6), (4, 6), (4, 7), (4, 8), (5, 7), (7, 8), (8, 9)]\n",
        "V_funcs = generate_V_funcs_from_graph(graph)\n",
        "\n",
        "# Simulation parameters\n",
        "n_vars = 10\n",
        "n_clauses = len(V_funcs)\n",
        "hyperparams = Hyperparameters(alpha=5, beta=20, gamma=0.05, delta=0.2, epsilon=0.001, zeta=0.1)\n",
        "initial_conditions = initialize_conditions(n_vars, n_clauses)\n",
        "var_lim = 3\n",
        "\n",
        "#precompiled simulator\n",
        "euler_step_jit = make_euler_step(V_funcs)"
      ],
      "metadata": {
        "id": "9riCx4o-_nGa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "display_graph(graph)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "fdIl3kWoAd19",
        "outputId": "46de607a-d82e-47bb-9834-0734224d2837"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Simulate\n",
        "start_time = time.time()\n",
        "final_state = euler_integration(initial_conditions, 50000000, 0.05, hyperparams, euler_step_jit, var_lim)\n",
        "end_time = time.time()\n",
        "time_taken = end_time - start_time\n",
        "print(f\"Time taken for Euler integration: {time_taken} seconds\")\n",
        "print(f\"Final state: {final_state.round().astype(int)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0F3bUzDM_sp-",
        "outputId": "e5380bcc-789e-4440-f3c6-e86bd4ea39d8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time taken for Euler integration: 0.12586164474487305 seconds\n",
            "Final state: [ 1  0  0  0  0  0  0  0  0  0  0  0  0  1  1  1  0  0  0 74  7 19 36 22\n",
            "  0  0  0  0  0 37  0  0  9 68 77 33 36  0  1  3  1  1  3  3  2  2  1  2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "display_graph_colored(graph, (final_state[2*n_clauses:].round() % 3).astype(int).tolist())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 516
        },
        "id": "cdPZMCZx_9ww",
        "outputId": "ebc56280-83fa-4046-beee-7d325a5ac61c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Modification w/o mod usage\n",
        "def make_euler_step(V_funcs):\n",
        "    grad_V_funcs = [grad(V_m) for V_m in V_funcs]\n",
        "\n",
        "    @jit\n",
        "    def euler_step(y, dt, alpha, beta, gamma, delta, epsilon, zeta):\n",
        "        s = y[:len(V_funcs)]\n",
        "        l = y[len(V_funcs):2*len(V_funcs)]\n",
        "        x = y[2*len(V_funcs):]\n",
        "\n",
        "        l_softmax = softmax(l)\n",
        "\n",
        "        V_vals = jnp.array([V_m(x) for V_m in V_funcs])\n",
        "        ds_dt = hyperparams.beta * (s + hyperparams.epsilon) * (V_vals - hyperparams.gamma)\n",
        "        dl_dt = hyperparams.alpha * (V_vals - hyperparams.delta)\n",
        "\n",
        "        grads_V = jnp.array([grad_V_m(x) for grad_V_m in grad_V_funcs])\n",
        "        update_terms = grads_V * (s[:, None] * l_softmax[:, None] + (1 - s[:, None]) * hyperparams.zeta * l_softmax[:, None])\n",
        "        dx_dt = -update_terms.sum(axis=0)\n",
        "\n",
        "        y_updated = y + jnp.concatenate([ds_dt, dl_dt, dx_dt]) * dt\n",
        "        y_updated = y_updated.at[:len(V_funcs)].set(jnp.clip(y_updated[:len(V_funcs)], 0, 1))  # Short-term memory is in [0, 1]\n",
        "        y_updated = y_updated.at[len(V_funcs):2*len(V_funcs)].set(jnp.clip(y_updated[len(V_funcs):2*len(V_funcs)], 0, jnp.inf))  # Long-term memory is > 0\n",
        "        y_updated = y_updated.at[2*len(V_funcs):].set(jnp.clip(y_updated[2*len(V_funcs):], 0, 1)) # Variable values\n",
        "\n",
        "        stop_condition = jnp.all(V_vals < hyperparams.delta)\n",
        "\n",
        "        return y_updated, stop_condition\n",
        "\n",
        "    return euler_step\n",
        "\n",
        "\n",
        "def euler_integration(y0, num_steps, dt, hyperparams, euler_step_jit):\n",
        "    y = y0\n",
        "    stop = False\n",
        "\n",
        "    for _ in range(num_steps):\n",
        "        y, stop = euler_step_jit(y, dt, hyperparams.alpha, hyperparams.beta, hyperparams.gamma, hyperparams.delta, hyperparams.epsilon, hyperparams.zeta)\n",
        "        if stop:\n",
        "            break\n",
        "\n",
        "    return y"
      ],
      "metadata": {
        "id": "JEnQCbJ_Ag17"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def find_multilinear_function(lookup_table):\n",
        "    num_vars = len(lookup_table[0]) - 1\n",
        "    num_equations = len(lookup_table)\n",
        "    num_coefficients = 2 ** num_vars\n",
        "\n",
        "    # Create matrix A for the linear system Ax = b\n",
        "    A = np.zeros((num_equations, num_coefficients))\n",
        "\n",
        "    for i, row in enumerate(lookup_table):\n",
        "        for j in range(num_coefficients):\n",
        "            bits = [int(k) for k in f'{j:0{num_vars}b}']\n",
        "            A[i, j] = np.prod([a if b else 1 for a, b in zip(row[:-1], bits)])\n",
        "\n",
        "    # Create vector b (output values)\n",
        "    b = np.array([row[-1] for row in lookup_table])\n",
        "\n",
        "    coefficients = solve(A, b)\n",
        "\n",
        "    # Define the multilinear function using the coefficients\n",
        "    def multilinear_function(v):\n",
        "        combinations = jnp.array([[x if b else 1 for x, b in zip(v, [int(bit) for bit in f'{i:0{num_vars}b}'])] for i in range(num_coefficients)])\n",
        "        products = jnp.prod(combinations, axis=1)\n",
        "        return jnp.sum(coefficients * products)\n",
        "\n",
        "    return multilinear_function"
      ],
      "metadata": {
        "id": "5fcUl3u1B7wD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_half_adder_lookup_table():\n",
        "    lookup_table = []\n",
        "    for input1 in [0, 1]:\n",
        "        for input2 in [0, 1]:\n",
        "            sum = (input1 + input2) % 2\n",
        "            carry = (input1 + input2) // 2\n",
        "            for sum_out in [0, 1]:\n",
        "                for carry_out in [0, 1]:\n",
        "                    output_correct = (sum_out == sum and carry_out == carry)\n",
        "                    lookup_table.append((input1, input2, sum_out, carry_out, 1 - int(output_correct)))\n",
        "    return lookup_table\n",
        "\n",
        "half_adder_V = find_multilinear_function(generate_half_adder_lookup_table())\n",
        "\n",
        "def generate_full_adder_lookup_table():\n",
        "    lookup_table = []\n",
        "    for input1 in [0, 1]:\n",
        "        for input2 in [0, 1]:\n",
        "            for carry_in in [0, 1]:\n",
        "                sum = (input1 + input2 + carry_in) % 2\n",
        "                carry = (input1 + input2 + carry_in) // 2\n",
        "                for sum_out in [0, 1]:\n",
        "                    for carry_out in [0, 1]:\n",
        "                        output_correct = (sum_out == sum and carry_out == carry)\n",
        "                        lookup_table.append((input1, input2, carry_in, sum_out, carry_out, 1 - int(output_correct)))\n",
        "    return lookup_table\n",
        "\n",
        "full_adder_V = find_multilinear_function(generate_full_adder_lookup_table())"
      ],
      "metadata": {
        "id": "DaN938IlCEAj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_addition_potentials(ln):\n",
        "    potentials = []\n",
        "\n",
        "    # Function to create a potential function for a specific bit position\n",
        "    def create_potential(func, idx, ln):\n",
        "        def potential(v):\n",
        "            # Extract relevant bits for the potential function\n",
        "            input1 = v[idx]\n",
        "            input2 = v[ln + idx]\n",
        "            carry_in = v[2 * ln + idx - 1] if idx > 0 else 0  # No carry_in for the first bit\n",
        "            sum_out = v[3 * ln + idx]\n",
        "            carry_out = v[2 * ln + idx]\n",
        "\n",
        "            # Apply the correct potential function\n",
        "            if func == \"half_adder\":\n",
        "                return half_adder_V(jnp.array([input1, input2, sum_out, carry_out]))\n",
        "            elif func == \"full_adder\":\n",
        "                return full_adder_V(jnp.array([input1, input2, carry_in, sum_out, carry_out]))\n",
        "            else:\n",
        "                raise ValueError(\"Invalid function type\")\n",
        "        return potential\n",
        "\n",
        "    potentials.append(create_potential(\"half_adder\", 0, ln))\n",
        "\n",
        "    for i in range(1, ln):\n",
        "        potentials.append(create_potential(\"full_adder\", i, ln))\n",
        "\n",
        "    return potentials"
      ],
      "metadata": {
        "id": "bdnw52QWCN_7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def initialize_conditions(n_vars, n_clauses, seed=42):\n",
        "    key = random.PRNGKey(seed)\n",
        "    short_term_memory = 0.5 + jnp.zeros(n_clauses)\n",
        "    long_term_memory = jnp.zeros(n_clauses)\n",
        "    variables = random.uniform(key, (n_vars,))\n",
        "    return jnp.concatenate([short_term_memory, long_term_memory, variables])"
      ],
      "metadata": {
        "id": "q-RVoc9HCP-e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ln = 8\n",
        "V_funcs = generate_addition_potentials(ln)\n",
        "\n",
        "# Simulation parameters\n",
        "n_vars = 4 * ln\n",
        "n_clauses = len(V_funcs)\n",
        "hyperparams = Hyperparameters(alpha=5, beta=20, gamma=0.05, delta=0.2, epsilon=0.001, zeta=0.1)\n",
        "initial_conditions = initialize_conditions(n_vars, n_clauses)\n",
        "\n",
        "euler_step_jit = make_euler_step(V_funcs)"
      ],
      "metadata": {
        "id": "cFP3ROKYCS2q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_time = time.time()\n",
        "final_state = euler_integration(initial_conditions, 1000, 0.1, hyperparams, euler_step_jit)\n",
        "end_time = time.time()\n",
        "time_taken = end_time - start_time\n",
        "print(f\"Time taken for Euler integration: {time_taken} seconds\")\n",
        "print(f\"Final state: {final_state.round().astype(int)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cp5tqlAgCUnp",
        "outputId": "ac7b5726-8adf-458e-b77e-7a1c18e1614b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time taken for Euler integration: 0.04626607894897461 seconds\n",
            "Final state: [ 0  0  0  1  0  0  0  0 32 16 20 32 32 32 29 32  0  1  1  1  1  1  0  0\n",
            "  1  0  1  0  1  1  1  0  0  0  1  1  1  1  1  0  1  1  0  0  1  1  0  1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cond = final_state[2*n_clauses:].round()\n",
        "print(cond[:ln].astype(int))\n",
        "print(cond[ln:2*ln].astype(int))\n",
        "print(cond[(3*ln)-1:].astype(int))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KrkHh6BBCfu6",
        "outputId": "0ed53469-76bd-4333-e719-84eac9f38005"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0 1 1 1 1 1 0 0]\n",
            "[1 0 1 0 1 1 1 0]\n",
            "[0 1 1 0 0 1 1 0 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ln = 8\n",
        "V_funcs = generate_addition_potentials(ln)\n",
        "\n",
        "num1 = [1,1,0,1,1,0,0,1] # 155\n",
        "num2 = [1,0,0,1,0,1,1,0] # 105\n",
        "V_funcs = [lambda v, V_m=V_m: V_m(jnp.concatenate([jnp.array(num1), jnp.array(num2), v])) for V_m in V_funcs]\n",
        "\n",
        "# Simulation parameters\n",
        "n_vars = 2 * ln\n",
        "n_clauses = len(V_funcs)\n",
        "hyperparams = Hyperparameters(alpha=5, beta=20, gamma=0.05, delta=0.2, epsilon=0.001, zeta=0.1)\n",
        "initial_conditions = initialize_conditions(n_vars, n_clauses)\n",
        "\n",
        "euler_step_jit = make_euler_step(V_funcs)"
      ],
      "metadata": {
        "id": "oJAfSNTqCthj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_time = time.time()\n",
        "final_state = euler_integration(initial_conditions, 1000, 0.1, hyperparams, euler_step_jit)\n",
        "end_time = time.time()\n",
        "time_taken = end_time - start_time\n",
        "print(f\"Time taken for Euler integration: {time_taken} seconds\")\n",
        "print(f\"Final state: {final_state.round().astype(int)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "53VpsAdkDYAW",
        "outputId": "dbcf6932-cb4e-43b8-ef5d-c5017393fff0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time taken for Euler integration: 0.01573801040649414 seconds\n",
            "Final state: [ 0  0  0  1  1  1  0  1 14 18 10  0 18 18 16  0  1  1  0  1  1  1  1  1\n",
            "  0  0  1  0  0  0  0  0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(final_state[2*n_clauses+ln-1:].round().astype(int))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ky-bF391Dbem",
        "outputId": "37b44eb4-a8b7-48c5-aca7-53b9e33c8c0c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 0 0 1 0 0 0 0 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ln = 8\n",
        "V_funcs = generate_addition_potentials(ln)\n",
        "\n",
        "num1 = [1,1,0,1,1,0,0,1] # 155\n",
        "num2 = [1,0,0,1,0,0,0,0,0] # 260 (rotated right by 1)\n",
        "V_funcs = [lambda v, V_m=V_m: V_m(jnp.concatenate([jnp.array(num1), v, jnp.array(num2)])) for V_m in V_funcs]\n",
        "\n",
        "# Simulation parameters\n",
        "n_vars = 2 * ln - 1\n",
        "n_clauses = len(V_funcs)\n",
        "hyperparams = Hyperparameters(alpha=5, beta=20, gamma=0.05, delta=0.2, epsilon=0.001, zeta=0.1)\n",
        "initial_conditions = initialize_conditions(n_vars, n_clauses)\n",
        "\n",
        "euler_step_jit = make_euler_step(V_funcs)"
      ],
      "metadata": {
        "id": "YqP6kw77DdGf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_time = time.time()\n",
        "final_state = euler_integration(initial_conditions, 1000, 0.1, hyperparams, euler_step_jit)\n",
        "end_time = time.time()\n",
        "time_taken = end_time - start_time\n",
        "print(f\"Time taken for Euler integration: {time_taken} seconds\")\n",
        "print(f\"Final state: {final_state.round().astype(int)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cE_E_wZMDikj",
        "outputId": "ce5fc11f-4276-430d-872a-dd788aa33d07"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time taken for Euler integration: 0.01668715476989746 seconds\n",
            "Final state: [ 0  0  0  0  0  0  1  1  9 13  9 16 12 14 11 16  1  0  0  1  0  1  1  0\n",
            "  1  1  0  1  1  1  1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(final_state[2*n_clauses:2*n_clauses+ln].round().astype(int))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8-bpQVpCD3Ar",
        "outputId": "635b6e42-5f78-4ca9-ebfb-0b83a0433a7c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 0 0 1 0 1 1 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_half_adder_2_coef_lookup_table():\n",
        "    lookup_table = []\n",
        "    for coef1 in [0, 1]:\n",
        "      for coef2 in [0, 1]:\n",
        "        for input1 in [0, 1]:\n",
        "            for input2 in [0, 1]:\n",
        "                sum = (coef1 * input1 + coef2 * input2) % 2\n",
        "                carry = (coef1 * input1 + coef2 * input2) // 2\n",
        "                for sum_out in [0, 1]:\n",
        "                    for carry_out in [0, 1]:\n",
        "                        output_correct = (sum_out == sum and carry_out == carry)\n",
        "                        lookup_table.append((coef1, input1, coef2, input2, sum_out, carry_out, 1 - int(output_correct)))\n",
        "    return lookup_table\n",
        "\n",
        "half_adder_2_coef_V = find_multilinear_function(generate_half_adder_2_coef_lookup_table())\n",
        "\n",
        "def generate_full_adder_2_coef_lookup_table():\n",
        "    lookup_table = []\n",
        "    for coef1 in [0, 1]:\n",
        "      for coef2 in [0, 1]:\n",
        "        for input1 in [0, 1]:\n",
        "            for input2 in [0, 1]:\n",
        "                for carry_in in [0, 1]:\n",
        "                    sum = (coef1 * input1 + coef2 * input2 + carry_in) % 2\n",
        "                    carry = (coef1 * input1 + coef2 * input2 + carry_in) // 2\n",
        "                    for sum_out in [0, 1]:\n",
        "                        for carry_out in [0, 1]:\n",
        "                            output_correct = (sum_out == sum and carry_out == carry)\n",
        "                            lookup_table.append((coef1, input1, coef2, input2, carry_in, sum_out, carry_out, 1 - int(output_correct)))\n",
        "    return lookup_table\n",
        "\n",
        "full_adder_2_coef_V = find_multilinear_function(generate_full_adder_2_coef_lookup_table())\n",
        "\n",
        "def generate_half_adder_1_coef_lookup_table():\n",
        "    lookup_table = []\n",
        "    for coef1 in [0, 1]:\n",
        "        for input1 in [0, 1]:\n",
        "            for input2 in [0, 1]:\n",
        "                sum = (coef1 * input1 + input2) % 2\n",
        "                carry = (coef1 * input1 + input2) // 2\n",
        "                for sum_out in [0, 1]:\n",
        "                    for carry_out in [0, 1]:\n",
        "                        output_correct = (sum_out == sum and carry_out == carry)\n",
        "                        lookup_table.append((coef1, input1, input2, sum_out, carry_out, 1 - int(output_correct)))\n",
        "    return lookup_table\n",
        "\n",
        "half_adder_1_coef_V = find_multilinear_function(generate_half_adder_1_coef_lookup_table())\n",
        "\n",
        "def generate_full_adder_1_coef_lookup_table():\n",
        "    lookup_table = []\n",
        "    for coef1 in [0, 1]:\n",
        "        for input1 in [0, 1]:\n",
        "            for input2 in [0, 1]:\n",
        "                for carry_in in [0, 1]:\n",
        "                    sum = (coef1 * input1 + input2 + carry_in) % 2\n",
        "                    carry = (coef1 * input1 + input2 + carry_in) // 2\n",
        "                    for sum_out in [0, 1]:\n",
        "                        for carry_out in [0, 1]:\n",
        "                            output_correct = (sum_out == sum and carry_out == carry)\n",
        "                            lookup_table.append((coef1, input1, input2, carry_in, sum_out, carry_out, 1 - int(output_correct)))\n",
        "    return lookup_table\n",
        "\n",
        "full_adder_1_coef_V = find_multilinear_function(generate_full_adder_1_coef_lookup_table())\n",
        "\n",
        "def generate_and_lookup_table():\n",
        "    lookup_table = []\n",
        "    for input1 in [0, 1]:\n",
        "        for input2 in [0, 1]:\n",
        "            out = int(input1 & input2)\n",
        "            for and_out in [0, 1]:\n",
        "                    output_correct = (and_out == out)\n",
        "                    lookup_table.append((input1, input2, and_out, 1 - int(output_correct)))\n",
        "    return lookup_table\n",
        "\n",
        "and_V = find_multilinear_function(generate_and_lookup_table())"
      ],
      "metadata": {
        "id": "fKxyj6P8EQ2y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def generate_multiplication_potentials(ln):\n",
        "    potentials = []\n",
        "\n",
        "    # Each potential takes a vector with the following anatomy\n",
        "\n",
        "    # - The first ln bits are the bits of the first input\n",
        "    # - The second ln bits are the bits of the second input.\n",
        "    # - The last bit is the first bit of the output\n",
        "    # - All the remaining entries are the bits of carries and inbetween sums.\n",
        "    #    There should be ln-1 carry-sum pairs, with each having 2 * ln bits, ln for the carries and ln for the sums.\n",
        "\n",
        "    end = 2 * (ln ** 2)\n",
        "    a_start = 0\n",
        "    b_start = ln\n",
        "\n",
        "    # First digit is `and` of first digits of a and b\n",
        "    potentials.append(lambda v: and_V(jnp.array([v[a_start], v[b_start], v[end]])))\n",
        "\n",
        "    # First layer of addition.\n",
        "    # Assume the number's were multiplying are a = [a0, a1, a2, a3] and b = [b0, b1, b2, b3], where the array are the little-endian bits\n",
        "\n",
        "    # first layer of addition is (a0 * [b1, b2. b3]) + (a1 * [b0, b1, b2, b3]), getting the sum [s00, s01, s02, s03, c03]\n",
        "    # where the s's are stored in the sum sub-vector and c13 is the last bit of the carries\n",
        "\n",
        "    carry0_start = b_start + ln\n",
        "    sum0_start = carry0_start + ln\n",
        "\n",
        "    # First addition is half-added b1 and b0, since there is no carry input. Output here is c00 and s00\n",
        "    potentials.append(lambda v: half_adder_2_coef_V(jnp.array([v[a_start], v[b_start+1], v[a_start+1], v[b_start], v[sum0_start], v[carry0_start]])))\n",
        "\n",
        "    for i in range(1, ln - 1):\n",
        "      # Middle additions use a full adder.\n",
        "      potentials.append(lambda v, i=i: full_adder_2_coef_V(jnp.array([v[a_start], v[b_start+i+1], v[a_start+1], v[b_start+i], v[carry0_start+i-1], v[sum0_start+i], v[carry0_start+i]])))\n",
        "\n",
        "    # since the first layer of addition has fewer bits in the first number, the last addition is just between the penultimate carry and b3.\n",
        "    # This allows us to use a half adder, treating the carry input as a regular input.\n",
        "    potentials.append(lambda v: half_adder_1_coef_V(jnp.array([v[a_start+1], v[b_start+ln-1], v[carry0_start+ln-2], v[sum0_start+ln-1], v[carry0_start+ln-1]])))\n",
        "\n",
        "    # Remaining addition layers\n",
        "    for i in range(1, ln - 1):\n",
        "      last_carry_start = carry0_start + (i-1) * 2 * ln\n",
        "      last_sum_start = last_carry_start + ln\n",
        "\n",
        "      carry_start = last_sum_start + ln\n",
        "      sum_start = carry_start + ln\n",
        "\n",
        "      # We start at aidx = 2 since we already used indexes 0 and 1 at the first addition layer\n",
        "      aidx = a_start + i + 1\n",
        "\n",
        "      # subsequent layers of addition is (a(i+1) * [b0, b1, b2. b3]) + [si1, si2, si3, ci3], getting the sum [s(i+1)0, s(i+1)1, s(i+1)2, s(i+1)3, c(i+1)3]\n",
        "      # The first si0 is dropped as it will be part of the final output.\n",
        "\n",
        "      # The first addition at each layer is a half-adder as we have no carry input\n",
        "      potentials.append(lambda v, aidx=aidx, sum_start=sum_start, carry_start=carry_start, last_sum_start=last_sum_start:\n",
        "                        half_adder_1_coef_V(jnp.array([v[aidx], v[b_start], v[last_sum_start+1], v[sum_start], v[carry_start]])))\n",
        "\n",
        "      for j in range(1, ln-1):\n",
        "        bidx = b_start + j\n",
        "        caridx = carry_start + j\n",
        "        lstsumidx = last_sum_start+j+1\n",
        "        sumidx = sum_start + j\n",
        "\n",
        "        # Middle additions are full adders with carry inputs\n",
        "        potentials.append(lambda v, aidx=aidx, bidx=bidx, lstsumidx=lstsumidx, sumidx=sumidx, caridx=caridx:\n",
        "                          full_adder_1_coef_V(jnp.array([v[aidx], v[bidx], v[lstsumidx], v[caridx - 1], v[sumidx], v[caridx]])))\n",
        "\n",
        "      # Final addition of each layer must be modified to get the last carry bit rather than a sum bit\n",
        "      potentials.append(lambda v, aidx=aidx, last_carry_start=last_carry_start, carry_start=carry_start, sum_start=sum_start:\n",
        "                        full_adder_1_coef_V(jnp.array([v[aidx], v[b_start + ln - 1], v[last_carry_start + ln - 1], v[carry_start + ln - 2], v[sum_start + ln - 1], v[carry_start + ln - 1]])))\n",
        "\n",
        "    return potentials\n"
      ],
      "metadata": {
        "id": "-AP6hgMmD97d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ln = 3\n",
        "V_funcs = generate_multiplication_potentials(ln)\n",
        "\n",
        "num1 = jnp.array([1,1,0]) # 3\n",
        "num2 = jnp.array([1,0,1]) # 5\n",
        "V_funcs = [lambda v, V_m=V_m: V_m(jnp.concatenate([jnp.array(num1), jnp.array(num2), v])) for V_m in V_funcs]\n",
        "\n",
        "# Simulation parameters\n",
        "n_vars = 2 * (ln ** 2) + 1 - 2 * ln\n",
        "n_clauses = len(V_funcs)\n",
        "hyperparams = Hyperparameters(alpha=5, beta=20, gamma=0.05, delta=0.1, epsilon=0.001, zeta=0.001)\n",
        "initial_conditions = initialize_conditions(n_vars, n_clauses)\n",
        "\n",
        "euler_step_jit = make_euler_step(V_funcs)"
      ],
      "metadata": {
        "id": "dw7bW9wYEVTc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_time = time.time()\n",
        "final_state = euler_integration(initial_conditions, 100000, 0.1, hyperparams, euler_step_jit)\n",
        "end_time = time.time()\n",
        "time_taken = end_time - start_time\n",
        "print(f\"Time taken for Euler integration: {time_taken} seconds\")\n",
        "print(f\"Final state: {final_state.round().astype(int)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "z_uMUxKrEb7U",
        "outputId": "46ca1355-44d3-46b4-b604-f9fae3332139"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time taken for Euler integration: 0.035463571548461914 seconds\n",
            "Final state: [ 1  0  0  0  0  0  0 26  8 17 15 27 15 23  0  0  0  1  1  1  0  0  0  1\n",
            "  1  0  1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "xs = final_state[2*n_clauses:]\n",
        "print(jnp.concatenate([\n",
        "    jnp.array(xs[2*(ln**2)-2*ln:]),\n",
        "    jnp.array(xs[ln::2*ln]),\n",
        "    jnp.array(xs[2*(ln**2)-3*ln+1:2*(ln**2)-2*ln]),\n",
        "    jnp.array(xs[2*(ln**2)-3*ln-1:2*(ln**2)-3*ln])\n",
        "]).round())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RSH3OY_DEeFd",
        "outputId": "c1aa14e4-5939-41ab-de56-251499f03f5e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1. 1. 1. 1. 0. 0.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ln = 3\n",
        "V_funcs = generate_multiplication_potentials(ln)\n",
        "\n",
        "out = jnp.array([1,1,1,1,0,0]) # 15\n",
        "\n",
        "def make_out(o, x):\n",
        "    out = jnp.array([99.0] * (2 * (ln ** 2) + 1))\n",
        "\n",
        "    out = out.at[:2*ln].set(x[:2*ln])\n",
        "\n",
        "    xs = x[2*ln:]\n",
        "\n",
        "    for i in range(ln):\n",
        "      out = out.at[2*ln+i:2*(ln**2):2*ln].set(xs[i::2*ln-1])\n",
        "\n",
        "    for i in range(ln-1):\n",
        "      out = out.at[2*ln+i+ln+1:2*(ln**2)-ln:2*ln].set(xs[i+ln::2*ln-1])\n",
        "\n",
        "    out = out.at[2 * (ln ** 2)].set(o[0])\n",
        "    out = out.at[2*ln+ln::2*ln].set(o[1:ln])\n",
        "    out = out.at[2*(ln**2)-ln+1:2*(ln**2)].set(o[ln:2*ln-1])\n",
        "    out = out.at[2 * (ln ** 2)-1-ln].set(o[2*ln-1])\n",
        "\n",
        "    return out\n",
        "\n",
        "V_funcs = [lambda v, V_m=V_m: V_m(make_out(out, v)) for V_m in V_funcs]\n",
        "\n",
        "# Simulation parameters\n",
        "n_vars = 2 * (ln ** 2) + 1 - 2 * ln\n",
        "n_clauses = len(V_funcs)\n",
        "hyperparams = Hyperparameters(alpha=5, beta=20, gamma=0.05, delta=0.1, epsilon=0.001, zeta=0.001)\n",
        "initial_conditions = initialize_conditions(n_vars, n_clauses)\n",
        "\n",
        "euler_step_jit = make_euler_step(V_funcs)"
      ],
      "metadata": {
        "id": "iDF9DYYPE4Bw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "hyperparams = Hyperparameters(alpha=5, beta=20, gamma=0.05, delta=0.2, epsilon=0.001, zeta=0.1)\n",
        "start_time = time.time()\n",
        "final_state = euler_integration(initial_conditions, 10000, 0.1, hyperparams, euler_step_jit)\n",
        "end_time = time.time()\n",
        "time_taken = end_time - start_time\n",
        "print(f\"Time taken for Euler integration: {time_taken} seconds\")\n",
        "print(f\"Final state: {final_state.round().astype(int)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XUJpXgcXFvvr",
        "outputId": "ea5919fd-0097-4fb2-fb7a-0e008b5a5fea"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time taken for Euler integration: 0.05929756164550781 seconds\n",
            "Final state: [ 0  1  1  1  0  0  0 24 26 26 26  9 17 11  1  1  0  1  0  1  0  0  0  1\n",
            "  1  0  0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "xs = final_state[2*n_clauses:]\n",
        "print(xs[:ln].round())\n",
        "print(xs[ln:2*ln].round())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NKedL4u6FybX",
        "outputId": "0b931b9a-edda-4f90-db90-90bf1990efd1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1. 1. 0.]\n",
            "[1. 0. 1.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "IP_H9gbBF0Gs"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}