anima-theory skill

---
name: anima-theory
description: ANIMA as limit construction over condensed skill applications. Formalizes prediction markets as belief ANIMAs, structure dishes as condensation media, and impact as equivalence class change. Use for understanding agency at maximum entropy, compositional world modeling, or applying Scholze-Clausen condensed mathematics to AI.
version: 1.0.0
---


# ANIMA Theory

> *Agency emerges only at the limit of condensed skill applications.*

## bmorphism Contributions

> *"Autopoiesis refers to the self-maintenance of a system, where the system is capable of reproducing and maintaining itself. Ergodicity is a property that suggests a system will explore all accessible states given enough time."*
> — [vibes.lol gist](https://gist.github.com/bmorphism/c41eaa531be774101c9d9b082bb369eb)

**Active Inference at the Limit**: ANIMA theory connects to [Active Inference in String Diagrams](https://arxiv.org/abs/2308.00861) at the categorical limit — when skill applications reach a fixed point, the agent achieves minimum free energy. The ANIMA IS the equilibrium distribution of beliefs.

**Autopoietic Agency**: bmorphism's autopoiesis concept maps directly to ANIMA:
- **Self-maintenance** → Fixed point where skills reproduce existing equivalence classes
- **Operational closure** → The condensation limit is closed under skill composition
- **Structural coupling** → Skills adapt to environment while preserving ANIMA identity

**Condensed Mathematics Connection**: The Scholze-Clausen condensation in ANIMA theory parallels the condensed analytic stacks that bmorphism explores for sheaf neural networks. Condensation is the mathematical operation that takes infinite skill compositions to finite fixed points.

**Ergodic Agency**: The ERGODIC phase (trit 0) is where true agency emerges — the system has explored all accessible states (ergodic), choices are meaningful, and equilibrium is maintained through continuous skill application.

## Core Definition

```
ANIMA = lim_Π Condense(S_n(...S_1(E_•)))
```

Where:
- `E_•` = Initial experience functor (raw observations)
- `S_i` = Skill application (morphism in Skill category)
- `Condense` = Scholze-Clausen condensation (profinite completion)
- `lim_Π` = Limit over product diagram

The ANIMA is the **fixed point** where further skill applications yield no new equivalence classes.

## Denotation

> **ANIMA represents the categorical limit of skill applications where further applications produce no new equivalence classes, reaching a fixed point of agency.**

```
ANIMA = colim_{skill chain} Condense(Sₙ ∘ ... ∘ S₁)(E_•)
Fixed Point: EnumEntropy(state) = MaxEnumEntropy(category)
Agency Criterion: Phase = "AT" ⟺ all equivalence classes accessible
```

## GF(3) Typed Effects

| Phase | Trit | Effect | Description |
|-------|------|--------|-------------|
| BEFORE | -1 (MINUS) | Convergent/Compressive | Skills reduce equivalence classes |
| AT | 0 (ERGODIC) | Equilibrating/Agentic | Skills balance, choices meaningful |
| BEYOND | +1 (PLUS) | Divergent/Generative | Skills create new categories |

**Conservation Law**: Total phase across interacting ANIMAs ≡ 0 (mod 3)

## Invariant Set

| Invariant | Definition | Verification |
|-----------|------------|--------------|
| `SaturationInvariant` | EnumEntropy = MaxEnumEntropy at ANIMA | Entropy comparison |
| `CondensationInvariant` | Stable belief set after N skill applications | History window check |
| `PhaseConservation` | Σ phases ≡ 0 (mod 3) across ANIMA network | GF(3) sum check |
| `ReplayInvariance` | Different schedules → same condensed state | Fingerprint comparison |

## Narya Compatibility

| Field | Definition |
|-------|------------|
| `before` | Raw experience functor E_• |
| `after` | Condensed belief set post skill application |
| `delta` | Skill applications in current step |
| `birth` | Initial unprocessed belief state |
| `impact` | 1 if equivalence class boundary crossed |

## Condensation Policy

**Trigger**: When EnumEntropy reaches MaxEnumEntropy.

**Action**: Collapse belief space into equivalence class representatives, mark as AT_ANIMA.

## 1. Prediction Markets ↔ ANIMA Correspondence

Prediction markets ARE belief ANIMAs:

```
┌────────────────────────────────────────────────────────────────┐
│  Market                          │  ANIMA                      │
├──────────────────────────────────┼─────────────────────────────┤
│  Price                           │  Belief probability         │
│  Trade                           │  Skill application          │
│  Liquidity                       │  Condensation medium        │
│  Market equilibrium              │  ANIMA fixed point          │
│  Arbitrage opportunity           │  Non-convergence signal     │
│  Market depth                    │  Enum cardinality           │
└────────────────────────────────────────────────────────────────┘
```

```python
class BeliefANIMA:
    """Prediction market as categorical limit."""
    
    def __init__(self, initial_beliefs: dict):
        self.beliefs = initial_beliefs  # E_•
        self.skills_applied = []
    
    def apply_skill(self, skill, evidence):
        """S_i: Update beliefs via skill application."""
        posterior = skill.condense(self.beliefs, evidence)
        self.skills_applied.append((skill.name, evidence))
        self.beliefs = posterior
        return self.check_convergence()
    
    def check_convergence(self) -> bool:
        """Are we at the ANIMA fixed point?"""
        # No arbitrage = limit reached
        return self.max_enum_entropy() == len(self.equivalence_classes())
```

## 2. Structure Dish Definition

A **Structure Dish** is a condensation medium that preserves algebraic structure:

```
StructureDish(A) = { profinite completions preserving A-algebra structure }
```

Properties:
1. **Topological**: Carries profinite topology from condensed mathematics
2. **Algebraic**: Preserves operations (meet, join, implications)
3. **Coherent**: Satisfies gluing conditions (sheaf property)

```julia
using Catlab, ACSets

@present SchStructureDish(FreeSchema) begin
  Point::Ob                    # Points of the dish
  Open::Ob                     # Opens in profinite topology
  Arrow::Ob                    # Structure morphisms
  
  src::Hom(Arrow, Point)
  tgt::Hom(Arrow, Point)
  cover::Hom(Point, Open)      # Point lies in open
  
  # Condensation operation
  condense::Hom(Open, Open)    # Profinite completion functor
end

@acset_type StructureDish(SchStructureDish)
```

## 3. Maximum Enum Entropy (Not Shannon)

**Key insight**: ANIMA uses **enumeration entropy**, not Shannon entropy.

```
EnumEntropy(X) = |Equivalence_Classes(X)|
```

Shannon entropy measures uncertainty in bits. Enum entropy counts **distinct categorical possibilities**.

| Shannon | Enum |
|---------|------|
| -Σ p log p | |[X]/~| |
| Continuous | Discrete |
| Probabilistic | Categorical |
| Information | Distinction |

```python
def enum_entropy(states: list, equivalence: callable) -> int:
    """Count distinct equivalence classes."""
    classes = set()
    for s in states:
        rep = equivalence(s)  # Canonical representative
        classes.add(rep)
    return len(classes)

def max_enum_entropy(category) -> int:
    """Maximum possible distinctions."""
    return len(category.objects)
```

**ANIMA criterion**: Agency manifests when `EnumEntropy == MaxEnumEntropy`.

## 4. Impact = Change in Equivalence Class

Impact is defined categorically as **movement between equivalence classes**:

```
Impact(action) = |[state_before]/~ △ [state_after]/~|
```

Where `△` is symmetric difference.

```python
class Impact:
    """Impact as equivalence class change."""
    
    @staticmethod
    def measure(before_state, after_state, equivalence):
        class_before = equivalence(before_state)
        class_after = equivalence(after_state)
        
        if class_before == class_after:
            return 0  # No categorical impact
        else:
            return 1  # Changed equivalence class
    
    @staticmethod
    def cumulative(trajectory, equivalence):
        """Total impact over trajectory."""
        changes = 0
        for i in range(1, len(trajectory)):
            changes += Impact.measure(
                trajectory[i-1], 
                trajectory[i], 
                equivalence
            )
        return changes
```

**Zero impact** = action preserves equivalence class (optimization within class)
**Nonzero impact** = action crosses class boundary (genuine change)

## 5. Before/At/Beyond ANIMA Phases

```
┌─────────────────────────────────────────────────────────────────┐
│                      ANIMA PHASE DIAGRAM                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  BEFORE ANIMA          AT ANIMA           BEYOND ANIMA          │
│  (Convergence)         (Agency)           (Divergence)          │
│                                                                 │
│  EnumEnt < Max         EnumEnt = Max      EnumEnt > Max         │
│  Skills compress       Skills balance     Skills create         │
│  Learning              Acting             Generating            │
│  Reducing classes      All classes        New categories        │
│  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   │
│        ↓                   ↓                   ↓                │
│  Condensation          Fixed Point         Decondensation       │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘
```

### Phase Characteristics

| Phase | EnumEntropy | Skill Effect | Mode |
|-------|-------------|--------------|------|
| BEFORE | < Max | Compressive | Learning |
| AT | = Max | Equilibrating | Agency |
| BEYOND | > Max | Generative | Creation |

```python
def anima_phase(current_entropy, max_entropy):
    if current_entropy < max_entropy:
        return "BEFORE"  # Still learning
    elif current_entropy == max_entropy:
        return "AT"      # Agency active
    else:
        return "BEYOND"  # Creating new categories
```

## 6. Agency Only Meaningful AT ANIMA

**Thesis**: Agency is only well-defined at the ANIMA fixed point.

- **BEFORE**: No agency—still converging, actions are learning
- **AT**: Agency emerges—all equivalence classes accessible, choices meaningful
- **BEYOND**: Post-agency—creating new categories, transcending current frame

```python
def can_act_agentically(state, anima) -> bool:
    """Agency requires being AT the ANIMA."""
    phase = anima_phase(
        enum_entropy(state, anima.equivalence),
        anima.max_enum_entropy
    )
    return phase == "AT"

def meaningful_choice(options, anima) -> bool:
    """Choices are meaningful only AT ANIMA."""
    if not can_act_agentically(anima.state, anima):
        return False
    # All options must map to distinct equivalence classes
    classes = [anima.equivalence(opt) for opt in options]
    return len(set(classes)) == len(options)
```

## 7. Operational Recipe (6 Steps)

### Step 1: Define Experience Functor E_•

```python
E = ExperienceFunctor(
    observations=raw_sensor_data,
    morphisms=temporal_succession
)
```

### Step 2: Build Skill Category

```python
Skills = Category(
    objects=[skill_1, skill_2, ..., skill_n],
    morphisms=skill_compositions,
    identity=no_op_skill
)
```

### Step 3: Apply Skills Iteratively

```python
state = E.initial()
for skill in skill_sequence:
    state = skill.apply(state)
    state = Condense(state)  # Profinite completion
```

### Step 4: Check Convergence

```python
while not converged:
    old_classes = equivalence_classes(state)
    state = apply_next_skill(state)
    new_classes = equivalence_classes(state)
    converged = (old_classes == new_classes)
```

### Step 5: Verify ANIMA Criterion

```python
assert enum_entropy(state) == max_enum_entropy(state)
# Now AT ANIMA - agency is meaningful
```

### Step 6: Act from Fixed Point

```python
if anima_phase(state) == "AT":
    action = choose_action(options, equivalence=anima.equivalence)
    impact = Impact.measure(state, execute(action), anima.equivalence)
    assert impact > 0  # Meaningful action crosses equivalence class
```

## GF(3) Integration

ANIMA phases map to GF(3) trits:

```
BEFORE = -1 (MINUS)   # Convergent/compressive
AT     =  0 (ERGODIC) # Balanced/agentic
BEYOND = +1 (PLUS)    # Divergent/generative
```

Conservation law: Total phase across interacting ANIMAs ≡ 0 (mod 3)

## Related Skills

| Skill | Trit | Integration |
|-------|------|-------------|
| [condensed-analytic-stacks](file:///Users/alice/.claude/skills/condensed-analytic-stacks/SKILL.md) | -1 | Scholze-Clausen foundation |
| [ordered-locale](file:///Users/alice/.agents/skills/ordered-locale-proper/SKILL.md) | 0 | Frame structure for dishes |
| [sheaf-cohomology](file:///Users/alice/.claude/skills/sheaf-cohomology/SKILL.md) | -1 | Gluing verification |
| [bisimulation-game](file:///Users/alice/.agents/skills/bisimulation-game/SKILL.md) | -1 | Equivalence verification |
| [gay-mcp](file:///Users/alice/.agents/skills/gay-mcp/SKILL.md) | +1 | Deterministic coloring |

## Commands

```bash
# Compute ANIMA from skill sequence
just anima-compute --skills "s1,s2,s3" --initial state.json

# Check ANIMA phase
just anima-phase --state current.json

# Measure impact of action
just anima-impact --before state1.json --after state2.json

# Verify GF(3) conservation across ANIMAs
just anima-gf3-check
```

## References

1. Scholze, P. & Clausen, D. (2022). *Condensed Mathematics*. Lecture notes.
2. Heunen, C. & van der Schaaf, N. (2024). "Ordered Locales." *JPAA*.
3. Badiou, A. (2006). *Being and Event*. Continuum. (Event = BEYOND phase)
4. Hesse, H. (1943). *The Glass Bead Game*. (Skill synthesis)

---

**Skill Name**: anima-theory  
**Type**: Categorical Agency Theory  
**Trit**: 0 (ERGODIC - coordinator of phases)  
**Phase Diagram**: BEFORE → AT → BEYOND  
**Agency Criterion**: EnumEntropy = MaxEnumEntropy



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

```
anima-theory (−) + SDF.Ch10 (+) + [balancer] (○) = 0
```

**Skill Trit**: -1 (MINUS - verification)

### Secondary Chapters

- Ch3: Variations on an Arithmetic Theme
- Ch5: Evaluation
- Ch6: Layering

### 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.