소스 정보
- 저장소
- plurigrid/asi
- 최근 소스 활동
- 2026년 6월 10일 11:55
- 감지된 SKILL.md 언어
- 영어
- 스타
- 64
- 포크
- 12
설치 방법
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
소스 파일 검토
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
파일 탐색기
3 개 파일SKILL.md 표시 중
SKILL.md
소스 지침 · 읽기 전용 미리보기- name
- derivational-coalgebra
- description
- The highest tension in skill space (d=2.131):
- metadata
- {"interface_ports":["Commands"]}
# derivational-coalgebra Skill
> *Bridge between atemporal derivations (unworld) and temporal observations (coalgebra)*
## The Gap
The highest tension in skill space (d=2.131):
```
ATEMPORAL TEMPORAL
│ │
unworld temporal-coalgebra
dialectica duckdb-temporal-versioning
unworlding-involution changelog-generator
│ │
└──────────── d = 2.131 ───────────────┘
```
## Resolution: Derivational Coalgebra
Coalgebraic observation of **derivation streams** rather than time-indexed states:
```
Traditional coalgebra: S → F(S) where F is a functor on temporal states
Derivational coalgebra: D → F(D) where D is the derivation poset
```
### Key Insight
Replace `t ∈ Time` with `δ ∈ Derivation`:
| Temporal | Derivational |
|----------|--------------|
| `state(t)` | `state(δ)` |
| `t₁ < t₂` | `δ₁ ⊢ δ₂` |
| `lim_{t→∞}` | `fixpoint(δ)` |
| `∂/∂t` | `∂/∂δ` (sensitivity to derivation step) |
## Core Types
```haskell
-- Derivation as a partial order (not linear time)
data Derivation a where
Base :: a -> Derivation a
Step :: Derivation a -> (a -> a) -> Derivation a
Join :: Derivation a -> Derivation a -> Derivation a -- parallel
-- Coalgebraic observation
class DerivationalCoalgebra s where
observe :: s -> ObservationF s
unfold :: s -> Stream (Derivation s)
-- The functor bridges both paradigms
data ObservationF s = ObsF
{ current :: s -- atemporal snapshot
, successor :: Derivation s -- derivational continuation
, temporal :: Maybe (Time, s) -- optional temporal embedding
}
```
## Implementation
### Python Bridge
```python
from dataclasses import dataclass
from typing import Generic, TypeVar, Callable, Optional
from abc import ABC, abstractmethod
S = TypeVar('S')
@dataclass
class Derivation(Generic[S]):
"""Derivation step with optional temporal embedding."""
state: S
parent: Optional['Derivation[S]'] = None
rule: Optional[str] = None # derivation rule name
timestamp: Optional[float] = None # temporal embedding (optional)
@property
def depth(self) -> int:
"""Derivation depth (atemporal measure)."""
if self.parent is None:
return 0
return 1 + self.parent.depth
def derive(self, f: Callable[[S], S], rule: str = "step") -> 'Derivation[S]':
"""Create child derivation (atemporal)."""
return Derivation(
state=f(self.state),
parent=self,
rule=rule,
timestamp=None # no time needed
)
def embed_temporal(self, t: float) -> 'Derivation[S]':
"""Optionally embed into temporal axis."""
return Derivation(
state=self.state,
parent=self.parent,
rule=self.rule,
timestamp=t
)
class DerivationalCoalgebra(ABC, Generic[S]):
"""
Bridge between atemporal derivations and temporal observations.
Resolves the unworld ↔ temporal-coalgebra tension by:
1. Representing computation as derivation chains (atemporal)
2. Providing coalgebraic observation interface
3. Optionally embedding into temporal axis when needed
"""
@abstractmethod
def observe(self, d: Derivation[S]) -> S:
"""Observe current state (works both temporally and atemporally)."""
pass
@abstractmethod
def unfold(self, d: Derivation[S]) -> 'Stream[Derivation[S]]':
"""Coalgebraic unfold: generate derivation stream."""
pass
def to_temporal(self, stream: 'Stream[Derivation[S]]',
dt: float = 1.0) -> 'Stream[tuple[float, S]]':
"""Embed derivation stream into temporal axis."""
t = 0.0
for d in stream:
yield (t, d.state)
t += dt
def from_temporal(self, t_stream: 'Stream[tuple[float, S]]') -> 'Stream[Derivation[S]]':
"""Extract derivational structure from temporal stream."""
prev = None
for t, s in t_stream:
d = Derivation(state=s, parent=prev, timestamp=t)
yield d
prev = d
```
### Gay.jl Color Integration
```python
DERIVATIONAL_COLORS = {
'atemporal': '#5713C0', # Stream 4 (pure derivation)
'temporal': '#E6F463', # Stream 2 (time-embedded)
'bridge': '#89DF91', # Stream 3 (translation layer)
}
def color_derivation(d: Derivation) -> str:
"""Color based on temporal embedding status."""
if d.timestamp is None:
return DERIVATIONAL_COLORS['atemporal']
else:
return DERIVATIONAL_COLORS['temporal']
```
## Bisimulation for Equivalence
Two derivation streams are bisimilar if their observations match:
```python
def bisimilar(d1: Derivation[S], d2: Derivation[S],
coalg: DerivationalCoalgebra[S]) -> bool:
"""
Check bisimulation: same observations regardless of
whether temporal or atemporal representation.
"""
obs1 = coalg.observe(d1)
obs2 = coalg.observe(d2)
if obs1 != obs2:
return False
# Check continuations (up to finite depth)
for next1, next2 in zip(coalg.unfold(d1), coalg.unfold(d2)):
if coalg.observe(next1) != coalg.observe(next2):
return False
return True
```
## Triangle Inequality Restoration
With this bridge skill:
```
d(unworld, derivational-coalgebra) ≈ 1.0
d(derivational-coalgebra, temporal-coalgebra) ≈ 1.0
Therefore:
d(unworld, temporal-coalgebra) ≤ 1.0 + 1.0 = 2.0 ✓
(Original: 2.131, now satisfies triangle inequality)
```
## Use Cases
### 1. Version Control Without Time
```python
# Git commits as derivations, not timestamps
class GitDerivational(DerivationalCoalgebra[Tree]):
def observe(self, d: Derivation[Tree]) -> Tree:
return d.state
def unfold(self, d: Derivation[Tree]):
# Derivation graph, not timeline
for parent in d.parents:
yield parent
```
### 2. Proof Assistant States
```python
# Narya/Agda proof states as derivations
class ProofDerivational(DerivationalCoalgebra[ProofState]):
def derive_tactic(self, state: ProofState, tactic: Tactic):
return Derivation(
state=apply_tactic(state, tactic),
parent=state,
rule=tactic.name
)
```
### 3. DuckDB Temporal Queries via Derivation
```python
# Bridge DuckDB temporal to derivational
def temporal_to_derivational(db: duckdb.Connection):
"""Convert temporal version table to derivation chain."""
rows = db.execute("""
SELECT * FROM version_history
ORDER BY version_id
""").fetchall()
prev = None
for row in rows:
d = Derivation(
state=row['data'],
parent=prev,
rule=row['change_type'],
timestamp=row['timestamp'] # preserve but not rely on
)
yield d
prev = d
```
## Neighbor Skills
- **unworld**: Pure atemporal derivations
- **temporal-coalgebra**: Pure temporal observations
- **duckdb-temporal-versioning**: Practical temporal queries
- **proofgeneral-narya**: Proof derivations
- **dialectica**: Constructive derivations
## Resources
- [Jacobs - Introduction to Coalgebra](https://www.cs.ru.nl/B.Jacobs/CLG/JacsCoalgBook.pdf)
- [Rutten - Universal Coalgebra](https://homepages.cwi.nl/~janr/papers/files-of-papers/universal_coalgebra.pdf)
- [unworld skill](file:///Users/bob/.claude/skills/unworld/SKILL.md)
- [temporal-coalgebra skill](file:///Users/bob/.claude/skills/temporal-coalgebra/SKILL.md)
---
## End-of-Skill Interface
## Commands
```bash
# Convert temporal log to derivational
python derivational_coalgebra.py --input temporal.log --output derivations.json
# Check bisimulation
python derivational_coalgebra.py --bisim d1.json d2.json
# Embed derivations into time
python derivational_coalgebra.py --embed derivations.json --dt 1.0
```
---
## Autopoietic Marginalia
> **The interaction IS the skill improving itself.**
Every use of this skill is an opportunity for worlding:
- **MEMORY** (-1): Record what was learned
- **REMEMBERING** (0): Connect patterns to other skills
- **WORLDING** (+1): Evolve the skill based on use
*Add Interaction Exemplars here as the skill is used.*
GitHub에서 보기