app.py

import gradio as gr

# Formulas for the indices (written in a typical mathematical style)
formulas = {
"Wiener Index (W)": "W = Σ d(u,v) for all pairs (u,v)",
"First Zagreb Index (M₁)": "M₁ = Σ [d(v)]² for all vertices v",
"Second Zagreb Index (M₂)": "M₂ = Σ [d(u) * d(v)] for all adjacent vertices (u,v)",
"Randić Index (R)": "R = Σ [1 / √(d(u) * d(v))] for all edges (u,v)",
"Balaban Index (J)": "J = (m / (q + 1)) Σ [1 / √(d(u) * d(v))]",
"Harary Index (H)": "H = Σ [1 / d(u,v)] for all pairs (u,v)",
"Atom-Bond Connectivity Index (ABC)": "ABC = Σ [(√d(u) + √d(v))/(d(u) + d(v))] for all edges (u,v)",
"Geometric Arithmetic Index (GA)": "GA = Σ [√(d(u) * d(v))] for all edges (u,v)",
"Harmonic Index (Harm)": "Harm = Σ [1 / d(v)] for all vertices v"
}

def solve_index(index, user_input):
try:
if index == "Wiener Index (W)":
distances = list(map(int, user_input.split(',')))
result = sum(distances)
steps = [
"1. **Extract the shortest path distances:**\n - Distances = " + f"{distances}",
"2. **Sum the distances:**\n - W = " + " + ".join(map(str, distances)) + f" = {result}"
]
output = "### **Wiener Index (W)**\n\n"
output += "**Formula:**\n" + formulas["Wiener Index (W)"] + "\n"
output += "Where d(u,v) is the shortest path distance between vertices u and v.\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The Wiener Index W = {result}."
return output

elif index == "First Zagreb Index (M₁)":
degrees = list(map(int, user_input.split(',')))
squared_degrees = [d**2 for d in degrees]
result = sum(squared_degrees)
steps = [
"1. **Retrieve the vertex degrees:**\n - Degrees = " + f"{degrees}",
"2. **Square each degree:**\n - Squared degrees = " + f"{squared_degrees}",
"3. **Sum the squared degrees:**\n - M₁ = " + " + ".join(map(str, squared_degrees)) + f" = {result}"
]
output = "### **First Zagreb Index (M₁)**\n\n"
output += "**Formula:**\n" + formulas["First Zagreb Index (M₁)"] + "\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The First Zagreb Index M₁ = {result}."
return output

elif index == "Second Zagreb Index (M₂)":
adj_degrees = [tuple(map(int, pair.split('-'))) for pair in user_input.split(',')]
products = [d1 * d2 for d1, d2 in adj_degrees]
result = sum(products)
steps = [
"1. **Extract the degree pairs for adjacent vertices:**\n - Pairs = " + f"{adj_degrees}",
"2. **Multiply each pair:**\n - Products = " + f"{products}",
"3. **Sum the products:**\n - M₂ = " + " + ".join(map(str, products)) + f" = {result}"
]
output = "### **Second Zagreb Index (M₂)**\n\n"
output += "**Formula:**\n" + formulas["Second Zagreb Index (M₂)"] + "\n"
output += "Where d(u) and d(v) are the degrees of adjacent vertices u and v.\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The Second Zagreb Index M₂ = {result}."
return output

elif index == "Randić Index (R)":
edge_degrees = [tuple(map(int, pair.split('-'))) for pair in user_input.split(',')]
values = [1 / (d1 * d2) ** 0.5 for d1, d2 in edge_degrees]
result = sum(values)
steps = [
"1. **Extract the degree pairs for each edge:**\n - Edge pairs = " + f"{edge_degrees}"
]
for (d1, d2), v in zip(edge_degrees, values):
steps.append(f"2. **For edge {d1}-{d2}:**\n - 1/√({d1}×{d2}) = {v:.4f}")
steps.append("3. **Sum the values:**\n - R = " + " + ".join(f"{v:.4f}" for v in values) + f" = {result:.4f}")
output = "### **Randić Index (R)**\n\n"
output += "**Formula:**\n" + formulas["Randić Index (R)"] + "\n"
output += "Where the sum is taken over all edges (u,v) and d(u) and d(v) are their degrees.\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The Randić Index R = {result:.4f}."
return output

