Spaces:
Runtime error
Runtime error
| """ | |
| Void Attention -- When Attention Meets Game Theory | |
| Interactive demo of section 15.11: the structural identity between void walking | |
| and transformer attention. Two-player game theory negotiation where the | |
| complement distribution over rejection history IS softmax attention. | |
| Query = current proposal. Key = void boundary. Value = complement weight. | |
| Temperature = 1/eta. The void boundary IS the KV cache. We just named the parts. | |
| All computation is live. No hardcoded outputs. Deterministic seeds for | |
| reproducibility. Pure Python + numpy. | |
| Reference: "Fork, Race, Fold: the Shape of Irreversible Process" | |
| https://forkracefold.com/ | |
| """ | |
| import gradio as gr | |
| import numpy as np | |
| import matplotlib | |
| matplotlib.use("Agg") | |
| import matplotlib.pyplot as plt | |
| from dataclasses import dataclass | |
| from typing import Dict, List, Tuple | |
| # --------------------------------------------------------------------------- | |
| # Game definitions | |
| # --------------------------------------------------------------------------- | |
| GAMES = { | |
| "Hawk-Dove": { | |
| "payoffs": np.array([ | |
| [[3, 3], [1, 5]], # Player A: [cooperate, defect] x Player B: [cooperate, defect] | |
| [[5, 1], [0, 0]], | |
| ]), | |
| "actions": ["Dove (cooperate)", "Hawk (defect)"], | |
| "nash_coop_rate": 1 / 3, # Mixed Nash: play Dove 1/3 of the time | |
| "description": "Asymmetric conflict. Nash equilibrium mixes at 33.3% cooperation. " | |
| "Void walkers learn to cooperate at ~67-88% by accumulating rejection " | |
| "signal from mutual Hawk crashes.", | |
| }, | |
| "Prisoner's Dilemma": { | |
| "payoffs": np.array([ | |
| [[3, 3], [0, 5]], | |
| [[5, 0], [1, 1]], | |
| ]), | |
| "actions": ["Cooperate", "Defect"], | |
| "nash_coop_rate": 0.0, # Pure Nash: both defect | |
| "description": "The canonical social dilemma. Nash equilibrium is mutual defection (0% cooperation). " | |
| "Void walkers discover that mutual defection accumulates rejection, " | |
| "pushing the complement distribution toward cooperation.", | |
| }, | |
| "Coordination": { | |
| "payoffs": np.array([ | |
| [[4, 4], [0, 0]], | |
| [[0, 0], [2, 2]], | |
| ]), | |
| "actions": ["High payoff", "Low payoff"], | |
| "nash_coop_rate": 0.5, # Two pure Nash equilibria; mixed gives 50% | |
| "description": "Two equilibria: both choose High (payoff 4) or both choose Low (payoff 2). " | |
| "Mixed Nash is 50%. Void walkers learn to coordinate on the Pareto-dominant " | |
| "equilibrium through rejection of miscoordination.", | |
| }, | |
| "Stag Hunt": { | |
| "payoffs": np.array([ | |
| [[5, 5], [0, 3]], | |
| [[3, 0], [3, 3]], | |
| ]), | |
| "actions": ["Stag (cooperate)", "Hare (safe)"], | |
| "nash_coop_rate": 0.5, # Two pure Nash; mixed gives 50% | |
| "description": "Trust game. Stag hunting requires mutual cooperation (payoff 5). " | |
| "Hare hunting is safe but suboptimal (payoff 3). Mixed Nash is 50%. " | |
| "Void walkers build trust through accumulated rejection of betrayal outcomes.", | |
| }, | |
| } | |
| # --------------------------------------------------------------------------- | |
| # 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)) | |
| class VariantWalker: | |
| """Strategy-aware void walker with legacy, dual, and trident reads.""" | |
| n_actions: int | |
| eta: float | |
| 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.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 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 remains the void-side read. Legacy Deceptacon still leaves the | |
| branch implicit; DualVoid and Trident make the read explicit. | |
| """ | |
| 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_weight | |
| 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) | |
| 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: | |
| if rng.random() < epsilon: | |
| 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() | |
| 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( | |
| game_name: str, | |
| n_rounds: int, | |
| eta: float, | |
| epsilon: float, | |
| seed: int, | |
| 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] | |
| nash_coop = game["nash_coop_rate"] | |
| rng = np.random.default_rng(seed) | |
| 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 _ in range(n_rounds): | |
| action_a = walker_a.select_action(rng, epsilon) | |
| action_b = walker_b.select_action(rng, epsilon) | |
| action_history_a.append(action_a) | |
| action_history_b.append(action_b) | |
| # Get payoffs | |
| payoff_a = payoffs[0, action_a, action_b] | |
| payoff_b = payoffs[1, action_a, action_b] | |
| # Determine cooperation (action 0 is the cooperative action) | |
| both_cooperated = (action_a == 0) and (action_b == 0) | |
| cooperation_history.append(1.0 if both_cooperated else 0.0) | |
| 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) | |
| coop_rates = [] | |
| for i in range(len(cooperation_history)): | |
| start = max(0, i - window + 1) | |
| coop_rates.append(np.mean(cooperation_history[start:i + 1])) | |
| dist_a = walker_a.current_distribution() | |
| dist_b = walker_b.current_distribution() | |
| overall_coop = np.mean(cooperation_history) | |
| last_quarter_coop = np.mean(cooperation_history[3 * n_rounds // 4:]) | |
| nash_improvement = last_quarter_coop - nash_coop | |
| # Count how often the Nash equilibrium action profile was played | |
| nash_action_count = 0 | |
| for a_act, b_act in zip(action_history_a, action_history_b): | |
| # For PD and Hawk-Dove, Nash is (defect, defect) = (1, 1) | |
| # For Coordination and Stag Hunt, Nash includes (0,0) and (1,1) | |
| if game_name in ["Prisoner's Dilemma", "Hawk-Dove"]: | |
| if a_act == 1 and b_act == 1: | |
| nash_action_count += 1 | |
| else: | |
| if a_act == b_act: | |
| 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 NegotiationResult( | |
| coop_rates=coop_rates, | |
| walker_a=walker_a, | |
| walker_b=walker_b, | |
| dist_a=dist_a, | |
| dist_b=dist_b, | |
| stats=stats, | |
| ) | |
| # --------------------------------------------------------------------------- | |
| # Visualization | |
| # --------------------------------------------------------------------------- | |
| def create_plots( | |
| game_name: str, | |
| n_rounds: int, | |
| 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"] | |
| 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" | |
| text_color = "#e0e0e0" | |
| grid_color = "#2a2d35" | |
| accent_blue = "#3b82f6" | |
| accent_teal = "#14b8a6" | |
| accent_amber = "#f59e0b" | |
| accent_red = "#ef4444" | |
| accent_purple = "#a855f7" | |
| fig, axes = plt.subplots(2, 2, figsize=(14, 10), facecolor=bg_color) | |
| fig.suptitle( | |
| f"Void Attention: {game_name} ({strategy})", | |
| fontsize=16, fontweight="bold", color=text_color, y=0.98 | |
| ) | |
| for ax in axes.flat: | |
| ax.set_facecolor(bg_color) | |
| ax.tick_params(colors=text_color, labelsize=9) | |
| ax.spines["bottom"].set_color(grid_color) | |
| ax.spines["left"].set_color(grid_color) | |
| ax.spines["top"].set_visible(False) | |
| ax.spines["right"].set_visible(False) | |
| # 1. Cooperation rate over time | |
| ax1 = axes[0, 0] | |
| rounds = np.arange(1, len(coop_rates) + 1) | |
| ax1.plot(rounds, coop_rates, color=accent_teal, linewidth=1.5, label="Void Walker") | |
| ax1.axhline(y=stats["nash_equilibrium_rate"], color=accent_red, linestyle="--", | |
| linewidth=1.5, label=f"Nash eq. ({stats['nash_equilibrium_rate']:.1%})") | |
| ax1.fill_between(rounds, coop_rates, stats["nash_equilibrium_rate"], | |
| alpha=0.15, color=accent_teal, | |
| where=[c > stats["nash_equilibrium_rate"] for c in coop_rates]) | |
| ax1.set_xlabel("Round", color=text_color, fontsize=10) | |
| ax1.set_ylabel("Cooperation Rate", color=text_color, fontsize=10) | |
| ax1.set_title("Cooperation Rate Over Time", color=text_color, fontsize=12) | |
| ax1.legend(loc="lower right", fontsize=9, facecolor=bg_color, edgecolor=grid_color, | |
| labelcolor=text_color) | |
| ax1.set_ylim(-0.05, 1.05) | |
| # 2. Foreground boundary counts or live signal | |
| ax2 = axes[0, 1] | |
| x = np.arange(len(actions)) | |
| width = 0.35 | |
| 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(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) | |
| 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 + max(height * 0.03, 0.03), | |
| f"{height:.1f}", ha="center", va="bottom", | |
| color=text_color, fontsize=8) | |
| # 3. Foreground distribution (final) | |
| ax3 = axes[1, 0] | |
| 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, 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) | |
| 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) | |
| ax3.set_ylim(0, 1.0) | |
| for bar in list(bars_ca) + list(bars_cb): | |
| height = bar.get_height() | |
| ax3.text(bar.get_x() + bar.get_width() / 2., height + 0.01, | |
| f"{height:.1%}", ha="center", va="bottom", | |
| color=text_color, fontsize=9) | |
| # 4. Summary text panel | |
| ax4 = axes[1, 1] | |
| ax4.axis("off") | |
| summary_lines = [ | |
| 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%}", | |
| "", | |
| "VOID { Q = proposal, K = void boundary,", | |
| " V = complement weight }", | |
| "", | |
| "projection/search are operations,", | |
| "not branch names.", | |
| ] | |
| summary_text = "\n".join(summary_lines) | |
| ax4.text(0.05, 0.95, summary_text, transform=ax4.transAxes, | |
| fontsize=11, verticalalignment="top", fontfamily="monospace", | |
| color=text_color, | |
| bbox=dict(boxstyle="round,pad=0.8", facecolor="#1a1d25", | |
| edgecolor=grid_color, alpha=0.9)) | |
| plt.tight_layout(rect=[0, 0, 1, 0.95]) | |
| return fig | |
| 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), | |
| strategy, | |
| void_toggle, | |
| active_branch, | |
| int(rotations), | |
| ) | |
| 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"] | |
| delta_sign = "+" if delta >= 0 else "" | |
| verdict = "outperforms" if delta > 0.01 else ("matches" if abs(delta) <= 0.01 else "underperforms") | |
| stats_md = f"""## Results | |
| | Metric | Value | | |
| |--------|-------| | |
| | Overall cooperation | **{stats['overall_cooperation']:.1%}** | | |
| | Final quarter cooperation | **{stats['final_cooperation']:.1%}** | | |
| | 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) | |
| | Action | Player A | Player B | | |
| |--------|----------|----------| | |
| """ | |
| actions = game["actions"] | |
| for i, act in enumerate(actions): | |
| 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 | |
| # --------------------------------------------------------------------------- | |
| # Attention mapping table (static) | |
| # --------------------------------------------------------------------------- | |
| ATTENTION_TABLE = """## The Structural Identity (section 15.11) | |
| The complement distribution `complement(i) = softmax(-eta * v)_i` is structurally identical to transformer attention. | |
| | Component | Transformer | Void Walking | | |
| |-----------|------------|--------------| | |
| | **Query** | Current token embedding | Current proposal | | |
| | **Key** | Cached key vectors | Void boundary (rejection history) | | |
| | **Value** | Cached value vectors | Complement weight per action | | |
| | **Temperature** | 1/sqrt(d_k) | 1/eta | | |
| | **Multi-head** | H parallel attention heads | H parallel walkers | | |
| | **Cross-attention** | Encoder-decoder attention | Skyrms walker on joint void surface | | |
| | **Residual connection** | x + Attention(x) | Void boundary persistence across rounds | | |
| | **Layer norm** | Normalize activations | Void decay (forgetting old rejections) | | |
| | **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 | |
| ``` | |
| cross(i, j) ~ complement_A[i] * complement_B[j] * complement_S[i*B + j] | |
| ``` | |
| where S is the Skyrms mediator walker's own void over the joint proposal space (the gate). | |
| **The void boundary was always the KV cache. The complement distribution was always softmax attention. We just named the parts.** | |
| ### Key theorem (Lean 4, zero sorry) | |
| - `buleyean_positivity` -- P(i) > 0 for all i (the sliver guarantees exploration) | |
| - `void_boundary_sufficient_statistic` -- the void boundary contains all information needed for optimal action selection | |
| - `void_walkers_converge` -- same rejection history produces same distribution | |
| - `failure_strictly_more_informative` -- rejection carries N-1 bits vs 1 bit for selection | |
| """ | |
| ABOUT_TEXT = """## About | |
| This demo implements section 15.11 of *Fork, Race, Fold: the Shape of Irreversible Process* -- the structural identity between void walking (game-theoretic negotiation via rejection history) and transformer attention. | |
| ### How it works | |
| 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. 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 | | |
| |------|--------------------------|----------------------------|-------| | |
| | Hawk-Dove | 43.4% | 67.4% | +24.0 pp | | |
| | Coordination (3x3) | 7.2% | 22.9% | +15.7 pp | | |
| | Prisoner's Dilemma | 52.2% | 53.7% | +1.4 pp | | |
| | Stag Hunt | 52.2% | 53.7% | +1.4 pp | | |
| The improvement is largest on asymmetric games where the walkers' complement distributions diverge. | |
| ### Formal verification | |
| - 13 Lean 4 theorems (zero sorry) | |
| - 7 TLA+ models (VoidBoundaryMeasurable, VoidDominance, VoidTunnel, VoidAttention, SkyrmsNadir, SkyrmsThreeWalker, NegotiationConvergence) | |
| - 263 companion tests, 695 assertions, 0 failures | |
| --- | |
| **Whitepaper**: [forkracefold.com](https://forkracefold.com/) | |
| **More demos**: | |
| [Aether](https://huggingface.co/spaces/forkjoin-ai/aether) | | |
| [Edge Mesh](https://huggingface.co/spaces/forkjoin-ai/aether-browser) | | |
| [The Void](https://huggingface.co/spaces/forkjoin-ai/the-void) | | |
| [Buleyean RL](https://huggingface.co/spaces/forkjoin-ai/buleyean-rl) | | |
| [Glossolalia](https://huggingface.co/spaces/forkjoin-ai/glossolalia) | | |
| [Glossolalia Examples](https://huggingface.co/spaces/forkjoin-ai/glossolalia-examples) | | |
| [Metacog](https://huggingface.co/spaces/forkjoin-ai/metacog) | | |
| [Five Bules](https://huggingface.co/spaces/forkjoin-ai/five-bules) | | |
| [Quark Personality](https://huggingface.co/spaces/forkjoin-ai/quark-personality) | |
| **Training spaces**: | |
| [Buleyean RL 70B Trainer](https://huggingface.co/spaces/forkjoin-ai/buleyean-rl-70b-trainer) | | |
| [Buleyean RL Mistral 7B Trainer](https://huggingface.co/spaces/forkjoin-ai/buleyean-rl-mistral-7b-trainer) | | |
| [Buleyean RL Qwen 7B Trainer](https://huggingface.co/spaces/forkjoin-ai/buleyean-rl-qwen2.5-7b-trainer) | | |
| [Buleyean RL DeepSeek R1 7B Trainer](https://huggingface.co/spaces/forkjoin-ai/buleyean-rl-deepseek-r1-7b-trainer) | | |
| [Buleyean RL Gemma 9B Trainer](https://huggingface.co/spaces/forkjoin-ai/buleyean-rl-gemma2-9b-trainer) | | |
| [Buleyean RL Qwen 14B Trainer](https://huggingface.co/spaces/forkjoin-ai/buleyean-rl-qwen2.5-14b-trainer) | | |
| [Buleyean RL Mistral Small 24B Trainer](https://huggingface.co/spaces/forkjoin-ai/buleyean-rl-mistral-small-24b-trainer) | |
| **Source**: [github.com/affectively-ai/aeon](https://github.com/affectively-ai/aeon) | |
| Built by [AFFECTIVELY](https://affectively.ai). The complement distribution was always softmax attention. The void boundary was always the KV cache. We just named the parts. | |
| Copyright 2026 forkjoin.ai | |
| """ | |
| # --------------------------------------------------------------------------- | |
| # Gradio interface | |
| # --------------------------------------------------------------------------- | |
| def build_app(): | |
| with gr.Blocks( | |
| title="Void Attention - When Attention Meets Game Theory", | |
| theme=gr.themes.Base( | |
| primary_hue="blue", | |
| secondary_hue="teal", | |
| neutral_hue="slate", | |
| font=gr.themes.GoogleFont("Inter"), | |
| ), | |
| css=""" | |
| .gradio-container { max-width: 1200px !important; } | |
| footer { display: none !important; } | |
| """, | |
| ) as app: | |
| gr.Markdown( | |
| "# Void Attention -- When Attention Meets Game Theory\n" | |
| "*section 15.11: the structural identity between void walking and transformer attention, now with explicit Deceptacon variants*" | |
| ) | |
| with gr.Tabs(): | |
| with gr.Tab("Simulator"): | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| game_select = gr.Dropdown( | |
| choices=list(GAMES.keys()), | |
| value="Hawk-Dove", | |
| label="Game", | |
| info="Select a game theory scenario", | |
| ) | |
| n_rounds = gr.Slider( | |
| minimum=50, maximum=500, value=200, step=10, | |
| label="Rounds", | |
| info="Number of negotiation rounds", | |
| ) | |
| eta = gr.Slider( | |
| minimum=0.1, maximum=5.0, value=1.5, step=0.1, | |
| label="eta (temperature)", | |
| info="Higher eta = sharper complement distribution = more exploitation", | |
| ) | |
| epsilon = gr.Slider( | |
| minimum=0.0, maximum=0.5, value=0.1, step=0.01, | |
| 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", | |
| precision=0, | |
| ) | |
| run_btn = gr.Button("Run Negotiation", variant="primary") | |
| with gr.Column(scale=3): | |
| plot_output = gr.Plot(label="Void Attention Visualization") | |
| stats_output = gr.Markdown() | |
| run_btn.click( | |
| fn=run_demo, | |
| 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, | |
| strategy, | |
| void_toggle, | |
| active_branch, | |
| rotations, | |
| ], | |
| outputs=[plot_output, stats_output], | |
| ) | |
| with gr.Tab("Attention Mapping"): | |
| gr.Markdown(ATTENTION_TABLE) | |
| with gr.Tab("About"): | |
| gr.Markdown(ABOUT_TEXT) | |
| return app | |
| if __name__ == "__main__": | |
| app = build_app() | |
| app.launch(server_name="0.0.0.0", server_port=7860) | |