CRDT-Merge Multi-Node Convergence Laboratory - all 26 strategies

README.md

@@ -18,7 +18,7 @@ tags:
   - convergence
   - neural-network
   - federated-learning
-short_description: "CRDT convergence proof: 100 nodes, 26 strategies"
+short_description: "CRDT convergence lab for 26 merge strategies"
 ---
 
 # CRDT-Merge Multi-Node Convergence Laboratory

app.py

@@ -15,28 +15,37 @@ import time
 import random
 import json
 from collections import defaultdict
-from typing import Tuple
 
 from crdt_merge.model import CRDTMergeState
 
-NO_BASE_STRATEGIES = sorted(
-    set(CRDTMergeState.KNOWN_STRATEGIES) - CRDTMergeState.BASE_REQUIRED
-)
+ALL_STRATEGIES = sorted(CRDTMergeState.KNOWN_STRATEGIES)
+BASE_REQUIRED = CRDTMergeState.BASE_REQUIRED
+NO_BASE_STRATEGIES = sorted(set(ALL_STRATEGIES) - BASE_REQUIRED)
 
 
+def _make_state(strategy, base=None):
+    """Create a CRDTMergeState, providing base if the strategy requires it."""
+    if strategy in BASE_REQUIRED:
+        return CRDTMergeState(strategy, base=base)
+    return CRDTMergeState(strategy)
+
+
+# ===== Experiment 1: Multi-Node Convergence =====
+
 def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings=5, seed=42):
     n_nodes, tensor_dim, n_random_orderings, seed = int(n_nodes), int(tensor_dim), int(n_random_orderings), int(seed)
     np.random.seed(seed)
     shape = (tensor_dim, tensor_dim)
     total_params = tensor_dim * tensor_dim * n_nodes
+    base = np.random.randn(*shape).astype(np.float64)
     tensors = [np.random.randn(*shape).astype(np.float64) for _ in range(n_nodes)]
 
     log = []
     log.append(f"{'='*72}")
     log.append(f"  MULTI-NODE CONVERGENCE EXPERIMENT")
     log.append(f"{'='*72}")
-    log.append(f"  Nodes: {n_nodes}  |  Tensor: {shape}  |  Params: {total_params:,}  |  Strategy: {strategy}")
-    log.append(f"  Random orderings: {n_random_orderings}")
+    log.append(f"  Nodes: {n_nodes}  |  Tensor: {shape}  |  Params: {total_params:,}")
+    log.append(f"  Strategy: {strategy}  |  Orderings: {n_random_orderings}")
     log.append(f"{'='*72}\n")
 
     all_resolved, all_hashes, ordering_times = [], [], []
@@ -45,17 +54,15 @@ def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings
         rng = random.Random(seed + oidx)
         nodes = []
         for i in range(n_nodes):
-            s = CRDTMergeState(strategy)
+            s = _make_state(strategy, base)
             s.add(tensors[i], model_id=f"node-{i}")
             nodes.append(s)
 
         t0 = time.perf_counter()
-        order = list(range(n_nodes))
-        rng.shuffle(order)
+        order = list(range(n_nodes)); rng.shuffle(order)
         merge_count = 0
         for i in order:
-            targets = list(range(n_nodes))
-            rng.shuffle(targets)
+            targets = list(range(n_nodes)); rng.shuffle(targets)
             for j in targets:
                 if i != j:
                     nodes[i].merge(nodes[j])
@@ -75,14 +82,10 @@ def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings
         ordering_times.append(gossip_ms)
 
         status = "CONVERGED" if (unique == 1 and bitwise) else "DIVERGED"
-        log.append(
-            f"  Ordering {oidx+1}: {status}  | gossip {gossip_ms:7.1f}ms "
-            f"| resolve {resolve_ms:7.1f}ms | merges {merge_count:,} | max_diff {max_diff:.1e}"
-        )
+        log.append(f"  Ordering {oidx+1}: {status}  | gossip {gossip_ms:7.1f}ms | resolve {resolve_ms:7.1f}ms | merges {merge_count:,} | max_diff {max_diff:.1e}")
 
     cross_equal = all(np.array_equal(all_resolved[0], r) for r in all_resolved[1:])
     cross_hashes = len(set(all_hashes)) == 1
