app.py

import subprocess
import math
import gradio as gr

# Ensure required packages are installed
def install(package):
subprocess.check_call(["pip", "install", package])

install("gradio")

# =========================
# Mathematical Formulas (from the paper and our implementation)
# =========================
formulas = {
"Wiener Index (W)":
"W = Σ d(u,v)\nwhere d(u,v) is the shortest-path distance between every unordered pair of vertices.",
"First Zagreb Index (M₁)":
"M₁ = Σ [deg(v)] for v ∈ V(G)\n(This sums the degrees of all vertices.)",
"Second Zagreb Index (M₂)":
"M₂ = Σ [deg(u) × deg(v)] for each edge uv ∈ E(G)\n(This sums the product of the degrees for each edge.)",
"Randić Index (R)":
"R = Σ [1 / √(deg(u) × deg(v))] for each edge uv ∈ E(G)\n(This measures connectivity by using the inverse square root of vertex degree products.)",
"Atom-Bond Connectivity Index (ABC)":
"ABC = Σ √((deg(u)+deg(v)-2)/(deg(u)×deg(v))) for each edge uv ∈ E(G)\n(This index relates to the molecular stability in chemical graphs.)",
"Augmented Zagreb Index (AZI)":
"AZI = Σ [(deg(u)×deg(v))/(deg(u)+deg(v)-2)]³ for each edge uv ∈ E(G)\n(This index amplifies the contribution of high-degree vertices.)",
"Geometric-Arithmetic Index (GA)":
"GA = Σ [2×√(deg(u)×deg(v))/(deg(u)+deg(v))] for each edge uv ∈ E(G)\n(This index blends the geometric and arithmetic means of vertex degrees.)",
"Sum-Connectivity Index (SCI)":
"SCI = Σ [1/√(deg(u)+deg(v))] for each edge uv ∈ E(G)\n(This index focuses on the sum of the degrees.)",
"Harmonic Index (Harm)":
"Harm = Σ [2/(deg(u)+deg(v))] for each edge uv ∈ E(G)\n(A measure emphasizing balanced degrees.)",
"Gutman Index (Gut)":
"Gut = Σ [deg(u)×deg(v)×d(u,v)] for every unordered pair u,v\n(This index combines connectivity with distance information.)",
"Eccentric Connectivity Index (ECI)":
"ECI = Σ [deg(v)×ecc(v)] for every vertex v\n(Here, ecc(v) is the maximum distance from v to any other vertex.)",
"Total Eccentricity (TE)":
"TE = Σ [ecc(v)] for every vertex v\n(This sums the eccentricity of each vertex.)",
"Harary Index (H)":
"H = Σ [1/d(u,v)] for every unordered pair u,v\n(This sums the reciprocals of distances for each vertex pair.)"
}

# ==========================
# Functions to update which input groups are visible based on the selected index
# ==========================
def update_inputs(selected_index):
# Indices that use vertex-based values only: M₁, TE, ECI.
vertex_vis = selected_index in ["First Zagreb Index (M₁)", "Total Eccentricity (TE)",
"Eccentric Connectivity Index (ECI)"]
# Indices that use edge-based inputs: M₂, R, ABC, AZI, GA, SCI, Harm.
edge_vis = selected_index in ["Second Zagreb Index (M₂)",
"Randić Index (R)",
"Atom-Bond Connectivity Index (ABC)",
"Augmented Zagreb Index (AZI)",
"Geometric-Arithmetic Index (GA)",
"Sum-Connectivity Index (SCI)",
"Harmonic Index (Harm)"]
# Gutman index uses its own group.
gutman_vis = (selected_index == "Gutman Index (Gut)")
# Wiener and Harary indices use distance inputs.
distance_vis = selected_index in ["Wiener Index (W)", "Harary Index (H)"]
return (
gr.update(visible=vertex_vis),
gr.update(visible=edge_vis),
gr.update(visible=gutman_vis),
gr.update(visible=distance_vis)
)

