topological_index_visualizer.py

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"])

import os
import math
import itertools
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
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 = {
"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

topological_index_visualizer.py

@@ -0,0 +1,327 @@
+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"])
+
+import os
+import math
+import itertools
+import numpy as np
+import networkx as nx
+import matplotlib.pyplot as plt
+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 = {
+    "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 distances (e.g., 3,4,5)",
+        "First Zagreb Index (M₁)": "Enter vertex degrees (e.g., 2,3,4)",
+        "Second Zagreb Index (M₂)": "Enter adjacent vertex degrees (e.g., 2-3,3-4)",
+        "Randić Index (R)": "Enter edge degrees (e.g., 2-3,3-4)",
+        "Balaban Index (J)": "Enter m;q;edge pairs (e.g., 6;4;2-3,3-4)",
+        "Harary Index (H)": "Enter shortest path distances (e.g., 3,4,5)",
+        "Atom-Bond Connectivity Index (ABC)": "Enter edge pairs (e.g., 2-3,3-4)",
+        "Geometric Arithmetic Index (GA)": "Enter edge pairs (e.g., 2-3,3-4)",
+        "Harmonic Index (Harm)": "Enter vertex degrees (e.g., 2,3,4)"
+    }
+    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
+# -------------------------------
+
+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.
+    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])
+
+demo.launch()