bisimulation-game

Bisimulation game for resilient skill dispersal across AI agents with GF(3) conservation and observational bridge types.

Ir para a instalação

Repositório: plurigrid/asi
Última atividade na origem: 10 de junho de 2026 às 11:55
Idioma detectado do SKILL.md: inglês
Estrelas: 56
Forks: 13

Opções de instalação

Por padrão, está selecionado o prompt que primeiro revisa a origem. Você pode mudar para um comando direto ou baixar uma cópia local.

Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.

Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.

npx skills add https://github.com/plurigrid/asi --skill bisimulation-game

O comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.

Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.

Revise os arquivos de origem

Leia o SKILL.md e os arquivos complementares exibidos pelo SkillsMP antes de decidir se vai instalar.

Explorador de arquivos

2 arquivos

SKILL.md

Instruções da origem · Visualização somente leitura

Voltar à pesquisa Voltar à instalação

compressive-vasomotion

Compressive Vasomotion Hypothesis (CVH) — vasomotion as a fast compression sweep that collapses ambivalent neural resonances (the Bayesian-blur problem) into a definite state. Use when modeling the ~100ms taṇhā 'grab', precision-weighting as compression forcefulness, or the generative collapse step of vasocomputational active inference.

2026-06-29

latched-hyperprior

Latched Hyperprior Hypothesis (LHH) — a sustained vascular contraction engages the smooth-muscle latch-bridge, durably freezing a circuit as a committed hyperprior isolated from global updating; unlatches when its prediction resolves. Use when modeling durable commitments, trauma/PTSD as cemented priors, latch spirals, or the cross-substrate latch (mechanical/bioelectric/immune/sheaf).

2026-06-29

neural-potentiation

Synaptic substrate of biological active inference — long-term potentiation/depression (LTP/LTD) writes priors into synaptic weights = the learning landscape (Deep CANALs). A held vascular latch annealed long enough crystallizes into a neuron prior. Use when modeling consolidation, neuron priors, the inference→learning landscape write-path, or commit-to-disk of a held prediction.

2026-06-29

Ver todas deste repositório

Bisimulation Game Skill

"Two systems are bisimilar if they cannot be distinguished by any observation."

Overview

The bisimulation game provides a framework for:

Resilient skill dispersal across multiple AI agents

GF(3) conservation during state transitions

Observational bridge types for version-aware synchronization

Self-rewriting capabilities via MCP Tasks protocol

Game Rules

Players

Player

Role

Trit

Color

Attacker

Tries to distinguish systems

-1

Blue

Defender

Maintains equivalence

Red

Arbiter

Verifies conservation

Green

Moves

┌─────────────────────────────────────────────────────────────┐ │ Round n: │ │ │ │ 1. Attacker chooses: system S₁ or S₂ │ │ 2. Attacker makes: transition s₁ →ᵃ s₁' │ │ 3. Defender responds: matching transition s₂ →ᵃ s₂' │ │ 4. Arbiter verifies: GF(3) conservation │ │ │ │ If Defender cannot respond → Attacker wins (distinguishable)│ │ If game continues forever → Defender wins (bisimilar) │ └─────────────────────────────────────────────────────────────┘

# localsend_bisim.py import asyncio from localsend_mcp import LocalSendClient class BisimulationDispersalProtocol: """Disperse skills via LocalSend with bisimulation verification.""" def __init__(self, skill_path, seed=1069): self.skill_path = skill_path self.client = LocalSendClient() self.rng = SplitMixTernary(seed) self.game_log = [] async def discover_peers(self): """Find all agents on local network.""" peers = await self.client.list_peers(source="all") return [p for p in peers if p.get("capabilities", []).count("skill-sync")] async def disperse_with_bisim(self, skill_file): """Disperse skill to all peers with bisimulation verification.""" peers = await self.discover_peers() for i, peer in enumerate(peers): trit = (i % 3) - 1 # Assign trits: -1, 0, +1, -1, ... # Negotiate transfer session session = await self.client.negotiate( peer_id=peer["id"], preferred_transport="tailscale" # Or localsend, nats ) # Send skill (Attacker move) self.game_log.append({ "round": len(self.game_log), "role": "attacker", "action": f"send:{skill_file}", "peer": peer["id"], "trit": trit }) result = await self.client.send( session_id=session["sessionId"], file_path=skill_file ) # Verify receipt (Defender move) defender_trit = await self.verify_peer_receipt(peer, skill_file) self.game_log.append({ "round": len(self.game_log), "role": "defender", "action": f"ack:{result['status']}", "peer": peer["id"], "trit": defender_trit }) # Arbiter verifies GF(3) conservation return self.verify_gf3_conservation() def verify_gf3_conservation(self): """Check that sum of trits ≡ 0 (mod 3).""" total = sum(entry["trit"] for entry in self.game_log) conserved = (total % 3) == 0 self.game_log.append({ "round": len(self.game_log), "role": "arbiter", "conserved": conserved, "total_trit": total, "trit": 0 }) return conserved