-
     log.append(f"\n{'~'*72}")
     log.append(f"  CROSS-ORDERING VERIFICATION")
     log.append(f"{'~'*72}")
@@ -90,7 +93,6 @@ def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings
     log.append(f"  All orderings bitwise equal:   {'YES' if cross_equal else 'NO'}")
     log.append(f"  Canonical hash: {all_hashes[0][:40]}...")
     log.append(f"  Avg gossip: {np.mean(ordering_times):.1f}ms")
-
     verdict = "PASS" if (cross_equal and cross_hashes) else "FAIL"
     log.append(f"\n  VERDICT: {verdict}")
 
@@ -104,10 +106,13 @@ def run_convergence_experiment(n_nodes, tensor_dim, strategy, n_random_orderings
     return "\n".join(log), json.dumps(summary, indent=2)
 
 
+# ===== Experiment 2: Network Partition & Healing =====
+
 def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed=42):
     n_nodes, tensor_dim, n_partitions, seed = int(n_nodes), int(tensor_dim), int(n_partitions), int(seed)
     np.random.seed(seed)
     shape = (tensor_dim, tensor_dim)
+    base = np.random.randn(*shape).astype(np.float64)
     tensors = [np.random.randn(*shape).astype(np.float64) for _ in range(n_nodes)]
 
     log = []
@@ -119,7 +124,7 @@ def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed
 
     nodes = []
     for i in range(n_nodes):
-        s = CRDTMergeState(strategy)
+        s = _make_state(strategy, base)
         s.add(tensors[i], model_id=f"node-{i}")
         nodes.append(s)
 
@@ -135,8 +140,7 @@ def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed
     for pid, members in partitions.items():
         for i in members:
             for j in members:
-                if i != j:
-                    nodes[i].merge(nodes[j])
+                if i != j: nodes[i].merge(nodes[j])
     partition_ms = (time.perf_counter() - t0) * 1000
     log.append(f"\n    Partition gossip time: {partition_ms:.1f}ms\n")
 
@@ -147,19 +151,16 @@ def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed
         ok = len(h) == 1
         log.append(f"    Partition {pid}: {'consistent' if ok else 'INCONSISTENT'}  hash: {list(h)[0][:24]}...")
 
-    all_unique_hashes = set()
-    for h in partition_hashes.values():
-        all_unique_hashes.update(h)
-    partitions_differ = len(all_unique_hashes) >= min(n_partitions, n_nodes)
+    all_unique = set()
+    for h in partition_hashes.values(): all_unique.update(h)
+    partitions_differ = len(all_unique) >= min(n_partitions, n_nodes)
     log.append(f"\n    Partitions differ from each other: {'YES' if partitions_differ else 'NO'}")
 
     log.append(f"\n  -- Phase 2: Partition Healing (full gossip resumes) --\n")
-
     t0 = time.perf_counter()
     for i in range(n_nodes):
         for j in range(n_nodes):
-            if i != j:
-                nodes[i].merge(nodes[j])
+            if i != j: nodes[i].merge(nodes[j])
     heal_ms = (time.perf_counter() - t0) * 1000
 
     healed = set(n.state_hash for n in nodes)
@@ -167,15 +168,10 @@ def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed
     log.append(f"    Healing time: {heal_ms:.1f}ms")
     log.append(f"    All {n_nodes} nodes converged: {'YES' if all_consistent else 'NO'}")
 
-    t0 = time.perf_counter()
     resolved = [n.resolve() for n in nodes]
-    resolve_ms = (time.perf_counter() - t0) * 1000
     bitwise = all(np.array_equal(resolved[0], r) for r in resolved[1:])
-
     log.append(f"    All resolved bitwise identical: {'YES' if bitwise else 'NO'}")
-    log.append(f"    Resolve time: {resolve_ms:.1f}ms")
     log.append(f"    Final hash: {list(healed)[0][:40]}...")
-
     verdict = "PASS" if (all_consistent and bitwise) else "FAIL"
     log.append(f"\n  VERDICT: {verdict}")
 
@@ -190,45 +186,57 @@ def run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions=3, seed
     return "\n".join(log), json.dumps(summary, indent=2)
 
 
