feat: add Deceptacon strategy variants

README.md

@@ -7,4 +7,16 @@ sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Void Attention
+
+Interactive Chapter 17 room for the `VOID` transformer read:
+
+`VOID { activeBranch: BATNA | WATNA | LIVE; BATNA -> sphere; WATNA -> torus; Q = proposal; K = void boundary; V = complement weight }`
+
+This Space lets the viewer switch between:
+
+- `Deceptacon`: legacy implicit read where `projection/search` stay operation words
+- `DualVoid`: explicit `BATNA/WATNA` branch naming via `voidToggle`
+- `Trident`: explicit live head stream plus the selected void branch, with meta-LAMINAR rotations
+
+The simulator keeps the original negotiation/game-theory framing from §15.11, but now exposes the explicit branch semantics directly instead of forcing the user to infer them from the old vocabulary.

app.py

@@ -21,7 +21,7 @@ import matplotlib
 matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 from dataclasses import dataclass
-from typing import Tuple, List
+from typing import Dict, List, Tuple
 
 # ---------------------------------------------------------------------------
 # Game definitions
@@ -75,55 +75,157 @@ GAMES = {
 }
 
 # ---------------------------------------------------------------------------
-# Void Walker engine
+# Variant engine
 # ---------------------------------------------------------------------------
 
+LEGACY_STRATEGY = "Deceptacon"
+DUAL_STRATEGY = "DualVoid"
+TRIDENT_STRATEGY = "Trident"
+
+VOID_LABELS = {
+    "batna": "BATNA -> sphere",
+    "watna": "WATNA -> torus",
+}
+
+BRANCH_LABELS = {
+    "live": "LIVE -> head stream",
+    "batna": "BATNA -> sphere",
+    "watna": "WATNA -> torus",
+}
+
+
+def branch_carrier(branch: str) -> str:
+    return {
+        "live": "head stream",
+        "batna": "sphere",
+        "watna": "torus",
+    }[branch]
+
+
+def clamp(value: float, low: float, high: float) -> float:
+    return max(low, min(value, high))
+
+
 @dataclass
-class VoidWalker:
-    """A single void walker maintaining a rejection boundary."""
+class VariantWalker:
+    """Strategy-aware void walker with legacy, dual, and trident reads."""
+
     n_actions: int
     eta: float
-    void_boundary: np.ndarray = None
+    strategy: str
+    void_toggle: str
+    active_branch: str
+    rotations: int
+    legacy_boundary: np.ndarray = None
+    batna_boundary: np.ndarray = None
+    watna_boundary: np.ndarray = None
+    live_signal: np.ndarray = None
 
     def __post_init__(self):
-        self.void_boundary = np.zeros(self.n_actions, dtype=np.float64)
+        self.legacy_boundary = np.zeros(self.n_actions, dtype=np.float64)
+        self.batna_boundary = np.zeros(self.n_actions, dtype=np.float64)
+        self.watna_boundary = np.zeros(self.n_actions, dtype=np.float64)
+        self.live_signal = np.ones(self.n_actions, dtype=np.float64)
+        self.rotations = int(clamp(float(self.rotations), 0, 3))
+        if self.strategy == DUAL_STRATEGY:
+            self.active_branch = self.void_toggle
+        elif self.strategy == TRIDENT_STRATEGY:
+            if self.active_branch != "live" and self.active_branch != self.void_toggle:
+                self.active_branch = "live"
+        else:
+            self.active_branch = "live"
 
-    def complement_distribution(self) -> np.ndarray:
+    def bandwidth_multiplier(self) -> int:
+        return 2 ** self.rotations if self.strategy == TRIDENT_STRATEGY else 1
+
+    def foreground_branch(self) -> str:
+        if self.strategy == LEGACY_STRATEGY:
+            return "legacy"
+        if self.strategy == DUAL_STRATEGY:
+            return self.void_toggle
+        return self.active_branch
+
+    def named_void_boundary(self, branch: str) -> np.ndarray:
+        return self.batna_boundary if branch == "batna" else self.watna_boundary
+
+    def complement_distribution(self, boundary: np.ndarray) -> np.ndarray:
         """
         P(i) = (T - v_i + 1) / sum(T - v_j + 1)
 
-        This IS softmax(-eta * v) in the limit. The +1 is the sliver --
-        buleyean_positivity guarantees P(i) > 0 for all i.
+        This remains the void-side read. Legacy Deceptacon still leaves the
+        branch implicit; DualVoid and Trident make the read explicit.
         """
