home / skills / plurigrid / asi / shadow-goblin

shadow-goblin skill

safe

This skill connects graph theory tooling with domain-specific DSL concepts to enable modular, embeddable analysis workflows.

npx playbooks add skill plurigrid/asi --skill shadow-goblin

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

Files (1)

SKILL.md

1.2 KB

---
name: shadow-goblin
description: shadow-goblin
version: 1.0.0
---


# shadow-goblin

Auto-generated skill placeholder.



## Scientific Skill Interleaving

This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:

### Graph Theory
- **networkx** [○] via bicomodule
  - Universal graph hub

### Bibliography References

- `general`: 734 citations in bib.duckdb



## SDF Interleaving

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

### Primary Chapter: 2. Domain-Specific Languages

**Concepts**: DSL, wrapper, pattern-directed, embedding

### GF(3) Balanced Triad

```
shadow-goblin (○) + SDF.Ch2 (−) + [balancer] (+) = 0
```

**Skill Trit**: 0 (ERGODIC - coordination)


### Connection Pattern

DSLs embed domain knowledge. This skill defines domain-specific operations.
## Cat# Integration

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
```

### GF(3) Naturality

The skill participates in triads satisfying:
```
(-1) + (0) + (+1) ≡ 0 (mod 3)
```

This ensures compositional coherence in the Cat# equipment structure.

Overview

This skill implements a compact, domain-aware wrapper for defining and composing small domain-specific languages and algebraic structures used in topological chemistry workflows. It exposes compositional patterns and lightweight tooling to embed operations, define bicomodule relationships, and reason about GF(3) triads. The design emphasizes interoperability with graph and bibliography hubs and flexible composition for experiment scripting.

How this skill works

The skill provides primitives to declare DSL operations, compose them as bicomodules, and validate triadic coherence conditions like GF(3) naturality. It inspects module metadata, maps poly-operations (⊗) between contexts, and emits simple proofs or diagnostics about ergodicity and kan-adjoints. Integrations surface networkx-style graph hooks and bibliography references to aid reproducible workflows.

When to use it

When defining small, task-specific DSLs for chemical or topological experiment sequences.
When composing modules that must satisfy algebraic coherence (e.g., GF(3) triads).
When you need a lightweight wrapper to connect graph-based analyses with DSL operators.
When creating reproducible pipelines that reference bibliographic citations programmatically.
When modeling compositional structures as bicomodules or Prof-style adjunctions.

Best practices

Keep DSL primitives minimal and well-documented to preserve composability.
Declare algebraic invariants (e.g., triad sums) early and validate after composition.
Use the graph integration for visualizing module dependencies and data flows.
Surface human-readable diagnostics for failed coherence checks to speed debugging.
Combine bibliographic metadata with operations for traceable experiment provenance.

Example use cases

Create a small DSL for encoding synthesis steps and compose it with analysis modules to verify topological invariants.
Model an experiment as a bicomodule network, then run automated checks that ensure GF(3) naturality across components.
Embed citation-aware operations so workflows automatically attach literature references to generated results.
Connect a graph hub to trace operator compositions and detect isolated or ergodic components in the pipeline.

FAQ

Does this skill run experiments or perform numerical chemistry calculations?

No. It focuses on defining, composing, and validating DSL-style operators and algebraic coherence. Use specialized numerical packages for simulations and link them into workflows.

How does integration with graph tools work?

The skill exposes hooks compatible with common graph libraries so you can map module relationships, visualize bicomodule connections, and analyze connectivity or ergodicity.