Update app.py

app.py

@@ -23,6 +23,31 @@ DEFAULTS = {
 
 # ---------- Hypercube utilities ----------
 
+
+def consecutive_triple_start(indices: list[int], n: int, is_closed: bool) -> int | None:
+    """
+    Given 3 indices, return the start index s such that {s,s+1,s+2} (mod n if closed)
+    equals the given set. If not possible, return None.
+    """
+    if len(indices) != 3 or n <= 0:
+        return None
+
+    S = set(indices)
+
+    if is_closed:
+        for s in range(n):
+            if {(s) % n, (s + 1) % n, (s + 2) % n} == S:
+                return s
+        return None
+    else:
+        # open path: must be literal consecutive indices
+        mn = min(S)
+        if S == {mn, mn + 1, mn + 2} and (mn + 2) < n:
+            return mn
+        return None
+
+
+
 def cycle_edge_dims(cycle: List[int], d: int) -> List[int] | None:
     """
     cycle is vertex list WITHOUT repeating start at end.
@@ -540,17 +565,31 @@ def make_figure(d: int,
     # ---------- selected vertices for switch-dims (3 consecutive vertices) ----------
     switchsel = switchsel or {}
     switch_active = bool(switchsel.get("active"))
-    sw_s = switchsel.get("start_idx")
-    sw_e = switchsel.get("end_idx")
-
+    picked = switchsel.get("picked") or []
+    
     switch_vertices = set()
-    if switch_active and sw_s is not None and sw_e is not None and path:
+    switch_segment_edges = []  # list of (a,b) edges to highlight if we can infer the triple segment
+    
+    if switch_active and path:
         is_closed = (len(path) >= 2 and path[0] == path[-1])
         cycle = path[:-1] if is_closed else path[:]
         n = len(cycle)
+    
+        # picked are indices into cycle/path
         if n > 0:
-            dist = (sw_e - sw_s) % n
-            switch_vertices = {cycle[(sw_s + i) % n] for i in range(dist + 1)}
+            for idx in picked:
+                if isinstance(idx, int):
+                    switch_vertices.add(cycle[idx % n] if is_closed else cycle[idx])
+    
+            # If exactly 3 picked and they form a consecutive triple, highlight the 2 edges of that triple
+            if len(picked) == 3:
+                s0 = consecutive_triple_start([int(i) for i in picked], n, is_closed)
+                if s0 is not None:
+                    a = cycle[s0 % n] if is_closed else cycle[s0]
+                    b = cycle[(s0 + 1) % n] if is_closed else cycle[s0 + 1]
+                    c = cycle[(s0 + 2) % n] if is_closed else cycle[s0 + 2]
+                    switch_segment_edges = [(a, b), (b, c)]
+
 
 
     
@@ -677,29 +716,22 @@ def make_figure(d: int,
                 )
             )
 
-    # ---------- highlight switch-dims selection edges ----------
-    if switch_active and sw_s is not None and sw_e is not None and path:
-        is_closed = (len(path) >= 2 and path[0] == path[-1])
-        cycle = path[:-1] if is_closed else path[:]
-        n = len(cycle)
-        if n > 0:
-            dist = (sw_e - sw_s) % n
-            for k in range(dist):
-                a = cycle[(sw_s + k) % n]
-                b = cycle[(sw_s + k + 1) % n]
-                x1, y1 = pos[a]
-                x2, y2 = pos[b]
-                edge_traces.append(
-                    go.Scatter(
-                        x=[x1, x2],
-                        y=[y1, y2],
-                        mode="lines",
-                        line=dict(width=max(2, edge_w * 2), color="#DC2626"),
-                        opacity=1.0,
-                        hoverinfo="skip",
-                        name="switch dims selection",
-                    )
+    # ---------- highlight switch-dims selection edges (only when triple is valid) ----------
+    if switch_active and switch_segment_edges:
+        for (a, b) in switch_segment_edges:
+            x1, y1 = pos[a]
+            x2, y2 = pos[b]
+            edge_traces.append(
+                go.Scatter(
+                    x=[x1, x2],
+                    y=[y1, y2],
+                    mode="lines",
+                    line=dict(width=max(2, edge_w * 2), color="#DC2626"),
+                    opacity=1.0,
+                    hoverinfo="skip",
+                    name="switch dims selection",
                 )
+            )
 
 
     
@@ -888,10 +920,9 @@ app.layout = html.Div(
                 
                 dcc.Store(
                     id="switch_dims_store",
-                    data={"active": False, "start_idx": None, "end_idx": None}
+                    data={"active": False, "picked": []}   # picked holds indices into cycle/path
                 ),
 
-
                 html.Div(),  # empty cell just to keep the grid tidy
             ],
         ),
@@ -1141,11 +1172,9 @@ def update_path(clickData,
     if trigger == "btn_switch_dims":
         active = bool(switchsel.get("active"))
         if not active:
-            # enter switch-dims selection mode
-            return path, subsel, {"active": True, "start_idx": None, "end_idx": None}
+            return path, subsel, {"active": True, "picked": []}
         else:
-            # cancel switch-dims selection mode
-            return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
+            return path, subsel, {"active": False, "picked": []}
 
     
     # 8) Figure clicks
@@ -1154,82 +1183,75 @@ def update_path(clickData,
         cd = p.get("customdata")
 
         # If we're in switch-dims mode, vertex clicks define exactly 3 consecutive vertices
+        # If we're in switch-dims mode, user can pick 3 consecutive vertices in ANY order
         if switchsel.get("active") and isinstance(cd, (int, float)):
             vid = int(cd)
-
-            # Work on a cycle if path is explicitly closed
+        
             is_closed = (len(path) >= 2 and path[0] == path[-1])
             cycle = path[:-1] if is_closed else path[:]
             n = len(cycle)
-
+        
             if n < 3:
-                return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
-
-            # In a proper cycle representation, vertices are unique
+                return path, subsel, {"active": False, "picked": []}
+        
+            # find index of clicked vertex inside cycle/path
             try:
-                idx = cycle.index(vid)
+                idx = cycle.index(vid)  # vertices assumed unique in a valid snake/coil
             except ValueError:
                 return path, subsel, switchsel
+        
+            picked = list(switchsel.get("picked") or [])
+        
+            # toggle behavior: click again removes it
+            if idx in picked:
+                picked = [i for i in picked if i != idx]
+                return path, subsel, {"active": True, "picked": picked}
+        
+            # add it (up to 3)
+            if len(picked) >= 3:
+                # start over from this click
+                picked = [idx]
+                return path, subsel, {"active": True, "picked": picked}
+        
+            picked.append(idx)
+        
+            # if not yet 3, just store
+            if len(picked) < 3:
+                return path, subsel, {"active": True, "picked": picked}
+        
+            # now we have 3: check if they form a consecutive triple
+            s0 = consecutive_triple_start([int(i) for i in picked], n, is_closed)
+            if s0 is None:
+                # not a valid triple, keep them so user can adjust (toggle)
+                return path, subsel, {"active": True, "picked": picked}
+        
+            # canonical triple order along the cycle/path
+            x = cycle[s0 % n] if is_closed else cycle[s0]
+            y = cycle[(s0 + 1) % n] if is_closed else cycle[s0 + 1]
+            z = cycle[(s0 + 2) % n] if is_closed else cycle[s0 + 2]
+        
+            a = edge_dimension(x, y)
+            b = edge_dimension(y, z)
+            if a is None or b is None:
+                return path, subsel, {"active": False, "picked": []}
+        
+            # new middle vertex to traverse b then a
+            y2 = x ^ (1 << b)
+        
+            # verify the new 2-edge path really reaches z via dimensions b then a
+            if edge_dimension(y2, z) != a:
+                return path, subsel, {"active": False, "picked": []}
+        
+            # avoid duplicates in the cycle/path (allow x and z)
+            if y2 in set(cycle) and y2 not in {x, z}:
+                return path, subsel, {"active": False, "picked": []}
+        
+            cycle2 = cycle[:]
+            cycle2[(s0 + 1) % n if is_closed else (s0 + 1)] = y2
+        
+            new_path = cycle2 + [cycle2[0]] if is_closed else cycle2
+            return new_path, subsel, {"active": False, "picked": []}
 
-            s = switchsel.get("start_idx")
-            e = switchsel.get("end_idx")
-
-            # first vertex
-            if s is None:
-                return path, subsel, {"active": True, "start_idx": idx, "end_idx": idx}
-
-            if e is None:
-                e = s
-
-            # distance forward on the cycle (0,1,2,...)
-            dist = (e - s) % n
-
-            # must extend consecutively forward (with wrap)
-            expected = (e + 1) % n
-            if idx == expected and dist < 2:
-                new_e = idx
-                new_dist = (new_e - s) % n
-
-                # if we have 3 vertices selected: apply switch
-                if new_dist == 2:
-                    x = cycle[s]
-                    y = cycle[(s + 1) % n]
-                    z = cycle[(s + 2) % n]
-
-                    a = edge_dimension(x, y)
-                    b = edge_dimension(y, z)
-                    if a is None or b is None:
-                        return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
-
-                    # new middle vertex to traverse b then a
-                    y2 = x ^ (1 << b)
-
-                    # verify it actually reaches z by traversing a next
-                    if edge_dimension(y2, z) != a:
-                        return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
-
-                    # avoid creating duplicates in the cycle (allow x,z)
-                    if y2 in set(cycle) and y2 not in {x, z}:
-                        return path, subsel, {"active": False, "start_idx": None, "end_idx": None}
-
-                    cycle2 = cycle[:]
-                    cycle2[(s + 1) % n] = y2
-
-                    new_path = cycle2 + [cycle2[0]] if is_closed else cycle2
-                    return new_path, subsel, {"active": False, "start_idx": None, "end_idx": None}
-
-                return path, subsel, {"active": True, "start_idx": s, "end_idx": new_e}
-
-            # allow shrinking by clicking current end
-            if idx == e:
-                if e != s:
-                    new_e = (e - 1) % n
-                else:
-                    new_e = s
-                return path, subsel, {"active": True, "start_idx": s, "end_idx": new_e}
-
-            # otherwise ignore
-            return path, subsel, switchsel
 
 
         # If we're in subpath selection mode, vertex clicks define (start_idx, end_idx)