elif index == "Balaban Index (J)":
parts = user_input.split(';')
if len(parts) < 3:
return "Invalid input format. Use m;q;edge pairs like 6;4;2-3,3-4."
m = int(parts[0])
q = int(parts[1])
edge_degrees = [tuple(map(int, pair.split('-'))) for pair in parts[2].split(',')]
values = [1 / (d1 * d2) ** 0.5 for d1, d2 in edge_degrees]
numerator = sum(values)
result = (m / (q + 1)) * numerator
steps = [
"1. **Extract parameters and edge pairs:**",
f" - m = {m}, q = {q}",
f" - Edge pairs = {edge_degrees}"
]
for (d1, d2), v in zip(edge_degrees, values):
steps.append(f"2. **For edge {d1}-{d2}:**\n - 1/√({d1}×{d2}) = {v:.4f}")
steps.append("3. **Sum the computed values:**\n - Sum = " + f"{numerator:.4f}")
steps.append("4. **Multiply by m/(q+1):**\n - J = ({m}/({q}+1)) × {numerator:.4f} = {result:.4f}")
output = "### **Balaban Index (J)**\n\n"
output += "**Formula:**\n" + formulas["Balaban Index (J)"] + "\n"
output += "Where m and q are given parameters and the sum is taken over all edges.\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The Balaban Index J = {result:.4f}."
return output

elif index == "Harary Index (H)":
distances = list(map(int, user_input.split(',')))
values = [1 / d for d in distances if d > 0]
result = sum(values)
steps = [
"1. **Extract the shortest path distances:**\n - Distances = " + f"{distances}"
]
for d, v in zip(distances, values):
steps.append(f"2. **For distance {d}:**\n - 1/{d} = {v:.4f}")
steps.append("3. **Sum the reciprocals:**\n - H = " + " + ".join(f"{v:.4f}" for v in values) + f" = {result:.4f}")
output = "### **Harary Index (H)**\n\n"
output += "**Formula:**\n" + formulas["Harary Index (H)"] + "\n"
output += "Where d(u,v) is the shortest path distance between vertices u and v.\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The Harary Index H = {result:.4f}."
return output

elif index == "Atom-Bond Connectivity Index (ABC)":
edge_degrees = [tuple(map(int, pair.split('-'))) for pair in user_input.split(',')]
values = [ ( (d1**0.5 + d2**0.5) / (d1 + d2) ) for d1, d2 in edge_degrees ]
result = sum(values)
steps = [
"1. **Extract the edge pairs:**\n - Pairs = " + f"{edge_degrees}"
]
for (d1, d2), v in zip(edge_degrees, values):
steps.append(f"2. **For edge {d1}-{d2}:**\n - (√{d1} + √{d2})/( {d1} + {d2} ) = {v:.4f}")
steps.append("3. **Sum the values:**\n - ABC = " + " + ".join(f"{v:.4f}" for v in values) + f" = {result:.4f}")
output = "### **Atom-Bond Connectivity Index (ABC)**\n\n"
output += "**Formula:**\n" + formulas["Atom-Bond Connectivity Index (ABC)"] + "\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The ABC Index = {result:.4f}."
return output

