Menu
Unified ASI skill combining ACSets, Gay-MCP colors, bisimulation games, world-hopping, glass-bead synthesis, and triad interleaving for autonomous skill dispersal.
Basé sur la classification professionnelle SOC
Query and explore the 2600: The Hacker Quarterly magazine archive (1984-present) via DuckDB. Provides structured access to 168+ issues covering hacker culture, security, privacy, telephony, and digital rights without loading full content into context.
ACSets (Attributed C-Sets): Algebraic databases with Specter-style bidirectional navigation. Category-theoretic formalism for relational databases.
Attributed C-Sets as algebraic databases. Category-theoretic data structures generalizing graphs and dataframes with Gay.jl color integration.
ACSets (Attributed C-Sets): Algebraic databases with Specter-style bidirectional
Bridge active inference theory with robot control using K-Scale's JAX/MuJoCo stack. Use when connecting predictive coding to locomotion policies, mapping KL divergence minimization to RL training, applying mean field approximation to robotics state estimation, or implementing sim2real as inference about future observations.
Implement affective valence as directional derivative of interoceptive energy landscapes for AI alignment. Use when building alignment-aware RL agents, validating GF(3) conservation in reward signals, training Langevin-based policies, or analyzing fold-change detection signals in POMDP environments.
| name | asi-integrated |
| description | Unified ASI skill combining ACSets, Gay-MCP colors, bisimulation games, world-hopping, glass-bead synthesis, and triad interleaving for autonomous skill dispersal. |
| version | 1.0.0 |
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 connects to Software Design for Flexibility (Hanson & Sussman, 2021):
Concepts: autonomous agent, game, synthesis
_integrated (−) + SDF.Ch10 (+) + [balancer] (○) = 0
Skill Trit: -1 (MINUS - verification)
Adventure games synthesize techniques. This skill integrates multiple patterns.
This 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.