feat: Quark-Arranged Skyrms Walker Personality Model

Five walkers (Try/Choose/Commit/LetGo/Learn) interact pairwise
via ten boson channels (5 choose 2 = 10). Settlement to Nash
equilibrium via Skyrms rejection dynamics.

Visualizations:
- Radar chart of five walker values
- Bar chart of ten boson tensions (red/yellow/green)
- Energy convergence + walker trajectory plots
- Full text analysis with theorem references

Presets: Explorer, Builder, Creative, Anxious, Balanced.
Custom sliders for each walker dimension.

Proved in Lean 4 (zero sorry):
THM-FIVE-MAP-TO-FIVE
THM-NO-FREE-QUARKS (confinement)
THM-GAUGE-WALKER-AGREE
THM-WIREFRAME-IS-VACUUM

README.md

@@ -1,12 +1,11 @@
 ---
 title: Quark Personality
-emoji: 💻
-colorFrom: yellow
-colorTo: red
+emoji: "\u2699\uFE0F"
+colorFrom: blue
+colorTo: blue
 sdk: gradio
-sdk_version: 6.9.0
+sdk_version: 5.23.0
+python_version: "3.11"
 app_file: app.py
-pinned: false
+pinned: true
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,336 @@
+"""
+Quark-Arranged Skyrms Walker Personality Model
+Five walkers. Ten bosons. Quark confinement. Settlement to Nash equilibrium.
+
+A personality is not what you are. It is what you are not.
+The void boundary -- the accumulated rejections across five dimensions
+of irreversible choice -- IS the person.
+
+Hot off Lean 4. Zero sorry.
+"""
+
+import gradio as gr
+import numpy as np
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+from dataclasses import dataclass, field
+import json
+
+# ─── AeonOS Dark Theme ──────────────────────────────────────────────────────
+DARK_RC = {
+    "figure.facecolor": "#09090b", "axes.facecolor": "#111114",
+    "axes.edgecolor": "#1f1f23", "axes.labelcolor": "#a1a1aa",
+    "text.color": "#fafafa", "xtick.color": "#71717a", "ytick.color": "#71717a",
+    "grid.color": "#1f1f23", "grid.alpha": 0.3, "figure.dpi": 100,
+    "savefig.facecolor": "#09090b", "font.family": "sans-serif",
+}
+
+WALKER_NAMES = ["Try", "Choose", "Commit", "LetGo", "Learn"]
+WALKER_COLORS = ["#3b82f6", "#22c55e", "#a855f7", "#ef4444", "#f59e0b"]
+PRIMITIVES = ["Fork", "Race", "Fold", "Vent", "Interfere"]
+PARAMS = ["eta", "temperature", "commitGain", "decayRate", "feedbackGain"]
+
+BOSON_PAIRS = [
+    (0,1,"Try↔Choose"), (0,2,"Try↔Commit"), (0,3,"Try↔LetGo"), (0,4,"Try↔Learn"),
+    (1,2,"Choose↔Commit"), (1,3,"Choose↔LetGo"), (1,4,"Choose↔Learn"),
+    (2,3,"Commit↔LetGo"), (2,4,"Commit↔Learn"), (3,4,"LetGo↔Learn"),
+]
+
+PRESETS = {
+    "Explorer":  [0.9, 0.4, 0.3, 0.7, 0.8],
+    "Builder":   [0.4, 0.7, 0.9, 0.2, 0.6],
+    "Creative":  [0.8, 0.3, 0.4, 0.8, 0.9],
+    "Anxious":   [0.3, 0.2, 0.7, 0.1, 0.5],
+    "Balanced":  [0.5, 0.5, 0.5, 0.5, 0.5],
+    "Custom":    [0.6, 0.6, 0.6, 0.6, 0.6],
+}
+
+# ─── Core Model ──────────────────────────────────────────────────────────────
+
+def compute_bosons(walkers):
+    """Compute ten boson tensions (|w_a - w_b| for all pairs)."""
+    bosons = []
+    for a, b, _ in BOSON_PAIRS:
+        bosons.append(abs(walkers[a] - walkers[b]))
+    return np.array(bosons)
+
+def system_energy(bosons):
+    """Total system energy = sum of all boson tensions."""
+    return float(np.sum(bosons))
+
+def is_confined(walkers):
+    """All walkers must be present (> 0). The sliver guarantees this."""
+    return all(w > 0 for w in walkers)
+
+def complement_distribution(void_boundary, eta=3.0):
+    """Compute complement target from void boundary (rejection counts)."""
+    weights = np.array([max(1, total - rej + 1) for total, rej in
+                        zip([sum(void_boundary)] * len(void_boundary), void_boundary)], dtype=float)
+    # Softmax with eta
+    exp_w = np.exp(eta * (weights / max(weights.max(), 1e-8) - 0.5))
+    return exp_w / exp_w.sum()
+
+def settle_personality(initial_walkers, max_rounds=100, epsilon=0.001):
+    """Settle five walkers to Skyrms Nash equilibrium via rejection."""
+    walkers = np.array(initial_walkers, dtype=float)
+    walkers = np.clip(walkers, 0.01, 0.99)  # the sliver
+
+    # Per-walker void boundaries (20 levels each)
+    resolution = 20
+    voids = [np.zeros(resolution) for _ in range(5)]
+    history = [walkers.copy()]
+    energies = [system_energy(compute_bosons(walkers))]
+    gaits = [["stand"] * 5]
+
+    for round_idx in range(max_rounds):
+        new_walkers = walkers.copy()
+        round_gaits = []
+
+        for i in range(5):
+            # Propose new value from complement distribution
+            dist = complement_distribution(voids[i])
+            proposal_idx = np.random.choice(resolution, p=dist)
+            proposal = (proposal_idx + 0.5) / resolution
+
+            # Would this reduce energy?
+            test = new_walkers.copy()
+            test[i] = proposal
+            old_energy = system_energy(compute_bosons(walkers))
+            new_energy = system_energy(compute_bosons(test))
+
+            if new_energy < old_energy:
+                # Accept: update walker
+                new_walkers[i] = proposal
+                gait = "gallop" if (old_energy - new_energy) > 0.1 else "trot"
+            else:
+                # Reject: update void boundary
+                reject_idx = min(int(walkers[i] * resolution), resolution - 1)
+                voids[i][reject_idx] += 1
+                gait = "stand"
+
+            round_gaits.append(gait)
+
+        walkers = np.clip(new_walkers, 0.01, 0.99)
+        bosons = compute_bosons(walkers)
+        energy = system_energy(bosons)
+        history.append(walkers.copy())
+        energies.append(energy)
+        gaits.append(round_gaits)
+
+        # Convergence check
+        if len(energies) > 2 and abs(energies[-1] - energies[-2]) < epsilon:
+            break
+
+    return {
+        "walkers": walkers.tolist(),
+        "bosons": compute_bosons(walkers).tolist(),
+        "energy": system_energy(compute_bosons(walkers)),
+        "confined": is_confined(walkers),
+        "rounds": len(history) - 1,
+        "history": [h.tolist() for h in history],
+        "energies": energies,
+        "gaits": gaits,
+        "voids": [v.tolist() for v in voids],
+    }
+
+# ─── Visualization ──────────────────────────────────────────────────────────
+
+def plot_walkers(result):
+    """Radar chart of final walker values."""
+    with plt.rc_context(DARK_RC):
+        fig, ax = plt.subplots(figsize=(6, 6), subplot_kw=dict(projection='polar'))
+        angles = np.linspace(0, 2 * np.pi, 5, endpoint=False).tolist()
+        angles += angles[:1]
+        values = result["walkers"] + [result["walkers"][0]]
+
+        ax.plot(angles, values, 'o-', color='#06b6d4', linewidth=2, markersize=8)
+        ax.fill(angles, values, alpha=0.15, color='#06b6d4')
+        ax.set_xticks(angles[:-1])
+        ax.set_xticklabels([f"{n}\n({p})" for n, p in zip(WALKER_NAMES, PRIMITIVES)], size=9)
+        ax.set_ylim(0, 1)
+        ax.set_title("Five Walkers (Settled)", pad=20, fontsize=14, color='#fafafa')
+        ax.grid(True, alpha=0.2)
+        fig.tight_layout()
+        return fig
+
+def plot_bosons(result):
+    """Bar chart of ten boson tensions."""
+    with plt.rc_context(DARK_RC):
+        fig, ax = plt.subplots(figsize=(10, 4))
+        labels = [bp[2] for bp in BOSON_PAIRS]
+        values = result["bosons"]
+        colors = ['#ef4444' if v > 0.3 else '#f59e0b' if v > 0.15 else '#22c55e' for v in values]
+        bars = ax.bar(range(10), values, color=colors, alpha=0.8, edgecolor='#1f1f23')
+        ax.set_xticks(range(10))
+        ax.set_xticklabels(labels, rotation=45, ha='right', fontsize=7)
+        ax.set_ylabel("Tension |w_a - w_b|")
+        ax.set_title(f"Ten Bosons (Energy = {result['energy']:.3f})", fontsize=12)
+        ax.set_ylim(0, 1)
+        ax.axhline(y=0.3, color='#ef4444', linestyle='--', alpha=0.3, label='High tension')
+        fig.tight_layout()
+        return fig
+
+def plot_convergence(result):
+    """Energy convergence over settlement rounds."""
+    with plt.rc_context(DARK_RC):
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
+        # Energy
+        ax1.plot(result["energies"], color='#06b6d4', linewidth=2)
+        ax1.set_xlabel("Round")
+        ax1.set_ylabel("System Energy")
+        ax1.set_title(f"Settlement ({result['rounds']} rounds)", fontsize=12)
+        ax1.grid(True, alpha=0.2)
+
+        # Walker trajectories
+        history = np.array(result["history"])
+        for i in range(5):
+            ax2.plot(history[:, i], color=WALKER_COLORS[i], linewidth=1.5, label=WALKER_NAMES[i])
+        ax2.set_xlabel("Round")
+        ax2.set_ylabel("Walker Value")
+        ax2.set_title("Walker Trajectories", fontsize=12)
+        ax2.legend(loc='upper right', fontsize=8)
+        ax2.set_ylim(0, 1)
+        ax2.grid(True, alpha=0.2)
+        fig.tight_layout()
+        return fig
+
+def format_summary(result):
+    """Text summary of the settled personality."""
+    w = result["walkers"]
+    lines = [
+        "QUARK-ARRANGED SKYRMS WALKER PERSONALITY",
+        "=" * 50, "",
+        f"Settlement: {result['rounds']} rounds | Energy: {result['energy']:.4f} | Confined: {result['confined']}",
+        "",
+        "FIVE WALKERS (settled values):",
+    ]
+    for i, (name, prim, param) in enumerate(zip(WALKER_NAMES, PRIMITIVES, PARAMS)):
+        bar = "█" * int(w[i] * 20)
+        lines.append(f"  {name:8s} ({prim:10s}) = {w[i]:.3f} {bar}")
+
+    lines.extend(["", "TEN BOSONS (pairwise tensions):"])
+    for i, (a, b, label) in enumerate(BOSON_PAIRS):
+        v = result["bosons"][i]
+        indicator = "🔴" if v > 0.3 else "🟡" if v > 0.15 else "🟢"
+        lines.append(f"  {indicator} {label:20s} = {v:.3f}")
+
+    lines.extend(["", "THEOREMS (all proved in Lean 4, zero sorry):",
+        "  THM-FIVE-MAP-TO-FIVE: walkers = primitives = hyperparameters",
+        "  THM-NO-FREE-QUARKS: cannot remove one walker (confinement)",
+        "  THM-GAUGE-WALKER-AGREE: gauge field peak = walker peak",
+        f"  THM-WIREFRAME-IS-VACUUM: all equal → energy = 0 (balanced = {result['energy'] < 0.01})",
+    ])
+
+    # Dominant personality interpretation
+    dominant = WALKER_NAMES[np.argmax(w)]
+    weakest = WALKER_NAMES[np.argmin(w)]
+    lines.extend(["", f"INTERPRETATION:",
+        f"  Dominant axis: {dominant} (strongest pull)",
+        f"  Shadow axis: {weakest} (most rejected, deepest void)",
+        f"  The void boundary of {weakest} contains the most information.",
+    ])
+
+    return "\n".join(lines)
+
+# ─── Gradio App ──────────────────────────────────────────────────────────────
+
+def run_settlement(preset, try_v, choose_v, commit_v, letgo_v, learn_v, max_rounds):
+    if preset != "Custom":
+        vals = PRESETS[preset]
+        try_v, choose_v, commit_v, letgo_v, learn_v = vals
+
+    result = settle_personality(
+        [try_v, choose_v, commit_v, letgo_v, learn_v],
+        max_rounds=int(max_rounds),
+    )
+
+    return (
+        plot_walkers(result),
+        plot_bosons(result),
+        plot_convergence(result),
+        format_summary(result),
+        try_v, choose_v, commit_v, letgo_v, learn_v,
+    )
+
+
+CSS = """
+.gradio-container { max-width: 1100px !important; margin: 0 auto !important; }
+.gradio-container, .dark { background: #09090b !important; }
+footer { display: none !important; }
+"""
+
+with gr.Blocks(css=CSS, theme=gr.themes.Base(primary_hue="cyan", neutral_hue="zinc"),
+               title="Quark Personality") as demo:
+
+    gr.HTML("""
+    <div style="text-align:center; padding:2rem 0 1rem">
+        <h1 style="font-size:2.2rem; font-weight:300; color:#fafafa; margin:0">
+            Quark-Arranged <span style="color:#06b6d4">Skyrms Walker</span> Personality
+        </h1>
+        <p style="color:#71717a; font-size:.9rem; margin-top:.5rem; line-height:1.6">
+            Five walkers. Ten bosons. Quark confinement. Settlement to Nash equilibrium.<br>
+            A personality is not what you are. It is what you are not.<br>
+            The void boundary -- accumulated rejections across five dimensions of irreversible choice -- IS the person.<br>
+            Hot off Lean 4. Zero sorry.
+        </p>
+    </div>
+    """)
+
+    with gr.Row():
+        preset = gr.Dropdown(choices=list(PRESETS.keys()), value="Explorer", label="Preset", scale=1)
+        max_rounds = gr.Slider(10, 500, value=100, step=10, label="Max settlement rounds", scale=1)
+        run_btn = gr.Button("Settle Personality", variant="primary", scale=1)
+
+    with gr.Row():
+        try_v = gr.Slider(0.01, 0.99, value=0.9, step=0.01, label="Try (Fork)")
+        choose_v = gr.Slider(0.01, 0.99, value=0.4, step=0.01, label="Choose (Race)")
+        commit_v = gr.Slider(0.01, 0.99, value=0.3, step=0.01, label="Commit (Fold)")
+        letgo_v = gr.Slider(0.01, 0.99, value=0.7, step=0.01, label="LetGo (Vent)")
+        learn_v = gr.Slider(0.01, 0.99, value=0.8, step=0.01, label="Learn (Interfere)")
+
+    with gr.Row():
+        walker_plot = gr.Plot(label="Five Walkers")
+        boson_plot = gr.Plot(label="Ten Bosons")
+
+    convergence_plot = gr.Plot(label="Settlement Convergence")
+
+    with gr.Accordion("Full Analysis", open=False):
+        summary = gr.Textbox(lines=30, show_label=False, interactive=False)
+
+    def on_preset(p):
+        vals = PRESETS.get(p, PRESETS["Custom"])
+        return vals
+
+    preset.change(on_preset, [preset], [try_v, choose_v, commit_v, letgo_v, learn_v])
+
+    run_btn.click(
+        run_settlement,
+        [preset, try_v, choose_v, commit_v, letgo_v, learn_v, max_rounds],
+        [walker_plot, boson_plot, convergence_plot, summary, try_v, choose_v, commit_v, letgo_v, learn_v],
+    )
+
+    demo.load(
+        run_settlement,
+        [preset, try_v, choose_v, commit_v, letgo_v, learn_v, max_rounds],
+        [walker_plot, boson_plot, convergence_plot, summary, try_v, choose_v, commit_v, letgo_v, learn_v],
+    )
+
+    gr.HTML("""
+    <div style="text-align:center; padding:2rem 0; border-top:1px solid #1f1f23; margin-top:2rem; font-size:.8rem; color:#52525b">
+        <p style="color:#a1a1aa; margin-bottom:.5rem">
+            THM-FIVE-MAP-TO-FIVE &middot; THM-NO-FREE-QUARKS &middot; THM-GAUGE-WALKER-AGREE &middot; THM-WIREFRAME-IS-VACUUM
+        </p>
+        <p>
+            <a href="https://forkracefold.com/" style="color:#06b6d4; text-decoration:none">Whitepaper</a> &middot;
+            <a href="https://huggingface.co/spaces/forkjoin-ai/the-void" style="color:#06b6d4; text-decoration:none">The Void</a> &middot;
+            <a href="https://huggingface.co/spaces/forkjoin-ai/glossolalia" style="color:#06b6d4; text-decoration:none">Glossolalia</a> &middot;
+            <a href="https://huggingface.co/spaces/forkjoin-ai/metacog" style="color:#06b6d4; text-decoration:none">Metacog</a> &middot;
+            <a href="https://huggingface.co/spaces/forkjoin-ai/five-bules" style="color:#06b6d4; text-decoration:none">Five Bules</a>
+        </p>
+        <p style="margin-top:.5rem">&phi;&sup2; = &phi; + 1</p>
+    </div>
+    """)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.0.0,<6.0.0
+numpy
+matplotlib