Update app.py

app.py

@@ -193,6 +193,92 @@ def classify_path(path, d: int):
     return "snake", True
 
 
+def snake_violations(path: List[int], d: int):
+    """
+    Return a dict with violating pairs for the snake/coil inducedness + adjacency rules.
+
+    We follow the same conventions as classify_path:
+    - If path is closed (path[0]==path[-1]), work with cycle = path[:-1]
+    - Consecutive edges must be adjacent
+    - Inducedness forbids any chord between non-consecutive vertices,
+      except we always allow the endpoints pair (0, n-1)
+      (closing edge for coil, or would-be closing edge for almost coil)
+    """
+    if not path or len(path) <= 1:
+        return {
+            "dup_vertices": [],
+            "non_adjacent_steps": [],
+            "chords": [],
+            "bad_closing_edge": [],
+        }
+
+    is_closed = (path[0] == path[-1])
+    cycle = path[:-1] if is_closed else path[:]
+    n = len(cycle)
+
+    dup_vertices = []
+    non_adjacent_steps = []
+    chords = []
+    bad_closing_edge = []
+
+    # 1) duplicates (report as pairs of positions, but return as vertex pairs for display)
+    # We'll report every duplicate occurrence pair (v, v).
+    pos = {}
+    for i, v in enumerate(cycle):
+        if v in pos:
+            dup_vertices.append((v, v))
+        else:
+            pos[v] = i
+
+    # 2) consecutive non-adjacent steps (pairs of vertices)
+    for i in range(n - 1):
+        a, b = cycle[i], cycle[i + 1]
+        if hamming_dist(a, b) != 1:
+            non_adjacent_steps.append((a, b))
+
+    # closing edge required only if explicitly closed
+    if n >= 2:
+        closing_adjacent = (hamming_dist(cycle[0], cycle[-1]) == 1)
+        if is_closed and not closing_adjacent:
+            bad_closing_edge.append((cycle[-1], cycle[0]))
+
+    # 3) inducedness chords: any non-consecutive adjacent pair, skipping (0,n-1)
+    # To avoid O(n^2) scans on long paths, we use bit-neighbor checks.
+    # For each vertex v, check all its d neighbors u; if u appears in the path,
+    # and the indices are not consecutive (modulo nothing; this is snake logic),
+    # then it's a chord (unless it's endpoints pair).
+    idx_of = {v: i for i, v in enumerate(cycle)}
+    for v, i in idx_of.items():
+        for bit in range(d):
+            u = v ^ (1 << bit)
+            j = idx_of.get(u)
+            if j is None:
+                continue
+
+            # skip actual path edges
+            if abs(i - j) == 1:
+                continue
+
+            # skip endpoints pair (0, n-1) always
+            if (i == 0 and j == n - 1) or (i == n - 1 and j == 0):
+                continue
+
+            # record chord once (as an unordered pair)
+            a, b = (v, u) if v < u else (u, v)
+            chords.append((a, b))
+
+    # de-duplicate chords list
+    chords = sorted(set(chords))
+
+    return {
+        "dup_vertices": dup_vertices,
+        "non_adjacent_steps": non_adjacent_steps,
+        "chords": chords,
+        "bad_closing_edge": bad_closing_edge,
+    }
+
+
+
 def edge_dimension(a: int, b: int) -> int | None:
     """
     Return the dimension index of the edge (a,b) if they are adjacent,
@@ -1255,14 +1341,13 @@ def render(d, show_labels_vals, path, mark_vals, mark_dist_vals, subsel, switchs
 )
 def path_info(d, path):
     path = path or []
+    d = int(d)
 
     if not path:
         return html.Span("Path: (empty)")
 
-    # Vertex list
     path_str = ", ".join(str(v) for v in path)
 
-    # Classification
     label, valid = classify_path(path, d)
     color = {
         "snake": "green",
@@ -1276,25 +1361,57 @@ def path_info(d, path):
     dims = []
     for i in range(len(path) - 1):
         dim = edge_dimension(path[i], path[i + 1])
-        if dim is not None:
-            dims.append(dim)
-        else:
-            # non adjacent step, keep something explicit
-            dims.append("?")
-
+        dims.append(dim if dim is not None else "?")
     dims_str = ", ".join(str(x) for x in dims) if dims else "(none)"
 
-    return html.Div([
-        html.Div([
-            html.Span(f"Path: {path_str} "),
-            html.Span(f"[{label}]", style={"color": color, "fontWeight": "bold"}),
-        ]),
-        html.Div([
-            html.Span("Dimensions: "),
-            html.Span(dims_str, style={"fontFamily": "monospace"}),
-        ]),
-    ])
+    extra = None
+    if label == "not snake":
+        viol = snake_violations(path, d)
+
+        pairs = []
+        # Keep categories separate so it's interpretable
+        if viol["dup_vertices"]:
+            pairs.extend(viol["dup_vertices"])
+        if viol["non_adjacent_steps"]:
+            pairs.extend(viol["non_adjacent_steps"])
+        if viol["bad_closing_edge"]:
+            pairs.extend(viol["bad_closing_edge"])
+        if viol["chords"]:
+            pairs.extend(viol["chords"])
+
+        # Format: (a,b), (c,d), ...
+        # If there are many, don’t explode the UI
+        MAX_SHOW = 30
+        shown = pairs[:MAX_SHOW]
+        pairs_str = ", ".join(f"({a},{b})" for a, b in shown)
+        if len(pairs) > MAX_SHOW:
+            pairs_str += f", ... (+{len(pairs) - MAX_SHOW} more)"
+
+        extra = html.Div(
+            [
+                html.Span("Violations: ", style={"fontWeight": "bold"}),
+                html.Span(pairs_str if pairs_str else "(none)", style={"fontFamily": "monospace"}),
+            ],
+            style={"marginTop": "4px"},
+        )
 
+    return html.Div(
+        [
+            html.Div(
+                [
+                    html.Span(f"Path: {path_str} "),
+                    html.Span(f"[{label}]", style={"color": color, "fontWeight": "bold"}),
+                ]
+            ),
+            html.Div(
+                [
+                    html.Span("Dimensions: "),
+                    html.Span(dims_str, style={"fontFamily": "monospace"}),
+                ]
+            ),
+            extra if extra is not None else html.Span(),
+        ]
+    )
 
 @app.callback(
     Output("path_bits", "children"),