-def run_strategy_sweep(n_nodes, tensor_dim, seed=42, progress=gr.Progress()):
+# ===== Experiment 3: Cross-Strategy Sweep (ALL 26) =====
+
+SLOW_STRATEGIES = {"evolutionary_merge", "genetic_merge"}
+
+def run_strategy_sweep(n_nodes, tensor_dim, seed=42, skip_slow=True, progress=gr.Progress()):
     n_nodes, tensor_dim, seed = int(n_nodes), int(tensor_dim), int(seed)
     np.random.seed(seed)
     shape = (tensor_dim, tensor_dim)
+    base = np.random.randn(*shape).astype(np.float64)
     tensors = [np.random.randn(*shape).astype(np.float64) for _ in range(n_nodes)]
 
+    strategies = ALL_STRATEGIES
+    if skip_slow:
+        strategies = [s for s in strategies if s not in SLOW_STRATEGIES]
+        skipped = sorted(SLOW_STRATEGIES)
+    else:
+        skipped = []
+
     log = []
     log.append(f"{'='*72}")
-    log.append(f"  CROSS-STRATEGY CONVERGENCE SWEEP")
+    log.append(f"  CROSS-STRATEGY CONVERGENCE SWEEP — ALL 26 STRATEGIES")
     log.append(f"{'='*72}")
-    log.append(f"  Nodes: {n_nodes}  |  Tensor: {shape}  |  Strategies: {len(NO_BASE_STRATEGIES)}")
+    log.append(f"  Nodes: {n_nodes}  |  Tensor: {shape}  |  Testing: {len(strategies)}/{len(ALL_STRATEGIES)}")
+    if skipped:
+        log.append(f"  Skipped (slow): {', '.join(skipped)}")
     log.append(f"{'='*72}\n")
 
-    header = f"  {'Strategy':<28s} {'Conv':>5s}  {'Gossip':>9s}  {'Resolve':>9s}  {'Hash':>24s}"
+    header = f"  {'Strategy':<28s} {'Base':>4s} {'Conv':>5s}  {'Gossip':>9s}  {'Resolve':>9s}  {'Hash':>24s}"
     log.append(header)
-    log.append(f"  {'~'*28} {'~'*5}  {'~'*9}  {'~'*9}  {'~'*24}")
+    log.append(f"  {'~'*28} {'~'*4} {'~'*5}  {'~'*9}  {'~'*9}  {'~'*24}")
 
     pass_count, fail_count = 0, 0
     rows = []
 
-    for idx, strat in enumerate(NO_BASE_STRATEGIES):
-        progress((idx + 1) / len(NO_BASE_STRATEGIES), f"Testing {strat}...")
+    for idx, strat in enumerate(strategies):
+        progress((idx + 1) / len(strategies), f"Testing {strat}...")
         try:
+            needs_base = strat in BASE_REQUIRED
             rng = random.Random(seed)
             nds = []
             for i in range(n_nodes):
-                s = CRDTMergeState(strat)
-                s.add(tensors[i], model_id=f"node-{i}")
+                s = _make_state(strat, base)
+                s.add(tensors[i], model_id=f"n-{i}")
                 nds.append(s)
 
             t0 = time.perf_counter()
-            order = list(range(n_nodes))
-            rng.shuffle(order)
+            order = list(range(n_nodes)); rng.shuffle(order)
             for i in order:
-                tgts = list(range(n_nodes))
-                rng.shuffle(tgts)
+                tgts = list(range(n_nodes)); rng.shuffle(tgts)
                 for j in tgts:
-                    if i != j:
-                        nds[i].merge(nds[j])
+                    if i != j: nds[i].merge(nds[j])
             g_ms = (time.perf_counter() - t0) * 1000
 
             hashes = [n.state_hash for n in nds]
@@ -237,30 +245,43 @@ def run_strategy_sweep(n_nodes, tensor_dim, seed=42, progress=gr.Progress()):
             r_ms = (time.perf_counter() - t0) * 1000
 
             ok = len(set(hashes)) == 1 and all(np.array_equal(resolved[0], r) for r in resolved[1:])