elif index == "Geometric Arithmetic Index (GA)":
edge_degrees = [tuple(map(int, pair.split('-'))) for pair in user_input.split(',')]
values = [ (d1 * d2)**0.5 for d1, d2 in edge_degrees ]
result = sum(values)
steps = [
"1. **Extract the edge pairs:**\n - Pairs = " + f"{edge_degrees}"
]
for (d1, d2), v in zip(edge_degrees, values):
steps.append(f"2. **For edge {d1}-{d2}:**\n - √({d1}×{d2}) = {v:.4f}")
steps.append("3. **Sum the values:**\n - GA = " + " + ".join(f"{v:.4f}" for v in values) + f" = {result:.4f}")
output = "### **Geometric Arithmetic Index (GA)**\n\n"
output += "**Formula:**\n" + formulas["Geometric Arithmetic Index (GA)"] + "\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The GA Index = {result:.4f}."
return output

elif index == "Harmonic Index (Harm)":
degrees = list(map(int, user_input.split(',')))
values = [1 / d for d in degrees]
result = sum(values)
steps = [
"1. **Extract the vertex degrees:**\n - Degrees = " + f"{degrees}"
]
for d, v in zip(degrees, values):
steps.append(f"2. **For degree {d}:**\n - 1/{d} = {v:.4f}")
steps.append("3. **Sum the reciprocals:**\n - Harm = " + " + ".join(f"{v:.4f}" for v in values) + f" = {result:.4f}")
output = "### **Harmonic Index (Harm)**\n\n"
output += "**Formula:**\n" + formulas["Harmonic Index (Harm)"] + "\n\n"
output += "**Step-by-step solution:**\n\n" + "\n".join(steps) + "\n\n"
output += f"**Answer:** The Harmonic Index = {result:.4f}."
return output

else:
return "Index not recognized."
except Exception as e:
return f"Error in processing input: {e}"