╔══════════════════════════════════════════════════════════════════════╗ ║ BISIMULATION GAME TRANSCRIPT ║ ╠══════════════════════════════════════════════════════════════════════╣ ║ Systems: S₁ = Codex skill state, S₂ = Claude skill state ║ ║ Goal: Prove skills are bisimilar (observationally equivalent) ║ ╠══════════════════════════════════════════════════════════════════════╣ ROUND 1: ┌─ ATTACKER (Blue, trit=-1) ─────────────────────────────────────────┐ │ "I choose S₁ and execute: load_skill('gay-mcp')" │ │ Transition: s₁ →^load s₁' where s₁'.has_skill('gay-mcp') = true │ └────────────────────────────────────────────────────────────────────┘ ┌─ DEFENDER (Red, trit=+1) ──────────────────────────────────────────┐ │ "I match in S₂: load_skill('gay-mcp')" │ │ Transition: s₂ →^load s₂' where s₂'.has_skill('gay-mcp') = true │ │ Response: MATCHED ✓ │ └────────────────────────────────────────────────────────────────────┘ ┌─ ARBITER (Green, trit=0) ──────────────────────────────────────────┐ │ GF(3) check: (-1) + (+1) + (0) = 0 ≡ 0 (mod 3) ✓ │ │ ROUND 1: VALID │ └────────────────────────────────────────────────────────────────────┘ ROUND 2: ┌─ ATTACKER ─────────────────────────────────────────────────────────┐ │ "I choose S₂ and execute: generate_color(seed=0x42)" │ │ Transition: s₂' →^gen s₂'' where s₂''.color = #FF6B6B │ └────────────────────────────────────────────────────────────────────┘ ┌─ DEFENDER ─────────────────────────────────────────────────────────┐ │ "I match in S₁: generate_color(seed=0x42)" │ │ Transition: s₁' →^gen s₁'' where s₁''.color = #FF6B6B │ │ Response: MATCHED ✓ (deterministic - same seed = same color) │ └────────────────────────────────────────────────────────────────────┘ ┌─ ARBITER ──────────────────────────────────────────────────────────┐ │ GF(3) check: (-1) + (+1) + (0) = 0 ≡ 0 (mod 3) ✓ │ │ ROUND 2: VALID │ └────────────────────────────────────────────────────────────────────┘ ROUND 3: ┌─ ATTACKER ─────────────────────────────────────────────────────────┐ │ "I choose S₁ and execute: self_modify(patch='add_feature')" │ │ Transition: s₁'' →^mod s₁''' (skill version incremented) │ └────────────────────────────────────────────────────────────────────┘ ┌─ DEFENDER ─────────────────────────────────────────────────────────┐ │ "I match in S₂ via observational bridge type:" │ │ Bridge: (s₁''.version, s₂''.version) →₁ (s₁'''.version, s₂'''.v) │ │ Transition: s₂'' →^mod s₂''' using same patch │ │ Response: MATCHED ✓ (bridge type ensures coherence) │ └────────────────────────────────────────────────────────────────────┘ ┌─ ARBITER ──────────────────────────────────────────────────────────┐ │ GF(3) check: (-1) + (+1) + (0) = 0 ≡ 0 (mod 3) ✓ │ │ ROUND 3: VALID │ │ │ │ After 3 rounds: Defender has matched all Attacker moves │ │ Verdict: S₁ ∼ S₂ (bisimilar to depth 3) │ └────────────────────────────────────────────────────────────────────┘ ╠══════════════════════════════════════════════════════════════════════╣ ║ RESULT: BISIMULATION ESTABLISHED ║ ║ - All transitions matched ║ ║ - GF(3) conserved across all rounds ║ ║ - Skills are observationally equivalent ║ ╚══════════════════════════════════════════════════════════════════════╝

name	bisimulation-game
description	Bisimulation game for resilient skill dispersal across AI agents with GF(3) conservation and observational bridge types.
license	MIT
metadata	{"source":"music-topos + DiscoHy + DisCoPy","xenomodern":true,"ironic_detachment":0.42}

name	bisimulation-game
description	Bisimulation game for resilient skill dispersal across AI agents with GF(3) conservation and observational bridge types.
license	MIT
metadata	{"source":"music-topos + DiscoHy + DisCoPy","xenomodern":true,"ironic_detachment":0.42}

bisimulation-game

Opções de instalação

Revise os arquivos de origem