-            if ok:
-                pass_count += 1
-            else:
-                fail_count += 1
+            if ok: pass_count += 1
+            else: fail_count += 1
 
-            log.append(f"  {strat:<28s} {'PASS' if ok else 'FAIL':>5s}  {g_ms:8.1f}ms  {r_ms:8.1f}ms  {hashes[0][:24]}")
-            rows.append({"strategy": strat, "converged": bool(ok), "gossip_ms": round(g_ms, 1), "resolve_ms": round(r_ms, 1)})
+            base_tag = "  Y " if needs_base else "    "
+            log.append(f"  {strat:<28s} {base_tag} {'PASS' if ok else 'FAIL':>5s}  {g_ms:8.1f}ms  {r_ms:8.1f}ms  {hashes[0][:24]}")
+            rows.append({"strategy": strat, "needs_base": needs_base, "converged": bool(ok),
+                         "gossip_ms": round(g_ms, 1), "resolve_ms": round(r_ms, 1)})
         except Exception as e:
             fail_count += 1
-            log.append(f"  {strat:<28s}   ERR  {str(e)[:50]}")
+            log.append(f"  {strat:<28s}        ERR  {str(e)[:50]}")
             rows.append({"strategy": strat, "converged": False, "error": str(e)[:50]})
 
-    total = pass_count + fail_count
-    verdict = f"ALL {total} PASS" if fail_count == 0 else f"{fail_count}/{total} FAILED"
+    # Add skipped strategies as noted
+    for strat in skipped:
+        rows.append({"strategy": strat, "converged": "skipped", "note": "evolutionary/genetic (~60s each)"})
+
+    tested = pass_count + fail_count
+    log.append(f"\n{'~'*72}")
+    log.append(f"  Tested: {tested}/{len(ALL_STRATEGIES)} strategies  |  Passed: {pass_count}/{tested}")
+    if skipped:
+        log.append(f"  Skipped: {len(skipped)} (evolutionary strategies, ~60s each on CPU)")
+        log.append(f"  To include: uncheck 'Skip slow strategies'")
+    verdict = f"ALL {tested} PASS" if fail_count == 0 else f"{fail_count}/{tested} FAILED"
     log.append(f"\n  VERDICT: {verdict}")
 
-    summary = {"total_strategies": len(NO_BASE_STRATEGIES), "passed": pass_count, "failed": fail_count, "results": rows}
+    summary = {"total_strategies": len(ALL_STRATEGIES), "tested": tested,
+               "passed": pass_count, "failed": fail_count, "skipped": len(skipped), "results": rows}
     return "\n".join(log), json.dumps(summary, indent=2)
 
 
+# ===== Experiment 4: Scalability Benchmark =====
+
 def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, progress=gr.Progress()):
     max_nodes, tensor_dim, seed = int(max_nodes), int(tensor_dim), int(seed)
     np.random.seed(seed)
     shape = (tensor_dim, tensor_dim)
+    base = np.random.randn(*shape).astype(np.float64)
 
     log = []
     log.append(f"{'='*72}")
@@ -275,8 +296,7 @@ def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, progress=gr.Pr
 
     steps = sorted(set([2, 5, 10, 20, 30, 50, 75, 100]) & set(range(2, max_nodes + 1)))
     if max_nodes not in steps and max_nodes >= 2:
-        steps.append(max_nodes)
-        steps.sort()
+        steps.append(max_nodes); steps.sort()
 
     all_tensors = [np.random.randn(*shape).astype(np.float64) for _ in range(max_nodes)]
     node_counts, gossip_times, resolve_times = [], [], []
@@ -285,8 +305,8 @@ def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, progress=gr.Pr
         progress((si + 1) / len(steps), f"Testing {n} nodes...")
         nds = []
         for i in range(n):
-            s = CRDTMergeState(strategy)
-            s.add(all_tensors[i], model_id=f"node-{i}")
+            s = _make_state(strategy, base)
+            s.add(all_tensors[i], model_id=f"n-{i}")
             nds.append(s)
 
         t0 = time.perf_counter()
@@ -294,8 +314,7 @@ def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, progress=gr.Pr
         for i in range(n):
             for j in range(n):
                 if i != j:
