npx claudepluginhub plurigrid/asi --plugin asiThis skill uses the workspace's default tool permissions.
> "The shortest program that outputs the universe is the universe computing itself."
Enables playful multi-agent exploration via mutual ingression with Levin's algorithmic bounds for near-optimal emergent solutions and social computation.
Analyzes game theory for crypto protocols, DeFi mechanisms, governance, tokenomics, MEV, auctions, and web3 incentives. Identifies exploits, equilibria, and design improvements.
Orchestrates collaborative theorem proving in Lean using lc CLI for state management and parallel agents. Employs skeleton verification, math cards, and architecture planning for complex goals.
Share bugs, ideas, or general feedback.
"The shortest program that outputs the universe is the universe computing itself." — Levin, played lightly
┌─────────────────────────────────────────────────────────────────┐
│ LEVIN ⇌ LEVITY DIALECTIC │
├─────────────────────────────────────────────────────────────────┤
│ LEVIN (-1) │ Convergence, compression, Kolmogorov │
│ │ "Find the shortest program" │
│ │ τ_mix → 0 (rapid equilibration) │
├────────────────┼────────────────────────────────────────────────┤
│ LEVITY (+1) │ Exploration, expansion, serendipity │
│ │ "Discover new programs to compress" │
│ │ τ_mix → ∞ (eternal novelty) │
├────────────────┼────────────────────────────────────────────────┤
│ ERGODIC (0) │ Nash equilibrium of the two │
│ │ "Mutual ingression of minds" │
│ │ τ_mix = τ_optimal (WEV extracted) │
└─────────────────────────────────────────────────────────────────┘
The optimal algorithm for inversion problems runs all programs in parallel, weighted by 2^(-|p|):
L(x) = min_p { 2^|p| × T(p,x) }
where |p| is program length and T(p,x) is runtime. This is Levin complexity.
Levity interpretation: Run all proofs in parallel, weighted by their Kolmogorov complexity. The first to halt wins the $BEAVER bounty.
K(x) = length of shortest program producing x
Connection to BB(n):
WEV Insight: The gap between K(BB(n)) and the actual compute cost is the extractable inefficiency.
P(x) = Σ_p 2^(-|p|) for all p that output x
Levity interpretation: The probability that a random program outputs your proof. Higher algorithmic probability = lower $BEAVER reward (too easy!).
From triplet_1_week2_nash_solver.jl:
# Player profiles
LEVITY = RulePerformance(
"LEVITY",
quality = 0.72, # Explores alternative cofactors
exploration = 0.65, # High novelty
cofactor_discovery = 1.0 # Finds new patterns
)
LEVIN = RulePerformance(
"LEVIN",
quality = 0.88, # Fast convergence
exploration = 0.40, # Contracts search space
cofactor_discovery = 0.5 # Rediscovers known patterns
)
# Nash equilibrium
# Neither player can improve by unilateral weight change
w_levity = 0.5
w_levin = 0.5
# ERGODIC: balanced allocation extracts maximum combined payoff
Task Type │ Optimal w_levity │ Optimal w_levin │ Winner
───────────────┼──────────────────┼─────────────────┼────────
discovery │ 0.70 │ 0.30 │ LEVITY
convergence │ 0.30 │ 0.70 │ LEVIN
efficiency │ 0.55 │ 0.45 │ ERGODIC
balanced │ 0.50 │ 0.50 │ NASH
| World | Strategy | τ_mix | Cost | WEV |
|---|---|---|---|---|
| W_Nash (uncoordinated) | Each prover works alone | years | 100 human-years | — |
| W_Opt (market-coordinated) | $BEAVER prediction market | months | 10 human-years | 90 human-years |
WEV = C_Nash - C_Opt = 90 human-years of proof effort
$BEAVER Token Flow:
Discovery Event → Verification Phase (1 week)
→ Proofs submitted in Lean/Agda
→ Oracle verifies
→ $BEAVER minted ∝ log₃(BB(n))
→ WEV distributed to market participants
BEAVER_REWARD = log₃(BB(n)) × VERIFICATION_MULTIPLIER × TERNARY_BONUS
Where:
log₃(BB(n)) = Kolmogorov complexity in balanced ternary
VERIFICATION_MULTIPLIER = {1.0 (Move), 2.0 (Lean), 3.0 (Agda)}
TERNARY_BONUS = {-1: 0.5×, 0: 1.0×, +1: 1.5×}
log₃(47,176,870) ≈ 16.03 trits
Agda proof: 16.03 × 3.0 × 1.5 = 72.135 $BEAVER
Lean proof: 16.03 × 2.0 × 1.0 = 32.06 $BEAVER
Move proof: 16.03 × 1.0 × 1.0 = 16.03 $BEAVER
┌─────────────────────────────────────────────────────────────────┐
│ Skill │ Trit │ Role │
├───────────────────────────┼──────┼──────────────────────────────┤
│ busy-beaver-oracle │ +1 │ Generate lower bound proofs │
│ levin-levity (this) │ 0 │ Nash equilibrium + WEV │
│ prediction-market-oracle │ -1 │ Price discovery on cryptids │
├───────────────────────────┴──────┴──────────────────────────────┤
│ Sum: (+1) + (0) + (-1) = 0 ✓ GF(3) CONSERVED │
└─────────────────────────────────────────────────────────────────┘
The levity in Levin:
Mind A (LEVIN): "I seek the shortest proof"
Mind B (LEVITY): "I seek the most surprising proof"
Mind C (ERGODIC): "I arbitrage between your mixing times"
WEV = |τ_A - τ_B| × liquidity × information_asymmetry
# Compute Levin complexity
amp levin-complexity --program "BB(6) proof" --output complexity.json
# Simulate LEVITY-LEVIN game
julia src/triplet_1_week2_nash_solver.jl --task balanced
# Extract WEV from proof space
amp wev-extract --world-nash "solo-provers" --world-opt "market-coordinated"
triadic_allocation:
- skill: busy-beaver-oracle
trit: +1
role: "Generate proofs, emit $BEAVER"
- skill: levin-levity
trit: 0
role: "Nash equilibrium, WEV pricing"
- skill: prediction-market-oracle
trit: -1
role: "Market-making, belief aggregation"
/busy-beaver-oracle/BEAVER_TOKENOMICS.md/src/triplet_1_week2_nash_solver.jlTRIT_STREAM: [+1, -1, -1, +1, +1, +1, +1]
GF(3)_SUM: 0 (CONSERVED)
WEV_MIXING_BADGE: τ_market < τ_proof → extractable
"In the mutual ingression of minds, the shortest proof finds itself."