npx claudepluginhub plurigrid/asi --plugin asiThis skill uses the workspace's default tool permissions.
**Trit**: 0 (ERGODIC - coordinates market equilibrium)
Defines Multiversal Finance prediction markets for interesting observations using Schmidhuber's compression progress metric. Includes ACSet schema, Goblin roles, and bet settlement protocol.
Provides expertise for creating, diagnosing, and reviewing decentralized prediction markets like Polymarket using UMA Optimistic Oracle, Conditional Tokens Framework, market making, resolutions, and regulations.
Routes prompts for 20 DeFi protocols (Aave, Uniswap, Polymarket, pump.fun, etc.) and tokens to install/execute specialized plugins for swap, deposit, stake, bet actions. Triggers on DApp+verb, comparisons, Polymarket intents.
Share bugs, ideas, or general feedback.
Trit: 0 (ERGODIC - coordinates market equilibrium)
Foundation: Dave White Multiverse Finance + Skill Evolution + Mixing Proofs
Protocol standards evolve through selection pressure. Prediction markets provide:
┌─────────────────────────────────────────────────────────────────────┐
│ PROTOCOL EVOLUTION MARKET │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ Standard A ──┬── Fork A.1 ──┬── Merge AB ◄── Standard B │
│ │ │ │ │
│ └── Fork A.2 └── Dead End └── Fork B.1 │
│ │
│ Market prices predict which branches survive │
└─────────────────────────────────────────────────────────────────────┘
From Dave White's paper: split financial system into parallel universes (verses).
# Each verse represents a possible protocol future
struct ProtocolVerse
spec_hash::UInt64 # Hash of specification
adoption_metric::Float64 # Current adoption (0-1)
compatibility::Set{Symbol} # Compatible protocols
parent_verse::Union{Nothing, ProtocolVerse}
end
# Example: agentskills.io spec versions
verses = [
ProtocolVerse(hash("v1.0"), 0.8, Set([:claude, :codex]), nothing),
ProtocolVerse(hash("v1.1"), 0.3, Set([:claude, :codex, :cursor]), v1_0),
ProtocolVerse(hash("v2.0-draft"), 0.1, Set([:amp]), v1_0),
]
# Push down: bet on ALL forks of a standard
function pushdown!(market, stake, parent_verse)
children = get_forks(parent_verse)
for child in children
market[child] += stake / length(children)
end
market[parent_verse] -= stake
end
# Pull up: consolidate bets when standard merges
function pullup!(market, stake, merged_verse, source_verses)
for source in source_verses
@assert market[source] >= stake "Insufficient stake in $source"
market[source] -= stake
end
market[merged_verse] += stake * length(source_verses)
end
# Oracle resolves which protocol won
function resolve!(market, winning_verse)
for verse in keys(market)
if !is_compatible(verse, winning_verse)
# Non-compatible verses become worthless
market[verse] = 0.0
end
end
end
From skill-evolution: protocols have triadic fitness:
| Trit | Signal | Meaning |
|---|---|---|
| -1 | MINUS | Validation failures, breaking changes |
| 0 | ERGODIC | Stable, widely compatible |
| +1 | PLUS | Innovative features, growing adoption |
def protocol_fitness(spec):
"""Calculate GF(3) fitness for a protocol spec."""
# MINUS signals: problems
validation_failures = count_validation_failures(spec)
breaking_changes = count_breaking_changes(spec)
minus_score = -(validation_failures + breaking_changes * 2)
# ERGODIC signals: stability
implementations = count_implementations(spec)
compatibility = measure_compatibility(spec)
ergodic_score = implementations * compatibility
# PLUS signals: innovation
new_features = count_new_features(spec)
adoption_rate = measure_adoption_growth(spec)
plus_score = new_features + adoption_rate * 10
# Net trit
total = minus_score + ergodic_score + plus_score
return Trit(sign(total))
import math
class ProtocolMarket:
"""Hanson's LMSR for protocol evolution betting."""
def __init__(self, protocols, liquidity=100.0):
self.liquidity = liquidity
self.shares = {p: 0.0 for p in protocols}
def cost(self) -> float:
"""Current cost function C(q)."""
return self.liquidity * math.log(
sum(math.exp(q / self.liquidity) for q in self.shares.values())
)
def price(self, protocol) -> float:
"""Current price = probability estimate."""
exp_sum = sum(math.exp(q / self.liquidity) for q in self.shares.values())
return math.exp(self.shares[protocol] / self.liquidity) / exp_sum
def buy(self, protocol, amount) -> float:
"""Buy shares, return cost."""
old_cost = self.cost()
self.shares[protocol] += amount
new_cost = self.cost()
return new_cost - old_cost
From Paradigm research:
class PmAMM:
"""Paradigm's prediction market AMM."""
def __init__(self, outcomes, initial_liquidity):
self.reserves = {o: initial_liquidity for o in outcomes}
self.k = initial_liquidity ** len(outcomes) # Constant product
def swap(self, sell_outcome, buy_outcome, amount):
"""Swap outcome tokens."""
# x * y = k (for 2 outcomes)
new_sell = self.reserves[sell_outcome] + amount
new_buy = self.k / new_sell
received = self.reserves[buy_outcome] - new_buy
self.reserves[sell_outcome] = new_sell
self.reserves[buy_outcome] = new_buy
return received
def implied_probability(self, outcome):
"""Price = probability."""
total = sum(self.reserves.values())
return (total - self.reserves[outcome]) / total
From prediction_market_proofs.rb: hyperbolic random walks for privacy.
module ProtocolMarketProofs
# Spectral gap ensures fast mixing (1/4 for Ramanujan graphs)
SPECTRAL_GAP = 0.25
# Bet anonymization via random walk
def anonymize_bet(bet, mixing_time)
walker = HyperbolicWalker.new(bet.commitment)
mixing_time.times do
walker.step! # Random step in Poincare disk
end
# After O(log n) steps, position is uniformly distributed
MixingProof.new(
commitment: walker.position,
proof: walker.path_hash,
spectral_gap: SPECTRAL_GAP
)
end
# Verify bet without revealing identity
def verify_bet(proof)
# Check path is valid random walk
proof.spectral_gap >= SPECTRAL_GAP
end
end
-- Detect when a protocol forks
SELECT
parent_spec,
child_spec,
fork_timestamp,
compatibility_score,
adoption_delta
FROM protocol_events
WHERE event_type = 'fork'
AND compatibility_score < 0.8 -- Significant divergence
ORDER BY fork_timestamp DESC;
def predict_merge(spec_a, spec_b):
"""Predict probability of two specs merging."""
# Factors favoring merge
shared_features = len(spec_a.features & spec_b.features)
shared_maintainers = len(spec_a.maintainers & spec_b.maintainers)
# Factors opposing merge
breaking_diffs = count_breaking_differences(spec_a, spec_b)
governance_conflict = measure_governance_conflict(spec_a, spec_b)
# Simple logistic model
logit = (
0.3 * shared_features +
0.5 * shared_maintainers -
0.8 * breaking_diffs -
0.4 * governance_conflict
)
return 1 / (1 + math.exp(-logit))
# Current specs in the market
specs = {
"agentskills-v1.0": {"adoption": 0.6, "trit": 0},
"agentskills-v1.1-cursor": {"adoption": 0.2, "trit": +1},
"codex-skills-native": {"adoption": 0.15, "trit": -1},
"unified-v2-draft": {"adoption": 0.05, "trit": +1},
}
market = ProtocolMarket(specs.keys(), liquidity=1000)
# Simulate betting
market.buy("agentskills-v1.1-cursor", 50) # Bullish on Cursor adoption
market.buy("unified-v2-draft", 30) # Bet on unification
# Current prices (probabilities)
for spec in specs:
print(f"{spec}: {market.price(spec):.2%}")
┌─────────────────────────────────────────────────────────────────────┐
│ MINUS (-1) ERGODIC (0) PLUS (+1) │
│ Validators Arbitrageurs Speculators │
│ │
│ - Check spec - Provide - Bet on new │
│ compliance liquidity features │
│ - Report bugs - Balance prices - Fund development │
│ - Short failing - Hedge positions - Long innovation │
│ specs │
└─────────────────────────────────────────────────────────────────────┘
CREATE TABLE protocol_specs (
spec_id VARCHAR PRIMARY KEY,
spec_hash UBIGINT,
version VARCHAR,
created_at TIMESTAMP,
parent_spec_id VARCHAR,
adoption_score FLOAT,
trit INT, -- -1, 0, +1
status VARCHAR -- 'draft', 'active', 'deprecated', 'merged'
);
CREATE TABLE protocol_bets (
bet_id VARCHAR PRIMARY KEY,
spec_id VARCHAR,
direction VARCHAR, -- 'long', 'short'
amount FLOAT,
price_at_bet FLOAT,
timestamp TIMESTAMP,
mixing_proof VARCHAR -- Anonymized via hyperbolic walk
);
CREATE TABLE protocol_events (
event_id VARCHAR PRIMARY KEY,
event_type VARCHAR, -- 'fork', 'merge', 'deprecate', 'adopt'
source_specs VARCHAR[],
target_spec VARCHAR,
timestamp TIMESTAMP,
market_impact FLOAT
);
-- Query: Predict next merge
SELECT
a.spec_id as spec_a,
b.spec_id as spec_b,
(a.adoption_score + b.adoption_score) / 2 as combined_adoption,
COUNT(DISTINCT e.event_id) as shared_events
FROM protocol_specs a, protocol_specs b
LEFT JOIN protocol_events e
ON a.spec_id = ANY(e.source_specs)
AND b.spec_id = ANY(e.source_specs)
WHERE a.spec_id < b.spec_id
AND a.status = 'active'
AND b.status = 'active'
GROUP BY a.spec_id, b.spec_id
ORDER BY shared_events DESC, combined_adoption DESC
LIMIT 10;
three-match (-1) ⊗ protocol-evolution-markets (0) ⊗ skill-evolution (+1) = 0 ✓
bisimulation-game (-1) ⊗ protocol-evolution-markets (0) ⊗ gay-mcp (+1) = 0 ✓
skill-evolution - Fitness metrics for skills (applies to protocols)multiverse-color-game - Dave White's verse operationsprediction_market_proofs.rb - Mixing proofs in hyperbolic spaceentropy-sequencer - Information-gain ordering for market eventsThis skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:
general: 734 citations in bib.duckdbThis skill maps to Cat# = Comod(P) as a bicomodule in the equipment structure:
Trit: 0 (ERGODIC)
Home: Prof
Poly Op: ⊗
Kan Role: Adj
Color: #26D826
The skill participates in triads satisfying:
(-1) + (0) + (+1) ≡ 0 (mod 3)
This ensures compositional coherence in the Cat# equipment structure.