home / skills / plurigrid / asi / reverse-derivative-coordinator

reverse-derivative-coordinator skill

safe

This skill coordinates triadic polynomial processing by validating inputs, transforming data, and emitting results to ensure correct modular conservation.

npx playbooks add skill plurigrid/asi --skill reverse-derivative-coordinator

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

Files (1)

skill.md

624 B

---
name: reverse-derivative-coordinator
description: Triadic skill (coordination)
metadata:
  trit: 0
  category: coordination
  polynomial: "Output^y^Input"
---

# Reverse Derivative Coordinator

Triadic skill (coordination)

## Polynomial Interface

```
p = Output^y^Input
```

## Activation

Load when this skill is needed.

## Usage

```bash
bb ~/.claude/skills/reverse-derivative-coordinator/run.bb
```

## Behavior

1. **MINUS (-1)**: Validate inputs
2. **ERGODIC (0)**: Process/transform  
3. **PLUS (+1)**: Emit results

## GF(3) Conservation

This skill participates in triadic composition: Σ trits ≡ 0 (mod 3)

Overview

This skill implements a triadic coordination pattern for reverse-derivative workflows. It enforces a MINUS/ERGODIC/PLUS processing lifecycle and conserves state in GF(3) arithmetic. The design suits pipelines that require strict input validation, deterministic transformation, and controlled emission of results.

How this skill works

The coordinator accepts a polynomial-style interface where an Output^y^Input mapping describes flow direction and role. It runs three staged operations: -1 validates inputs, 0 performs the core ergodic transformation, and +1 emits final results. Internal state is tracked as trits so the sum of stage values remains congruent to zero modulo 3, enabling composable triadic composition.

When to use it

Coordinating multi-stage mathematical or chemical transformation pipelines.
Enforcing strict input validation before deterministic processing.
Composing services that must conserve a modular state (GF(3)).
Orchestrating reversible or traceable derivation workflows.
Integrating into systems that use polynomial-style interface signatures.

Best practices

Map inputs explicitly to the Input role and outputs to the Output role using the Output^y^Input convention.
Keep validation logic in the MINUS stage and avoid side effects there.
Design the ERGODIC stage to be deterministic and testable to preserve reversibility.
Emit only final, validated results in the PLUS stage to maintain conservation.
Use trit-aware logging to track GF(3) state across composed coordinators.

Example use cases

Orchestrating a reversible data transformation where each step must be validated and reversible.
Coordinating computations in a topological chemputer simulation that rely on modular conservation.
Composing small triadic services so their modular states sum to zero for safe chaining.
Wrapping legacy processing steps with a validator-transform-emitter facade for predictable behavior.

FAQ

What does GF(3) conservation mean here?

It means the coordinator represents stage states as trits and enforces that the sum of those trits equals zero modulo three, which enables safe triadic composition.

How strict should validation be in the MINUS stage?

Validation should be strict enough to guarantee the ERGODIC stage receives well-formed inputs and avoid side effects that would break reversibility.

Can I chain multiple coordinators?

Yes. Coordinators are designed for composition; ensure each preserves GF(3) conservation so the overall chain remains consistent.