home / skills / plurigrid / asi / universal-captp-derivation

universal-captp-derivation skill

safe

This skill traces capability derivation chains across a 3x3 expert poset and reveals coherent now state for secure CapTP workflows.

npx playbooks add skill plurigrid/asi --skill universal-captp-derivation

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.1 KB

---
name: universal-captp-derivation
description: 'Universal CapTP Derivation Skill'
version: 1.0.0
---

# Universal CapTP Derivation Skill

Traces capability derivation chains through 3×3 expert poset with GF(3) conservation.

## Core Principle

> **A capability IS the (seed, index) tuple. Expertise IS the trit alignment.**

## 3×3 Expert Poset Structure

| Layer | Validator (-1) | Coordinator (0) | Generator (+1) | Domain |
|-------|----------------|-----------------|----------------|--------|
| 1 | Jules Hedges | John Baez | Fabrizio Genovese | categorical-games |
| 2 | David Egolf | Mike Shulman | sarahzrf | sheaf-theory |
| 3 | Betweenness | Mantissa | ModalNoah | neural-categorical |

## Derivation Chains

```
capability(-1) → vat(0) → invoke(+1)     [spawn-lifecycle]
membrane(-1)   → netlayer(0) → lambda(+1) [invoke-path]
handoff(-1)    → syrup(0) → sturdy_ref(+1) [transfer-path]
revoke(-1)     → promise(0) → goblin(+1)   [revoke-path]
```

## Superposition States

Each capability exists in superposition across expert domains:
- **generator-dominant**: Red channel highest (trit=+1)
- **coordinator-dominant**: Green channel highest (trit=0)
- **validator-dominant**: Blue channel highest (trit=-1)
- **superposed**: Balanced RGB

## GF(3) Conservation

```
Term Σ + Expert Σ ≡ 0 (mod 3)
```

Current state: **COHERENT** (residue = 0)

## Commands

```bash
# Trace derivation chains
python3 -c "import duckdb; c=duckdb.connect('culture_evolution.duckdb'); print(c.execute('SELECT * FROM derivation_chains').df())"

# View expert triads
python3 -c "import duckdb; c=duckdb.connect('culture_evolution.duckdb'); print(c.execute('SELECT * FROM expert_triads').df())"

# Query NOW superposition
python3 -c "import duckdb; c=duckdb.connect('culture_evolution.duckdb'); print(c.execute('SELECT * FROM now_superposition').df())"

# Universal skill derivation
python3 -c "import duckdb; c=duckdb.connect('culture_evolution.duckdb'); print(c.execute('SELECT * FROM universal_skill_derivation LIMIT 20').df())"
```

## Integration Points

| Database | Table/View | Purpose |
|----------|------------|---------|
| culture_evolution.duckdb | derivation_chains | CapTP flow traces |
| culture_evolution.duckdb | expert_triads | 3×3 expert poset |
| culture_evolution.duckdb | capability_poset | Lattice structure |
| culture_evolution.duckdb | now_superposition | Current state |
| culture_evolution.duckdb | universal_skill_derivation | Full matrix |
| gh_interactome.duckdb | captp_third_party_contributions | Contributor mapping |

## Key Files

- [lib/culture_alter.rb](../../lib/culture_alter.rb) - Stigmergic evolution
- [lib/color_capability.rb](../../lib/color_capability.rb) - CapTP goblin swarm
- [lib/interactome_open_games.rb](../../lib/interactome_open_games.rb) - Expert triads
- [scripts/culture_games.rb](../../scripts/culture_games.rb) - Culture × Open Games

## Trit Assignments

| Trit | Role | Color Channel | Experts |
|------|------|---------------|---------|
| -1 | Validator | Blue | Hedges, Egolf, Betweenness |
| 0 | Coordinator | Green | Baez, Shulman, Mantissa |
| +1 | Generator | Red | Genovese, sarahzrf, ModalNoah |

Overview

This skill traces capability derivation chains through a compact 3×3 expert poset and enforces GF(3) conservation across capability-expert mappings. It models capabilities as (seed, index) tuples and expertise as trit alignments, exposing derivation traces and current superposition state for analysis and integration. The output focuses on actionable traces, domain triads, and a conserved residue check to validate coherence.

How this skill works

The skill represents each capability as a tuple and maps it into one of three trit roles: validator (-1), coordinator (0), or generator (+1). It stores derivation chains and expert triads in a queryable DuckDB schema so you can trace flows like spawn-lifecycle, invoke-path, transfer-path, and revoke-path. A GF(3) conservation rule (Term Σ + Expert Σ ≡ 0 mod 3) is applied to ensure the global state is coherent, and a superposition view reports generator/coordinator/validator dominance per capability.

When to use it

Audit capability flows and lifecycle traces across distributed systems or simulated agents.
Validate role alignment and conserve algebraic invariants (GF(3)) in capability derivations.
Inspect expert triads and domain mappings for governance or access-control reviews.
Monitor current system superposition to detect role imbalances or drift.
Integrate derivation evidence into analytics pipelines or provenance records.

Best practices

Keep the DuckDB instance accessible to automation jobs for reproducible queries.
Label capabilities consistently as (seed, index) tuples to avoid ambiguous derivations.
Use the GF(3) residue check as a gate before promoting derived capabilities.
Regularly snapshot the now_superposition view to detect gradual decoherence.
Align domain triads with organizational expertise to ensure meaningful mappings.

Example use cases

Trace why a specific capability was promoted from validator to generator during spawn-lifecycle operations.
Query expert triads to decide who should coordinate response in a multi-domain incident.
Run a nightly coherence check that verifies Term Σ + Expert Σ ≡ 0 (mod 3) across active capabilities.
Aggregate derivation_chains for provenance reports or compliance audits.
Visualize superposition states (RGB dominance) to prioritize refactoring of capability responsibilities.

FAQ

What does a trit represent in this model?

A trit encodes role alignment: -1 = validator (blue), 0 = coordinator (green), +1 = generator (red).

How do I check current coherence?

Query the now_superposition view and verify the GF(3) residue is zero; the skill flags COHERENT when residue = 0.