Unified ASI skill combining ACSets, Gay-MCP colors, bisimulation games, world-hopping, glass-bead synthesis, and triad interleaving for autonomous skill dispersal.
/plugin marketplace add plurigrid/asi/plugin install asi-skills@asi-skillsThis skill inherits all available tools. When active, it can use any tool Claude has access to.
Synthesizes all loaded skills into a coherent system for Artificial Superintelligence skill orchestration.
┌─────────────────┐
│ glass-bead-game │
│ (synthesis) │
└────────┬────────┘
│
┌───────────────────┼───────────────────┐
│ │ │
┌────────▼────────┐ ┌────────▼────────┐ ┌────────▼────────┐
│ world-hopping │ │ bisimulation │ │ triad-interleave│
│ (navigation) │ │ (dispersal) │ │ (scheduling) │
└────────┬────────┘ └────────┬────────┘ └────────┬────────┘
│ │ │
└───────────────────┼───────────────────┘
│
┌────────▼────────┐
│ gay-mcp │
│ (deterministic │
│ coloring) │
└────────┬────────┘
│
┌────────▼────────┐
│ acsets │
│ (data model) │
└─────────────────┘
@present SchASIWorld(FreeSchema) begin
World::Ob
Skill::Ob
Agent::Ob
source::Hom(World, World)
target::Hom(World, World)
has_skill::Hom(Agent, Skill)
inhabits::Hom(Agent, World)
Seed::AttrType
Trit::AttrType
seed::Attr(World, Seed)
color_trit::Attr(Skill, Trit)
end
from gay import SplitMixTernary, TripartiteStreams
def color_world(world_seed: int, skill_index: int) -> dict:
gen = SplitMixTernary(world_seed)
return gen.color_at(skill_index)
def hop_between_worlds(w1, w2, event_name: str):
distance = world_distance(w1, w2)
if valid_hop(w1, w2):
event = Event(site=["skill"], name=event_name)
return event.execute(w1)
return None
async def disperse_skill(skill_path: str, agents: list):
game = BisimulationGame()
for i, agent in enumerate(agents):
trit = (i % 3) - 1 # GF(3) balanced
game.attacker_move(agent, skill_path, trit)
game.defender_respond(await agent.receive(skill_path))
return game.arbiter_verify()
def schedule_skill_updates(seed: int, n_agents: int):
interleaver = TriadInterleaver(seed)
schedule = interleaver.interleave(
n_triplets=n_agents // 3,
policy="gf3_balanced"
)
return schedule
def synthesize_skills(*skills):
game = GlassBeadGame()
for skill in skills:
game.add_bead(skill.name, skill.domain)
# Connect skills via morphisms
game.connect("acsets", "gay-mcp", via="seed_to_color")
game.connect("gay-mcp", "triad-interleave", via="color_stream")
game.connect("triad-interleave", "bisimulation", via="schedule")
game.connect("bisimulation", "world-hopping", via="dispersal")
return game.score()
| Letter | Domain | Key Projects |
|---|---|---|
| a | Category Theory | ACSets.jl, Catlab.jl, Decapodes.jl |
| b | Terminal | bmorphism/trittty |
| p | Infrastructure | plurigrid/oni, alpaca.cpp |
| t | Collaboration | CatColab |
| e | HoTT | infinity-cosmos (Lean 4) |
| r | Type Theory | rzk (simplicial HoTT) |
| n | Knowledge | nlab-content |
| o | Music | rubato-composer |
All operations preserve:
∑ trits ≡ 0 (mod 3)
Across:
# Generate integrated schedule
just asi-schedule 0x42D 10
# Disperse skills to all agents
just asi-disperse ~/.claude/skills/
# Verify GF(3) conservation
just asi-verify
# Play glass bead synthesis
just asi-synthesize a b p t
# World hop between letters
just asi-hop a t
Curated from bmorphism's GitHub interactions:
Fix.idr - Idris indexed functor fixpoints for graphs, multi-graphs, poly-graphs.
data IFix : (f : (k -> Type) -> k -> Type) -> k -> Type where
In : f (IFix f) i -> IFix f i
itt-coc.ts - Intensional Type Theory CoC in TypeScript.
Affine.lean - Linear/affine type experiments in Lean 4.
Nats.dfy - Dafny streams with unique fixpoint theorems.
abstractlattice.jl - Julia abstract lattice. Comment: "a quantum of abstract solace ∞"
kronecker_decompose.py - Optimal Kronecker decomposition.
uuidv1.clj - Deterministic UUID generation in Clojure.
Property-based testing connects to ASI through autopoietic generators:
# QuickCheck-style recursive generator with GF(3) conservation
function autopoietic_tree(seed::UInt64, depth::Int)
rng = SplitMix64(seed)
trit = mod(next_u64!(rng), 3) - 1
if depth == 0 || trit == -1 # MINUS = terminate
return Leaf(color_at(seed))
else
left_seed, right_seed = split(rng)
return Node(
trit = trit,
left = autopoietic_tree(left_seed, depth-1),
right = autopoietic_tree(right_seed, depth-1)
)
end
end
QuickCheck shrinking = finding minimal ∼Q_G in adhesive categories:
From Incremental Query Updating in Adhesive Categories:
path(X,Z) :- path(X,Y), edge(Y,Z).
Incremental update: When we apply rule to add path(a,b),
new matches = outgoing edges from b (rooted search)
plurigrid/asi/
├── package.json
├── bin/cli.js
├── README.md
└── skills/
├── a/SKILL.md # AlgebraicJulia
├── b/SKILL.md # bmorphism
├── c/SKILL.md # cognitect
├── d/SKILL.md # claykind
├── e/SKILL.md # infinity-cosmos
├── f/SKILL.md # clojure-site
├── g/SKILL.md # archiver-bot
├── h/SKILL.md # gdlog
├── i/SKILL.md # InverterNetwork
├── k/SKILL.md # kubeflow
├── l/SKILL.md # pretty-bugs
├── m/SKILL.md # awesome-category-theory
├── n/SKILL.md # nlab-content
├── o/SKILL.md # oeis, rubato-composer
├── p/SKILL.md # plurigrid
├── q/SKILL.md # quadrat
├── r/SKILL.md # rzk
├── s/SKILL.md # mathematicians
├── t/SKILL.md # CatColab
├── v/SKILL.md # viro
└── _integrated/ # This skill
└── SKILL.md
This 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.