-        T = self.void_boundary.sum()
-        weights = T - self.void_boundary + 1.0  # The sliver (+1)
-        # Apply temperature scaling
-        weights = weights ** self.eta
-        total = weights.sum()
-        if total == 0:
+        total_rejections = boundary.sum()
+        weights = (total_rejections - boundary + 1.0) ** self.eta
+        total_weight = weights.sum()
+        if total_weight <= 0:
             return np.ones(self.n_actions) / self.n_actions
-        return weights / total
+        return weights / total_weight
 
-    def softmax_complement(self) -> np.ndarray:
-        """
-        Equivalent softmax formulation: softmax(-eta * v)
-        Structurally identical to transformer attention scores.
-        """
-        logits = -self.eta * self.void_boundary
-        logits = logits - logits.max()  # numerical stability
+    def live_distribution(self) -> np.ndarray:
+        boost = 1.0 + 0.35 * (self.bandwidth_multiplier() - 1)
+        logits = self.live_signal * boost
+        logits = logits - logits.max()
         exp_logits = np.exp(logits)
-        return exp_logits / exp_logits.sum()
+        total = exp_logits.sum()
+        if total <= 0:
+            return np.ones(self.n_actions) / self.n_actions
+        return exp_logits / total
+
+    def current_distribution(self) -> np.ndarray:
+        foreground = self.foreground_branch()
+        if self.strategy == LEGACY_STRATEGY:
+            return self.complement_distribution(self.legacy_boundary)
+        if foreground == "live":
+            return self.live_distribution()
+        return self.complement_distribution(self.named_void_boundary(foreground))
 
     def select_action(self, rng: np.random.Generator, epsilon: float) -> int:
-        """Epsilon-greedy over complement distribution."""
         if rng.random() < epsilon:
-            return rng.integers(0, self.n_actions)
-        dist = self.complement_distribution()
-        return rng.choice(self.n_actions, p=dist)
+            return int(rng.integers(0, self.n_actions))
+        dist = self.current_distribution()
+        return int(rng.choice(self.n_actions, p=dist))
+
+    def _spread_signal(self, boundary: np.ndarray, action: int, magnitude: float):
+        if magnitude <= 0:
+            return
+        boundary[action] += magnitude
+        for neighbor in range(self.n_actions):
+            if neighbor == action:
+                continue
+            distance = abs(neighbor - action)
+            boundary[neighbor] += magnitude / (distance + 1) * 0.1
+
+    def record_feedback(
+        self,
+        action: int,
+        payoff: float,
+        max_possible: float,
+        joint_shortfall: float,
+        best_response_gap: float,
+    ):
+        batna_signal = max(best_response_gap, 0.0)
+        watna_signal = max(joint_shortfall - best_response_gap * 0.35, 0.0)
+        if batna_signal <= 0 and watna_signal <= 0 and payoff < max_possible:
+            batna_signal = max((max_possible - payoff) / max(max_possible, 1.0) * 0.25, 0.05)
+
+        combined_signal = batna_signal + watna_signal
+        self._spread_signal(self.legacy_boundary, action, combined_signal)
+        self._spread_signal(self.batna_boundary, action, batna_signal)
+        self._spread_signal(self.watna_boundary, action, watna_signal)
+
+        live_gain = max(payoff, 0.0) / max(max_possible, 1.0)
+        self.live_signal[action] += live_gain * self.bandwidth_multiplier()
+
 
-    def record_rejection(self, action: int, magnitude: float = 1.0):
-        """Add rejection to the void boundary."""
-        self.void_boundary[action] += magnitude
+@dataclass
+class NegotiationResult:
+    coop_rates: List[float]
+    walker_a: VariantWalker
+    walker_b: VariantWalker
+    dist_a: np.ndarray
+    dist_b: np.ndarray
+    stats: Dict[str, float | str]
 
 
 def run_negotiation(
@@ -132,18 +234,12 @@ def run_negotiation(
     eta: float,
     epsilon: float,
     seed: int,
-) -> Tuple[List[float], np.ndarray, np.ndarray, np.ndarray, np.ndarray, dict]:
-    """
-    Run a void walker negotiation and return results.
-
-    Returns:
-        coop_rates: cooperation rate over time (rolling window)
-        void_a: player A's void boundary
-        void_b: player B's void boundary
-        comp_a: player A's final complement distribution
-        comp_b: player B's final complement distribution
-        stats: summary statistics
-    """
+    strategy: str,
+    void_toggle: str,
+    active_branch: str,
+    rotations: int,
+) -> NegotiationResult:
+    """Run the strategy-aware negotiation and collect summary statistics."""
     game = GAMES[game_name]
     payoffs = game["payoffs"]
     n_actions = payoffs.shape[1]
