5D_Logic_Particle_(Incomplete_Cohesive_Vectron).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "4da2fa0b64c2447a8800ccd11577c18a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "VBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [
              "widget-interact"
            ],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "VBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "VBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_90255e91bd354c4bab72fd1f12af8566",
              "IPY_MODEL_f9605c0dd57a40e0a894448133d52fab"
            ],
            "layout": "IPY_MODEL_3a1cdfec75284710a588bc2a62577c86"
          }
        },
        "90255e91bd354c4bab72fd1f12af8566": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatSliderModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatSliderModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "FloatSliderView",
            "continuous_update": true,
            "description": "coefficient",
            "description_tooltip": null,
            "disabled": false,
            "layout": "IPY_MODEL_42f1a373d82f4625a79c89e0d032b0b0",
            "max": 10,
            "min": 0.1,
            "orientation": "horizontal",
            "readout": true,
            "readout_format": ".2f",
            "step": 0.1,
            "style": "IPY_MODEL_879bd044e737441fb07ff62e3551def4",
            "value": 1
          }
        },
        "f9605c0dd57a40e0a894448133d52fab": {
          "model_module": "@jupyter-widgets/output",
          "model_name": "OutputModel",
          "model_module_version": "1.0.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/output",
            "_model_module_version": "1.0.0",
            "_model_name": "OutputModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/output",
            "_view_module_version": "1.0.0",
            "_view_name": "OutputView",
            "layout": "IPY_MODEL_c0a6b241185e4264b1f6b0ff386d3b20",
            "msg_id": "",
            "outputs": [
              {
                "output_type": "display_data",
                "data": {
                  "text/plain": "<Figure size 640x480 with 1 Axes>",
                  "image/png": "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\n"
                },
                "metadata": {}
              }
            ]
          }
        },
        "3a1cdfec75284710a588bc2a62577c86": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "42f1a373d82f4625a79c89e0d032b0b0": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "879bd044e737441fb07ff62e3551def4": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "SliderStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "SliderStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": "",
            "handle_color": null
          }
        },
        "c0a6b241185e4264b1f6b0ff386d3b20": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        }
      }
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 601,
          "referenced_widgets": [
            "4da2fa0b64c2447a8800ccd11577c18a",
            "90255e91bd354c4bab72fd1f12af8566",
            "f9605c0dd57a40e0a894448133d52fab",
            "3a1cdfec75284710a588bc2a62577c86",
            "42f1a373d82f4625a79c89e0d032b0b0",
            "879bd044e737441fb07ff62e3551def4",
            "c0a6b241185e4264b1f6b0ff386d3b20"
          ]
        },
        "id": "m9pRLLOUkzdj",
        "outputId": "01d06559-1dc9-47d6-bf58-9cdd4a9bfd55"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/matplotlib/animation.py:884: UserWarning: Animation was deleted without rendering anything. This is most likely not intended. To prevent deletion, assign the Animation to a variable, e.g. `anim`, that exists until you output the Animation using `plt.show()` or `anim.save()`.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "interactive(children=(FloatSlider(value=1.0, description='coefficient', max=10.0, min=0.1), Output()), _dom_cl…"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "4da2fa0b64c2447a8800ccd11577c18a"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<function __main__.interactive_logic_energy(coefficient)>"
            ],
            "text/html": [
              "<div style=\"max-width:800px; border: 1px solid var(--colab-border-color);\"><style>\n",
              "      pre.function-repr-contents {\n",
              "        overflow-x: auto;\n",
              "        padding: 8px 12px;\n",
              "        max-height: 500px;\n",
              "      }\n",
              "\n",
              "      pre.function-repr-contents.function-repr-contents-collapsed {\n",
              "        cursor: pointer;\n",
              "        max-height: 100px;\n",
              "      }\n",
              "    </style>\n",
              "    <pre style=\"white-space: initial; background:\n",
              "         var(--colab-secondary-surface-color); padding: 8px 12px;\n",
              "         border-bottom: 1px solid var(--colab-border-color);\"><b>interactive_logic_energy</b><br/>def interactive_logic_energy(coefficient)</pre><pre class=\"function-repr-contents function-repr-contents-collapsed\" style=\"\"><a class=\"filepath\" style=\"display:none\" href=\"#\">/content/&lt;ipython-input-2-b0417bf1f2e3&gt;</a>&lt;no docstring&gt;</pre></div>"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, FloatSlider\n",
        "\n",
        "# Function to create a decision graph\n",
        "def create_decision_graph(nodes=5):\n",
        "    G = nx.DiGraph()\n",
        "    for i in range(nodes):\n",
        "        G.add_node(i, value=np.random.rand())\n",
        "    for i in range(1, nodes):\n",
        "        G.add_edge(0, i)\n",
        "    return G\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value**2\n",
        "\n",
        "# Interactive visualization function\n",
        "def interactive_logic_energy(coefficient):\n",
        "    G = create_decision_graph()\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots()\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis)\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Energy Number Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# Interactive slider for coefficient\n",
        "interact(interactive_logic_energy, coefficient=FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0))"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Function to generate random network with given number of nodes and edges\n",
        "def generate_random_network(nodes, edges):\n",
        "    G = nx.gnm_random_graph(nodes, edges)\n",
        "    return G\n",
        "\n",
        "# Function to calculate energy based on node degree and coefficient\n",
        "def calculate_energy(degree, coefficient):\n",
        "    return coefficient * degree**2\n",
        "\n",
        "# Interactive visualization function\n",
        "def interactive_physical_energy(coefficient):\n",
        "    G = generate_random_network(10, 20)\n",
        "    energies = [calculate_energy(G.degree[node], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots()\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis)\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    plt.title('Interactive Physical Structure and Energy Number Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# Interactive slider for coefficient\n",
        "interact(interactive_physical_energy, coefficient=FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0))"
      ],
      "metadata": {
        "id": "KKVnWBK7lHDU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Import necessary libraries\n",
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, FloatSlider, IntSlider\n",
        "\n",
        "# Function to create a decision graph\n",
        "def create_decision_graph(nodes=5):\n",
        "    G = nx.DiGraph()\n",
        "    for i in range(nodes):\n",
        "        G.add_node(i, value=np.random.rand())\n",
        "    for i in range(1, nodes):\n",
        "        G.add_edge(0, i)\n",
        "    return G\n",
        "\n",
        "# Function to calculate entropy based on node value and some parameters\n",
        "def calculate_entropy(value, coefficient):\n",
        "    return -value * np.log(value) * coefficient\n",
        "\n",
        "# Interactive visualization function\n",
        "def interactive_logic_entropy(coefficient, nodes):\n",
        "    G = create_decision_graph(nodes)\n",
        "    entropies = [calculate_entropy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots()\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=entropies, cmap=plt.cm.viridis)\n",
        "\n",
        "    # Visualize node entropies\n",
        "    for node, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{entropies[node]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Entropy Number Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# Interactive sliders for coefficient and number of nodes\n",
        "interact(interactive_logic_entropy, coefficient=FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0), nodes=IntSlider(min=5, max=20, step=1, value=10))"
      ],
      "metadata": {
        "id": "kXB6TNamlLEX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, IntSlider, FloatSlider\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "from collections import Counter\n",
        "\n",
        "def sieve_of_eratosthenes(n):\n",
        "    prime_num = [True for i in range(n + 1)]\n",
        "    p = 2\n",
        "    while (p * p <= n):\n",
        "        if (prime_num[p] == True):\n",
        "            for i in range(p * 2, n + 1, p):\n",
        "                prime_num[i] = False\n",
        "        p += 1\n",
        "    prime_numbers = []\n",
        "    for p in range(2, n + 1):\n",
        "        if prime_num[p]:\n",
        "            prime_numbers.append(p)\n",
        "    return prime_numbers\n",
        "\n",
        "def compute_occurrences(max_range):\n",
        "    occurrences_matrix = np.zeros(max_range + 1)\n",
        "    prime_numbers = sieve_of_eratosthenes(max_range)\n",
        "    for i in range(1, max_range + 1):\n",
        "        if i in prime_numbers:\n",
        "            occurrences_matrix[i] = occurrences_matrix[i // 2] + 1\n",
        "        else:\n",
        "            occurrences_matrix[i] = occurrences_matrix[i // 2]\n",
        "    return occurrences_matrix\n",
        "\n",
        "def create_decision_graph(nodes=5):\n",
        "    G = nx.DiGraph()\n",
        "    for i in range(nodes):\n",
        "        G.add_node(i, value=np.random.rand())\n",
        "    for i in range(1, nodes):\n",
        "        G.add_edge(0, i)\n",
        "    return G\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(node_value, coefficient, velocity):\n",
        "    return coefficient * (node_value**2) * (1 + velocity)\n",
        "\n",
        "# Function to calculate phenomenological velocity based on curvature or node value\n",
        "def calculate_velocity(node_value, coefficient):\n",
        "    curvature = coefficient * node_value**2  # Simplified interaction\n",
        "    velocity = np.sqrt(curvature + 1)        # Example function\n",
        "    return velocity\n",
        "\n",
        "# Combined interactive visualization function\n",
        "def interactive_plot(max_range, coefficient):\n",
        "    occurrences_matrix = compute_occurrences(max_range)\n",
        "\n",
        "    # Plot the 3D bar chart for occurrence of prime numbers\n",
        "    fig = plt.figure(figsize=(10, 5))\n",
        "    ax = fig.add_subplot(121, projection='3d')\n",
        "    x_data, y_data = np.meshgrid(range(max_range + 1), [0])\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",
        "    ax.set_xlabel('Number (n)')\n",
        "    ax.set_ylabel('Prime Number')\n",
        "    ax.set_zlabel('Number of Prime Numbers')\n",
        "\n",
        "    # Create and visualize the decision graph\n",
        "    G = create_decision_graph(nodes=max_range + 1)\n",
        "    prime_occurrences = occurrences_matrix[:max_range + 1].sum() / (max_range + 1)\n",
        "\n",
        "    # Normalize the values for visualization\n",
        "    node_values = [prime_occurrences] * (max_range + 1)\n",
        "    velocities = [calculate_velocity(value, coefficient) for value in node_values]\n",
        "    energies = [calculate_energy(node_values[i], coefficient, velocities[i]) for i in range(len(node_values))]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    ax2 = fig.add_subplot(122)\n",
        "    nx.draw(G, pos, ax=ax2, with_labels=True, node_color=energies, cmap=plt.cm.viridis, node_size=500)\n",
        "\n",
        "    # Visualize node energies and velocities\n",
        "    for node, (x, y) in pos.items():\n",
        "        ax2.text(x, y + 0.1, f\"E:{energies[node]:.2f}\\nV:{velocities[node]:.2f}\",\n",
        "                 bbox=dict(facecolor='white', alpha=0.5),\n",
        "                 horizontalalignment='center', fontsize=8)\n",
        "\n",
        "    plt.title('Interactive Prime Number Occurrences and Decision Graph Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# Interactive sliders for max_range and coefficient\n",
        "interact(\n",
        "    interactive_plot,\n",
        "    max_range=IntSlider(min=2, max=100, step=1, value=20, description='Max Range'),\n",
        "    coefficient=FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0, description='Coefficient')\n",
        ")"
      ],
      "metadata": {
        "id": "FcKnR67IlOCS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from ipywidgets import interact, IntSlider, FloatSlider\n",
        "from sklearn.datasets import make_blobs\n",
        "\n",
        "def create_decision_graph(nodes=5):\n",
        "    G = nx.DiGraph()\n",
        "    for i in range(nodes):\n",
        "        G.add_node(i, value=np.random.rand())\n",
        "    for i in range(1, nodes):\n",
        "        G.add_edge(0, i)\n",
        "    return G\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(node_value, coefficient, velocity):\n",
        "    return coefficient * (node_value**2) * (1 + velocity)\n",
        "\n",
        "# Function to calculate phenomenological velocity based on curvature or node value\n",
        "def calculate_velocity(node_value, coefficient):\n",
        "    curvature = coefficient * node_value**2  # Simplified interaction\n",
        "    velocity = np.sqrt(curvature + 1)  # Example function\n",
        "    return velocity\n",
        "\n",
        "# Combined interactive visualization function\n",
        "def interactive_plot(num_samples, centers, max_iter, coefficient):\n",
        "    # Generate data\n",
        "    X, y = make_blobs(n_samples=num_samples, centers=centers, cluster_std=1.0, random_state=1)\n",
        "    data = pd.DataFrame(data=X, columns=['X1', 'X2'])\n",
        "    data['y'] = y\n",
        "\n",
        "    # Calculate centroid of each cluster\n",
        "    centroids = []\n",
        "    for i in range(centers):\n",
        "        centroid = data[data['y'] == i][['X1', 'X2']].mean(axis=0)\n",
        "        centroids.append(list(centroid))\n",
        "\n",
        "    # Create and visualize the decision graph\n",
        "    G = create_decision_graph(nodes=num_samples)\n",
        "    centroid_distances = []\n",
        "    for node in G.nodes():\n",
        "        distances = []\n",
        "        for center in centroids:\n",
        "            distance = np.sqrt(np.sum((data.iloc[node, :2].values - center)**2))\n",
        "            distances.append(distance)\n",
        "        centroid_distances.append(distances)\n",
        "\n",
        "    centroid_distances = np.array(centroid_distances)\n",
        "    node_values = np.sum(np.exp(-centroid_distances), axis=1) / num_samples\n",
        "    velocities = [calculate_velocity(node_values[i], coefficient) for i in range(len(node_values))]\n",
        "    energies = [calculate_energy(node_values[i], coefficient, velocities[i]) for i in range(len(node_values))]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    plt.figure(figsize=(7, 7))\n",
        "    nx.draw(G, pos, with_labels=True, node_color=energies, cmap=plt.cm.viridis, node_size=500)\n",
        "\n",
        "    # Visualize node energies and velocities\n",
        "    for node, (x, y) in pos.items():\n",
        "        plt.text(x, y + 0.1, f\"E:{energies[node]:.2f}\\nV:{velocities[node]:.2f}\",\n",
        "                bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center', fontsize=8)\n",
        "\n",
        "    plt.title('Interactive Decision Graph Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# Interactive sliders for number of samples, number of centers, max iterations and coefficient\n",
        "interact(\n",
        "    interactive_plot,\n",
        "    num_samples=IntSlider(min=2, max=500, step=1, value=100, description='Number of Samples'),\n",
        "    centers=IntSlider(min=2, max=10, step=1, value=5, description='Number of Centers'),\n",
        "    max_iter=IntSlider(min=5, max=100, step=5, value=10, description='Max Iterations'),\n",
        "    coefficient=FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0, description='Coefficient')\n",
        ")"
      ],
      "metadata": {
        "id": "ILCOPuyZlP0y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import networkx as nx\n",
        "import matplotlib.pyplot as plt\n",
        "from ipywidgets import interact, IntSlider, FloatSlider\n",
        "\n",
        "def create_decision_graph(nodes=5):\n",
        "    G = nx.DiGraph()\n",
        "    for i in range(nodes):\n",
        "        G.add_node(i, value=np.random.rand())\n",
        "    for i in range(1, nodes):\n",
        "        G.add_edge(0, i)\n",
        "    return G\n",
        "\n",
        "def calculate_entropy(probabilities):\n",
        "    entropy = 0\n",
        "    for p in probabilities:\n",
        "        if p != 0:\n",
        "            entropy -= p * np.log2(p)\n",
        "    return entropy\n",
        "\n",
        "def calculate_decision_graph_entropy(G):\n",
        "    # Get node values and normalize\n",
        "    node_values = nx.get_node_attributes(G, 'value')\n",
        "    node_values = [x / sum(node_values.values()) for x in node_values.values()]\n",
        "\n",
        "    # Calculate probabilities for each node\n",
        "    probabilities = node_values\n",
        "\n",
        "    # Calculate total entropy\n",
        "    total_entropy = calculate_entropy(probabilities)\n",
        "    return total_entropy\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(node_value, coefficient, velocity):\n",
        "    return coefficient * (node_value**2) * (1 + velocity)\n",
        "\n",
        "# Function to calculate phenomenological velocity based on curvature or node value\n",
        "def calculate_velocity(node_value, coefficient):\n",
        "    curvature = coefficient * node_value**2  # Simplified interaction\n",
        "    velocity = np.sqrt(curvature + 1)  # Example function\n",
        "    return velocity\n",
        "\n",
        "# Combined interactive visualization function\n",
        "def interactive_plot(nodes, coefficient):\n",
        "    G = create_decision_graph(nodes)\n",
        "\n",
        "    # Calculate entropy for original graph\n",
        "    original_entropy = calculate_decision_graph_entropy(G)\n",
        "\n",
        "    # Plot energy and velocity for different coefficient values\n",
        "    coefficients = np.linspace(0.1, 5.0, 50)\n",
        "    energies = []\n",
        "    velocities = []\n",
        "    for coeff in coefficients:\n",
        "        coeff_energies = [calculate_energy(node_value, coeff, calculate_velocity(node_value, coeff)) for node_value in np.linspace(0, 1, nodes)]\n",
        "        coeff_velocities = [calculate_velocity(node_value, coeff) for node_value in np.linspace(0, 1, nodes)]\n",
        "        energies.append(np.mean(coeff_energies))\n",
        "        velocities.append(np.mean(coeff_velocities))\n",
        "\n",
        "    fig = plt.figure(figsize=(10, 5))\n",
        "    ax1 = fig.add_subplot(121)\n",
        "    ax1.plot(coefficients, energies)\n",
        "    ax1.set_xlabel(\"Coefficient\")\n",
        "    ax1.set_ylabel(\"Energy\")\n",
        "    ax1.set_title(\"Energy vs. Coefficient\")\n",
        "\n",
        "    ax2 = fig.add_subplot(122)\n",
        "    ax2.plot(coefficients, velocities)\n",
        "    ax2.set_xlabel(\"Coefficient\")\n",
        "    ax2.set_ylabel(\"Velocity\")\n",
        "    ax2.set_title(\"Phenomenological Velocity vs. Coefficient\")\n",
        "\n",
        "    plt.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "    # Calculate entropy for decision graphs with different coefficient values\n",
        "    entropies = []\n",
        "    for coeff in coefficients:\n",
        "        G = create_decision_graph(nodes)\n",
        "        energies = [calculate_energy(node_value, coeff, calculate_velocity(node_value, coeff)) for node_value in np.linspace(0, 1, nodes)]\n",
        "        velocities = [calculate_velocity(node_value, coeff) for node_value in np.linspace(0, 1, nodes)]\n",
        "        nx.set_node_attributes(G, values={node:energy for node, energy in enumerate(energies)}, name='energy')\n",
        "        nx.set_node_attributes(G, values={node:velocity for node, velocity in enumerate(velocities)}, name='velocity')\n",
        "        entropy = calculate_decision_graph_entropy(G)\n",
        "        entropies.append(entropy)\n",
        "\n",
        "    # Find the coefficient that has the lowest entropy\n",
        "    min_entropy_coefficient = coefficients[np.argmin(entropies)]\n",
        "    min_entropy_value = np.min(entropies)\n",
        "    print(f\"The coefficient with the lowest entropy is approximately: {min_entropy_coefficient:.2f}, with an entropy of {min_entropy_value:.4f}\")\n",
        "\n",
        "    # Plot entropy vs. coefficient\n",
        "    fig = plt.figure(figsize=(10, 5))\n",
        "    ax = fig.add_subplot()\n",
        "    ax.plot(coefficients, entropies)\n",
        "    ax.plot(coefficient, original_entropy, 'ro')\n",
        "    ax.annotate('Original Entropy', xy=(coefficient, original_entropy), xytext=(coefficient, original_entropy + 0.1),\n",
        "                arrowprops=dict(facecolor='black', shrink=0.05))\n",
        "    ax.set_xlabel(\"Coefficient\")\n",
        "    ax.set_ylabel(\"Entropy\")\n",
        "    ax.set_title(\"Entropy vs. Coefficient\")\n",
        "    plt.show()\n",
        "\n",
        "# Interactive sliders for number of nodes and coefficient\n",
        "interact(\n",
        "    interactive_plot,\n",
        "    nodes=IntSlider(min=2, max=20, step=1, value=5, description='Nodes'),\n",
        "    coefficient=FloatSlider(min=0.1, max=5.0, step=0.1, value=1.0, description='Coefficient')\n",
        ")"
      ],
      "metadata": {
        "id": "xmTXfZNblTuR"
      },
      "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 ipywidgets import interact, FloatSlider, IntSlider\n",
        "import networkx as nx\n",
        "from sympy import symbols, Function, simplify, init_printing\n",
        "import itertools\n",
        "import random\n",
        "\n",
        "# Initialize pretty printing for symbolic expressions\n",
        "init_printing()\n",
        "\n",
        "# Defining polynomial and primitive functions for \\mathcal{L}\n",
        "def polynomial_P_sigma_psi(sigma, coeffs, psi):\n",
        "    poly = sum(coeffs[k] * psi ** k for k in range(sigma))\n",
        "    return poly\n",
        "\n",
        "def L_function(psi_iota, tau_psi, alpha_psi, a, b, c):\n",
        "    return a * psi_iota + b * tau_psi + c * tau_psi * psi_iota\n",
        "\n",
        "\n",
        "# Implement the Singleton Channel and Functional Relationship\n",
        "def singleton_channel(weights):\n",
        "    return weights\n",
        "\n",
        "def functional_L(singleton, d_tau_psi, alpha_psi, a, b, c):\n",
        "    psi_0 = symbols('psi_0')\n",
        "    term1 = a * psi_0 * d_tau_psi(psi_0)\n",
        "    term2 = b * d_tau_psi(alpha_psi(psi_0))\n",
        "    term3 = c * d_tau_psi(psi_0) * psi_0\n",
        "    return term1 + term2 + term3\n",
        "\n",
        "\n",
        "# Verifying the Eigenchannel relations\n",
        "def alpha_eigenchannel(a, b, c, d_tau_psi, alpha_psi, tau_psi):\n",
        "    psi_0 = symbols('psi_0')\n",
        "    lhs = a * psi_0 * d_tau_psi(psi_0) + b * tau_psi(psi_0) * d_tau_psi(alpha_psi(psi_0)) + c * tau_psi(psi_0) * psi_0 * d_tau_psi(psi_0)\n",
        "    rhs = (a + b + c) * psi_0 * d_tau_psi(psi_0)\n",
        "    eigen_channel_relation = simplify(lhs - rhs)\n",
        "    return eigen_channel_relation == 0\n",
        "\n",
        "\n",
        "# Search for eigenchannel relationships that hold\n",
        "def search_eigenchannels():\n",
        "    psi_0 = symbols('psi_0')\n",
        "\n",
        "    # Example transformations\n",
        "    transformations = [\n",
        "        (lambda psi: 2 * psi, lambda psi: psi ** 2, lambda psi: psi),\n",
        "        (lambda psi: psi + 1, lambda psi: psi ** 2, lambda psi: psi),\n",
        "        (lambda psi: psi - 1, lambda psi: psi + 1, lambda psi: psi ** 2),\n",
        "        (lambda psi: psi ** 2, lambda psi: psi ** 3, lambda psi: psi)\n",
        "    ]\n",
        "\n",
        "    # Define parameter ranges for a, b, c\n",
        "    param_range = np.linspace(-5, 5, 11)  # Example range [-5, 5] with step size +1\n",
        "    valid_parameters = []\n",
        "\n",
        "    for d_tau_psi, alpha_psi, tau_psi in transformations:\n",
        "        for a, b, c in itertools.product(param_range, repeat=3):\n",
        "            if alpha_eigenchannel(a, b, c, d_tau_psi, alpha_psi, tau_psi):\n",
        "                valid_parameters.append((a, b, c, d_tau_psi(psi_0), alpha_psi(psi_0), tau_psi(psi_0)))\n",
        "\n",
        "    return valid_parameters\n",
        "\n",
        "\n",
        "# Function to create a decision graph\n",
        "def create_decision_graph(nodes=5):\n",
        "    G = nx.DiGraph()\n",
        "    for i in range(nodes):\n",
        "        G.add_node(i, value=np.random.rand())\n",
        "    for i in range(1, nodes):\n",
        "        G.add_edge(0, i)\n",
        "    return G\n",
        "\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value ** 2\n",
        "\n",
        "\n",
        "# Interactive visualization function for logical energy\n",
        "def interactive_logic_energy(coefficient):\n",
        "    G = create_decision_graph()\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots()\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis)\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Energy Number Visualization')\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "# Function to generate random network with a given number of nodes and edges\n",
        "def generate_random_network(nodes, edges):\n",
        "    G = nx.gnm_random_graph(nodes, edges)\n",
        "    return G\n",
        "\n",
        "\n",
        "# Function to calculate energy based on node degree and coefficient\n",
        "def calculate_node_degree_energy(degree, coefficient):\n",
        "    return coefficient * degree ** 2\n",
        "\n",
        "\n",
        "# Function to calculate combined energies from a graph and coefficient\n",
        "def calculate_combined_energy(G, coefficient):\n",
        "    energies = []\n",
        "    for node in G.nodes:\n",
        "        decision_graph = create_decision_graph()\n",
        "        logic_energy = [calculate_energy(decision_graph.nodes[n]['value'], coefficient) for n in decision_graph.nodes]\n",
        "        total_logic_energy = sum(logic_energy)\n",
        "        physical_energy = calculate_node_degree_energy(G.degree[node], coefficient)\n",
        "        combined_energy = physical_energy + total_logic_energy\n",
        "        energies.append(combined_energy)\n",
        "    return energies\n",
        "\n",
        "\n",
        "# Interactive visualization function for combined energies\n",
        "def interactive_combined_energy(coefficient, nodes=10, edges=20):\n",
        "    G = generate_random_network(nodes, edges)\n",
        "    energies = calculate_combined_energy(G, coefficient)\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots()\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis)\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    plt.title('Interactive Combined Energy Visualization')\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "# Main program to search for eigenchannels and visualize them\n",
        "def main():\n",
        "    # Search for valid eigenchannel relations\n",
        "    valid_eigenchannels = search_eigenchannels()\n",
        "\n",
        "    if valid_eigenchannels:\n",
        "        print(\"Valid eigenchannel relationships found:\")\n",
        "        for params in valid_eigenchannels:\n",
        "            print(f\"a = {params[0]}, b = {params[1]}, c = {params[2]}, d_tau_psi = {params[3]}, alpha_psi = {params[4]}, tau_psi = {params[5]}\")\n",
        "    else:\n",
        "        print(\"No valid eigenchannel relationships found.\")\n",
        "\n",
        "    # Interactive visualizations\n",
        "    interact(interactive_logic_energy, coefficient=FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0))\n",
        "    interact(interactive_combined_energy, coefficient=FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0))\n",
        "\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ],
      "metadata": {
        "id": "0FwE8kdNlYWG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, FloatSlider\n",
        "\n",
        "# Define logical transforms with proper LaTeX formatting\n",
        "def logical_transform(label, coef):\n",
        "    # Strip the $ at the start and end of the label if it exists\n",
        "    clean_label = label.strip('$')\n",
        "    # Format the label to avoid nested exponents\n",
        "    if '_' in clean_label or '^' in clean_label:\n",
        "        clean_label = f\"\\\\left({clean_label}\\\\right)\"\n",
        "    new_label = rf\"{clean_label}^{{{coef:.1f}}}\"\n",
        "    # Re-add the $ to mark it as LaTeX\n",
        "    return f\"${new_label}$\"\n",
        "\n",
        "# Function to generate logical network with given transforms and coefficients\n",
        "def generate_logic_network(nodes, coefficients):\n",
        "    G = nx.DiGraph()\n",
        "\n",
        "    # Generate initial spore (seed node)\n",
        "    initial_node = r\"$\\frac{\\forall y \\in \\mathbb{N}, P(y) \\rightarrow Q(y)}{\\Delta}$\"\n",
        "    G.add_node(0, label=initial_node, value=np.random.rand())\n",
        "\n",
        "    # Apply transformations\n",
        "    for i in range(1, nodes):\n",
        "        source_node = np.random.choice(list(G.nodes()))\n",
        "        label = G.nodes[source_node]['label']\n",
        "        new_label = logical_transform(label, coefficients[i % len(coefficients)])\n",
        "\n",
        "        # Verify if the LaTeX string is valid (only for debugging, can skip this later)\n",
        "        try:\n",
        "            from matplotlib.mathtext import MathTextParser\n",
        "            parser = MathTextParser('path')  # Use 'path' as a valid value instead of 'bitmap'\n",
        "            parser.parse(new_label)\n",
        "        except Exception as e:\n",
        "            print(f\"Invalid LaTeX string for node {i}: '{new_label}' - Error: {e}\")\n",
        "            new_label = label  # Keep the old label to avoid breaking the graph\n",
        "\n",
        "        G.add_node(i, label=new_label, value=np.random.rand())\n",
        "        G.add_edge(source_node, i)\n",
        "\n",
        "    return G\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value**2\n",
        "\n",
        "# Interactive visualization function\n",
        "def interactive_logic_energy(coeff_1, coeff_2, coeff_3, coeff_4, nodes=10):\n",
        "    coefficients = [coeff_1, coeff_2, coeff_3, coeff_4]\n",
        "    G = generate_logic_network(nodes, coefficients)\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficients[node % len(coefficients)]) for node in G.nodes()]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots(figsize=(12, 8))  # Adjusted figure size for better visibility\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis, labels=nx.get_node_attributes(G, 'label'))\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node, (x, y) in pos.items():\n",
        "        energy_text = f\"{energies[node]:.2f}\"\n",
        "        ax.text(x, y + 0.1, energy_text, bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    plt.title('Interactive Logic Network and Energy Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# Interactive sliders for coefficients for logical transforms\n",
        "sliders = [\n",
        "    FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0, description=f'Co-ef {i+1}')\n",
        "    for i in range(4)\n",
        "]\n",
        "\n",
        "# Use interact to bind sliders to the interactive function\n",
        "interact(interactive_logic_energy, coeff_1=sliders[0], coeff_2=sliders[1], coeff_3=sliders[2], coeff_4=sliders[3])"
      ],
      "metadata": {
        "id": "Sqt1Sm0BlgSd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, FloatSlider\n",
        "from sympy import symbols, Implies, And, Or, simplify\n",
        "\n",
        "# Define symbolic variables for use in logical expressions\n",
        "y, x, z, P, Q, R, S, T, U = symbols('y x z P Q R S T U')\n",
        "\n",
        "# Define logical expressions using Implies, And, and Or from sympy\n",
        "P_y = Implies(P, Q)\n",
        "R_x_and_S_x = And(R, S)\n",
        "T_z_or_U_z = Or(T, U)\n",
        "\n",
        "# Define transformation functions\n",
        "def T_1_2(expr):\n",
        "    return simplify(expr)\n",
        "\n",
        "def T_1_3(expr):\n",
        "    return expr.subs(y, y + 1)\n",
        "\n",
        "def T_1_4(expr):\n",
        "    return expr.subs(y, y ** 2)\n",
        "\n",
        "def T_1_5(expr):\n",
        "    return expr.subs(y, y - 1)\n",
        "\n",
        "def T_identity(expr):\n",
        "    return expr\n",
        "\n",
        "# Define all the transformations\n",
        "transformations = {\n",
        "    (1, 2): T_1_2,\n",
        "    (1, 3): T_1_3,\n",
        "    (1, 4): T_1_4,\n",
        "    (1, 5): T_1_5,\n",
        "    (2, 1): T_identity,\n",
        "    (2, 3): T_identity,\n",
        "    (2, 4): T_identity,\n",
        "    (2, 5): T_identity,\n",
        "    (3, 1): T_identity,\n",
        "    (3, 2): T_identity,\n",
        "    (3, 4): T_identity,\n",
        "    (3, 5): T_identity,\n",
        "    (4, 1): T_identity,\n",
        "    (4, 2): T_identity,\n",
        "    (4, 3): T_identity,\n",
        "    (4, 5): T_identity,\n",
        "    (5, 1): T_identity,\n",
        "    (5, 2): T_identity,\n",
        "    (5, 3): T_identity,\n",
        "    (5, 4): T_identity\n",
        "}\n",
        "\n",
        "# Example initial logic vector/matrix elements\n",
        "logic_vectors = {\n",
        "    1: P_y,\n",
        "    2: R_x_and_S_x,\n",
        "    3: T_z_or_U_z\n",
        "}\n",
        "\n",
        "# Create a directed graph\n",
        "G = nx.DiGraph()\n",
        "\n",
        "# Add nodes to the graph for each branch\n",
        "num_nodes = 5\n",
        "for i in range(num_nodes):\n",
        "    G.add_node(i, label=f\"B{i+1}\", value=np.random.rand())  # Node labels B1, B2, B3, B4, B5\n",
        "\n",
        "# Add edges using the transformations to represent logic transformations\n",
        "for (i, j) in transformations.keys():\n",
        "    G.add_edge(i-1, j-1, label=f\"T_{i}_{j}\")  # Convert 1-based to 0-based indexing\n",
        "\n",
        "# Initialize the adjacency matrix of symbolic expressions\n",
        "adj_matrix = np.full((num_nodes, num_nodes), None)\n",
        "\n",
        "# Populate the adjacency matrix with logic transformations\n",
        "for (i, j), transform in transformations.items():\n",
        "    expr = logic_vectors.get(i, y)  # Use initial logic vectors if available\n",
        "    try:\n",
        "        adj_matrix[i-1][j-1] = transform(expr)\n",
        "    except Exception as e:\n",
        "        adj_matrix[i-1][j-1] = f\"Error: {e}\"\n",
        "\n",
        "print(\"Adjacency Matrix of Symbolic Expressions:\")\n",
        "for row in adj_matrix:\n",
        "    print(row)\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value**2\n",
        "\n",
        "# Interactive visualization function for logic energy\n",
        "def interactive_logic_energy(coefficient):\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots(figsize=(12, 8))\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis,\n",
        "            labels=nx.get_node_attributes(G, 'label'), node_size=3000, font_size=10, font_weight='bold')\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Energy Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# Interactive slider for coefficient\n",
        "interact(interactive_logic_energy, coefficient=FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0))"
      ],
      "metadata": {
        "id": "TnH-UwBqlj0N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, FloatSlider, Text\n",
        "from sympy import symbols, Implies, And, Or, simplify\n",
        "\n",
        "# Define symbolic variables for use in logical expressions\n",
        "y, x, z, P, Q, R, S, T, U = symbols('y x z P Q R S T U')\n",
        "\n",
        "# Define logical expressions using Implies, And, and Or from sympy\n",
        "P_y = Implies(P, Q)\n",
        "R_x_and_S_x = And(R, S)\n",
        "T_z_or_U_z = Or(T, U)\n",
        "\n",
        "# Define transformation functions\n",
        "def T_1_2(expr):\n",
        "    return simplify(expr)\n",
        "\n",
        "def T_1_3(expr):\n",
        "    return expr.subs(y, y + 1)\n",
        "\n",
        "def T_1_4(expr):\n",
        "    return expr.subs(y, y ** 2)\n",
        "\n",
        "def T_1_5(expr):\n",
        "    return expr.subs(y, y - 1)\n",
        "\n",
        "def T_2_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_2_3(expr):\n",
        "    return simplify(expr * 2)\n",
        "\n",
        "def T_2_4(expr):\n",
        "    return expr.subs(x, x + 2)\n",
        "\n",
        "def T_2_5(expr):\n",
        "    return expr.subs(x, x - 2)\n",
        "\n",
        "def T_3_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_3_2(expr):\n",
        "    return simplify(expr / 2)\n",
        "\n",
        "def T_3_4(expr):\n",
        "    return expr.subs(z, z + 3)\n",
        "\n",
        "def T_3_5(expr):\n",
        "    return expr.subs(z, z - 3)\n",
        "\n",
        "def T_4_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_4_2(expr):\n",
        "    return simplify(expr - 1)\n",
        "\n",
        "def T_4_3(expr):\n",
        "    return expr.subs(y, y + z)\n",
        "\n",
        "def T_4_5(expr):\n",
        "    return expr.subs(x, x - y)\n",
        "\n",
        "def T_5_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_5_2(expr):\n",
        "    return simplify(expr + 1)\n",
        "\n",
        "def T_5_3(expr):\n",
        "    return expr.subs(z, z + x)\n",
        "\n",
        "def T_5_4(expr):\n",
        "    return expr.subs(y, y - z)\n",
        "\n",
        "# Define all the transformations in a dictionary\n",
        "transformations = {\n",
        "    (1, 2): T_1_2,\n",
        "    (1, 3): T_1_3,\n",
        "    (1, 4): T_1_4,\n",
        "    (1, 5): T_1_5,\n",
        "    (2, 1): T_2_1,\n",
        "    (2, 3): T_2_3,\n",
        "    (2, 4): T_2_4,\n",
        "    (2, 5): T_2_5,\n",
        "    (3, 1): T_3_1,\n",
        "    (3, 2): T_3_2,\n",
        "    (3, 4): T_3_4,\n",
        "    (3, 5): T_3_5,\n",
        "    (4, 1): T_4_1,\n",
        "    (4, 2): T_4_2,\n",
        "    (4, 3): T_4_3,\n",
        "    (4, 5): T_4_5,\n",
        "    (5, 1): T_5_1,\n",
        "    (5, 2): T_5_2,\n",
        "    (5, 3): T_5_3,\n",
        "    (5, 4): T_5_4\n",
        "}\n",
        "\n",
        "# Example initial logic vector/matrix elements\n",
        "logic_vectors = {\n",
        "    1: P_y,\n",
        "    2: R_x_and_S_x,\n",
        "    3: T_z_or_U_z,\n",
        "    4: P_y,\n",
        "    5: R_x_and_S_x\n",
        "}\n",
        "\n",
        "# Create a directed graph\n",
        "G = nx.DiGraph()\n",
        "\n",
        "# Add nodes to the graph for each branch\n",
        "num_nodes = 5\n",
        "for i in range(1, num_nodes + 1):\n",
        "    G.add_node(i, label=f\"B{i}\", value=np.random.rand())  # Node labels B1, B2, B3, B4, B5\n",
        "\n",
        "# Add edges using the transformations to represent logic transformations\n",
        "for (i, j) in transformations.keys():\n",
        "    G.add_edge(i, j, label=f\"T_{i}_{j}\")\n",
        "\n",
        "# Initialize the adjacency matrix of symbolic expressions\n",
        "adj_matrix = np.full((num_nodes, num_nodes), None)\n",
        "\n",
        "# Populate the adjacency matrix with logic transformations\n",
        "for (i, j), transform in transformations.items():\n",
        "    expr = logic_vectors.get(i, y)  # Use initial logic vectors if available\n",
        "    try:\n",
        "        adj_matrix[i-1][j-1] = transform(expr)\n",
        "    except Exception as e:\n",
        "        adj_matrix[i-1][j-1] = f\"Error: {e}\"\n",
        "\n",
        "print(\"Adjacency Matrix of Symbolic Expressions:\")\n",
        "for row in adj_matrix:\n",
        "    print(row)\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value**2\n",
        "\n",
        "# Interactive function to update logic expressions and graph dynamically\n",
        "def update_logic_expression(expr_str, source, target):\n",
        "    source = int(source)\n",
        "    target = int(target)\n",
        "    try:\n",
        "        # Safely evaluate the expression string\n",
        "        expr = simplify(eval(expr_str, {'P': P, 'Q': Q, 'R': R, 'S': S, 'T': T, 'U': U, 'Implies': Implies, 'And': And, 'Or': Or, 'symbols': symbols}))\n",
        "        transformations[(source, target)] = lambda _: expr\n",
        "        adj_matrix[source-1][target-1] = expr\n",
        "        if G.has_edge(source, target):\n",
        "            G.edges[(source, target)]['label'] = f\"T_{source}_{target}: {expr}\"\n",
        "    except Exception as e:\n",
        "        adj_matrix[source-1][target-1] = f\"Error: {e}\"\n",
        "        if G.has_edge(source, target):\n",
        "            G.edges[(source, target)]['label'] = f\"Error: {e}\"\n",
        "\n",
        "# Interactive visualization function for logic energy\n",
        "def interactive_logic_energy(coefficient, expr_str, source, target):\n",
        "    update_logic_expression(expr_str, source, target)\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots(figsize=(12, 8))\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis,\n",
        "            labels=nx.get_node_attributes(G, 'label'), node_size=3000, font_size=10, font_weight='bold')\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node_id, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node_id - 1]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    # Add edge labels to visualize the transformation details\n",
        "    edge_labels = nx.get_edge_attributes(G, 'label')\n",
        "    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red')\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Energy Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# Interactive widgets for coefficient and logic expression input\n",
        "coefficient_slider = FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0, description='Coefficient')\n",
        "expression_input = Text(value='P >> Q', description='Logic Expression')\n",
        "source_input = FloatSlider(min=1, max=5, step=1, value=1, description='Source Node')\n",
        "target_input = FloatSlider(min=1, max=5, step=1, value=2, description='Target Node')\n",
        "\n",
        "interact(interactive_logic_energy, coefficient=coefficient_slider, expr_str=expression_input, source=source_input, target=target_input)"
      ],
      "metadata": {
        "id": "aWGsY009lrue"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, FloatSlider, Text\n",
        "from sympy import symbols, Implies, And, Or, simplify\n",
        "\n",
        "# Define symbolic variables for use in logical expressions\n",
        "y, x, z, P, Q, R, S, T, U = symbols('y x z P Q R S T U')\n",
        "\n",
        "# Define logical expressions using Implies, And, and Or from sympy\n",
        "P_y = Implies(P, Q)\n",
        "R_x_and_S_x = And(R, S)\n",
        "T_z_or_U_z = Or(T, U)\n",
        "\n",
        "# Define transformation functions using matrix structure\n",
        "def T_1_2(expr):\n",
        "    return simplify(expr)  # This can simply return the simplified expression for now.\n",
        "\n",
        "def T_1_3(expr):\n",
        "    return expr.subs(y, y + 1)\n",
        "\n",
        "def T_1_4(expr):\n",
        "    return expr.subs(y, y ** 2)\n",
        "\n",
        "def T_1_5(expr):\n",
        "    return expr.subs(y, y - 1)\n",
        "\n",
        "def T_2_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_2_3(expr):\n",
        "    return simplify(expr * 2)\n",
        "\n",
        "def T_2_4(expr):\n",
        "    return expr.subs(x, x + 2)\n",
        "\n",
        "def T_2_5(expr):\n",
        "    return expr.subs(x, x - 2)\n",
        "\n",
        "def T_3_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_3_2(expr):\n",
        "    return simplify(expr / 2)\n",
        "\n",
        "def T_3_4(expr):\n",
        "    return expr.subs(z, z + 3)\n",
        "\n",
        "def T_3_5(expr):\n",
        "    return expr.subs(z, z - 3)\n",
        "\n",
        "def T_4_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_4_2(expr):\n",
        "    return simplify(expr - 1)\n",
        "\n",
        "def T_4_3(expr):\n",
        "    return expr.subs(y, y + z)\n",
        "\n",
        "def T_4_5(expr):\n",
        "    return expr.subs(x, x - y)\n",
        "\n",
        "def T_5_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_5_2(expr):\n",
        "    return simplify(expr + 1)\n",
        "\n",
        "def T_5_3(expr):\n",
        "    return expr.subs(z, z + x)\n",
        "\n",
        "def T_5_4(expr):\n",
        "    return expr.subs(y, y - z)\n",
        "\n",
        "# Define all the transformations in a dictionary\n",
        "transformations = {\n",
        "    (1, 2): T_1_2,\n",
        "    (1, 3): T_1_3,\n",
        "    (1, 4): T_1_4,\n",
        "    (1, 5): T_1_5,\n",
        "    (2, 1): T_2_1,\n",
        "    (2, 3): T_2_3,\n",
        "    (2, 4): T_2_4,\n",
        "    (2, 5): T_2_5,\n",
        "    (3, 1): T_3_1,\n",
        "    (3, 2): T_3_2,\n",
        "    (3, 4): T_3_4,\n",
        "    (3, 5): T_3_5,\n",
        "    (4, 1): T_4_1,\n",
        "    (4, 2): T_4_2,\n",
        "    (4, 3): T_4_3,\n",
        "    (4, 5): T_4_5,\n",
        "    (5, 1): T_5_1,\n",
        "    (5, 2): T_5_2,\n",
        "    (5, 3): T_5_3,\n",
        "    (5, 4): T_5_4\n",
        "}\n",
        "\n",
        "# Example initial logic vector/matrix elements\n",
        "logic_vectors = {\n",
        "    1: P_y,\n",
        "    2: R_x_and_S_x,\n",
        "    3: T_z_or_U_z,\n",
        "    4: P_y,\n",
        "    5: R_x_and_S_x\n",
        "}\n",
        "\n",
        "# Create a directed graph\n",
        "G = nx.DiGraph()\n",
        "\n",
        "# Add nodes to the graph for each branch\n",
        "num_nodes = 5\n",
        "for i in range(1, num_nodes + 1):\n",
        "    G.add_node(i, label=f\"B{i}\", value=np.random.rand())  # Node labels B1, B2, B3, B4, B5\n",
        "\n",
        "# Add edges using the transformations to represent logic transformations\n",
        "for (i, j) in transformations.keys():\n",
        "    G.add_edge(i, j, label=f\"T_{i}_{j}\")\n",
        "\n",
        "# Initialize the adjacency matrix of symbolic expressions\n",
        "adj_matrix = np.full((num_nodes, num_nodes), None)\n",
        "\n",
        "# Populate the adjacency matrix with logic transformations\n",
        "for (i, j), transform in transformations.items():\n",
        "    expr = logic_vectors.get(i, y)  # Use initial logic vectors if available\n",
        "    try:\n",
        "        adj_matrix[i-1][j-1] = transform(expr)\n",
        "    except Exception as e:\n",
        "        adj_matrix[i-1][j-1] = f\"Error: {e}\"\n",
        "\n",
        "print(\"Adjacency Matrix of Symbolic Expressions:\")\n",
        "for row in adj_matrix:\n",
        "    print(row)\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value**2\n",
        "\n",
        "# Interactive function to update logic expressions and graph dynamically\n",
        "def update_logic_expression(expr_str, source, target):\n",
        "    source = int(source)\n",
        "    target = int(target)\n",
        "    try:\n",
        "        # Safely evaluate the expression string\n",
        "        expr = simplify(eval(expr_str, {'P': P, 'Q': Q, 'R': R, 'S': S, 'T': T, 'U': U, 'Implies': Implies, 'And': And, 'Or': Or, 'symbols': symbols}))\n",
        "        transformations[(source, target)] = lambda _: expr\n",
        "        adj_matrix[source-1][target-1] = expr\n",
        "        if G.has_edge(source, target):\n",
        "            G.edges[(source, target)]['label'] = f\"T_{source}_{target}: {expr}\"\n",
        "    except Exception as e:\n",
        "        adj_matrix[source-1][target-1] = f\"Error: {e}\"\n",
        "        if G.has_edge(source, target):\n",
        "            G.edges[(source, target)]['label'] = f\"Error: {e}\"\n",
        "\n",
        "# Interactive visualization function for logic energy\n",
        "def interactive_logic_energy(coefficient, expr_str, source, target):\n",
        "    update_logic_expression(expr_str, source, target)\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots(figsize=(12, 8))\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis,\n",
        "            labels=nx.get_node_attributes(G, 'label'), node_size=3000, font_size=10, font_weight='bold')\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node_id, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node_id - 1]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    # Add edge labels to visualize the transformation details\n",
        "    edge_labels = nx.get_edge_attributes(G, 'label')\n",
        "    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red')\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Energy Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# New matrices for richer transformation handling\n",
        "coefficient_slider = FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0, description='Coefficient')\n",
        "expression_input = Text(value='P >> Q', description='Logic Expression')\n",
        "source_input = FloatSlider(min=1, max=5, step=1, value=1, description='Source Node')\n",
        "target_input = FloatSlider(min=1, max=5, step=1, value=2, description='Target Node')\n",
        "\n",
        "interact(interactive_logic_energy, coefficient=coefficient_slider, expr_str=expression_input, source=source_input, target=target_input)"
      ],
      "metadata": {
        "id": "srgh5LYHlury"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Function to create a decision graph\n",
        "def create_decision_graph(nodes=5):\n",
        "    G = nx.DiGraph()\n",
        "    for i in range(nodes):\n",
        "        G.add_node(i, label=f\"B{i}\", value=np.random.rand())\n",
        "    for i in range(1, nodes):\n",
        "        G.add_edge(0, i, label=f\"T{0}{i}\")\n",
        "    return G\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value**2\n",
        "\n",
        "# Function to parse and evaluate logical expressions\n",
        "def parse_expression(expr_str):\n",
        "    try:\n",
        "        expr = eval(expr_str, {'P': P, 'Q': Q, 'R': R, 'S': S, 'T': T, 'U': U, 'And': And, 'Or': Or, 'Not': Not})\n",
        "        return expr\n",
        "    except Exception as e:\n",
        "        return f\"Error: {e}\"\n",
        "\n",
        "# Interactive visualization function for logic energy\n",
        "def interactive_logic_energy(coefficient, expr_str):\n",
        "    G = create_decision_graph()\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    # Update edge labels based on the logical expression\n",
        "    for edge in G.edges:\n",
        "        # Extract the source and target nodes\n",
        "        source, target = edge\n",
        "\n",
        "        # Parse and evaluate the expression\n",
        "        expr = parse_expression(expr_str)\n",
        "        if expr != None:\n",
        "            G.edges[edge]['label'] = f\"T{source}{target}: {expr}\"\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots(figsize=(12, 8))\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis,\n",
        "            labels=nx.get_node_attributes(G, 'label'), node_size=3000, font_size=10, font_weight='bold')\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node_id, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node_id]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    # Add edge labels to visualize the transformation details\n",
        "    edge_labels = nx.get_edge_attributes(G, 'label')\n",
        "    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red', font_size=10)\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Energy Number Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# New slider for coefficient and text input for expressions\n",
        "coefficient_slider = FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0, description='Coefficient')\n",
        "expression_input = Text(value='P >> Q', description='Logic Expression')\n",
        "\n",
        "interact(interactive_logic_energy, coefficient=coefficient_slider, expr_str=expression_input)"
      ],
      "metadata": {
        "id": "_2WNp-0Ilxr_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, FloatSlider, Text, SelectMultiple\n",
        "from sympy import symbols, Implies, And, Or, Not, simplify, Function\n",
        "\n",
        "# Define symbolic variables for use in logical expressions\n",
        "y, x, z, P, Q, R, S = symbols('y x z P Q R S')\n",
        "\n",
        "# Define logical expressions using Implies, And, Or, Not from sympy\n",
        "P_y = Implies(P, Q)\n",
        "R_x_and_S_x = And(R, S)\n",
        "\n",
        "# Logical functions for higher-order constructs\n",
        "nabla = Function('∇')\n",
        "partial = Function('∂')\n",
        "\n",
        "# Define transformation functions to handle different logical constructs\n",
        "def T_1_2(expr):\n",
        "    return simplify(expr)\n",
        "\n",
        "def T_2_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_1_3(expr):\n",
        "    return expr.subs(y, y + 1)\n",
        "\n",
        "def T_3_1(expr):\n",
        "    return expr.subs(y, y - 1)\n",
        "\n",
        "def T_1_4(expr):\n",
        "    return expr.subs(y, y**2)\n",
        "\n",
        "def T_4_1(expr):\n",
        "    return expr.subs(y, y**(1/2))\n",
        "\n",
        "def T_1_5(expr):\n",
        "    return expr.subs(y, y - 1)\n",
        "\n",
        "def T_5_1(expr):\n",
        "    return expr\n",
        "\n",
        "def T_2_3(expr):\n",
        "    return simplify(expr * 2)\n",
        "\n",
        "def T_3_2(expr):\n",
        "    return simplify(expr / 2)\n",
        "\n",
        "def T_2_4(expr):\n",
        "    return expr.subs(x, x + 2)\n",
        "\n",
        "def T_4_2(expr):\n",
        "    return expr.subs(x, x - 2)\n",
        "\n",
        "def T_3_4(expr):\n",
        "    return expr.subs(z, z + 3)\n",
        "\n",
        "def T_4_3(expr):\n",
        "    return expr.subs(z, z - 3)\n",
        "\n",
        "def T_3_5(expr):\n",
        "    return expr.subs(z, z - 1)\n",
        "\n",
        "def T_5_3(expr):\n",
        "    return expr.subs(z, z + 1)\n",
        "\n",
        "def T_4_5(expr):\n",
        "    return simplify(expr - R)\n",
        "\n",
        "def T_5_4(expr):\n",
        "    return simplify(expr + R)\n",
        "\n",
        "# Define all the transformations in a dictionary\n",
        "transformations = {\n",
        "    (1, 2): T_1_2,\n",
        "    (2, 1): T_2_1,\n",
        "    (1, 3): T_1_3,\n",
        "    (3, 1): T_3_1,\n",
        "    (1, 4): T_1_4,\n",
        "    (4, 1): T_4_1,\n",
        "    (1, 5): T_1_5,\n",
        "    (5, 1): T_5_1,\n",
        "    (2, 3): T_2_3,\n",
        "    (3, 2): T_3_2,\n",
        "    (2, 4): T_2_4,\n",
        "    (4, 2): T_4_2,\n",
        "    (3, 4): T_3_4,\n",
        "    (4, 3): T_4_3,\n",
        "    (3, 5): T_3_5,\n",
        "    (5, 3): T_5_3,\n",
        "    (4, 5): T_4_5,\n",
        "    (5, 4): T_5_4\n",
        "}\n",
        "\n",
        "# Example initial logic vector/matrix elements\n",
        "logic_vectors = {\n",
        "    1: P_y,\n",
        "    2: R_x_and_S_x,\n",
        "    3: T_z_or_U_z,\n",
        "    4: P_y,\n",
        "    5: R_x_and_S_x\n",
        "}\n",
        "\n",
        "# Create a directed graph\n",
        "G = nx.DiGraph()\n",
        "\n",
        "# Add nodes to the graph for each branch\n",
        "num_nodes = 5\n",
        "for i in range(1, num_nodes + 1):\n",
        "    G.add_node(i, label=f\"B{i}\", value=np.random.rand())  # Node labels B1, B2, B3, B4, B5\n",
        "\n",
        "# Add edges using the transformations to represent logic transformations\n",
        "for (i, j) in transformations.keys():\n",
        "    G.add_edge(i, j, label=f\"T_{i}_{j}\")\n",
        "\n",
        "# Initialize the adjacency matrix of symbolic expressions\n",
        "adj_matrix = np.full((num_nodes, num_nodes), None)\n",
        "\n",
        "# Populate the adjacency matrix with logic transformations\n",
        "for (i, j), transform in transformations.items():\n",
        "    expr = logic_vectors.get(i, y)  # Use initial logic vectors if available\n",
        "    try:\n",
        "        adj_matrix[i-1][j-1] = transform(expr)\n",
        "    except Exception as e:\n",
        "        adj_matrix[i-1][j-1] = f\"Error: {e}\"\n",
        "\n",
        "print(\"Adjacency Matrix of Symbolic Expressions:\")\n",
        "for row in adj_matrix:\n",
        "    print(row)\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value**2\n",
        "\n",
        "# Function to parse and evaluate logic expressions\n",
        "def parse_expression(expr_str):\n",
        "    try:\n",
        "        # Safe evaluation of logic expressions\n",
        "        expr = simplify(eval(expr_str, {'P': P, 'Q': Q, 'R': R, 'S': S, 'T': T, 'U': U, 'Implies': Implies, 'And': And, 'Or': Or, 'Not': Not, 'nabla': nabla, 'partial': partial}))\n",
        "        return expr\n",
        "    except Exception as e:\n",
        "        return f\"Error: {e}\"\n",
        "\n",
        "# Interactive function to update logic expressions and graph dynamically\n",
        "def update_logic_expression(expr_str, source, target):\n",
        "    source = int(source)\n",
        "    target = int(target)\n",
        "    expr = parse_expression(expr_str)\n",
        "    transformations[(source, target)] = lambda _: expr\n",
        "    adj_matrix[source-1][target-1] = expr\n",
        "    if G.has_edge(source, target):\n",
        "        G.edges[(source, target)]['label'] = f\"T_{source}_{target}: {expr}\"\n",
        "\n",
        "# Interactive function to select logic vectors to use as initial values\n",
        "def update_logic_vectors(selected_vectors):\n",
        "    global logic_vectors\n",
        "    logic_vectors = {int(key): value for key, value in logic_vectors.items() if int(key) in selected_vectors}\n",
        "    print(f\"Using logic vectors: {selected_vectors}\")\n",
        "\n",
        "# Interactive visualization function for logic energy\n",
        "def interactive_logic_energy(coefficient, expr_str, source, target, initial_vectors):\n",
        "    update_logic_expression(expr_str, source, target)\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots(figsize=(12, 8))\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis,\n",
        "            labels=nx.get_node_attributes(G, 'label'), node_size=3000, font_size=10, font_weight='bold')\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node_id, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node_id - 1]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    # Add edge labels to visualize the transformation details\n",
        "    edge_labels = nx.get_edge_attributes(G, 'label')\n",
        "    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red')\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Energy Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# New matrices for richer transformation handling\n",
        "coefficient_slider = FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0, description='Coefficient')\n",
        "expression_input = Text(value='P >> Q', description='Logic Expression')\n",
        "source_input = FloatSlider(min=1, max=5, step=1, value=1, description='Source Node')\n",
        "target_input = FloatSlider(min=1, max=5, step=1, value=2, description='Target Node')\n",
        "initial_vectors_input = SelectMultiple(options=[('Vector B1', 1), ('Vector B2', 2), ('Vector B3', 3), ('Vector B4', 4), ('Vector B5', 5)],\n",
        "                                        value=(1, 2, 3, 4, 5), rows=5, description='Initial Vectors')\n",
        "\n",
        "# Interactive widgets to update graph and expressions\n",
        "interact(update_logic_vectors, selected_vectors=initial_vectors_input)\n",
        "interact(interactive_logic_energy, coefficient=coefficient_slider, expr_str=expression_input, source=source_input, target=target_input, initial_vectors=initial_vectors_input)"
      ],
      "metadata": {
        "id": "wXG1b64Xl4W0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import networkx as nx\n",
        "import numpy as np\n",
        "from ipywidgets import interact, FloatSlider, Text\n",
        "from sympy import symbols, Implies, And, Or, simplify, Not\n",
        "\n",
        "# Define symbolic variables for use in logical expressions\n",
        "y, x, z, P, Q, R, S, T, U = symbols('y x z P Q R S T U')\n",
        "\n",
        "# Define logical expressions using Implies, And, Or, and Not from sympy\n",
        "P_y = Implies(P, Q)\n",
        "R_x_and_S_x = And(R, S)\n",
        "T_z_or_U_z = Or(T, U)\n",
        "\n",
        "# Define transformation functions using matrix structure\n",
        "def T_1_2(expr):\n",
        "    return simplify(Not(expr))  # Example transformation for not operation\n",
        "\n",
        "def T_1_3(expr):\n",
        "    return simplify(expr.subs(y, y + 1))  # Increment y in expressions\n",
        "\n",
        "def T_1_4(expr):\n",
        "    return simplify(expr.subs(y, y ** 2))  # Square the variable y\n",
        "\n",
        "def T_1_5(expr):\n",
        "    return simplify(expr.subs(y, y - 1))  # Decrement y in expressions\n",
        "\n",
        "def T_2_1(expr):\n",
        "    return expr  # Identity transformation\n",
        "\n",
        "def T_2_3(expr):\n",
        "    return simplify(expr * 2)  # Scaling transformation\n",
        "\n",
        "def T_2_4(expr):\n",
        "    return simplify(expr.subs(x, x + 2))  # Increment x in expressions\n",
        "\n",
        "def T_2_5(expr):\n",
        "    return simplify(expr.subs(x, x - 2))  # Decrement x in expressions\n",
        "\n",
        "def T_3_1(expr):\n",
        "    return expr  # Identity transformation\n",
        "\n",
        "def T_3_2(expr):\n",
        "    return simplify(expr / 2)  # Scaling transformation\n",
        "\n",
        "def T_3_4(expr):\n",
        "    return simplify(expr.subs(z, z + 3))  # Increment z in expressions\n",
        "\n",
        "def T_3_5(expr):\n",
        "    return simplify(expr.subs(z, z - 3))  # Decrement z in expressions\n",
        "\n",
        "def T_4_1(expr):\n",
        "    return expr  # Identity transformation\n",
        "\n",
        "def T_4_2(expr):\n",
        "    return simplify(expr - 1)  # Subtract constant transformation\n",
        "\n",
        "def T_4_3(expr):\n",
        "    return simplify(expr.subs(y, y + z))  # Mixed variable transformation\n",
        "\n",
        "def T_4_5(expr):\n",
        "    return simplify(expr.subs(x, x - y))  # Mixed variable transformation\n",
        "\n",
        "def T_5_1(expr):\n",
        "    return expr  # Identity transformation\n",
        "\n",
        "def T_5_2(expr):\n",
        "    return simplify(expr + 1)  # Add constant transformation\n",
        "\n",
        "def T_5_3(expr):\n",
        "    return simplify(expr.subs(z, z + x))  # Mixed variable transformation\n",
        "\n",
        "def T_5_4(expr):\n",
        "    return simplify(expr.subs(y, y - z))  # Mixed variable transformation\n",
        "\n",
        "# Define all the transformations in a dictionary\n",
        "transformations = {\n",
        "    (1, 2): T_1_2,\n",
        "    (1, 3): T_1_3,\n",
        "    (1, 4): T_1_4,\n",
        "    (1, 5): T_1_5,\n",
        "    (2, 1): T_2_1,\n",
        "    (2, 3): T_2_3,\n",
        "    (2, 4): T_2_4,\n",
        "    (2, 5): T_2_5,\n",
        "    (3, 1): T_3_1,\n",
        "    (3, 2): T_3_2,\n",
        "    (3, 4): T_3_4,\n",
        "    (3, 5): T_3_5,\n",
        "    (4, 1): T_4_1,\n",
        "    (4, 2): T_4_2,\n",
        "    (4, 3): T_4_3,\n",
        "    (4, 5): T_4_5,\n",
        "    (5, 1): T_5_1,\n",
        "    (5, 2): T_5_2,\n",
        "    (5, 3): T_5_3,\n",
        "    (5, 4): T_5_4\n",
        "}\n",
        "\n",
        "# Example initial logic vector/matrix elements\n",
        "logic_vectors = {\n",
        "    1: P_y,\n",
        "    2: R_x_and_S_x,\n",
        "    3: T_z_or_U_z,\n",
        "    4: P_y,\n",
        "    5: R_x_and_S_x\n",
        "}\n",
        "\n",
        "# Create a directed graph\n",
        "G = nx.DiGraph()\n",
        "\n",
        "# Add nodes to the graph for each branch\n",
        "num_nodes = 5\n",
        "for i in range(1, num_nodes + 1):\n",
        "    G.add_node(i, label=f\"B{i}\", value=np.random.rand())  # Node labels B1, B2, B3, B4, B5\n",
        "\n",
        "# Add edges using the transformations to represent logic transformations\n",
        "for (i, j) in transformations.keys():\n",
        "    G.add_edge(i, j, label=f\"T_{i}_{j}\")\n",
        "\n",
        "# Initialize the adjacency matrix of symbolic expressions\n",
        "adj_matrix = np.full((num_nodes, num_nodes), None)\n",
        "\n",
        "# Populate the adjacency matrix with logic transformations\n",
        "for (i, j), transform in transformations.items():\n",
        "    expr = logic_vectors.get(i, y)  # Use initial logic vectors if available\n",
        "    try:\n",
        "        adj_matrix[i-1][j-1] = transform(expr)\n",
        "    except Exception as e:\n",
        "        adj_matrix[i-1][j-1] = f\"Error: {e}\"\n",
        "\n",
        "print(\"Adjacency Matrix of Symbolic Expressions:\")\n",
        "for row in adj_matrix:\n",
        "    print(row)\n",
        "\n",
        "# Function to calculate energy based on node value and some parameters\n",
        "def calculate_energy(value, coefficient):\n",
        "    return coefficient * value**2\n",
        "\n",
        "# Interactive function to update logic expressions and graph dynamically\n",
        "def update_logic_expression(expr_str, source, target):\n",
        "    source = int(source)\n",
        "    target = int(target)\n",
        "    try:\n",
        "        # Safely evaluate the expression string\n",
        "        expr = simplify(eval(expr_str, {'P': P, 'Q': Q, 'R': R, 'S': S, 'T': T, 'U': U, 'Implies': Implies, 'And': And, 'Or': Or, 'Not': Not, 'symbols': symbols}))\n",
        "        transformations[(source, target)] = lambda _: expr\n",
        "        adj_matrix[source-1][target-1] = expr\n",
        "        if G.has_edge(source, target):\n",
        "            G.edges[(source, target)]['label'] = f\"T_{source}_{target}: {expr}\"\n",
        "    except Exception as e:\n",
        "        adj_matrix[source-1][target-1] = f\"Error: {e}\"\n",
        "        if G.has_edge(source, target):\n",
        "            G.edges[(source, target)]['label'] = f\"Error: {e}\"\n",
        "\n",
        "# Interactive visualization function for logic energy\n",
        "def interactive_logic_energy(coefficient, expr_str, source, target):\n",
        "    update_logic_expression(expr_str, source, target)\n",
        "    energies = [calculate_energy(G.nodes[node]['value'], coefficient) for node in G.nodes]\n",
        "\n",
        "    pos = nx.spring_layout(G)\n",
        "    fig, ax = plt.subplots(figsize=(12, 8))\n",
        "    nx.draw(G, pos, ax=ax, with_labels=True, node_color=energies, cmap=plt.cm.viridis,\n",
        "            labels=nx.get_node_attributes(G, 'label'), node_size=3000, font_size=10, font_weight='bold')\n",
        "\n",
        "    # Visualize node energies\n",
        "    for node_id, (x, y) in pos.items():\n",
        "        ax.text(x, y + 0.1, f\"{energies[node_id - 1]:.2f}\", bbox=dict(facecolor='white', alpha=0.5), horizontalalignment='center')\n",
        "\n",
        "    # Add edge labels to visualize the transformation details\n",
        "    edge_labels = nx.get_edge_attributes(G, 'label')\n",
        "    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_color='red')\n",
        "\n",
        "    plt.title('Interactive Logical Structure and Energy Visualization')\n",
        "    plt.show()\n",
        "\n",
        "# New matrices for richer transformation handling\n",
        "coefficient_slider = FloatSlider(min=0.1, max=10.0, step=0.1, value=1.0, description='Coefficient')\n",
        "expression_input = Text(value='P >> Q', description='Logic Expression')\n",
        "source_input = FloatSlider(min=1, max=5, step=1, value=1, description='Source Node')\n",
        "target_input = FloatSlider(min=1, max=5, step=1, value=2, description='Target Node')\n",
        "\n",
        "interact(interactive_logic_energy, coefficient=coefficient_slider, expr_str=expression_input, source=source_input, target=target_input)"
      ],
      "metadata": {
        "id": "q39tZj4Gl6z2"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}