# ==========================
# Calculation Functions
# (For simplicity, we assume a triangle graph with 3 vertices, 3 edges, and 3 unordered pairs.)
# ==========================
def solve_index(selected_index, vertex_deg1, vertex_deg2, vertex_deg3,
vertex_ecc1, vertex_ecc2, vertex_ecc3,
edge1_a, edge1_b, edge2_a, edge2_b, edge3_a, edge3_b,
gutman_degs, gutman_dists,
distance1, distance2, distance3):
try:
# -----------------------
# Vertex-based Calculations
# -----------------------
if selected_index == "First Zagreb Index (M₁)":
degrees = [vertex_deg1, vertex_deg2, vertex_deg3]
result = sum(degrees)
steps = [
f"Step 1: Record the degree of each vertex: {degrees}.",
f"Step 2: Sum all vertex degrees since M₁ is defined as Σ deg(v): {degrees[0]} + {degrees[1]} + {degrees[2]} = {result}."
]
return f"### First Zagreb Index (M₁)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)

elif selected_index == "Total Eccentricity (TE)":
ecc = [vertex_ecc1, vertex_ecc2, vertex_ecc3]
result = sum(ecc)
steps = [
f"Step 1: Record the eccentricity (maximum distance) for each vertex: {ecc}.",
f"Step 2: Sum all eccentricities since TE is defined as Σ ecc(v): {ecc[0]} + {ecc[1]} + {ecc[2]} = {result}."
]
return f"### Total Eccentricity (TE)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)

elif selected_index == "Eccentric Connectivity Index (ECI)":
pairs = [(vertex_deg1, vertex_ecc1), (vertex_deg2, vertex_ecc2), (vertex_deg3, vertex_ecc3)]
contributions = [d * e for d, e in pairs]
result = sum(contributions)
steps = [
f"Step 1: For each vertex, record the pair (degree, eccentricity): {pairs}.",
f"Step 2: Multiply the degree and eccentricity for each vertex: {contributions} (because ECI = Σ [deg(v)×ecc(v)]).",
f"Step 3: Sum these products: {contributions[0]} + {contributions[1]} + {contributions[2]} = {result}."
]
return f"### Eccentric Connectivity Index (ECI)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)