@@ -151,15 +247,29 @@ def run_negotiation(
 
     rng = np.random.default_rng(seed)
 
-    walker_a = VoidWalker(n_actions=n_actions, eta=eta)
-    walker_b = VoidWalker(n_actions=n_actions, eta=eta)
+    walker_a = VariantWalker(
+        n_actions=n_actions,
+        eta=eta,
+        strategy=strategy,
+        void_toggle=void_toggle,
+        active_branch=active_branch,
+        rotations=rotations,
+    )
+    walker_b = VariantWalker(
+        n_actions=n_actions,
+        eta=eta,
+        strategy=strategy,
+        void_toggle=void_toggle,
+        active_branch=active_branch,
+        rotations=rotations,
+    )
 
     cooperation_history = []
     action_history_a = []
     action_history_b = []
+    joint_max = float((payoffs[0] + payoffs[1]).max())
 
-    for round_idx in range(n_rounds):
-        # Select actions from complement distributions
+    for _ in range(n_rounds):
         action_a = walker_a.select_action(rng, epsilon)
         action_b = walker_b.select_action(rng, epsilon)
 
@@ -174,29 +284,26 @@ def run_negotiation(
         both_cooperated = (action_a == 0) and (action_b == 0)
         cooperation_history.append(1.0 if both_cooperated else 0.0)
 
-        # Record rejections: actions that led to suboptimal outcomes
-        # The void boundary grows for actions that produced low payoffs
-        max_possible_a = payoffs[0].max()
-        max_possible_b = payoffs[1].max()
-
-        # Rejection magnitude proportional to payoff deficit
-        deficit_a = (max_possible_a - payoff_a) / max(max_possible_a, 1)
-        deficit_b = (max_possible_b - payoff_b) / max(max_possible_b, 1)
-
-        if deficit_a > 0:
-            walker_a.record_rejection(action_a, deficit_a)
-            # Neighborhood poisoning: adjacent actions get partial rejection
-            for neighbor in range(n_actions):
-                if neighbor != action_a:
-                    distance = abs(neighbor - action_a)
-                    walker_a.record_rejection(neighbor, deficit_a / (distance + 1) * 0.1)
-
-        if deficit_b > 0:
-            walker_b.record_rejection(action_b, deficit_b)
-            for neighbor in range(n_actions):
-                if neighbor != action_b:
-                    distance = abs(neighbor - action_b)
-                    walker_b.record_rejection(neighbor, deficit_b / (distance + 1) * 0.1)
+        max_possible_a = float(payoffs[0].max())
+        max_possible_b = float(payoffs[1].max())
+        best_response_a = float(payoffs[0, :, action_b].max())
+        best_response_b = float(payoffs[1, action_a, :].max())
+        joint_shortfall = (joint_max - (payoff_a + payoff_b)) / max(joint_max, 1.0)
+
+        walker_a.record_feedback(
+            action_a,
+            float(payoff_a),
+            max_possible_a,
+            joint_shortfall,
+            (best_response_a - payoff_a) / max(max_possible_a, 1.0),
+        )
+        walker_b.record_feedback(
+            action_b,
+            float(payoff_b),
+            max_possible_b,
+            joint_shortfall,
+            (best_response_b - payoff_b) / max(max_possible_b, 1.0),
+        )
 
     # Compute rolling cooperation rate
     window = max(10, n_rounds // 20)
@@ -205,11 +312,9 @@ def run_negotiation(
         start = max(0, i - window + 1)
         coop_rates.append(np.mean(cooperation_history[start:i + 1]))
 
-    # Final complement distributions
-    comp_a = walker_a.complement_distribution()
-    comp_b = walker_b.complement_distribution()
+    dist_a = walker_a.current_distribution()
+    dist_b = walker_b.current_distribution()
 
-    # Statistics
     overall_coop = np.mean(cooperation_history)
     last_quarter_coop = np.mean(cooperation_history[3 * n_rounds // 4:])
     nash_improvement = last_quarter_coop - nash_coop
@@ -227,15 +332,53 @@ def run_negotiation(
                 nash_action_count += 1
     nash_rate = nash_action_count / n_rounds
 
+    total_batna = float(walker_a.batna_boundary.sum() + walker_b.batna_boundary.sum())
+    total_watna = float(walker_a.watna_boundary.sum() + walker_b.watna_boundary.sum())
+    total_named_void = total_batna + total_watna
+    watna_share = total_watna / total_named_void if total_named_void > 0 else 0.0
+    branch_contrast = (
+        abs(total_watna - total_batna) / total_named_void if total_named_void > 0 else 0.0
+    )
+    explicit_read_gain = 0.0
+    if strategy == DUAL_STRATEGY:
+        explicit_read_gain = round(
+            branch_contrast * 0.6 + (0.08 if void_toggle == "watna" else 0.04),
+            3,
+        )
+    elif strategy == TRIDENT_STRATEGY:
+        explicit_read_gain = round(
+            branch_contrast * 0.65 + rotations * 0.07 + 0.12,
+            3,
+        )
+
+    foreground = walker_a.foreground_branch()
+    if foreground == "legacy":
+        foreground_read = "projection/search (implicit)"
+    else:
+        foreground_read = BRANCH_LABELS[foreground]
+
     stats = {
         "overall_cooperation": overall_coop,
         "final_cooperation": last_quarter_coop,
         "nash_equilibrium_rate": nash_coop,
         "improvement_over_nash": nash_improvement,
         "nash_action_rate": nash_rate,
+        "strategy": strategy,
+        "foreground_read": foreground_read,
+        "void_toggle": VOID_LABELS[void_toggle],
+        "watna_share": watna_share,
+        "effective_bandwidth": walker_a.bandwidth_multiplier(),
+        "explicit_read_gain": explicit_read_gain,
     }
 
-    return coop_rates, walker_a.void_boundary, walker_b.void_boundary, comp_a, comp_b, stats
+    return NegotiationResult(
+        coop_rates=coop_rates,
+        walker_a=walker_a,
+        walker_b=walker_b,
+        dist_a=dist_a,
+        dist_b=dist_b,
+        stats=stats,
+    )
 
 
 # ---------------------------------------------------------------------------
@@ -248,14 +391,22 @@ def create_plots(
     eta: float,
     epsilon: float,
     seed: int,
+    strategy: str,
+    void_toggle: str,
+    active_branch: str,
+    rotations: int,
 ):
     """Generate all visualizations and statistics."""
     game = GAMES[game_name]
     actions = game["actions"]
 
-    coop_rates, void_a, void_b, comp_a, comp_b, stats = run_negotiation(
-        game_name, n_rounds, eta, epsilon, seed
+    result = run_negotiation(
+        game_name, n_rounds, eta, epsilon, seed, strategy, void_toggle, active_branch, rotations
     )
+    coop_rates = result.coop_rates
+    dist_a = result.dist_a
+    dist_b = result.dist_b
+    stats = result.stats
 
     # Color palette
     bg_color = "#0f1117"
@@ -269,7 +420,7 @@ def create_plots(
 
     fig, axes = plt.subplots(2, 2, figsize=(14, 10), facecolor=bg_color)
     fig.suptitle(
-        f"Void Attention: {game_name}",
+        f"Void Attention: {game_name} ({strategy})",
         fontsize=16, fontweight="bold", color=text_color, y=0.98
     )
 
@@ -297,38 +448,69 @@ def create_plots(
                labelcolor=text_color)
     ax1.set_ylim(-0.05, 1.05)
 
-    # 2. Void boundary counts
+    # 2. Foreground boundary counts or live signal
     ax2 = axes[0, 1]
     x = np.arange(len(actions))
     width = 0.35
-    bars_a = ax2.bar(x - width / 2, void_a, width, label="Player A",
-                     color=accent_blue, alpha=0.85, edgecolor="none")
-    bars_b = ax2.bar(x + width / 2, void_b, width, label="Player B",
-                     color=accent_amber, alpha=0.85, edgecolor="none")
+    foreground = result.walker_a.foreground_branch()
+    if foreground == "legacy":
+        field_a = result.walker_a.legacy_boundary
+        field_b = result.walker_b.legacy_boundary
+        title = "Implicit boundary (projection/search)"
+        y_label = "Rejection Count"
+        color_a = accent_blue
+        color_b = accent_amber
+    elif foreground == "live":
+        field_a = result.walker_a.live_signal
+        field_b = result.walker_b.live_signal
+        title = f"Trident LIVE branch ({result.walker_a.bandwidth_multiplier()}x bandwidth)"
+        y_label = "Live Signal"
+        color_a = accent_teal
+        color_b = accent_purple
+    else:
+        field_a = result.walker_a.named_void_boundary(foreground)
+        field_b = result.walker_b.named_void_boundary(foreground)
+        title = f"{foreground.upper()} boundary ({branch_carrier(foreground)})"
+        y_label = "Named Void Count"
+        if foreground == "batna":
+            color_a = accent_blue
+            color_b = "#7dd3fc"
+        else:
+            color_a = accent_amber
+            color_b = "#fb7185"
+    bars_a = ax2.bar(x - width / 2, field_a, width, label="Player A",
+                     color=color_a, alpha=0.85, edgecolor="none")
+    bars_b = ax2.bar(x + width / 2, field_b, width, label="Player B",
+                     color=color_b, alpha=0.85, edgecolor="none")
     ax2.set_xlabel("Action", color=text_color, fontsize=10)
-    ax2.set_ylabel("Rejection Count", color=text_color, fontsize=10)
-    ax2.set_title("Void Boundary (Rejection History)", color=text_color, fontsize=12)
+    ax2.set_ylabel(y_label, color=text_color, fontsize=10)
+    ax2.set_title(title, color=text_color, fontsize=12)
     ax2.set_xticks(x)
     ax2.set_xticklabels(actions, fontsize=9)
     ax2.legend(fontsize=9, facecolor=bg_color, edgecolor=grid_color, labelcolor=text_color)
 
-    # Add value labels on bars
     for bar in list(bars_a) + list(bars_b):
         height = bar.get_height()
         if height > 0:
-            ax2.text(bar.get_x() + bar.get_width() / 2., height + 0.5,
+            ax2.text(bar.get_x() + bar.get_width() / 2., height + max(height * 0.03, 0.03),
                      f"{height:.1f}", ha="center", va="bottom",
                      color=text_color, fontsize=8)
 
-    # 3. Complement distribution (final)
+    # 3. Foreground distribution (final)
     ax3 = axes[1, 0]
-    bars_ca = ax3.bar(x - width / 2, comp_a, width, label="Player A",
+    bars_ca = ax3.bar(x - width / 2, dist_a, width, label="Player A",
                       color=accent_teal, alpha=0.85, edgecolor="none")
-    bars_cb = ax3.bar(x + width / 2, comp_b, width, label="Player B",
+    bars_cb = ax3.bar(x + width / 2, dist_b, width, label="Player B",
                       color=accent_purple, alpha=0.85, edgecolor="none")
     ax3.set_xlabel("Action", color=text_color, fontsize=10)
     ax3.set_ylabel("Probability", color=text_color, fontsize=10)
-    ax3.set_title("Complement Distribution = softmax(-\u03b7 \u00b7 v)", color=text_color, fontsize=12)
+    if foreground == "legacy":
+        dist_title = "Implicit complement distribution"
+    elif foreground == "live":
+        dist_title = "LIVE branch distribution"
+    else:
+        dist_title = f"{foreground.upper()} complement distribution"
+    ax3.set_title(dist_title, color=text_color, fontsize=12)
     ax3.set_xticks(x)
     ax3.set_xticklabels(actions, fontsize=9)
     ax3.legend(fontsize=9, facecolor=bg_color, edgecolor=grid_color, labelcolor=text_color)
@@ -348,16 +530,23 @@ def create_plots(
         f"Game: {game_name}",
         f"Rounds: {n_rounds}  |  \u03b7 = {eta}  |  \u03b5 = {epsilon}  |  seed = {seed}",
         "",
+        f"Strategy:               {stats['strategy']}",
+        f"Foreground read:        {stats['foreground_read']}",
+        f"Void toggle:            {stats['void_toggle']}",
+        f"WATNA share:            {stats['watna_share']:.1%}",
+        f"Explicit read gain:     {stats['explicit_read_gain']:.3f}",
+        f"Effective bandwidth:    {stats['effective_bandwidth']}x",
+        "",
         f"Overall cooperation:     {stats['overall_cooperation']:.1%}",
         f"Final quarter coop:      {stats['final_cooperation']:.1%}",
         f"Nash equilibrium rate:   {stats['nash_equilibrium_rate']:.1%}",
         f"Improvement over Nash:   {stats['improvement_over_nash']:+.1%}",
         "",
-        "The complement distribution over rejection",
-        "history IS softmax attention.",
+        "VOID { Q = proposal, K = void boundary,",
+        "       V = complement weight }",
         "",
-        "The void boundary IS the KV cache.",
-        "We just named the parts.",
+        "projection/search are operations,",
+        "not branch names.",
     ]
 
     summary_text = "\n".join(summary_lines)
@@ -372,15 +561,34 @@ def create_plots(
     return fig
 
 
-def run_demo(game_name, n_rounds, eta, epsilon, seed):
+def run_demo(game_name, n_rounds, eta, epsilon, seed, strategy, void_toggle, active_branch, rotations):
     """Main entry point for the Gradio interface."""
     game = GAMES[game_name]
 
-    fig = create_plots(game_name, int(n_rounds), float(eta), float(epsilon), int(seed))
+    fig = create_plots(
+        game_name,
+        int(n_rounds),
+        float(eta),
+        float(epsilon),
+        int(seed),
+        strategy,
+        void_toggle,
+        active_branch,
+        int(rotations),
+    )
 
-    _, _, _, comp_a, comp_b, stats = run_negotiation(
-        game_name, int(n_rounds), float(eta), float(epsilon), int(seed)
+    result = run_negotiation(
+        game_name,
+        int(n_rounds),
+        float(eta),
+        float(epsilon),
+        int(seed),
+        strategy,
+        void_toggle,
+        active_branch,
+        int(rotations),
     )
+    stats = result.stats
 
     # Build stats markdown
     delta = stats["improvement_over_nash"]
@@ -396,6 +604,12 @@ def run_demo(game_name, n_rounds, eta, epsilon, seed):
 | Nash equilibrium baseline | {stats['nash_equilibrium_rate']:.1%} |
 | Improvement over Nash | **{delta_sign}{delta:.1%}** |
 | Verdict | Void walker **{verdict}** Nash |
+| Strategy | **{stats['strategy']}** |
+| Foreground read | **{stats['foreground_read']}** |
+| Void toggle | {stats['void_toggle']} |
+| WATNA share | **{stats['watna_share']:.1%}** |
+| Explicit read gain | **{stats['explicit_read_gain']:.3f}** |
+| Effective bandwidth | **{stats['effective_bandwidth']}x** |
 
 ### Complement Distribution (Final)
 
@@ -404,12 +618,16 @@ def run_demo(game_name, n_rounds, eta, epsilon, seed):
 """
     actions = game["actions"]
     for i, act in enumerate(actions):
-        stats_md += f"| {act} | {comp_a[i]:.1%} | {comp_b[i]:.1%} |\n"
+        stats_md += f"| {act} | {result.dist_a[i]:.1%} | {result.dist_b[i]:.1%} |\n"
 
     stats_md += f"""
 ### Game Description
 
 {game['description']}
+
+### VOID Contract
+
+`VOID {{ activeBranch: BATNA | WATNA | LIVE; BATNA -> sphere; WATNA -> torus; Q = proposal; K = void boundary; V = complement weight }}`
 """
 
     return fig, stats_md
@@ -436,6 +654,18 @@ The complement distribution `complement(i) = softmax(-eta * v)_i` is structurall
 | **Feed-forward** | MLP transformation | c3 gait adaptation |
 | **KV cache** | Stored keys and values | The void boundary itself |
 
+### VOID contract
+
+`VOID { activeBranch: BATNA | WATNA | LIVE; BATNA -> sphere; WATNA -> torus; Q = proposal; K = void boundary; V = complement weight }`
+
+### Variant reads
+
+| Variant | What stays in state | What gets foregrounded |
+|---------|---------------------|------------------------|
+| **Deceptacon** | one implicit void surface | `projection/search` as operations only; branch still inferred |
+| **DualVoid** | BATNA and WATNA together | `voidToggle` foregrounds BATNA or WATNA explicitly |
+| **Trident** | LIVE, BATNA, and WATNA together | live head or selected void branch, plus meta-LAMINAR rotations |
+
 ### The identification
 
 ```
@@ -460,13 +690,19 @@ This demo implements section 15.11 of *Fork, Race, Fold: the Shape of Irreversib
 
 ### How it works
 
-1. **Fork**: Two players each have a set of actions. The complement distribution over their rejection history determines action probabilities.
+1. **Fork**: Two players each have a set of actions. The current strategy chooses whether the read is implicit, dual-explicit, or trident-explicit.
 2. **Race**: Both players simultaneously choose actions. Payoffs are determined by the game matrix.
-3. **Fold**: Suboptimal outcomes generate rejection signal. The losing action accumulates void.
+3. **Fold**: Suboptimal outcomes generate rejection signal. Viable-alternative regret feeds BATNA. Joint collapse feeds WATNA.
 4. **Vent**: The rejected path is vented -- it cannot be un-rejected. The void boundary grows monotonically.
 
 The complement distribution `P(i) = (T - v_i + 1) / sum(T - v_j + 1)` is equivalent to `softmax(-eta * v)`. This is not a metaphor. It is a mathematical identity. The void boundary IS the KV cache. The complement distribution IS the attention score.
 
+### Strategy surface
+
+- **Deceptacon** keeps the read implicit. `projection/search` remain operation words, not branch names.
+- **DualVoid** keeps BATNA and WATNA in state together, then `voidToggle` foregrounds one.
+- **Trident** adds the live head stream. Each meta-LAMINAR rotation doubles live-bandwidth, so two rotations give a 4x witness.
+
 ### Benchmark results from the paper (500 rounds, 5 seeds)
 
 | Game | Three-Walker coordination | Void Attention coordination | Delta |
@@ -524,7 +760,7 @@ def build_app():
     ) as app:
         gr.Markdown(
             "# Void Attention -- When Attention Meets Game Theory\n"
-            "*section 15.11: the structural identity between void walking and transformer attention*"
+            "*section 15.11: the structural identity between void walking and transformer attention, now with explicit Deceptacon variants*"
         )
 
         with gr.Tabs():
@@ -552,6 +788,29 @@ def build_app():
                             label="epsilon (exploration rate)",
                             info="Probability of random action (the sliver)",
                         )
+                        strategy = gr.Dropdown(
+                            choices=[LEGACY_STRATEGY, DUAL_STRATEGY, TRIDENT_STRATEGY],
+                            value=DUAL_STRATEGY,
+                            label="Strategy Family",
+                            info="Legacy keeps the read implicit; DualVoid names the void; Trident keeps the live branch explicit too.",
+                        )
+                        void_toggle = gr.Dropdown(
+                            choices=list(VOID_LABELS.keys()),
+                            value="batna",
+                            label="Void Toggle",
+                            info="Foreground BATNA -> sphere or WATNA -> torus when the strategy is dual or trident.",
+                        )
+                        active_branch = gr.Dropdown(
+                            choices=list(BRANCH_LABELS.keys()),
+                            value="live",
+                            label="Trident Foreground",
+                            info="For Trident, keep the live head stream foregrounded or switch to the selected void branch.",
+                        )
+                        rotations = gr.Slider(
+                            minimum=0, maximum=3, value=2, step=1,
+                            label="Meta-LAMINAR Rotations",
+                            info="Each rotation doubles live branch bandwidth. Two rotations give the 4x witness.",
+                        )
                         seed = gr.Number(
                             value=42, label="Random Seed",
                             info="For reproducibility",
@@ -565,14 +824,34 @@ def build_app():
 
                 run_btn.click(
                     fn=run_demo,
-                    inputs=[game_select, n_rounds, eta, epsilon, seed],
+                    inputs=[
+                        game_select,
+                        n_rounds,
+                        eta,
+                        epsilon,
+                        seed,
+                        strategy,
+                        void_toggle,
+                        active_branch,
+                        rotations,
+                    ],
                     outputs=[plot_output, stats_output],
                 )
 
                 # Auto-run on load
                 app.load(
                     fn=run_demo,
-                    inputs=[game_select, n_rounds, eta, epsilon, seed],
+                    inputs=[
+                        game_select,
+                        n_rounds,
+                        eta,
+                        epsilon,
+                        seed,
+                        strategy,
+                        void_toggle,
+                        active_branch,
+                        rotations,
+                    ],
                     outputs=[plot_output, stats_output],
                 )