-                    nds[i].merge(nds[j])
-                    merge_ops += 1
+                    nds[i].merge(nds[j]); merge_ops += 1
         g_ms = (time.perf_counter() - t0) * 1000
 
         t0 = time.perf_counter()
@@ -303,54 +322,39 @@ def run_scale_benchmark(max_nodes, tensor_dim, strategy, seed=42, progress=gr.Pr
         r_ms = (time.perf_counter() - t0) * 1000
 
         ok = len(set(nd.state_hash for nd in nds)) == 1 and all(np.array_equal(resolved[0], r) for r in resolved[1:])
-        node_counts.append(n)
-        gossip_times.append(g_ms)
-        resolve_times.append(r_ms)
+        node_counts.append(n); gossip_times.append(g_ms); resolve_times.append(r_ms)
 
-        log.append(
-            f"  {n:>6d}  {n * tensor_dim**2:>12,}  {g_ms:>9.1f}ms  "
-            f"{r_ms:>9.1f}ms  {merge_ops:>10,}  {'PASS' if ok else 'FAIL':>5s}"
-        )
+        log.append(f"  {n:>6d}  {n * tensor_dim**2:>12,}  {g_ms:>9.1f}ms  {r_ms:>9.1f}ms  {merge_ops:>10,}  {'PASS' if ok else 'FAIL':>5s}")
 
     log.append(f"\n  merge() is O(1) per call - independent of tensor size")
-    log.append(f"  Gossip scales as O(n^2) merge operations")
     log.append(f"  100% convergence at all tested scales")
 
-    summary = {
-        "node_counts": node_counts,
-        "gossip_times_ms": [round(g, 1) for g in gossip_times],
-        "resolve_times_ms": [round(r, 1) for r in resolve_times],
-        "strategy": strategy, "tensor_shape": list(shape),
-    }
+    summary = {"node_counts": node_counts, "gossip_times_ms": [round(g, 1) for g in gossip_times],
+               "resolve_times_ms": [round(r, 1) for r in resolve_times], "strategy": strategy}
     return "\n".join(log), json.dumps(summary, indent=2)
 
 
-def run_full_experiment(n_nodes, tensor_dim, strategy, n_orderings, n_partitions, seed, progress=gr.Progress()):
-    all_logs = []
-    summaries = {}
+# ===== Full Suite =====
+
+def run_full_experiment(n_nodes, tensor_dim, strategy, n_orderings, n_partitions, seed, skip_slow, progress=gr.Progress()):
+    all_logs, summaries = [], {}
 
     progress(0.05, "Running multi-node convergence...")
     l, s = run_convergence_experiment(n_nodes, tensor_dim, strategy, n_orderings, seed)
-    all_logs.append(l)
-    summaries["convergence"] = json.loads(s)
+    all_logs.append(l); summaries["convergence"] = json.loads(s)
 
     progress(0.30, "Running partition experiment...")
     l, s = run_partition_experiment(n_nodes, tensor_dim, strategy, n_partitions, seed)
-    all_logs.append(l)
-    summaries["partition"] = json.loads(s)
+    all_logs.append(l); summaries["partition"] = json.loads(s)
 
-    sweep_nodes = min(int(n_nodes), 10)
-    sweep_dim = min(int(tensor_dim), 64)
-
-    progress(0.55, "Running strategy sweep...")
-    l, s = run_strategy_sweep(sweep_nodes, sweep_dim, seed)
-    all_logs.append(l)
-    summaries["strategy_sweep"] = json.loads(s)
+    sweep_n = min(int(n_nodes), 10); sweep_d = min(int(tensor_dim), 64)
+    progress(0.55, "Running strategy sweep (all 26)...")
+    l, s = run_strategy_sweep(sweep_n, sweep_d, seed, skip_slow)
+    all_logs.append(l); summaries["strategy_sweep"] = json.loads(s)
 
     progress(0.80, "Running scalability benchmark...")
-    l, s = run_scale_benchmark(min(int(n_nodes), 50), sweep_dim, strategy, seed)
-    all_logs.append(l)
-    summaries["scalability"] = json.loads(s)
+    l, s = run_scale_benchmark(min(int(n_nodes), 50), sweep_d, strategy, seed)
+    all_logs.append(l); summaries["scalability"] = json.loads(s)
 
     progress(1.0, "Complete!")
 
@@ -364,19 +368,17 @@ def run_full_experiment(n_nodes, tensor_dim, strategy, n_orderings, n_partitions
         f"{'='*72}",
         f"  Multi-node convergence ({int(n_nodes)} nodes, {int(n_orderings)} orderings):  {'PASS' if c else 'FAIL'}",
         f"  Network partition healing ({int(n_partitions)} partitions):               {'PASS' if p else 'FAIL'}",
-        f"  Cross-strategy sweep ({summaries['strategy_sweep']['total_strategies']} strategies):                   {'PASS' if sw else 'FAIL'}",
+        f"  Cross-strategy sweep ({summaries['strategy_sweep']['tested']}/{summaries['strategy_sweep']['total_strategies']} strategies):                  {'PASS' if sw else 'FAIL'}",
         f"  Scalability benchmark:                                     PASS",
         f"{'='*72}",
     ]
-
     if c and p and sw:
         report.append(f"\n  >>> ALL EXPERIMENTS PASSED - CRDT COMPLIANCE VERIFIED <<<")
 
-    full_log = "\n\n".join(all_logs) + "\n" + "\n".join(report)
-    return full_log, json.dumps(summaries, indent=2)
+    return "\n\n".join(all_logs) + "\n" + "\n".join(report), json.dumps(summaries, indent=2)
 
 
-# ---- UI ----
+# ===== Gradio UI =====
 
 DESCRIPTION = """
 # CRDT-Merge Multi-Node Convergence Laboratory
@@ -387,7 +389,7 @@ or strategy choice.**
 
 > **Patent Pending**: UK Application No. 2607132.4 | **Library**: [crdt-merge](https://pypi.org/project/crdt-merge/) v0.9.4
 
-**Four experiments**: Multi-node convergence | Network partition & healing | Cross-strategy sweep | Scalability benchmark
+**Four experiments**: Multi-node convergence | Network partition & healing | All 26 strategies | Scalability benchmark
 """
 
 with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(primary_hue="slate", neutral_hue="slate")) as demo:
@@ -395,28 +397,29 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
 
     with gr.Tabs():
         with gr.TabItem("Full Suite"):
-            gr.Markdown("Run all four experiments in sequence.")
+            gr.Markdown("### Run all four experiments — tests all 26 merge strategies")
             with gr.Row():
                 with gr.Column(scale=1):
                     n_nodes = gr.Slider(3, 100, 30, step=1, label="Nodes")
                     tensor_dim = gr.Slider(16, 512, 128, step=16, label="Tensor Dim (d x d)")
-                    strategy = gr.Dropdown(NO_BASE_STRATEGIES, value="weight_average", label="Strategy")
+                    strategy = gr.Dropdown(ALL_STRATEGIES, value="weight_average", label="Primary Strategy")
                     n_orderings = gr.Slider(2, 20, 5, step=1, label="Random Orderings")
                     n_partitions = gr.Slider(2, 10, 3, step=1, label="Partitions")
                     seed = gr.Number(42, label="Seed", precision=0)
+                    skip_slow = gr.Checkbox(True, label="Skip evolutionary strategies (~2 min each on CPU)")
                     run_btn = gr.Button("Run Full Suite", variant="primary", size="lg")
                 with gr.Column(scale=2):
                     out_log = gr.Textbox(label="Experiment Log", lines=35, max_lines=80)
                     out_json = gr.Textbox(label="JSON", lines=10, max_lines=40)
-            run_btn.click(run_full_experiment, [n_nodes, tensor_dim, strategy, n_orderings, n_partitions, seed], [out_log, out_json])
+            run_btn.click(run_full_experiment, [n_nodes, tensor_dim, strategy, n_orderings, n_partitions, seed, skip_slow], [out_log, out_json])
 
         with gr.TabItem("Convergence"):
-            gr.Markdown("N nodes merge in different random orderings.")
+            gr.Markdown("### N nodes merge in different random orderings — all must produce identical results")
             with gr.Row():
                 with gr.Column(scale=1):
                     c_n = gr.Slider(3, 100, 30, step=1, label="Nodes")
                     c_d = gr.Slider(16, 512, 128, step=16, label="Tensor Dim")
