Delta Derivation

Delta Derivation Skill

Trit: -1 (MINUS - Validator) Color: #007FFF (Cold Blue) Role: Extract and verify conversation export deltas

Core Algorithm

# 1. Extract conversations from exports
unzip -o "$RECENT_ZIP" conversations.json -d /tmp/recent_export
unzip -o "$PREVIOUS_ZIP" conversations.json -d /tmp/previous_export

# 2. Extract conversation IDs
jq -r '.[].conversation_id' /tmp/recent_export/conversations.json | sort > /tmp/recent_ids.txt
jq -r '.[].conversation_id' /tmp/previous_export/conversations.json | sort > /tmp/prev_ids.txt

# 3. Compute delta (new conversations)
comm -23 /tmp/recent_ids.txt /tmp/prev_ids.txt > /tmp/new_ids.txt

# 4. Bisimulation check (mutations in shared conversations)
jq -r '.[] | "\(.conversation_id) \(.current_node)"' /tmp/recent_export/conversations.json | sort > /tmp/recent_states.txt
jq -r '.[] | "\(.conversation_id) \(.current_node)"' /tmp/previous_export/conversations.json | sort > /tmp/prev_states.txt
comm -3 /tmp/recent_states.txt /tmp/prev_states.txt > /tmp/mutated.txt

ACSets Schema

(def ConversationACSet
  {:objects #{:Conversation :Message :Node}
   :morphisms {:has_mapping [:Conversation :Node]
               :parent_of [:Node :Node]
               :contains [:Node :Message]}
   :attributes {:conversation_id [:Conversation :String]
                :title [:Conversation :String]
                :create_time [:Conversation :Timestamp]
                :update_time [:Conversation :Timestamp]
                :current_node [:Conversation :UUID]}})

(defn delta-morphism [recent previous]
  "Compute injective morphism from previous → recent"
  (let [shared (set/intersection (ids recent) (ids previous))
        new-convos (set/difference (ids recent) (ids previous))
        removed (set/difference (ids previous) (ids recent))]
    {:type :injection
     :shared (count shared)
     :new (count new-convos)
     :removed (count removed)
     :new-ids new-convos}))

Bisimulation Verification

(defn bisimilar? [conv1 conv2]
  "Check if two conversations are observationally equivalent"
  (and (= (:conversation_id conv1) (:conversation_id conv2))
       (= (:current_node conv1) (:current_node conv2))
       (= (count (:mapping conv1)) (count (:mapping conv2)))))

(defn find-mutations [recent previous]
  "Find conversations that exist in both but have diverged"
  (let [shared-ids (set/intersection (ids recent) (ids previous))]
    (filter (fn [id]
              (not (bisimilar? (get-conv recent id)
                               (get-conv previous id))))
            shared-ids)))

Skill Extraction

(defn extract-skill-mentions [conversations]
  "Find skill invocations in conversation content"
  (let [patterns [#"/(\w+)"                    ; slash commands
                  #"skill[:\s]+[\"']?(\w+)"   ; skill mentions
                  #"(\w+-\w+(?:-\w+)*)"]]     ; hyphenated skill names
    (->> conversations
         (mapcat :messages)
         (mapcat (fn [msg]
                   (for [p patterns
                         m (re-seq p (:content msg ""))]
                     (second m))))
         frequencies
         (sort-by val >))))

Full Pipeline

#!/usr/bin/env bash
# delta-derive.sh - Extract conversation export delta

set -euo pipefail

RECENT="$1"
PREVIOUS="$2"
OUTPUT="${3:-/tmp/delta_analysis.json}"

# Extract
unzip -qo "$RECENT" conversations.json -d /tmp/recent_export
unzip -qo "$PREVIOUS" conversations.json -d /tmp/previous_export

# Compute delta
jq -s '
  (.[0] | map({key: .conversation_id, value: .}) | from_entries) as $recent |
  (.[1] | map({key: .conversation_id, value: .}) | from_entries) as $prev |
  {
    recent_count: (.[0] | length),
    previous_count: (.[1] | length),
    new_conversations: [.[0][] | select(.conversation_id | in($prev) | not) | {
      id: .conversation_id,
      title: .title,
      created: .create_time,
      nodes: (.mapping | length)
    }],
    mutated_conversations: [.[0][] |
      select(.conversation_id | in($prev)) |
      select(.current_node != $prev[.conversation_id].current_node) |
      {
        id: .conversation_id,
        title: .title,
        old_node: $prev[.conversation_id].current_node,
        new_node: .current_node,
        node_delta: ((.mapping | length) - ($prev[.conversation_id].mapping | length))
      }
    ],
    delta_size_bytes: ((.[0] | tostring | length) - (.[1] | tostring | length))
  }
' /tmp/recent_export/conversations.json /tmp/previous_export/conversations.json > "$OUTPUT"

echo "Delta saved to $OUTPUT"
jq -r '"New: \(.new_conversations | length), Mutated: \(.mutated_conversations | length)"' "$OUTPUT"

GF(3) Triadic Analysis

(defn triadic-delta [recent previous]
  "Run delta derivation with GF(3) balanced agents"
  (let [minus (future (find-mutations recent previous))
        ergodic (future (compute-frequencies recent previous))
        plus (future (extract-new-convos recent previous))]
    {:mutations @minus
     :frequencies @ergodic
     :new-convos @plus
     :gf3-sum 0}))

Commands

just delta-derive RECENT.zip PREVIOUS.zip   # Full delta analysis
just delta-new RECENT.zip PREVIOUS.zip      # List new conversations only
just delta-mutated RECENT.zip PREVIOUS.zip  # List mutated conversations
just delta-skills RECENT.zip PREVIOUS.zip   # Extract skill frequencies
just delta-bisim RECENT.zip PREVIOUS.zip    # Run bisimulation check

Justfile Integration

# Delta derivation commands
delta-derive recent previous:
    @~/.claude/skills/delta-derivation/delta-derive.sh "{{recent}}" "{{previous}}"

delta-new recent previous:
    @unzip -qo "{{recent}}" conversations.json -d /tmp/r && \
     unzip -qo "{{previous}}" conversations.json -d /tmp/p && \
     comm -23 <(jq -r '.[].conversation_id' /tmp/r/conversations.json | sort) \
              <(jq -r '.[].conversation_id' /tmp/p/conversations.json | sort)

delta-skills recent previous:
    @~/.claude/skills/delta-derivation/delta-derive.sh "{{recent}}" "{{previous}}" && \
     jq '.new_conversations[].title' /tmp/delta_analysis.json

Related Skills

• acsets-relational-thinking (-1): Schema modeling
• bisimulation-game (0): Equivalence verification
• temporal-coalgebra (-1): Stream observation
• compression-progress (0): Information gain measurement

Base directory: ~/.claude/skills/delta-derivation

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: 10. Adventure Game Example

Concepts: autonomous agent, game, synthesis

GF(3) Balanced Triad

delta-derivation (+) + SDF.Ch10 (+) + [balancer] (+) = 0

Skill Trit: 1 (PLUS - generation)

Secondary Chapters

• Ch3: Variations on an Arithmetic Theme
• Ch4: Pattern Matching

Connection Pattern

Adventure games synthesize techniques. This skill integrates multiple patterns.

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.