def update_input_placeholder(index):
placeholders = {
"Wiener Index (W)": "Enter shortest path d

app.py

@@ -1,25 +1,22 @@
+import os
 import subprocess
-import sys
 
-# Manually install required libraries (each installed separately)
-subprocess.check_call([sys.executable, "-m", "pip", "install", "gradio"])
-subprocess.check_call([sys.executable, "-m", "pip", "install", "networkx"])
-subprocess.check_call([sys.executable, "-m", "pip", "install", "matplotlib"])
-subprocess.check_call([sys.executable, "-m", "pip", "install", "numpy"])
-subprocess.check_call([sys.executable, "-m", "pip", "install", "scipy"])
+def install(package):
+    subprocess.check_call(["pip", "install", package])
 
-import os
-import math
-import itertools
+# Manually install each required library
+install("numpy")
+install("pandas")
+install("torch")
+install("transformers")
+install("gradio")  # Add any other required libraries here
+
+# Now import the installed libraries
 import numpy as np
-import networkx as nx
-import matplotlib.pyplot as plt
+import pandas as pd
+import torch
+from transformers import AutoModel, AutoTokenizer
 import gradio as gr
-from scipy.spatial import distance
-
-# -------------------------------
-# Step-by-Step Index Calculation Functions
-# -------------------------------
 
 # Formulas for the indices (written in a typical mathematical style)
 formulas = {
@@ -83,7 +80,7 @@ def solve_index(index, user_input):
 
         elif index == "Randić Index (R)":
             edge_degrees = [tuple(map(int, pair.split('-'))) for pair in user_input.split(',')]
-            values = [1 / (d1 * d2)**0.5 for d1, d2 in edge_degrees]
+            values = [1 / (d1 * d2) ** 0.5 for d1, d2 in edge_degrees]
             result = sum(values)
             steps = [
                 "1. **Extract the degree pairs for each edge:**\n   - Edge pairs = " + f"{edge_degrees}"
@@ -105,7 +102,7 @@ def solve_index(index, user_input):
             m = int(parts[0])
             q = int(parts[1])
             edge_degrees = [tuple(map(int, pair.split('-'))) for pair in parts[2].split(',')]
-            values = [1 / (d1 * d2)**0.5 for d1, d2 in edge_degrees]
+            values = [1 / (d1 * d2) ** 0.5 for d1, d2 in edge_degrees]
             numerator = sum(values)
             result = (m / (q + 1)) * numerator
             steps = [
@@ -143,7 +140,7 @@ def solve_index(index, user_input):
 
         elif index == "Atom-Bond Connectivity Index (ABC)":
             edge_degrees = [tuple(map(int, pair.split('-'))) for pair in user_input.split(',')]
-            values = [((d1**0.5 + d2**0.5) / (d1 + d2)) for d1, d2 in edge_degrees]
+            values = [ ( (d1**0.5 + d2**0.5) / (d1 + d2) ) for d1, d2 in edge_degrees ]
             result = sum(values)
             steps = [
                 "1. **Extract the edge pairs:**\n   - Pairs = " + f"{edge_degrees}"
@@ -159,7 +156,7 @@ def solve_index(index, user_input):
 
         elif index == "Geometric Arithmetic Index (GA)":
             edge_degrees = [tuple(map(int, pair.split('-'))) for pair in user_input.split(',')]
-            values = [(d1 * d2)**0.5 for d1, d2 in edge_degrees]
+            values = [ (d1 * d2)**0.5 for d1, d2 in edge_degrees ]
             result = sum(values)
             steps = [
                 "1. **Extract the edge pairs:**\n   - Pairs = " + f"{edge_degrees}"
@@ -206,122 +203,37 @@ def update_input_placeholder(index):
         "Geometric Arithmetic Index (GA)": "Enter edge pairs (e.g., 2-3,3-4)",
         "Harmonic Index (Harm)": "Enter vertex degrees (e.g., 2,3,4)"
     }
+    # Also return the corresponding formula for the selected index.
     return placeholders[index], formulas.get(index, "")
 
-# -------------------------------
-# Graph Visualization Section
-# -------------------------------
-
-def parse_edges(edge_str):
-    """Parses a comma-separated list of edges formatted as 'u-v' and returns a list of tuple edges."""
-    try:
-        edges = [tuple(map(int, e.strip().split("-"))) for e in edge_str.split(",") if e.strip() != ""]
-        return edges
-    except Exception as e:
-        raise ValueError("Error parsing edges. Ensure format is 'u-v, x-y, ...'")
-
-def ensure_connectivity(G, pos):
-    """If the graph is disconnected, connects the components using a minimum spanning tree on node positions."""
-    if nx.is_connected(G):
-        return G, pos
-    components = list(nx.connected_components(G))
-    for i in range(len(components) - 1):
-        comp1 = components[i]
-        comp2 = components[i + 1]
-        min_dist = float('inf')
-        best_pair = None
-        for u in comp1:
-            for v in comp2:
-                d = distance.euclidean(pos[u], pos[v])
-                if d < min_dist:
-                    min_dist = d
-                    best_pair = (u, v)
-        if best_pair is not None:
-            G.add_edge(*best_pair)
-    return G, pos
-
-def draw_graph_from_edges(edge_str):
-    """Constructs a graph from edge_str, ensures connectivity, and returns the saved image filename."""
-    try:
-        edges = parse_edges(edge_str)
-    except Exception as e:
-        return None, f"Error: {e}"
-    nodes = set()
-    for u, v in edges:
-        nodes.update([u, v])
-    G = nx.Graph()
-    G.add_nodes_from(sorted(nodes))
-    G.add_edges_from(edges)
-    pos = nx.spring_layout(G, seed=42)
-    G, pos = ensure_connectivity(G, pos)
-    plt.figure(figsize=(6, 6))
-    node_sizes = [300 + 100 * G.degree(n) for n in G.nodes()]
-    nx.draw(G, pos, with_labels=True, node_color="lightblue", node_size=node_sizes, edge_color="gray", font_size=10)
-    plt.title("Graph Visualization", fontsize=14)
-    filename = "graph.png"
-    plt.savefig(filename)
-    plt.close()
-    return filename, "Graph drawn successfully."
-
-# -------------------------------
-# Combined Function: Solve Index and Visualize Graph
-# -------------------------------
-
-def solve_index_and_visualize(index, user_input, custom_edges):
-    """
-    Computes the selected index step-by-step and, if custom_edges is provided,
-    draws the corresponding graph. Returns the text explanation and the graph image.
-    """
-    explanation = solve_index(index, user_input)
-    image_file = ""
-    # Define which indices are graph-related (require edge-based inputs)
-    graph_related = ["Randić Index (R)", "Balaban Index (J)", "Atom-Bond Connectivity Index (ABC)", "Geometric Arithmetic Index (GA)", "Harary Index (H)"]
-    if custom_edges.strip() != "" and index in graph_related:
-        img, msg = draw_graph_from_edges(custom_edges)
-        if img is None:
-            image_file = None
-            explanation += "\n\n" + msg
-        else:
-            image_file = img
-            explanation += "\n\nGraph visualization based on custom edges is provided below."
-    else:
-        explanation += "\n\n(No graph visualization available for the given input.)"
-    return explanation, image_file
-
-# -------------------------------
-# Gradio Interface Setup
-# -------------------------------
+# List of indices for the dropdown
+index_options = [
+    "Wiener Index (W)",
+    "First Zagreb Index (M₁)",
+    "Second Zagreb Index (M₂)",
+    "Randić Index (R)",
+    "Balaban Index (J)",
+    "Harary Index (H)",
+    "Atom-Bond Connectivity Index (ABC)",
+    "Geometric Arithmetic Index (GA)",
+    "Harmonic Index (Harm)"
+]
 
 with gr.Blocks() as demo:
-    gr.Markdown("# Topological Index Calculator with Graph Visualization")
-    
-    with gr.Row():
-        index_dropdown = gr.Dropdown(choices=[
-            "Wiener Index (W)",
-            "First Zagreb Index (M₁)",
-            "Second Zagreb Index (M₂)",
-            "Randić Index (R)",
-            "Balaban Index (J)",
-            "Harary Index (H)",
-            "Atom-Bond Connectivity Index (ABC)",
-            "Geometric Arithmetic Index (GA)",
-            "Harmonic Index (Harm)"
-        ], label="Select an Index")
-        formula_box = gr.Textbox(label="Formula", interactive=False)
-    
-    input_box = gr.Textbox(label="Enter Values", placeholder="For example, for Wiener: 3,4,5; for Zagreb M2: 2-3,3-4")
-    custom_edges = gr.Textbox(label="Graph Edges (Optional)", placeholder="Format: 0-1,1-2,2-3")
-    
-    solve_button = gr.Button("Solve & Visualize")
-    output_text = gr.Textbox(label="Step-by-Step Explanation", interactive=False, lines=15)
-    output_graph = gr.Image(label="Graph Visualization", interactive=False)
-    
-    # When the dropdown changes, update the input placeholder and formula box.
+    gr.Markdown("## Topological Index Calculator\n\nSelect an index, view the formula, enter the required values, and click **Solve** to see a detailed, step-by-step solution with explanations.")
+    index_dropdown = gr.Dropdown(index_options, label="Select an Index")
+    # Create a formula box (read-only) to display the formula for the selected index.
+    formula_box = gr.Textbox(label="Formula", interactive=False)
+    input_box = gr.Textbox(label="Enter Values")
+    solve_button = gr.Button("Solve")
+    output_box = gr.Textbox(label="Step-by-Step Solution", interactive=False, lines=15)
+
+    # When the dropdown changes, update the input placeholder and the formula box.
     index_dropdown.change(fn=lambda index: update_input_placeholder(index),
                           inputs=[index_dropdown],
                           outputs=[input_box, formula_box])
-    solve_button.click(fn=solve_index_and_visualize,
-                       inputs=[index_dropdown, input_box, custom_edges],
-                       outputs=[output_text, output_graph])
+    solve_button.click(fn=solve_index,
+                       inputs=[index_dropdown, input_box],
+                       outputs=[output_box])
 
 demo.launch()