update

.python-version

@@ -0,0 +1 @@
+3.12.4-peta

src/streamlit_app.py

@@ -447,7 +447,17 @@ def analyze_network_connectivity(G, line_segments=None):
     return analysis
 
 
-def create_network_visualization(G, nodes, centrality_measures, show_labels=False):
+def create_network_visualization(
+    G,
+    nodes,
+    centrality_measures,
+    show_labels=False,
+    show_edge_details=False,
+    label_size=10,
+    label_color="white",
+    edge_offset=0.02,
+    show_edge_colors=True,
+):
     """Buat visualisasi jaringan menggunakan Plotly dengan error handling"""
     try:
         if G.number_of_nodes() == 0:
@@ -484,30 +494,134 @@ def create_network_visualization(G, nodes, centrality_measures, show_labels=Fals
             # Fallback ke spring layout jika tidak ada koordinat
             pos = nx.spring_layout(G, k=1, iterations=50)
 
-        # Siapkan data untuk edges
-        edge_x = []
-        edge_y = []
-        edge_info = []
+        # Siapkan data untuk edges dengan multiple edges terpisah
+        edge_traces = []  # List untuk menyimpan multiple traces
 
+        # Hitung statistik edge untuk normalisasi
+        edge_weights = [data.get("weight", 0) for _, _, data in G.edges(data=True)]
+        max_weight = max(edge_weights) if edge_weights else 1
+        min_weight = min(edge_weights) if edge_weights else 0
+
+        # Group edges berdasarkan pasangan node untuk mendeteksi multiple edges
+        edge_groups = {}
         for edge in G.edges(data=True):
-            if edge[0] in pos and edge[1] in pos:
-                x0, y0 = pos[edge[0]]
-                x1, y1 = pos[edge[1]]
-                edge_x.extend([x0, x1, None])
-                edge_y.extend([y0, y1, None])
+            node_pair = tuple(sorted([edge[0], edge[1]]))
+            if node_pair not in edge_groups:
+                edge_groups[node_pair] = []
+            edge_groups[node_pair].append(edge)
+
+        # Fungsi untuk membuat offset untuk multiple edges
+        def calculate_edge_offset(
+            x0, y0, x1, y1, offset_distance, edge_index, total_edges
+        ):
+            """Hitung offset untuk edge paralel"""
+            if total_edges == 1:
+                return x0, y0, x1, y1
+
+            # Hitung vektor perpendicular
+            dx = x1 - x0
+            dy = y1 - y0
+            length = (dx**2 + dy**2) ** 0.5
+
+            if length == 0:
+                return x0, y0, x1, y1
+
+            # Vektor unit perpendicular
+            perp_x = -dy / length
+            perp_y = dx / length
+
+            # Hitung offset untuk edge ini
+            if total_edges % 2 == 1:
+                # Odd number: center edge at 0, others at ±offset
+                center_index = total_edges // 2
+                offset = (edge_index - center_index) * offset_distance
+            else:
+                # Even number: no center edge
+                offset = (edge_index - (total_edges - 1) / 2) * offset_distance
+
+            # Apply offset
+            offset_x0 = x0 + perp_x * offset
+            offset_y0 = y0 + perp_y * offset
+            offset_x1 = x1 + perp_x * offset
+            offset_y1 = y1 + perp_y * offset
+
+            return offset_x0, offset_y0, offset_x1, offset_y1
+
+        # Proses setiap group edge
+        for node_pair, edges in edge_groups.items():
+            if edges[0][0] not in pos or edges[0][1] not in pos:
+                continue
+
+            x0, y0 = pos[edges[0][0]]
+            x1, y1 = pos[edges[0][1]]
+
+            total_edges = len(edges)
+            offset_distance = edge_offset  # Gunakan parameter yang dapat diatur
+
+            for edge_index, edge in enumerate(edges):
+                # Hitung posisi dengan offset
+                offset_x0, offset_y0, offset_x1, offset_y1 = calculate_edge_offset(
+                    x0, y0, x1, y1, offset_distance, edge_index, total_edges
+                )
 
                 weight = edge[2].get("weight", 0)
-                edge_info.append(f"Weight: {weight:.2f}m")
-
-        # Trace untuk edges dengan styling yang lebih baik
-        edge_trace = go.Scatter(
-            x=edge_x,
-            y=edge_y,
-            line=dict(width=0.8, color="rgba(125,125,125,0.8)"),
-            hoverinfo="none",
-            mode="lines",
-            name="Saluran Listrik",
-        )
+                line_name = edge[2].get("nama", f"Edge_{edge[0]}_{edge[1]}")
+                line_id = edge[2].get("line_id", f"ID_{edge[0]}_{edge[1]}")
+
+                # Info detail untuk hover
+                if show_edge_details:
+                    edge_info = (
+                        f"Edge: {edge[0]} ↔ {edge[1]}<br>"
+                        f"Nama: {line_name}<br>"
+                        f"ID: {line_id}<br>"
+                        f"Panjang: {weight:.2f}m ({weight/1000:.3f}km)<br>"
+                        f"Saluran {edge_index + 1} dari {total_edges}"
+                    )
+                else:
+                    edge_info = f"Edge: {edge[0]} ↔ {edge[1]}<br>Panjang: {weight:.2f}m"
+
+                # Warna berdasarkan jumlah edge paralel
+                if total_edges > 1 and show_edge_colors:
+                    # Multiple edges: gunakan warna berbeda jika diaktifkan
+                    colors = ["red", "blue", "green", "orange", "purple", "brown"]
+                    color = colors[edge_index % len(colors)]
+                    edge_color = color
+                    edge_width = 2.0  # Lebih tebal untuk multiple edges
+                elif total_edges > 1:
+                    # Multiple edges tanpa warna berbeda
+                    edge_color = "rgba(255,100,100,0.8)"  # Merah muda untuk multiple
+                    edge_width = 2.0
+                else:
+                    # Single edge: warna berdasarkan panjang
+                    if max_weight > min_weight:
+                        normalized_weight = (weight - min_weight) / (
+                            max_weight - min_weight
+                        )
+                        red_component = int(255 * (1 - normalized_weight))
+                        blue_component = int(255 * normalized_weight)
+                        edge_color = (
+                            f"rgba({red_component}, 100, {blue_component}, 0.7)"
+                        )
+                    else:
+                        edge_color = "rgba(125,125,125,0.8)"
+                    edge_width = 1.2
+
+                # Buat trace untuk edge ini
+                edge_trace = go.Scatter(
+                    x=[offset_x0, offset_x1, None],
+                    y=[offset_y0, offset_y1, None],
+                    line=dict(width=edge_width, color=edge_color),
+                    hoverinfo="text" if show_edge_details else "none",
+                    hovertext=edge_info if show_edge_details else None,
+                    mode="lines",
+                    name=(
+                        f"Saluran {edge_index + 1}"
+                        if total_edges > 1
+                        else "Saluran Listrik"
+                    ),
+                    showlegend=False,
+                )
+                edge_traces.append(edge_trace)
 
         # Siapkan data untuk nodes
         node_x = []
@@ -515,6 +629,7 @@ def create_network_visualization(G, nodes, centrality_measures, show_labels=Fals
         node_text = []
         node_color = []
         node_size = []
+        node_ids = []  # Pindahkan ke sini untuk sinkronisasi
 
         # Gunakan degree centrality untuk pewarnaan dan ukuran
         degree_cent = centrality_measures.get("degree", {})
@@ -524,14 +639,51 @@ def create_network_visualization(G, nodes, centrality_measures, show_labels=Fals
                 x, y = pos[node]
                 node_x.append(x)
                 node_y.append(y)
+                node_ids.append(str(node))  # Tambahkan ID node sesuai urutan
 
-                # Informasi node
+                # Informasi node dengan detail koneksi
                 adjacencies = list(G.neighbors(node))
-                node_info = f"Node: {node}<br>"
-                node_info += f"Koneksi: {len(adjacencies)}<br>"
-                node_info += f"Degree Centrality: {degree_cent.get(node, 0):.3f}<br>"
-                node_info += f'Betweenness: {centrality_measures.get("betweenness", {}).get(node, 0):.3f}<br>'
-                node_info += f'Closeness: {centrality_measures.get("closeness", {}).get(node, 0):.3f}'
+                node_degree = G.degree(node)
+
+                # Hitung total edge secara manual untuk verifikasi
+                total_edges_manual = 0
+                connection_details = []
+                for neighbor in adjacencies:
+                    # Hitung berapa banyak edge antara node ini dan neighbor
+                    edge_count = G.number_of_edges(node, neighbor)
+                    total_edges_manual += edge_count
+                    if edge_count > 1:
+                        connection_details.append(
+                            f"→ Node {neighbor} ({edge_count} saluran)"
+                        )
+                    else:
+                        connection_details.append(f"→ Node {neighbor}")
+
+                node_info = f"🔵 Node: {node}<br>"
+                node_info += f"📊 Degree (NetworkX): {node_degree}<br>"
+                node_info += f"🔢 Total Edge Manual: {total_edges_manual}<br>"
+                node_info += f"👥 Tetangga: {len(adjacencies)}<br>"
+
+                # Tampilkan peringatan jika ada ketidaksesuaian
+                if node_degree != total_edges_manual:
+                    node_info += f"⚠️ INCONSISTENCY DETECTED!<br>"
+
+                if show_edge_details and connection_details:
+                    node_info += f"🔗 Detail Koneksi:<br>"
+                    node_info += "<br>".join(
+                        connection_details[:5]
+                    )  # Batasi 5 koneksi pertama
+                    if len(connection_details) > 5:
+                        node_info += (
+                            f"<br>... dan {len(connection_details) - 5} lainnya"
+                        )
+                    node_info += "<br><br>"
+
+                node_info += f"📈 Sentralitas:<br>"
+                node_info += f"• Degree: {degree_cent.get(node, 0):.4f}<br>"
+                node_info += f'• Betweenness: {centrality_measures.get("betweenness", {}).get(node, 0):.4f}<br>'
+                node_info += f'• Closeness: {centrality_measures.get("closeness", {}).get(node, 0):.4f}<br>'
+                node_info += f'• Eigenvector: {centrality_measures.get("eigenvector", {}).get(node, 0):.4f}'
 
                 node_text.append(node_info)
                 node_color.append(degree_cent.get(node, 0))
@@ -541,15 +693,17 @@ def create_network_visualization(G, nodes, centrality_measures, show_labels=Fals
                 size_multiplier = 20
                 node_size.append(base_size + degree_cent.get(node, 0) * size_multiplier)
 
+        # node_ids sudah dibuat di loop sebelumnya, tidak perlu duplikasi
+
         # Trace untuk nodes dengan styling yang lebih menarik
         node_trace = go.Scatter(
             x=node_x,
             y=node_y,
             mode="markers+text" if show_labels else "markers",
             hoverinfo="text",
-            text=[str(i) for i in range(len(node_x))] if show_labels else [],
+            text=node_ids if show_labels else [],
             textposition="middle center",
-            textfont=dict(size=8, color="white"),
+            textfont=dict(size=label_size, color=label_color, family="Arial Black"),
             hovertext=node_text,
             marker=dict(
                 showscale=True,
@@ -570,9 +724,11 @@ def create_network_visualization(G, nodes, centrality_measures, show_labels=Fals
             name="Node/Junction",
         )
 
-        # Buat figure
+        # Buat figure dengan multiple edge traces
+        all_traces = edge_traces + [node_trace]
+
         fig = go.Figure(
-            data=[edge_trace, node_trace],
+            data=all_traces,
             layout=go.Layout(
                 title=dict(
                     text="Visualisasi Graf Jaringan Listrik DIY",
@@ -584,7 +740,7 @@ def create_network_visualization(G, nodes, centrality_measures, show_labels=Fals
                 margin=dict(b=40, l=40, r=60, t=80),
                 annotations=[
                     dict(
-                        text="Node berukuran dan berwarna berdasarkan Degree Centrality.<br>Node yang lebih besar dan gelap = lebih penting dalam jaringan",
+                        text="Node berukuran dan berwarna berdasarkan Degree Centrality.<br>Saluran paralel ditampilkan dengan garis terpisah dan warna berbeda.<br>Node yang lebih besar dan gelap = lebih penting dalam jaringan",
                         showarrow=False,
                         xref="paper",
                         yref="paper",
@@ -680,6 +836,139 @@ def create_centrality_comparison(centrality_measures):
         return go.Figure()
 
 
+def create_centrality_matrix(centrality_measures):
+    """Buat matriks sentralitas untuk semua node dengan error handling"""
+    try:
+        if not centrality_measures or not centrality_measures.get("degree"):
+            return pd.DataFrame()
+
+        # Ambil semua node
+        nodes = list(centrality_measures["degree"].keys())
+
+        # Buat DataFrame dengan semua ukuran sentralitas
+        centrality_data = {
+            "Node": nodes,
+            "Degree Centrality": [
+                centrality_measures["degree"].get(node, 0) for node in nodes
+            ],
+            "Closeness Centrality": [
+                centrality_measures["closeness"].get(node, 0) for node in nodes
+            ],
+            "Betweenness Centrality": [
+                centrality_measures["betweenness"].get(node, 0) for node in nodes
+            ],
+            "Eigenvector Centrality": [
+                centrality_measures["eigenvector"].get(node, 0) for node in nodes
+            ],
+        }
+
+        df = pd.DataFrame(centrality_data)
+
+        # Urutkan berdasarkan Degree Centrality (descending)
+        df = df.sort_values("Degree Centrality", ascending=False).reset_index(drop=True)
+
+        return df
+
+    except Exception as e:
+        st.error(f"Error creating centrality matrix: {str(e)}")
+        return pd.DataFrame()
+
+
+def create_node_connection_details(G, top_n=20):
+    """Buat tabel detail koneksi untuk node-node teratas"""
+    try:
+        if G.number_of_nodes() == 0:
+            return pd.DataFrame()
+
+        # Ambil node dengan degree tertinggi
+        node_degrees = dict(G.degree())
+        top_nodes = sorted(node_degrees.items(), key=lambda x: x[1], reverse=True)[
+            :top_n
+        ]
+
+        connection_data = []
+
+        # Deteksi self-loops dalam graf
+        self_loops = list(nx.selfloop_edges(G))
+        has_self_loops = len(self_loops) > 0
+
+        for node, degree in top_nodes:
+            neighbors = list(G.neighbors(node))
+            actual_neighbors = [n for n in neighbors if n != node]  # Exclude self-loop
+
+            # Hitung detail koneksi
+            connection_details = []
+            total_edges = 0
+
+            # Hitung edges ke tetangga sebenarnya
+            for neighbor in actual_neighbors:
+                edge_count = G.number_of_edges(node, neighbor)
+                total_edges += edge_count
+                if edge_count > 1:
+                    connection_details.append(f"Node {neighbor} ({edge_count}x)")
+                else:
+                    connection_details.append(f"Node {neighbor}")
+
+            # Tambahkan self-loop jika ada
+            if G.has_edge(node, node):
+                self_edge_count = G.number_of_edges(node, node)
+                total_edges += self_edge_count
+                connection_details.append(
+                    f"Node {node} (SELF-LOOP: {self_edge_count}x)"
+                )
+
+            # Batasi tampilan koneksi
+            if len(connection_details) > 8:
+                display_connections = (
+                    ", ".join(connection_details[:8])
+                    + f", ... (+{len(connection_details)-8})"
+                )
+            else:
+                display_connections = ", ".join(connection_details)
+
+            # Bandingkan degree NetworkX dengan perhitungan manual
+            degree_nx = G.degree(node)
+
+            # Cek self-loop untuk node ini
+            has_self_loop = G.has_edge(node, node)
+            self_loop_count = (
+                1 if has_self_loop else 0
+            )  # Self-loop dihitung 1x sesuai teori graf
+
+            # Total edges termasuk self-loop
+            total_edges_with_self = total_edges + self_loop_count
+            is_consistent = degree_nx == total_edges_with_self
+
+            # Status dengan informasi self-loop
+            if is_consistent:
+                status = "✅ OK" + (" (with self-loop)" if has_self_loop else "")
+            elif has_self_loop:
+                status = f"⚠️ SELF-LOOP (+{self_loop_count})"
+            else:
+                status = "⚠️ INCONSISTENT"
+
+            connection_data.append(
+                {
+                    "Node": node,
+                    "Degree (NetworkX)": degree_nx,
+                    "Total Edges (Manual)": total_edges,
+                    "Self-Loop": "Yes" if has_self_loop else "No",
+                    "Jumlah Tetangga": len(actual_neighbors),
+                    "Detail Koneksi": display_connections,
+                    "Rasio Edge/Tetangga": (
+                        f"{total_edges/len(neighbors):.2f}" if neighbors else "0"
+                    ),
+                    "Status": status,
+                }
+            )
+
+        return pd.DataFrame(connection_data)
+
+    except Exception as e:
+        st.error(f"Error creating connection details: {str(e)}")
+        return pd.DataFrame()
+
+
 def create_map_visualization(gdf_original):
     """Buat visualisasi peta menggunakan Folium dengan error handling"""
     try:
@@ -867,7 +1156,45 @@ def main():
                 st.sidebar.success(f"✅ Data berhasil diunduh: {len(gdf)} features")
 
     # Konfigurasi visualisasi
-    show_labels = st.sidebar.checkbox("Tampilkan Label Node", value=False)
+    st.sidebar.markdown("### 🎨 Pengaturan Visualisasi")
+    show_labels = st.sidebar.checkbox(
+        "Tampilkan Label Node",
+        value=True,
+        help="Menampilkan ID node pada visualisasi graf",
+    )
+    show_edge_details = st.sidebar.checkbox(
+        "Tampilkan Detail Edge",
+        value=False,
+        help="Menampilkan informasi detail tentang saluran listrik",
+    )
+
+    # Pengaturan tampilan label
+    with st.sidebar.expander("🏷️ Pengaturan Label Node"):
+        label_size = st.slider(
+            "Ukuran Label", 6, 16, 10, help="Ukuran font untuk label node"
+        )
+        label_color = st.selectbox(
+            "Warna Label",
+            ["white", "black", "red", "blue", "green"],
+            index=0,
+            help="Warna teks label node",
+        )
+
+    # Pengaturan edge paralel
+    with st.sidebar.expander("🔗 Pengaturan Saluran Paralel"):
+        edge_offset = st.slider(
+            "Jarak Antar Saluran Paralel",
+            0.01,
+            0.05,
+            0.02,
+            0.005,
+            help="Mengatur jarak visual antar saluran paralel",
+        )
+        show_edge_colors = st.checkbox(
+            "Warna Berbeda untuk Saluran Paralel",
+            value=True,
+            help="Memberikan warna berbeda untuk setiap saluran paralel",
+        )
 
     # Add performance settings
     with st.sidebar.expander("⚙️ Pengaturan Performa"):
@@ -1093,15 +1420,237 @@ def main():
                     f"ℹ️ Menampilkan {max_nodes_viz} node dengan degree tertinggi dari total {G.number_of_nodes()} nodes"
                 )
 
+            # Kontrol visualisasi tambahan
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                if show_edge_details:
+                    st.info(
+                        "ℹ️ Mode Detail Edge: Hover pada garis untuk melihat detail saluran"
+                    )
+            with col2:
+                if show_labels:
+                    st.info("ℹ️ Mode Label: ID node ditampilkan pada graf")
+            with col3:
+                # Fitur pencarian node
+                search_node = st.text_input(
+                    "🔍 Cari Node:",
+                    placeholder="Masukkan ID node (contoh: 13, 83, 154)",
+                    help="Masukkan ID node untuk mencari informasi detail",
+                )
+
+                if search_node:
+                    try:
+                        node_id = int(search_node)
+                        if node_id in G.nodes():
+                            neighbors = list(G.neighbors(node_id))
+                            degree_nx = G.degree(node_id)
+
+                            # Hitung manual untuk debugging (exclude self-loop dari neighbors)
+                            total_edges_manual = 0
+                            edge_details = []
+                            actual_neighbors = [
+                                n for n in neighbors if n != node_id
+                            ]  # Exclude self
+
+                            for neighbor in actual_neighbors:
+                                edge_count = G.number_of_edges(node_id, neighbor)
+                                total_edges_manual += edge_count
+                                edge_details.append(f"→ {neighbor} ({edge_count} edge)")
+
+                            # Tambahkan self-loop secara terpisah jika ada
+                            if G.has_edge(node_id, node_id):
+                                self_edge_count = G.number_of_edges(node_id, node_id)
+                                edge_details.append(
+                                    f"→ {node_id} (SELF-LOOP: {self_edge_count} edge)"
+                                )
+                                total_edges_manual += self_edge_count
+
+                            st.success(f"✅ Node {node_id} ditemukan!")
+                            st.write(f"• **Degree (NetworkX)**: {degree_nx}")
+                            st.write(
+                                f"• **Total Edges (Manual)**: {total_edges_manual}"
+                            )
+                            st.write(
+                                f"• **Jumlah Tetangga Sebenarnya**: {len(actual_neighbors)}"
+                            )
+                            st.write(
+                                f"• **Neighbors dari NetworkX**: {len(neighbors)} (mungkin termasuk self)"
+                            )
+
+                            # Debugging mendalam untuk edge
+                            has_self_loop_search = G.has_edge(node_id, node_id)
+                            self_loop_adjustment = 1 if has_self_loop_search else 0
+                            expected_degree = total_edges_manual
+
+                            # Debug: Lihat semua edge yang terhubung ke node ini
+                            st.write("**🔍 Debug - Semua Edge yang Terhubung:**")
+                            all_edges = []
+
+                            # Metode 1: Dari G.edges()
+                            for edge in G.edges(node_id, data=True):
+                                all_edges.append(
+                                    f"Edge: {edge[0]} → {edge[1]} (data: {edge[2]})"
+                                )
+
+                            # Metode 2: Cek degree calculation NetworkX
+                            degree_dict = dict(G.degree([node_id]))
+                            st.write(f"• NetworkX degree calculation: {degree_dict}")
+
+                            # Metode 3: Manual count semua edges
+                            manual_degree = 0
+                            for neighbor in G.neighbors(node_id):
+                                edge_count = G.number_of_edges(node_id, neighbor)
+                                manual_degree += edge_count
+                                st.write(f"• To {neighbor}: {edge_count} edge(s)")
+
+                            st.write(f"• **Manual degree total**: {manual_degree}")
+                            st.write(f"• **NetworkX degree**: {degree_nx}")
+                            st.write(f"• **Difference**: {degree_nx - manual_degree}")
+
+                            if all_edges:
+                                st.write("**All edges from G.edges():**")
+                                for edge in all_edges:
+                                    st.write(f"  {edge}")
+
+                            if degree_nx != manual_degree:
+                                st.error("⚠️ **NETWORKX BUG DETECTED!**")
+                                st.write("**Analysis:**")
+                                st.write(f"- Manual count (CORRECT): {manual_degree}")
+                                st.write(f"- NetworkX degree (WRONG): {degree_nx}")
+                                st.write(f"- Difference: +{degree_nx - manual_degree}")
+                                st.write(
+                                    f"- Self-loop present: {'Yes' if has_self_loop_search else 'No'}"
+                                )
+                                st.write("**Root Cause:**")
+                                st.write(
+                                    "- NetworkX internal bug with self-loop counting"
+                                )
+                                st.write("- Graf construction issue")
+                                st.write("- Use manual count as the correct value")
+
+                                st.success(
+                                    f"✅ **CORRECTED**: Node {node_id} has {manual_degree} connections"
+                                )
+                            elif has_self_loop_search:
+                                st.info(
+                                    "ℹ️ **Self-loop detected** (counted as +1 degree)"
+                                )
+                            else:
+                                st.success("✅ **All calculations consistent!**")
+
+                            st.write("**Detail Koneksi:**")
+                            for detail in edge_details[:8]:
+                                st.write(f"  {detail}")
+                            if len(edge_details) > 8:
+                                st.write(f"  ... dan {len(edge_details) - 8} lainnya")
+
+                        else:
+                            st.warning(f"❌ Node {node_id} tidak ditemukan dalam graf")
+                            # Tampilkan beberapa node yang tersedia untuk referensi
+                            available_nodes = sorted(list(G.nodes()))[:10]
+                            st.info(f"💡 Contoh node yang tersedia: {available_nodes}")
+                    except ValueError:
+                        st.warning("⚠️ Masukkan angka yang valid")
+
+            # Info tambahan tentang node
+            st.markdown("### 📋 Informasi Node")
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                total_nodes = G.number_of_nodes()
+                st.metric("Total Node", total_nodes)
+            with col2:
+                if total_nodes > 0:
+                    min_node = min(G.nodes())
+                    max_node = max(G.nodes())
+                    st.metric("Range Node ID", f"{min_node} - {max_node}")
+            with col3:
+                # Tampilkan beberapa node dengan degree tertinggi
+                if G.number_of_nodes() > 0:
+                    top_degree_nodes = sorted(
+                        G.degree(), key=lambda x: x[1], reverse=True
+                    )[:3]
+                    top_nodes_str = ", ".join(
+                        [str(node) for node, _ in top_degree_nodes]
+                    )
+                    st.metric("Top 3 Node (Degree)", top_nodes_str)
+
             # Visualisasi graf
             try:
                 network_fig = create_network_visualization(
-                    G_viz, st.session_state["nodes"], centrality_measures, show_labels
+                    G_viz,
+                    st.session_state["nodes"],
+                    centrality_measures,
+                    show_labels,
+                    show_edge_details,
+                    label_size,
+                    label_color,
+                    edge_offset,
+                    show_edge_colors,
                 )
                 st.plotly_chart(network_fig, use_container_width=True)
             except Exception as e:
                 st.error(f"Error creating network visualization: {str(e)}")
 
+            # Detail Koneksi Node
+            st.markdown("### 🔗 Detail Koneksi Node")
+
+            try:
+                connection_df = create_node_connection_details(G_viz, top_n=20)
+                if not connection_df.empty:
+                    st.markdown(
+                        """
+                    **Penjelasan Kolom:**
+                    - **Total Edges**: Jumlah total saluran yang terhubung ke node
+                    - **Jumlah Tetangga**: Jumlah node lain yang terhubung langsung
+                    - **Rasio Edge/Tetangga**: Rata-rata saluran per tetangga (>1 = ada saluran paralel)
+                    """
+                    )
+
+                    # Highlight nodes dengan multiple edges
+                    def highlight_multiple_edges(df):
+                        def color_ratio(val):
+                            try:
+                                ratio = float(val)
+                                if ratio > 1.5:
+                                    return "background-color: #ffcccc; font-weight: bold"  # Merah muda untuk rasio tinggi
+                                elif ratio > 1.0:
+                                    return "background-color: #fff2cc"  # Kuning untuk rasio sedang
+                                else:
+                                    return ""
+                            except:
+                                return ""
+
+                        return df.style.applymap(
+                            color_ratio, subset=["Rasio Edge/Tetangga"]
+                        )
+
+                    st.dataframe(
+                        highlight_multiple_edges(connection_df),
+                        use_container_width=True,
+                        height=400,
+                    )
+
+                    # Analisis tambahan
+                    high_ratio_nodes = connection_df[
+                        connection_df["Rasio Edge/Tetangga"].astype(float) > 1.0
+                    ]
+                    if not high_ratio_nodes.empty:
+                        st.markdown("### 🔍 Analisis Saluran Paralel")
+                        st.info(
+                            f"Ditemukan {len(high_ratio_nodes)} node dengan saluran paralel (rasio > 1.0)"
+                        )
+
+                        for _, row in high_ratio_nodes.head(5).iterrows():
+                            st.write(
+                                f"• **Node {row['Node']}**: {row['Total Edges']} saluran ke {row['Jumlah Tetangga']} tetangga (rasio: {row['Rasio Edge/Tetangga']})"
+                            )
+
+                else:
+                    st.warning("Tidak ada data koneksi untuk ditampilkan")
+
+            except Exception as e:
+                st.error(f"Error creating connection details: {str(e)}")
+
             # Informasi graf
             st.markdown("### 🔍 Interpretasi Graf")
             st.markdown(
@@ -1110,6 +1659,7 @@ def main():
             - **Edge (Sisi)**: Merepresentasikan saluran listrik yang menghubungkan antar titik
             - **Warna Node**: Intensitas warna menunjukkan tingkat kepentingan berdasarkan Degree Centrality
             - **Node dengan warna lebih gelap**: Memiliki lebih banyak koneksi (lebih kritis)
+            - **Saluran Paralel**: Node dengan rasio Edge/Tetangga > 1 memiliki multiple saluran ke tetangga yang sama
             """
             )
 
@@ -1126,6 +1676,166 @@ def main():
             except Exception as e:
                 st.error(f"Error creating centrality comparison: {str(e)}")
 
+            # Matriks Sentralitas
+            st.markdown("### 📊 Matriks Nilai Sentralitas")
+
+            try:
+                centrality_df = create_centrality_matrix(centrality_measures)
+                if not centrality_df.empty:
+                    # Tampilkan statistik ringkas
+                    col1, col2, col3, col4 = st.columns(4)
+
+                    with col1:
+                        st.metric("Total Node", len(centrality_df))
+                    with col2:
+                        st.metric(
+                            "Max Degree Centrality",
+                            f"{centrality_df['Degree Centrality'].max():.4f}",
+                        )
+                    with col3:
+                        st.metric(
+                            "Max Betweenness",
+                            f"{centrality_df['Betweenness Centrality'].max():.4f}",
+                        )
+                    with col4:
+                        st.metric(
+                            "Max Closeness",
+                            f"{centrality_df['Closeness Centrality'].max():.4f}",
+                        )
+
+                    # Opsi untuk menampilkan semua data atau hanya top N
+                    display_option = st.radio(
+                        "Pilih tampilan data:",
+                        ["Top 20 Node", "Top 50 Node", "Semua Node"],
+                        horizontal=True,
+                    )
+
+                    if display_option == "Top 20 Node":
+                        display_df = centrality_df.head(20)
+                    elif display_option == "Top 50 Node":
+                        display_df = centrality_df.head(50)
+                    else:
+                        display_df = centrality_df
+
+                    # Tampilkan tabel dengan styling dan color coding
+                    def highlight_values(df):
+                        """Apply color coding to centrality values"""
+                        styled_df = df.style
+
+                        # Color coding untuk setiap kolom centrality
+                        centrality_cols = [
+                            "Degree Centrality",
+                            "Closeness Centrality",
+                            "Betweenness Centrality",
+                            "Eigenvector Centrality",
+                        ]
+
+                        # Color mapping untuk setiap kolom dengan warna berbeda
+                        color_maps = {
+                            "Degree Centrality": "Reds",  # Merah
+                            "Closeness Centrality": "Blues",  # Biru
+                            "Betweenness Centrality": "Greens",  # Hijau
+                            "Eigenvector Centrality": "Purples",  # Ungu
+                        }
+
+                        for col in centrality_cols:
+                            if col in df.columns:
+                                # Gradient color berbeda untuk setiap kolom
+                                styled_df = styled_df.background_gradient(
+                                    subset=[col],
+                                    cmap=color_maps[col],
+                                    vmin=0,
+                                    vmax=df[col].max(),
+                                )
+
+                        # Format angka dengan 6 desimal
+                        format_dict = {}
+                        for col in centrality_cols:
+                            if col in df.columns:
+                                format_dict[col] = "{:.6f}"
+
+                        styled_df = styled_df.format(format_dict)
+
+                        # Styling tambahan
+                        styled_df = styled_df.set_properties(
+                            **{"font-weight": "bold", "text-align": "center"},
+                            subset=["Node"],
+                        )
+
+                        # Highlight top 5 nodes dengan border tebal
+                        top_5_indices = df.head(5).index
+                        styled_df = styled_df.set_properties(
+                            **{"border": "3px solid #ff6b6b", "font-weight": "bold"},
+                            subset=pd.IndexSlice[top_5_indices, :],
+                        )
+
+                        return styled_df
+
+                    # Tampilkan legend untuk color coding
+                    st.markdown(
+                        """
+                    **📋 Keterangan Visualisasi (Warna per Kolom):**
+                    - 🟥 **Degree Centrality**: Gradasi Merah (putih → merah gelap)
+                    - 🟦 **Closeness Centrality**: Gradasi Biru (putih → biru gelap)
+                    - 🟩 **Betweenness Centrality**: Gradasi Hijau (putih → hijau gelap)
+                    - 🟪 **Eigenvector Centrality**: Gradasi Ungu (putih → ungu gelap)
+                    - 🔴 **Border Merah Tebal**: Top 5 node paling penting
+
+                    *Semakin gelap warna = semakin tinggi nilai sentralitas*
+                    """
+                    )
+
+                    # Tampilkan tabel dengan styling
+                    st.dataframe(
+                        highlight_values(display_df),
+                        use_container_width=True,
+                        height=400,
+                    )
+
+                    # Informasi tambahan tentang interpretasi
+                    with st.expander("ℹ️ Cara Membaca Matriks Sentralitas"):
+                        st.markdown(
+                            """
+                        **Interpretasi Nilai Sentralitas:**
+
+                        1. **Degree Centrality (0-1)**:
+                           - Mengukur jumlah koneksi langsung
+                           - Nilai tinggi = node dengan banyak koneksi
+
+                        2. **Closeness Centrality (0-1)**:
+                           - Mengukur kedekatan ke semua node lain
+                           - Nilai tinggi = node yang mudah dijangkau dari mana saja
+
+                        3. **Betweenness Centrality (0-1)**:
+                           - Mengukur seberapa sering node berada di jalur terpendek
+                           - Nilai tinggi = node yang berperan sebagai jembatan penting
+
+                        4. **Eigenvector Centrality (0-1)**:
+                           - Mengukur pengaruh berdasarkan kualitas koneksi
+                           - Nilai tinggi = node yang terhubung ke node-node penting lainnya
+
+                        **Tips Analisis:**
+                        - Node dengan nilai tinggi di semua kategori = **Super Critical**
+                        - Node dengan Betweenness tinggi = **Bottleneck** potensial
+                        - Node dengan Degree tinggi tapi Eigenvector rendah = **Hub** lokal
+                        """
+                        )
+
+                    # Tombol download CSV
+                    csv = centrality_df.to_csv(index=False)
+                    st.download_button(
+                        label="📥 Download Matriks Sentralitas (CSV)",
+                        data=csv,
+                        file_name="centrality_matrix.csv",
+                        mime="text/csv",
+                    )
+
+                else:
+                    st.warning("Tidak ada data sentralitas untuk ditampilkan")
+
+            except Exception as e:
+                st.error(f"Error creating centrality matrix: {str(e)}")
+
             # Identifikasi node kritis
             st.markdown("### 🎯 Identifikasi Node Kritis")
 
@@ -1142,18 +1852,69 @@ def main():
                 for i, (node, centrality) in enumerate(top_nodes, 1):
                     st.write(f"{i}. Node {node}: {centrality:.4f}")
 
-                # Rekomendasi
-                st.markdown("### 💡 Rekomendasi")
-                if top_nodes:
+                # Rekomendasi berdasarkan analisis statistik
+                st.markdown("### 💡 Rekomendasi Berbasis Data")
+                if top_nodes and centrality_measures.get("degree"):
+                    # Analisis statistik degree centrality
+                    degree_values = list(centrality_measures["degree"].values())
+                    mean_degree = np.mean(degree_values)
+                    std_degree = np.std(degree_values)
+                    q75 = np.percentile(degree_values, 75)
+                    q90 = np.percentile(degree_values, 90)
+                    q95 = np.percentile(degree_values, 95)
+
+                    # Threshold berdasarkan statistik
+                    critical_threshold = q90  # Top 10%
+                    high_priority_threshold = q75  # Top 25%
+
+                    # Hitung jumlah node per kategori
+                    critical_nodes = [
+                        node
+                        for node, cent in centrality_measures["degree"].items()
+                        if cent >= critical_threshold
+                    ]
+                    high_priority_nodes = [
+                        node
+                        for node, cent in centrality_measures["degree"].items()
+                        if cent >= high_priority_threshold and cent < critical_threshold
+                    ]
+
+                    st.markdown("#### 📊 Analisis Statistik Degree Centrality")
+                    col1, col2, col3, col4 = st.columns(4)
+                    with col1:
+                        st.metric("Mean", f"{mean_degree:.4f}")
+                    with col2:
+                        st.metric("Std Dev", f"{std_degree:.4f}")
+                    with col3:
+                        st.metric("75th Percentile", f"{q75:.4f}")
+                    with col4:
+                        st.metric("90th Percentile", f"{q90:.4f}")
+
                     st.markdown(
                         f"""
                     **Node Paling Kritis:** Node {top_nodes[0][0]} (Degree Centrality: {top_nodes[0][1]:.4f})
-                    
-                    **Rekomendasi Kebijakan:**
-                    1. **Prioritas Pemeliharaan**: Fokuskan pemeliharaan pada node dengan centrality tinggi
-                    2. **Redundansi**: Pertimbangkan jalur alternatif untuk node kritis
-                    3. **Monitoring**: Pasang sistem monitoring khusus pada node dengan degree centrality > 0.1
-                    4. **Investasi**: Alokasikan investasi infrastruktur pada area dengan connectivity rendah
+
+                    **Rekomendasi Kebijakan Berbasis Data:**
+
+                    1. **🔴 Monitoring Kritis** (≥ {critical_threshold:.4f} - Top 10%):
+                       - **{len(critical_nodes)} node** memerlukan monitoring 24/7
+                       - Sistem backup dan redundansi wajib
+                       - Maintenance preventif bulanan
+
+                    2. **🟡 Monitoring Prioritas** ({high_priority_threshold:.4f} - {critical_threshold:.4f} - Top 25%):
+                       - **{len(high_priority_nodes)} node** monitoring reguler
+                       - Maintenance preventif triwulanan
+                       - Rencana contingency tersedia
+
+                    3. **🟢 Monitoring Standar** (< {high_priority_threshold:.4f}):
+                       - Monitoring rutin sesuai jadwal normal
+                       - Maintenance tahunan
+
+                    **Basis Ilmiah:**
+                    - Threshold berdasarkan distribusi statistik data aktual
+                    - Top 10% (90th percentile) untuk monitoring kritis
+                    - Top 25% (75th percentile) untuk monitoring prioritas
+                    - Menggunakan analisis risiko berbasis data, bukan nilai arbitrary
                     """
                     )
 
@@ -1164,24 +1925,125 @@ def main():
             )
 
             if mst.number_of_nodes() > 0:
+                # Perhitungan dasar
+                total_weight_mst = sum(
+                    [data["weight"] for _, _, data in mst.edges(data=True)]
+                )
+                original_weight = sum(
+                    [data["weight"] for _, _, data in G.edges(data=True)]
+                )
+                savings = original_weight - total_weight_mst
+                efficiency = (
+                    (savings / original_weight * 100) if original_weight > 0 else 0
+                )
+
+                # Tampilkan metrics
                 col1, col2 = st.columns(2)
                 with col1:
-                    total_weight = sum(
-                        [data["weight"] for _, _, data in mst.edges(data=True)]
-                    )
-                    st.metric("Total Bobot MST", f"{total_weight:.2f}m")
-                    st.metric("Jumlah Edge", mst.number_of_edges())
+                    st.metric("Total Bobot MST", f"{total_weight_mst:.2f}m")
+                    st.metric("Jumlah Edge MST", mst.number_of_edges())
                 with col2:
-                    original_weight = sum(
-                        [data["weight"] for _, _, data in G.edges(data=True)]
+                    st.metric("Efisiensi", f"{efficiency:.2f}%")
+                    st.metric("Penghematan", f"{savings:.2f}m")
+
+                # Proses Perhitungan Detail
+                st.markdown("### 🧮 Proses Perhitungan Efisiensi dan Penghematan")
+
+                with st.expander("📊 Detail Perhitungan Langkah demi Langkah"):
+                    st.markdown("#### 1️⃣ **Perhitungan Total Bobot Jaringan Asli**")
+                    st.code(
+                        f"""
+# Formula: Σ(weight_i) untuk semua edge dalam graf asli
+original_edges = {G.number_of_edges()} edge
+original_weight = Σ(weight_i) = {original_weight:.2f} meter
+                    """
+                    )
+
+                    st.markdown("#### 2️⃣ **Perhitungan Total Bobot MST**")
+                    st.code(
+                        f"""
+# Formula: Σ(weight_i) untuk edge dalam MST
+mst_edges = {mst.number_of_edges()} edge
+mst_weight = Σ(weight_i) = {total_weight_mst:.2f} meter
+                    """
                     )
-                    efficiency = (
-                        ((original_weight - total_weight) / original_weight * 100)
-                        if original_weight > 0
-                        else 0
+
+                    st.markdown("#### 3️⃣ **Perhitungan Penghematan Absolut**")
+                    st.code(
+                        f"""
+# Formula: Penghematan = Total_Asli - Total_MST
+savings = {original_weight:.2f} - {total_weight_mst:.2f}
+savings = {savings:.2f} meter
+                    """
                     )
-                    st.metric("Efisiensi", f"{efficiency:.2f}%")
-                    st.metric("Penghematan", f"{original_weight - total_weight:.2f}m")
+
+                    st.markdown("#### 4️⃣ **Perhitungan Efisiensi Relatif**")
+                    st.code(
+                        f"""
+# Formula: Efisiensi = (Penghematan / Total_Asli) × 100%
+efficiency = ({savings:.2f} / {original_weight:.2f}) × 100%
+efficiency = {efficiency:.2f}%
+                    """
+                    )
+
+                    st.markdown("#### 5️⃣ **Interpretasi Hasil**")
+                    if efficiency > 50:
+                        interpretation = (
+                            "🔴 **Sangat Tinggi** - Jaringan asli sangat tidak efisien"
+                        )
+                        recommendation = "Pertimbangkan restrukturisasi besar-besaran"
+                    elif efficiency > 30:
+                        interpretation = (
+                            "🟡 **Tinggi** - Ada potensi optimasi signifikan"
+                        )
+                        recommendation = "Evaluasi edge redundan untuk penghematan"
+                    elif efficiency > 10:
+                        interpretation = "🟢 **Sedang** - Jaringan cukup efisien"
+                        recommendation = "Optimasi minor pada area tertentu"
+                    else:
+                        interpretation = "✅ **Rendah** - Jaringan sudah sangat efisien"
+                        recommendation = "Pertahankan struktur existing"
+
+                    st.markdown(
+                        f"""
+**Tingkat Efisiensi:** {interpretation}
+**Rekomendasi:** {recommendation}
+
+**Penjelasan:**
+- **Efisiensi {efficiency:.2f}%** berarti MST dapat menghemat {efficiency:.2f}% dari total panjang kabel
+- **Penghematan {savings:.2f}m** setara dengan {savings/1000:.3f} km kabel
+- **Edge yang dihilangkan:** {G.number_of_edges() - mst.number_of_edges()} edge (redundan)
+                    """
+                    )
+
+                # Analisis Biaya (opsional)
+                st.markdown("### 💰 Analisis Biaya (Estimasi)")
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    cost_per_meter = st.number_input(
+                        "Biaya per meter (Rp)",
+                        min_value=0,
+                        value=500000,
+                        step=50000,
+                        help="Estimasi biaya instalasi kabel per meter",
+                    )
+
+                with col2:
+                    if cost_per_meter > 0:
+                        total_cost_original = original_weight * cost_per_meter
+                        total_cost_mst = total_weight_mst * cost_per_meter
+                        cost_savings = total_cost_original - total_cost_mst
+
+                        st.metric(
+                            "Biaya Jaringan Asli", f"Rp {total_cost_original:,.0f}"
+                        )
+                        st.metric("Biaya MST", f"Rp {total_cost_mst:,.0f}")
+                        st.metric("Penghematan Biaya", f"Rp {cost_savings:,.0f}")
+
+                        st.success(
+                            f"💡 **Insight**: Dengan MST, dapat menghemat **Rp {cost_savings:,.0f}** ({efficiency:.1f}%) dari biaya konstruksi!"
+                        )
 
                 # Visualisasi MST
                 try:
@@ -1199,12 +2061,158 @@ def main():
                 except Exception as e:
                     st.error(f"Error creating MST visualization: {str(e)}")
 
-                st.markdown("### 🔧 Interpretasi MST")
-                st.markdown(
+                st.markdown("### 🔧 Interpretasi MST dan Analisis Redundansi")
+
+                # Analisis Edge Redundan
+                st.markdown("#### 🔍 Analisis Edge Redundan")
+
+                # Identifikasi edge redundan
+                mst_edges = set(mst.edges())
+                original_edges = set(G.edges())
+                redundant_edges = []
+
+                for edge in original_edges:
+                    # Cek kedua arah karena edge tidak berarah
+                    if edge not in mst_edges and (edge[1], edge[0]) not in mst_edges:
+                        edge_data = G.get_edge_data(edge[0], edge[1])
+                        if edge_data:
+                            redundant_edges.append(
+                                (edge[0], edge[1], edge_data["weight"])
+                            )
+
+                # Hitung total bobot edge redundan
+                total_redundant_weight = sum(
+                    [weight for _, _, weight in redundant_edges]
+                )
+                redundant_percentage = (
+                    (total_redundant_weight / original_weight * 100)
+                    if original_weight > 0
+                    else 0
+                )
+
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Edge Redundan", f"{len(redundant_edges)}")
+                with col2:
+                    st.metric("Bobot Redundan", f"{total_redundant_weight:.2f}m")
+                with col3:
+                    st.metric("% Redundansi", f"{redundant_percentage:.2f}%")
+
+                # Detail perhitungan redundansi
+                with st.expander("🧮 Perhitungan Analisis Redundansi"):
+                    st.markdown("#### 1️⃣ **Identifikasi Edge Redundan**")
+                    st.code(
+                        f"""
+# Edge dalam jaringan asli: {len(original_edges)}
+# Edge dalam MST: {len(mst_edges)}
+# Edge redundan = Edge_asli - Edge_MST
+redundant_edges = {len(redundant_edges)}
                     """
-                - MST menunjukkan jaringan dengan biaya minimum yang tetap menghubungkan semua node
-                - Berguna untuk perencanaan infrastruktur baru atau optimasi jaringan existing
-                - Edge yang tidak termasuk dalam MST bisa dianggap sebagai redundansi
+                    )
+
+                    st.markdown("#### 2️⃣ **Perhitungan Bobot Redundan**")
+                    st.code(
+                        f"""
+# Formula: Σ(weight_i) untuk edge yang tidak ada dalam MST
+total_redundant_weight = Σ(weight_redundant_i)
+total_redundant_weight = {total_redundant_weight:.2f} meter
+                    """
+                    )
+
+                    st.markdown("#### 3️⃣ **Persentase Redundansi**")
+                    st.code(
+                        f"""
+# Formula: (Bobot_Redundan / Bobot_Total_Asli) × 100%
+redundancy_percentage = ({total_redundant_weight:.2f} / {original_weight:.2f}) × 100%
+redundancy_percentage = {redundant_percentage:.2f}%
+                    """
+                    )
+
+                    st.markdown("#### 4️⃣ **Verifikasi Konsistensi**")
+                    st.code(
+                        f"""
+# Verifikasi: MST_weight + Redundant_weight = Original_weight
+{total_weight_mst:.2f} + {total_redundant_weight:.2f} = {total_weight_mst + total_redundant_weight:.2f}
+Original weight: {original_weight:.2f}
+Difference: {abs(original_weight - (total_weight_mst + total_redundant_weight)):.2f}m
+                    """
+                    )
+
+                    # Tampilkan beberapa edge redundan terbesar
+                    if redundant_edges:
+                        st.markdown("#### 5️⃣ **Top 10 Edge Redundan Terpanjang**")
+                        redundant_sorted = sorted(
+                            redundant_edges, key=lambda x: x[2], reverse=True
+                        )[:10]
+                        redundant_df = pd.DataFrame(
+                            redundant_sorted,
+                            columns=["Node A", "Node B", "Panjang (m)"],
+                        )
+                        redundant_df["Panjang (km)"] = (
+                            redundant_df["Panjang (m)"] / 1000
+                        )
+                        st.dataframe(redundant_df, use_container_width=True)
+
+                # Interpretasi berdasarkan tingkat redundansi
+                st.markdown("#### 📊 Interpretasi Tingkat Redundansi")
+
+                if redundant_percentage > 40:
+                    redundancy_level = "🔴 **Sangat Tinggi**"
+                    redundancy_meaning = "Jaringan memiliki banyak jalur alternatif"
+                    redundancy_action = "Pertimbangkan untuk mengurangi edge redundan pada fase konstruksi baru"
+                elif redundant_percentage > 25:
+                    redundancy_level = "🟡 **Tinggi**"
+                    redundancy_meaning = (
+                        "Jaringan memiliki redundansi yang baik untuk keandalan"
+                    )
+                    redundancy_action = (
+                        "Evaluasi cost-benefit antara redundansi dan efisiensi"
+                    )
+                elif redundant_percentage > 10:
+                    redundancy_level = "🟢 **Sedang**"
+                    redundancy_meaning = "Tingkat redundansi optimal untuk keseimbangan efisiensi-keandalan"
+                    redundancy_action = "Pertahankan tingkat redundansi saat ini"
+                else:
+                    redundancy_level = "⚠️ **Rendah**"
+                    redundancy_meaning = (
+                        "Jaringan mendekati struktur minimal (seperti MST)"
+                    )
+                    redundancy_action = (
+                        "Pertimbangkan menambah redundansi untuk meningkatkan keandalan"
+                    )
+
+                st.markdown(
+                    f"""
+**Tingkat Redundansi:** {redundancy_level} ({redundant_percentage:.1f}%)
+
+**Makna:** {redundancy_meaning}
+
+**Rekomendasi:** {redundancy_action}
+
+**Analisis Teknis:**
+- **Edge redundan:** {len(redundant_edges)} dari {len(original_edges)} total edge
+- **Bobot redundan:** {total_redundant_weight:.2f}m ({total_redundant_weight/1000:.3f} km)
+- **Fungsi redundansi:** Menyediakan jalur alternatif jika terjadi gangguan
+- **Trade-off:** Redundansi ↑ = Keandalan ↑, Efisiensi ↓
+                """
+                )
+
+                # Kesimpulan MST
+                st.markdown("#### 🎯 Kesimpulan MST Analysis")
+                st.markdown(
+                    f"""
+**Ringkasan Analisis:**
+
+1. **Efisiensi Jaringan:** {efficiency:.1f}% - MST dapat menghemat {efficiency:.1f}% dari total panjang kabel
+2. **Redundansi Jaringan:** {redundant_percentage:.1f}% - {redundant_percentage:.1f}% dari jaringan bersifat redundan
+3. **Optimasi Potensial:** {len(redundant_edges)} edge dapat dievaluasi untuk penghematan
+4. **Keseimbangan:** Pertimbangkan trade-off antara efisiensi (MST) dan keandalan (redundansi)
+
+**Aplikasi Praktis:**
+- **Perencanaan Baru:** Gunakan MST sebagai baseline minimum
+- **Optimasi Existing:** Evaluasi edge redundan untuk cost reduction
+- **Maintenance:** Prioritaskan edge MST untuk pemeliharaan kritis
+- **Expansion:** Tambahkan edge di luar MST untuk meningkatkan redundansi
                 """
                 )
             else: