home / skills / plurigrid / asi / triangle-metrics

triangle-metrics skill

safe

This skill unifies triangle inequality checks across related metrics to ensure consistent distances and validate cross-skill coherence.

npx playbooks add skill plurigrid/asi --skill triangle-metrics

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

Files (1)

SKILL.md

4.1 KB

---
name: triangle-metrics
description: Triangle Metrics Skill
version: 1.0.0
---

# Triangle Metrics Skill

**Trit**: 0 (ERGODIC - synthesizer/coordinator)
**Purpose**: Unify all triangle inequality skills into a coherent metric space

---

## Cross-Referenced Skills

| Skill | Guarantee | Integration Point |
|-------|-----------|-------------------|
| **glass-hopping** | ≪ order transitivity | `TriangleInequality` Narya type |
| **world-hopping** | Dijkstra pruning | `d13 <= d12 + d23` constraint |
| **glass-bead-game** | Propagator constraint | `world_distance` comparisons |
| **epistemic-arbitrage** | Knowledge transfer bound | `d(A,C) ≤ d(A,B) + d(B,C)` |
| **l-space** | Navigation metric | `:triangle_inequality` traversal |
| **open-games** | Play/coplay equilibrium | `equilibrium ⟺ d(a,c) ≤ d(a,b) + d(b,c)` |

---

## Unified Interface

```julia
# Abstract metric interface all skills implement
abstract type TriangleMetric end

struct WorldDistance <: TriangleMetric
    d12::Float64
    d23::Float64
    d13::Float64
end

function triangle_valid(m::WorldDistance)::Bool
    m.d13 ≤ m.d12 + m.d23
end

# Skill-specific implementations
struct GlassHoppingMetric <: TriangleMetric
    h12::Bridge  # W₁ ≪ W₂
    h23::Bridge  # W₂ ≪ W₃
    # Transitivity guarantees h13
end

struct OpenGamesMetric <: TriangleMetric
    play::Strategy    # Forward distance
    coplay::Strategy  # Backward distance
    # Equilibrium ⟺ triangle satisfied
end
```

---

## Mutual Awareness Protocol

When any triangle skill is invoked:

1. **Check**: Query other loaded triangle skills
2. **Validate**: Ensure distances are consistent across all
3. **Propagate**: Share metric updates to siblings
4. **Witness**: Generate Narya proof if all agree

```narya
-- Unified triangle witness
def UnifiedTriangle 
    (glass : GlassHopping.Bridge)
    (world : WorldHopping.Path)
    (game  : OpenGames.Equilibrium)
    : TriangleValidated
```

---

## DuckLake Integration

```sql
-- Query triangle-validated interactions
SELECT a.id, a.trit, a.triangle_valid,
       b.id as next_id, b.trit as next_trit,
       c.id as third_id, c.trit as third_trit,
       ABS(c.trit - a.trit) as d13,
       ABS(b.trit - a.trit) + ABS(c.trit - b.trit) as d12_plus_d23
FROM activity_log a
JOIN activity_log b ON b.timestamp > a.timestamp
JOIN activity_log c ON c.timestamp > b.timestamp
WHERE d13 <= d12_plus_d23;  -- Triangle inequality
```

---

## GF(3) Conservation

The unified metric preserves GF(3):

```
Σ(skill trits) = glass-hopping(0) + world-hopping(0) + 
                 glass-bead-game(0) + epistemic-arbitrage(0) + 
                 l-space(0) + open-games(0) + 
                 triangle-metrics(0) = 0 ✓
```

---

## Usage

```bash
# Validate all triangle constraints
just triangle-validate

# Generate unified Narya witness
just triangle-witness

# Query cross-skill distances
just triangle-query
```

**Integration**: Load alongside any triangle skill for automatic mutual awareness.



## 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: 8. Degeneracy

**Concepts**: redundancy, fallback, multiple strategies, robustness

### GF(3) Balanced Triad

```
triangle-metrics (+) + SDF.Ch8 (−) + [balancer] (○) = 0
```

**Skill Trit**: 1 (PLUS - generation)

### Secondary Chapters

- Ch5: Evaluation
- Ch10: Adventure Game Example
- Ch7: Propagators
- Ch4: Pattern Matching

### Connection Pattern

Degeneracy provides fallbacks. This skill offers redundant strategies.
## 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 unifies triangle-inequality logic across related skills to provide a coherent metric space for cross-skill reasoning. It acts as a coordinator that validates, propagates, and witnesses distance constraints so downstream components can rely on consistent metric relationships. The skill is lightweight, interoperable, and designed to run alongside other triangle-aware skills for automatic mutual awareness.

How this skill works

The skill exposes a common TriangleMetric interface and concrete metric types (e.g., WorldDistance, GlassHoppingMetric, OpenGamesMetric). When invoked it queries other loaded triangle skills, validates distance constraints (d13 ≤ d12 + d23), propagates updates to siblings, and emits a unified proof/witness when consensus is reached. It also provides utilities to run batch validations, generate witnesses, and query cross-skill distances via simple commands or SQL-like queries.

When to use it

When multiple skills compute or assert pairwise distances and you need a single canonical check for triangle inequalities.
When coordinating cross-module pruning or path-finding that depends on metric consistency (e.g., Dijkstra-style pruning).
When you need to propagate metric updates across heterogeneous adapters (graph, game-theoretic strategies, world models).
When you want automated witness generation for audits, proofs, or downstream verification.
When integrating a new triangle-aware skill and you want it to interoperate without ad-hoc glue code.

Best practices

Implement the TriangleMetric interface for any new skill that produces or consumes distance-like values.
Run triangle-validate as part of pipeline checkpoints to catch transitivity violations early.
Prefer deterministic distance representations (floats with clear tolerances) and document tolerance thresholds.
Use the mutual awareness protocol so updates are propagated rather than patched manually.
Emit a witness only after all participating skills have agreed to avoid false positives.

Example use cases

Validate that world-model distance estimates satisfy triangle inequality before executing a path planner.
Coordinate game-theoretic equilibrium checks with graph-based navigation metrics to ensure consistent tradeoffs.
Aggregate heterogeneous distance signals (bridges, strategies, numeric trits) and produce a single Narya witness for auditing.
Run periodic SQL queries over event logs to find interactions that satisfy or violate the triangle constraint.
Use redundancy and degeneracy patterns to provide fallbacks when a primary metric provider is missing.

FAQ

What does the witness prove?

The witness certifies that all participating triangle skills agree on the validated triangle inequalities and that distances are mutually consistent.

How do I add a new metric provider?

Implement the TriangleMetric interface for your provider, register it with the mutual awareness protocol, and define deterministic distance fields and tolerances.