Agent skill

levin-levity

Leonid Levin''s algorithmic complexity meets playful mutual ingression. Use for: BB(n) prediction markets, Kolmogorov complexity rewards, WEV extraction from proof inefficiencies, Nash equilibrium between exploration (LEVITY) and convergence (LEVIN).

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/data/levin-levity

SKILL.md

Levin-Levity: Mutual Ingression of Minds

"The shortest program that outputs the universe is the universe computing itself." — Levin, played lightly

Core Duality

┌─────────────────────────────────────────────────────────────────┐
│              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)            │
└─────────────────────────────────────────────────────────────────┘

Leonid Levin's Key Ideas

1. Universal Search (Levin Search)

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.

2. Kolmogorov Complexity

K(x) = length of shortest program producing x

Connection to BB(n):

  • BB(n) = max halting output of n-state Turing machines
  • K(BB(n)) ≤ O(n) (trivially describable by n)
  • But computing BB(n) requires unbounded time

WEV Insight: The gap between K(BB(n)) and the actual compute cost is the extractable inefficiency.

3. Algorithmic Probability

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!).

The LEVITY-LEVIN Game

From triplet_1_week2_nash_solver.jl:

julia
# 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

Best Response Dynamics

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

BB(6) World Extractable Value (WEV)

Mixing Time Analysis

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

Extraction Mechanism

$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

Reward Formula

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×}

Example: BB(5) = 47,176,870

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

GF(3) Triad for BB(6) Oracle

┌─────────────────────────────────────────────────────────────────┐
│  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                 │
└─────────────────────────────────────────────────────────────────┘

Mutual Ingression of Minds

The levity in Levin:

  1. Compression is play: Finding shorter programs is the ultimate game
  2. Universality is democracy: Every program gets a fair (weighted) chance
  3. Incomputability is freedom: BB(n) ensures infinite exploration space
  4. Markets are minds: Prediction markets aggregate distributed cognition

The Ingression Pattern

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

Usage

When to invoke this skill

  • Designing prediction markets for undecidable problems
  • Extracting WEV from uncoordinated proof efforts
  • Computing Nash equilibria between exploration/convergence
  • Pricing proofs by Kolmogorov complexity
  • BB(n) tokenomics and $BEAVER reward calculations

Commands

bash
# 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"

Integration with other skills

yaml
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"

References

  • Levin, L. (1973). "Universal sequential search problems"
  • Solomonoff, R. (1964). "A formal theory of inductive inference"
  • Roughgarden, T. (2010). "Algorithmic Game Theory"
  • Busy Beaver Challenge: https://bbchallenge.org
  • BEAVER Tokenomics: /busy-beaver-oracle/BEAVER_TOKENOMICS.md
  • Nash Solver: /src/triplet_1_week2_nash_solver.jl

Seed 1069 Signature

TRIT_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."

SDF Interleaving

This skill connects to Software Design for Flexibility (Hanson & Sussman, 2021):

Primary Chapter: 8. Degeneracy

Concepts: redundancy, fallback, multiple strategies, robustness

GF(3) Balanced Triad

levin-levity (+) + SDF.Ch8 (−) + [balancer] (○) = 0

Skill Trit: 1 (PLUS - generation)

Secondary Chapters

  • Ch4: Pattern Matching
  • Ch5: Evaluation
  • Ch6: Layering
  • Ch10: Adventure Game Example

Connection Pattern

Degeneracy provides fallbacks. This skill offers redundant strategies.

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

majiayu000/claude-skill-registry

agent-ops-spec

Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-state

Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-spec

Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-testing

Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-testing

Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-state

Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.

163 31
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results