# -----------------------
# Edge-based Calculations
# -----------------------
elif selected_index in ["Second Zagreb Index (M₂)", "Randić Index (R)",
"Atom-Bond Connectivity Index (ABC)", "Augmented Zagreb Index (AZI)",
"Geometric-Arithmetic Index (GA)", "Sum-Connectivity Index (SCI)",
"Harmonic Index (Harm)"]:
edges = [(edge1_a, edge1_b), (edge2_a, edge2_b), (edge3_a, edge3_b)]
if selected_index == "Second Zagreb Index (M₂)":
products = [a * b for a, b in edges]
result = sum(products)
steps = [
f"Step 1: Each edge connects two vertices with degrees as given: {edges}.",
f"Step 2: For each edge, multiply the degrees: {products} (since M₂ sums the product for each edge).",
f"Step 3: Sum these products: {products[0]} + {products[1]} + {products[2]} = {result}."
]
elif selected_index == "Randić Index (R)":
values = [1 / math.sqrt(a * b) for a, b in edges]
result = sum(values)
steps = [
f"Step 1: Record the degree pairs for each edge: {edges}.",
f"Step 2: For each edge, compute 1/√(deg(u)×deg(v)): {['{:.4f}'.format(v) for v in values]}.",
f"Step 3: Sum these values to obtain R: {result:.4f}."
]
elif selected_index == "Atom-Bond Connectivity Index (ABC)":
values = [math.sqrt((a + b - 2) / (a * b)) for a, b in edges]
result = sum(values)
steps = [
f"Step 1: For each edge, note the degree pair: {edges}.",
f"Step 2: Compute √((deg(u)+deg(v)-2)/(deg(u)×deg(v))) for each edge: {['{:.4f}'.format(v) for v in values]}.",
f"Step 3: Sum the results: {result:.4f}."
]
elif selected_index == "Augmented Zagreb Index (AZI)":
values = []
for a, b in edges:
denom = a + b - 2
val = (a * b / denom) ** 3 if denom != 0 else 0
values.append(val)
result = sum(values)
steps = [
f"Step 1: For each edge, record degrees: {edges}.",
f"Step 2: For each, compute ( (deg(u)×deg(v))/(deg(u)+deg(v)-2) )³: {['{:.4f}'.format(v) for v in values]}.",
f"Step 3: Sum these values: {result:.4f}."
]
elif selected_index == "Geometric-Arithmetic Index (GA)":
values = [(2 * math.sqrt(a * b))/(a + b) for a, b in edges]
result = sum(values)
steps = [
f"Step 1: Record edge degree pairs: {edges}.",
f"Step 2: For each edge, calculate 2×√(deg(u)×deg(v))/(deg(u)+deg(v)): {['{:.4f}'.format(v) for v in values]}.",
f"Step 3: Sum to obtain GA: {result:.4f}."
]
elif selected_index == "Sum-Connectivity Index (SCI)":
values = [1 / math.sqrt(a + b) for a, b in edges]
result = sum(values)
steps = [
f"Step 1: Note the degree pairs for each edge: {edges}.",
f"Step 2: For each edge, compute 1/√(deg(u)+deg(v)): {['{:.4f}'.format(v) for v in values]}.",
f"Step 3: Sum the computed values to get SCI: {result:.4f}."
]
elif selected_index == "Harmonic Index (Harm)":
values = [2 / (a + b) for a, b in edges]
result = sum(values)
steps = [
f"Step 1: Record the edge degree pairs: {edges}.",
f"Step 2: For each edge, compute 2/(deg(u)+deg(v)): {['{:.4f}'.format(v) for v in values]}.",
f"Step 3: Sum these values

app.py

@@ -0,0 +1,305 @@
+import subprocess
+import math
+import gradio as gr
+
+# Ensure required packages are installed
+def install(package):
+    subprocess.check_call(["pip", "install", package])
+
+install("gradio")
+
+# =========================
+# Mathematical Formulas (from the paper and our implementation)
+# =========================
+formulas = {
+    "Wiener Index (W)":
+        "W = Σ d(u,v)\nwhere d(u,v) is the shortest-path distance between every unordered pair of vertices.",
+    "First Zagreb Index (M₁)":
+        "M₁ = Σ [deg(v)]  for v ∈ V(G)\n(This sums the degrees of all vertices.)",
+    "Second Zagreb Index (M₂)":
+        "M₂ = Σ [deg(u) × deg(v)] for each edge uv ∈ E(G)\n(This sums the product of the degrees for each edge.)",
+    "Randić Index (R)":
+        "R = Σ [1 / √(deg(u) × deg(v))] for each edge uv ∈ E(G)\n(This measures connectivity by using the inverse square root of vertex degree products.)",
+    "Atom-Bond Connectivity Index (ABC)":
+        "ABC = Σ √((deg(u)+deg(v)-2)/(deg(u)×deg(v))) for each edge uv ∈ E(G)\n(This index relates to the molecular stability in chemical graphs.)",
+    "Augmented Zagreb Index (AZI)":
+        "AZI = Σ [(deg(u)×deg(v))/(deg(u)+deg(v)-2)]³ for each edge uv ∈ E(G)\n(This index amplifies the contribution of high-degree vertices.)",
+    "Geometric-Arithmetic Index (GA)":
+        "GA = Σ [2×√(deg(u)×deg(v))/(deg(u)+deg(v))] for each edge uv ∈ E(G)\n(This index blends the geometric and arithmetic means of vertex degrees.)",
+    "Sum-Connectivity Index (SCI)":
+        "SCI = Σ [1/√(deg(u)+deg(v))] for each edge uv ∈ E(G)\n(This index focuses on the sum of the degrees.)",
+    "Harmonic Index (Harm)":
+        "Harm = Σ [2/(deg(u)+deg(v))] for each edge uv ∈ E(G)\n(A measure emphasizing balanced degrees.)",
+    "Gutman Index (Gut)":
+        "Gut = Σ [deg(u)×deg(v)×d(u,v)] for every unordered pair u,v\n(This index combines connectivity with distance information.)",
+    "Eccentric Connectivity Index (ECI)":
+        "ECI = Σ [deg(v)×ecc(v)] for every vertex v\n(Here, ecc(v) is the maximum distance from v to any other vertex.)",
+    "Total Eccentricity (TE)":
+        "TE = Σ [ecc(v)] for every vertex v\n(This sums the eccentricity of each vertex.)",
+    "Harary Index (H)":
+        "H = Σ [1/d(u,v)] for every unordered pair u,v\n(This sums the reciprocals of distances for each vertex pair.)"
+}
+
+# ==========================
+# Functions to update which input groups are visible based on the selected index
+# ==========================
+def update_inputs(selected_index):
+    # Indices that use vertex-based values only: M₁, TE, ECI.
+    vertex_vis = selected_index in ["First Zagreb Index (M₁)", "Total Eccentricity (TE)",
+                                     "Eccentric Connectivity Index (ECI)"]
+    # Indices that use edge-based inputs: M₂, R, ABC, AZI, GA, SCI, Harm.
+    edge_vis = selected_index in ["Second Zagreb Index (M₂)",
+                                   "Randić Index (R)",
+                                   "Atom-Bond Connectivity Index (ABC)",
+                                   "Augmented Zagreb Index (AZI)",
+                                   "Geometric-Arithmetic Index (GA)",
+                                   "Sum-Connectivity Index (SCI)",
+                                   "Harmonic Index (Harm)"]
+    # Gutman index uses its own group.
+    gutman_vis = (selected_index == "Gutman Index (Gut)")
+    # Wiener and Harary indices use distance inputs.
+    distance_vis = selected_index in ["Wiener Index (W)", "Harary Index (H)"]
+    return (
+        gr.update(visible=vertex_vis),
+        gr.update(visible=edge_vis),
+        gr.update(visible=gutman_vis),
+        gr.update(visible=distance_vis)
+    )
+
+# ==========================
+# Calculation Functions
+# (For simplicity, we assume a triangle graph with 3 vertices, 3 edges, and 3 unordered pairs.)
+# ==========================
+def solve_index(selected_index, vertex_deg1, vertex_deg2, vertex_deg3,
+                vertex_ecc1, vertex_ecc2, vertex_ecc3,
+                edge1_a, edge1_b, edge2_a, edge2_b, edge3_a, edge3_b,
+                gutman_degs, gutman_dists,
+                distance1, distance2, distance3):
+    try:
+        # -----------------------
+        # Vertex-based Calculations
+        # -----------------------
+        if selected_index == "First Zagreb Index (M₁)":
+            degrees = [vertex_deg1, vertex_deg2, vertex_deg3]
+            result = sum(degrees)
+            steps = [
+                f"Step 1: Record the degree of each vertex: {degrees}.",
+                f"Step 2: Sum all vertex degrees since M₁ is defined as Σ deg(v): {degrees[0]} + {degrees[1]} + {degrees[2]} = {result}."
+            ]
+            return f"### First Zagreb Index (M₁)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)
+        
+        elif selected_index == "Total Eccentricity (TE)":
+            ecc = [vertex_ecc1, vertex_ecc2, vertex_ecc3]
+            result = sum(ecc)
+            steps = [
+                f"Step 1: Record the eccentricity (maximum distance) for each vertex: {ecc}.",
+                f"Step 2: Sum all eccentricities since TE is defined as Σ ecc(v): {ecc[0]} + {ecc[1]} + {ecc[2]} = {result}."
+            ]
+            return f"### Total Eccentricity (TE)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)
+        
+        elif selected_index == "Eccentric Connectivity Index (ECI)":
+            pairs = [(vertex_deg1, vertex_ecc1), (vertex_deg2, vertex_ecc2), (vertex_deg3, vertex_ecc3)]
+            contributions = [d * e for d, e in pairs]
+            result = sum(contributions)
+            steps = [
+                f"Step 1: For each vertex, record the pair (degree, eccentricity): {pairs}.",
+                f"Step 2: Multiply the degree and eccentricity for each vertex: {contributions} (because ECI = Σ [deg(v)×ecc(v)]).",
+                f"Step 3: Sum these products: {contributions[0]} + {contributions[1]} + {contributions[2]} = {result}."
+            ]
+            return f"### Eccentric Connectivity Index (ECI)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)
+        
+        # -----------------------
+        # Edge-based Calculations
+        # -----------------------
+        elif selected_index in ["Second Zagreb Index (M₂)", "Randić Index (R)",
+                                 "Atom-Bond Connectivity Index (ABC)", "Augmented Zagreb Index (AZI)",
+                                 "Geometric-Arithmetic Index (GA)", "Sum-Connectivity Index (SCI)",
+                                 "Harmonic Index (Harm)"]:
+            edges = [(edge1_a, edge1_b), (edge2_a, edge2_b), (edge3_a, edge3_b)]
+            if selected_index == "Second Zagreb Index (M₂)":
+                products = [a * b for a, b in edges]
+                result = sum(products)
+                steps = [
+                    f"Step 1: Each edge connects two vertices with degrees as given: {edges}.",
+                    f"Step 2: For each edge, multiply the degrees: {products} (since M₂ sums the product for each edge).",
+                    f"Step 3: Sum these products: {products[0]} + {products[1]} + {products[2]} = {result}."
+                ]
+            elif selected_index == "Randić Index (R)":
+                values = [1 / math.sqrt(a * b) for a, b in edges]
+                result = sum(values)
+                steps = [
+                    f"Step 1: Record the degree pairs for each edge: {edges}.",
+                    f"Step 2: For each edge, compute 1/√(deg(u)×deg(v)): {['{:.4f}'.format(v) for v in values]}.",
+                    f"Step 3: Sum these values to obtain R: {result:.4f}."
+                ]
+            elif selected_index == "Atom-Bond Connectivity Index (ABC)":
+                values = [math.sqrt((a + b - 2) / (a * b)) for a, b in edges]
+                result = sum(values)
+                steps = [
+                    f"Step 1: For each edge, note the degree pair: {edges}.",
+                    f"Step 2: Compute √((deg(u)+deg(v)-2)/(deg(u)×deg(v))) for each edge: {['{:.4f}'.format(v) for v in values]}.",
+                    f"Step 3: Sum the results: {result:.4f}."
+                ]
+            elif selected_index == "Augmented Zagreb Index (AZI)":
+                values = []
+                for a, b in edges:
+                    denom = a + b - 2
+                    val = (a * b / denom) ** 3 if denom != 0 else 0
+                    values.append(val)
+                result = sum(values)
+                steps = [
+                    f"Step 1: For each edge, record degrees: {edges}.",
+                    f"Step 2: For each, compute ( (deg(u)×deg(v))/(deg(u)+deg(v)-2) )³: {['{:.4f}'.format(v) for v in values]}.",
+                    f"Step 3: Sum these values: {result:.4f}."
+                ]
+            elif selected_index == "Geometric-Arithmetic Index (GA)":
+                values = [(2 * math.sqrt(a * b))/(a + b) for a, b in edges]
+                result = sum(values)
+                steps = [
+                    f"Step 1: Record edge degree pairs: {edges}.",
+                    f"Step 2: For each edge, calculate 2×√(deg(u)×deg(v))/(deg(u)+deg(v)): {['{:.4f}'.format(v) for v in values]}.",
+                    f"Step 3: Sum to obtain GA: {result:.4f}."
+                ]
+            elif selected_index == "Sum-Connectivity Index (SCI)":
+                values = [1 / math.sqrt(a + b) for a, b in edges]
+                result = sum(values)
+                steps = [
+                    f"Step 1: Note the degree pairs for each edge: {edges}.",
+                    f"Step 2: For each edge, compute 1/√(deg(u)+deg(v)): {['{:.4f}'.format(v) for v in values]}.",
+                    f"Step 3: Sum the computed values to get SCI: {result:.4f}."
+                ]
+            elif selected_index == "Harmonic Index (Harm)":
+                values = [2 / (a + b) for a, b in edges]
+                result = sum(values)
+                steps = [
+                    f"Step 1: Record the edge degree pairs: {edges}.",
+                    f"Step 2: For each edge, compute 2/(deg(u)+deg(v)): {['{:.4f}'.format(v) for v in values]}.",
+                    f"Step 3: Sum these values for the final Harmonic Index: {result:.4f}."
+                ]
+            return f"### {selected_index}\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)
+        
+        # -----------------------
+        # Gutman Index: Requires vertex degrees and distances
+        # -----------------------
+        elif selected_index == "Gutman Index (Gut)":
+            degs = [float(x) for x in gutman_degs.split(',')]
+            dists = [float(x) for x in gutman_dists.split(',')]
+            # For a triangle, the unordered pairs are (1,2), (1,3), and (2,3)
+            total = degs[0]*degs[1]*dists[0] + degs[0]*degs[2]*dists[1] + degs[1]*degs[2]*dists[2]
+            steps = [
+                f"Step 1: The vertex degrees are recorded as: {degs}.",
+                f"Step 2: The shortest-path distances for unordered vertex pairs (1,2), (1,3), and (2,3) are: {dists}.",
+                f"Step 3: For each pair, multiply deg(u)×deg(v)×d(u,v):",
+                f"        For (1,2): {degs[0]}×{degs[1]}×{dists[0]} = {degs[0]*degs[1]*dists[0]},",
+                f"        For (1,3): {degs[0]}×{degs[2]}×{dists[1]} = {degs[0]*degs[2]*dists[1]},",
+                f"        For (2,3): {degs[1]}×{degs[2]}×{dists[2]} = {degs[1]*degs[2]*dists[2]}.",
+                f"Step 4: Sum all products: {total}."
+            ]
+            return f"### Gutman Index (Gut)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)
+        
+        # -----------------------
+        # Distance-based: Wiener and Harary indices
+        # -----------------------
+        elif selected_index in ["Wiener Index (W)", "Harary Index (H)"]:
+            dists = [distance1, distance2, distance3]
+            if selected_index == "Wiener Index (W)":
+                result = sum(dists)
+                steps = [
+                    f"Step 1: Record the shortest-path distances for each unordered pair: {dists}.",
+                    f"Step 2: Sum all distances: {dists[0]} + {dists[1]} + {dists[2]} = {result}."
+                ]
+                return f"### Wiener Index (W)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)
+            else:  # Harary Index (H)
+                values = [1/d if d != 0 else 0 for d in dists]
+                result = sum(values)
+                steps = [
+                    f"Step 1: Record the shortest-path distances: {dists}.",
+                    f"Step 2: Compute the reciprocal for each distance (1/d): {['{:.4f}'.format(1/d) if d!=0 else 'undefined' for d in dists]}.",
+                    f"Step 3: Sum these reciprocals: {result:.4f}."
+                ]
+                return f"### Harary Index (H)\n{formulas[selected_index]}\n\nDetailed Steps:\n" + "\n".join(steps)
+        else:
+            return "Index not recognized."
+    except Exception as e:
+        return f"Error: {e}"
+
+# ==========================
+# Build the Gradio Interface with Dynamic Input Groups
+# ==========================
+with gr.Blocks() as demo:
+    gr.Markdown("## Topological Index Calculator\n\nSelect an index and enter the required values in the relevant fields. The fields below will change based on the chosen index. (For illustration, this example uses a fixed triangle graph with 3 vertices, 3 edges, and 3 unordered pairs.)")
+    
+    index_dropdown = gr.Dropdown(
+        label="Select an Index", 
+        choices=[
+            "Wiener Index (W)",
+            "First Zagreb Index (M₁)",
+            "Second Zagreb Index (M₂)",
+            "Randić Index (R)",
+            "Atom-Bond Connectivity Index (ABC)",
+            "Augmented Zagreb Index (AZI)",
+            "Geometric-Arithmetic Index (GA)",
+            "Sum-Connectivity Index (SCI)",
+            "Harmonic Index (Harm)",
+            "Gutman Index (Gut)",
+            "Eccentric Connectivity Index (ECI)",
+            "Total Eccentricity (TE)",
+            "Harary Index (H)"
+        ]
+    )
+    
+    # Group 1: Vertex-based inputs (for M₁, TE, ECI)
+    with gr.Group(visible=False) as vertex_group:
+        gr.Markdown("### Vertex Inputs\nEnter the degree and/or eccentricity for each vertex.")
+        vertex_deg1 = gr.Number(label="Vertex 1 Degree", value=2)
+        vertex_deg2 = gr.Number(label="Vertex 2 Degree", value=2)
+        vertex_deg3 = gr.Number(label="Vertex 3 Degree", value=2)
+        vertex_ecc1 = gr.Number(label="Vertex 1 Eccentricity", value=1)
+        vertex_ecc2 = gr.Number(label="Vertex 2 Eccentricity", value=1)
+        vertex_ecc3 = gr.Number(label="Vertex 3 Eccentricity", value=1)
+    
+    # Group 2: Edge-based inputs (for M₂, R, ABC, AZI, GA, SCI, Harm)
+    with gr.Group(visible=False) as edge_group:
+        gr.Markdown("### Edge Inputs\nFor each edge, enter the degree of each end vertex.")
+        with gr.Row():
+            edge1_a = gr.Number(label="Edge 1: Vertex A Degree", value=2)
+            edge1_b = gr.Number(label="Edge 1: Vertex B Degree", value=2)
+        with gr.Row():
+            edge2_a = gr.Number(label="Edge 2: Vertex A Degree", value=2)
+            edge2_b = gr.Number(label="Edge 2: Vertex B Degree", value=2)
+        with gr.Row():
+            edge3_a = gr.Number(label="Edge 3: Vertex A Degree", value=2)
+            edge3_b = gr.Number(label="Edge 3: Vertex B Degree", value=2)
+    
+    # Group 3: Gutman inputs (for Gutman Index)
+    with gr.Group(visible=False) as gutman_group:
+        gr.Markdown("### Gutman Index Inputs\nEnter vertex degrees and the distances for each unordered vertex pair.")
+        gutman_degs = gr.Textbox(label="Vertex Degrees (comma-separated)", value="2,2,2")
+        gutman_dists = gr.Textbox(label="Distances for pairs ((1,2), (1,3), (2,3)) (comma-separated)", value="1,1,1")
+    
+    # Group 4: Distance-based inputs (for Wiener and Harary indices)
+    with gr.Group(visible=False) as distance_group:
+        gr.Markdown("### Distance Inputs\nEnter the shortest-path distance for each unordered vertex pair.")
+        distance1 = gr.Number(label="Distance for Pair 1", value=1)
+        distance2 = gr.Number(label="Distance for Pair 2", value=1)
+        distance3 = gr.Number(label="Distance for Pair 3", value=1)
+    
+    output_box = gr.Textbox(label="Step-by-Step Detailed Solution", lines=20)
+    solve_btn = gr.Button("Solve")
+    
+    # Update input group visibility when index is selected
+    index_dropdown.change(fn=update_inputs,
+                          inputs=index_dropdown,
+                          outputs=[vertex_group, edge_group, gutman_group, distance_group])
+    
+    # Run calculations when Solve is clicked
+    solve_btn.click(fn=solve_index,
+                    inputs=[index_dropdown, 
+                            vertex_deg1, vertex_deg2, vertex_deg3,
+                            vertex_ecc1, vertex_ecc2, vertex_ecc3,
+                            edge1_a, edge1_b, edge2_a, edge2_b, edge3_a, edge3_b,
+                            gutman_degs, gutman_dists,
+                            distance1, distance2, distance3],
+                    outputs=output_box)
+
+demo.launch()