-                    c_s = gr.Dropdown(NO_BASE_STRATEGIES, value="slerp", label="Strategy")
+                    c_s = gr.Dropdown(ALL_STRATEGIES, value="slerp", label="Strategy")
                     c_o = gr.Slider(2, 20, 8, step=1, label="Orderings")
                     c_seed = gr.Number(42, label="Seed", precision=0)
                     c_btn = gr.Button("Run", variant="primary")
@@ -426,12 +429,12 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
             c_btn.click(run_convergence_experiment, [c_n, c_d, c_s, c_o, c_seed], [c_log, c_json])
 
         with gr.TabItem("Partition & Healing"):
-            gr.Markdown("Split nodes into isolated partitions, gossip internally, heal, verify convergence.")
+            gr.Markdown("### Split nodes into isolated partitions, gossip internally, heal, verify convergence")
             with gr.Row():
                 with gr.Column(scale=1):
                     p_n = gr.Slider(6, 100, 30, step=1, label="Nodes")
                     p_d = gr.Slider(16, 512, 128, step=16, label="Tensor Dim")
-                    p_s = gr.Dropdown(NO_BASE_STRATEGIES, value="weight_average", label="Strategy")
+                    p_s = gr.Dropdown(ALL_STRATEGIES, value="ties", label="Strategy")
                     p_p = gr.Slider(2, 10, 4, step=1, label="Partitions")
                     p_seed = gr.Number(42, label="Seed", precision=0)
                     p_btn = gr.Button("Run", variant="primary")
@@ -440,26 +443,27 @@ with gr.Blocks(title="CRDT-Merge Convergence Lab", theme=gr.themes.Default(prima
                     p_json = gr.Textbox(label="JSON", lines=8)
             p_btn.click(run_partition_experiment, [p_n, p_d, p_s, p_p, p_seed], [p_log, p_json])
 
-        with gr.TabItem("Strategy Sweep"):
-            gr.Markdown("Every non-base strategy tested for convergence.")
+        with gr.TabItem("All 26 Strategies"):
+            gr.Markdown("### Every merge strategy tested for convergence — 13 base-free + 13 base-required")
             with gr.Row():
                 with gr.Column(scale=1):
                     sw_n = gr.Slider(3, 30, 10, step=1, label="Nodes")
                     sw_d = gr.Slider(16, 256, 64, step=16, label="Tensor Dim")
                     sw_seed = gr.Number(42, label="Seed", precision=0)
+                    sw_skip = gr.Checkbox(True, label="Skip evolutionary strategies (~2 min each)")
                     sw_btn = gr.Button("Run Sweep", variant="primary")
                 with gr.Column(scale=2):
                     sw_log = gr.Textbox(label="Log", lines=30, max_lines=60)
                     sw_json = gr.Textbox(label="JSON", lines=8)
-            sw_btn.click(run_strategy_sweep, [sw_n, sw_d, sw_seed], [sw_log, sw_json])
+            sw_btn.click(run_strategy_sweep, [sw_n, sw_d, sw_seed, sw_skip], [sw_log, sw_json])
 
         with gr.TabItem("Scalability"):
-            gr.Markdown("Measure convergence overhead from 2 to N nodes.")
+            gr.Markdown("### Measure convergence overhead from 2 to N nodes")
             with gr.Row():
                 with gr.Column(scale=1):
                     sc_m = gr.Slider(10, 100, 50, step=5, label="Max Nodes")
                     sc_d = gr.Slider(16, 256, 64, step=16, label="Tensor Dim")
-                    sc_s = gr.Dropdown(NO_BASE_STRATEGIES, value="weight_average", label="Strategy")
+                    sc_s = gr.Dropdown(ALL_STRATEGIES, value="weight_average", label="Strategy")
                     sc_seed = gr.Number(42, label="Seed", precision=0)
                     sc_btn = gr.Button("Run Benchmark", variant="primary")
                 with gr.Column(scale=2):

requirements.txt

@@ -1,3 +1,3 @@
-crdt-merge[all]>=0.9.3
+crdt-merge[all]>=0.9.4
 numpy>=1.24.0
 gradio>=5.0.0,<6.0.0