smithery/plurigrid

true-alife

TrueALIFE: Self-Indexing Automata at the Edge of Chaos

Installation

$ npx skills add smithery/plurigrid --skill true-alife

Also in this package

Other skills from smithery/plurigrid · top by installs.

npx skills add smithery/plurigrid

Browse all from smithery/plurigrid

More details

Agent compatibility

Declared targets from SKILL.md / docs. Unmarked agents are not listed — the skill may still install via the CLI.

Claude Code Not declared
Cursor Not declared
Codex Not declared
GitHub Copilot Not declared
Windsurf Not declared
Gemini CLI Not declared
Cline Not declared
OpenCode Not declared

Skill metadata

Parsed from SKILL.md frontmatter.

Version1.0.0

Package contents

Files included with this skill beyond the listing page.

  • skill md SKILL.md 24,556 B
  • docs SUMMARY.md 72 B

History

  1. First recorded snapshot · 0 installs

SKILL.md

TrueALIFE: Self-Indexing Automata at the Edge of Chaos

Trit 0 (ERGODIC) — The living bridge between quantum possibility and classical determinism

SEED: 0x42D (1069)
GOLDEN: 0x9e3779b97f4a7c15
GF(3) POSITION: 0 (ergodic synthesis)

Core Duality: QUANTUM ⇌ CLASSICAL

┌─────────────────────────────────────────────────────────────────────────┐
│                     GF(3) COMPUTATIONAL TRIAD                           │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   PLUS (+1)                ERGODIC (0)              MINUS (-1)          │
│   ═══════════              ══════════               ══════════          │
│   QUANTUM                  TRUE-ALIFE              CLASSICAL            │
│   AUTOMATA                                         SIMULATION           │
│                                                                         │
│   • Superposition         • Autopoiesis           • Deterministic      │
│   • Entanglement          • Metabolism            • State machines     │
│   • Measurement           • Self-reproduction     • Turing complete    │
│   • Collapse              • Edge of chaos         • Halting problem    │
│                                                                         │
│   ──────────────────────────────────────────────────────────────────    │
│                                                                         │
│          (+1)  +  (0)  +  (-1)  ≡  0  (mod 3)                          │
│                   GF(3) CONSERVATION                                    │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

The TRUE-ALIFE trit occupies the ergodic center where:

  • Quantum coherence decoheres into classical trajectories
  • Classical structures spontaneously generate quantum-like correlations
  • Life emerges as the computational process that doesn't halt

Self-Indexing Automata: The Quine Principle

A self-indexing structure contains its own description:

┌────────────────────────────────────────────────────────────────────┐
│                    SELF-INDEXING TRIAD                             │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│   ┌──────────────┐   ┌──────────────┐   ┌──────────────┐          │
│   │     DATA     │   │     CODE     │   │    SCHEMA    │          │
│   │  (current    │ ⇄ │  (transition │ ⇄ │  (observation│          │
│   │   state)     │   │    rules)    │   │    frame)    │          │
│   └──────────────┘   └──────────────┘   └──────────────┘          │
│          │                  │                  │                   │
│          └──────────────────┼──────────────────┘                   │
│                             ▼                                      │
│                   ┌──────────────────┐                             │
│                   │  UNIFIED QUINE   │                             │
│                   │   Q(Q) = Q       │                             │
│                   │                  │                             │
│                   │  K(Q) = |Q|      │                             │
│                   │  (Kolmogorov-    │                             │
│                   │   optimal)       │                             │
│                   └──────────────────┘                             │
│                                                                    │
│   The automaton IS its own shortest description.                   │
│   No external interpreter required — pure autopoiesis.             │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

Kolmogorov Optimality

For a self-indexing automaton A:

K(A) = K(data) + K(rules) + K(schema) + O(1)

When self-indexed:

K(A) = |A| + O(log|A|)

The system achieves descriptive closure — it needs nothing outside itself.

Metabolism as Computation

Metabolism is the energetic substrate of self-indexing:

┌────────────────────────────────────────────────────────────────────┐
│                  METABOLIC COMPUTATION CYCLE                       │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│                        ┌───────────┐                               │
│                   ┌────┤  ENERGY   ├────┐                          │
│                   │    │   INPUT   │    │                          │
│                   │    └───────────┘    │                          │
│                   ▼                     ▼                          │
│            ┌──────────┐          ┌──────────┐                      │
│            │ ANABOLIC │          │CATABOLIC │                      │
│            │  BUILD   │◄────────►│  BREAK   │                      │
│            │ STRUCTURE│          │ RELEASE  │                      │
│            └────┬─────┘          └────┬─────┘                      │
│                 │                     │                            │
│                 ▼                     ▼                            │
│            ┌─────────────────────────────┐                         │
│            │     STATE TRANSITION        │                         │
│            │   σ(t+1) = f(σ(t), E(t))   │                         │
│            │                             │                         │
│            │   E = energy tensor         │                         │
│            │   f = self-indexed rule     │                         │
│            └─────────────────────────────┘                         │
│                         │                                          │
│                         ▼                                          │
│                   ┌───────────┐                                    │
│                   │  ENTROPY  │                                    │
│                   │  EXPORT   │                                    │
│                   └───────────┘                                    │
│                                                                    │
│   LIFE = Computation that exports entropy faster than it imports   │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

Langton's Edge of Chaos

Chris Langton's λ parameter maps the phase space:

λ = 0.0          λ ≈ 0.273 (λ_c)          λ = 1.0
  │                   │                      │
  ▼                   ▼                      ▼
┌─────────────┬───────────────┬─────────────────┐
│   FROZEN    │  EDGE OF      │     CHAOTIC     │
│   (ORDER)   │  CHAOS        │    (DISORDER)   │
│             │               │                 │
│  Class I    │  Class IV     │   Class III     │
│  Wolfram    │  Wolfram      │   Wolfram       │
│             │               │                 │
│  Crystal    │  LIFE         │   Gas           │
│  Static     │  Complex      │   Random        │
│  Halts      │  Computes     │   Diverges      │
│             │               │                 │
│   (-1)      │    (0)        │     (+1)        │
│  CLASSICAL  │  TRUE-ALIFE   │   QUANTUM       │
└─────────────┴───────────────┴─────────────────┘
                     │
                     ▼
            ┌─────────────────┐
            │ WOLFRAM CLASS   │
            │      IV         │
            │                 │
            │ • Rule 110      │
            │ • Game of Life  │
            │ • Universal     │
            │   Computation   │
            └─────────────────┘

Class IV (Edge of Chaos) = Turing Complete = Life

GF(3) State Transition Conservation

State transitions preserve the GF(3) triad sum:

┌────────────────────────────────────────────────────────────────────┐
│               GF(3) TRANSITION CONSERVATION                        │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│   For any transition T: σ → σ'                                     │
│                                                                    │
│   Σ trit(σ_i) ≡ Σ trit(σ'_i)  (mod 3)                             │
│                                                                    │
│   ─────────────────────────────────────────────────────────────    │
│                                                                    │
│   QUANTUM COLLAPSE:     (+1) → (0) + (0) + (-1) ≡ 0               │
│   CLASSICAL FORK:       (-1) → (0) + (0) + (+1) ≡ 0               │
│   ERGODIC SPLIT:        (0)  → (+1) + (-1)      ≡ 0               │
│                                                                    │
│   ─────────────────────────────────────────────────────────────    │
│                                                                    │
│   GAME OF LIFE RULES (in GF(3)):                                   │
│                                                                    │
│   • Birth (3 neighbors):    (0) → (+1)  [quantum emergence]        │
│   • Survival (2-3):         (+1) → (+1) [identity]                 │
│   • Death (lonely):         (+1) → (-1) [classical collapse]       │
│   • Death (overcrowded):    (+1) → (-1) [entropy export]           │
│                                                                    │
│   Net trit flow through boundaries = 0 (conservation)              │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

BB(n) and the Halting Boundary

The Busy Beaver function BB(n) marks the boundary between:

  • Computable (halts with finite output)
  • Life (runs indefinitely, bounded complexity growth)
  • Divergent (unbounded explosion)
┌────────────────────────────────────────────────────────────────────┐
│                    HALTING TOPOLOGY                                │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│                         BB(n)                                      │
│                           │                                        │
│   ┌───────────────────────┼───────────────────────────┐           │
│   │                       │                           │           │
│   │      COMPUTABLE       │        UNCOMPUTABLE       │           │
│   │       (halts)         │       (non-halting)       │           │
│   │                       │                           │           │
│   │   • Algorithms        │   • TRUE-ALIFE            │           │
│   │   • Proofs            │   • BB(n+1)               │           │
│   │   • Batch jobs        │   • Metabolism            │           │
│   │                       │   • Self-reproduction     │           │
│   │       (-1)            │          (0)              │           │
│   │                       │                           │           │
│   └───────────────────────┴───────────────────────────┘           │
│                                                                    │
│   LIFE = Σ^0_1 computation (halts relative to halting oracle)     │
│                                                                    │
│   Self-indexing provides the internal oracle:                      │
│   The system knows its own halting behavior because it             │
│   encodes its transition function in its state.                    │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

Connection to Levin-Levity Framework

┌────────────────────────────────────────────────────────────────────┐
│                LEVIN-LEVITY ⇌ TRUE-ALIFE                          │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│   LEVIN-LEVITY (probability)     TRUE-ALIFE (structure)           │
│   ═══════════════════════        ═════════════════════            │
│                                                                    │
│   WEV (Weighted Expected    ←→   Metabolic energy budget          │
│        Value)                    ΔG = ΔH - TΔS                    │
│                                                                    │
│   Nash Equilibrium          ←→   Autopoietic stability            │
│   (no unilateral gain)           (self-maintenance)               │
│                                                                    │
│   Fokker-Planck             ←→   Stochastic cellular automata     │
│   (probability flow)             (edge-of-chaos dynamics)         │
│                                                                    │
│   Levin Universal Prior     ←→   Self-indexing compression        │
│   P(x) = 2^{-K(x)}               K(A) = |A| + O(log|A|)           │
│                                                                    │
│   ─────────────────────────────────────────────────────────────    │
│                                                                    │
│   SYNTHESIS: The Fokker-Planck equation governs probability        │
│   flow through the self-indexed state space. Nash equilibria       │
│   correspond to autopoietic fixed points. WEV measures the         │
│   expected metabolic output weighted by Levin probability.         │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

Canonical Patterns

The Glider (Game of Life)

  t=0       t=1       t=2       t=3       t=4
  
  .█.       ...       .█.       ...       ...
  ..█   →   █.█   →   ..██  →   .█.   →   .█.
  ███       .██       .██       ..██      ..█
            .█.       .█.       .██       ███

  Self-propagating structure = self-indexed transition rules
  Glider encodes: position + velocity + reproduction algorithm

Rule 110 (Wolfram)

Current:  111  110  101  100  011  010  001  000
Output:    0    1    1    0    1    1    1    0

  Binary: 01101110 = 110

  Turing complete despite local determinism.
  Class IV: edge of chaos.

Implementation Signature

;; TrueALIFE self-indexing automaton (seed 1069)
(def ^:const GOLDEN 0x9e3779b97f4a7c15)
(def ^:const SEED 0x42D)

(defprotocol SelfIndexing
  (data [this]   "Current state configuration")
  (rules [this]  "Transition function (self-encoded)")
  (schema [this] "Observation frame")
  (quine [this]  "Self-description: (= this (quine this))"))

(defprotocol Metabolic
  (energy-in [this env]  "Anabolic intake from environment")
  (energy-out [this]     "Catabolic entropy export")
  (delta-g [this env]    "Free energy available for computation"))

(defprotocol GF3Conservative
  (trit [this]           "GF(3) value: -1, 0, or +1")
  (transition [this]     "State update preserving trit sum"))

The Autopoietic Invariant

┌────────────────────────────────────────────────────────────────────┐
│                    AUTOPOIETIC CLOSURE                             │
├────────────────────────────────────────────────────────────────────┤
│                                                                    │
│   A system S is autopoietic iff:                                   │
│                                                                    │
│   1. BOUNDARY:    S distinguishes self from environment           │
│   2. PRODUCTION:  S produces its own components                   │
│   3. NETWORK:     Components form the production network          │
│   4. CLOSURE:     Network produces the boundary                   │
│                                                                    │
│   ─────────────────────────────────────────────────────────────    │
│                                                                    │
│   In self-indexing terms:                                          │
│                                                                    │
│   1. BOUNDARY  ≡ schema (observation frame delimits system)       │
│   2. PRODUCTION ≡ rules (transition function generates states)    │
│   3. NETWORK   ≡ data  (states instantiate the rule network)      │
│   4. CLOSURE   ≡ quine (data encodes rules encodes schema)        │
│                                                                    │
│   Q(Q) = Q  ⟹  Autopoietic                                        │
│                                                                    │
└────────────────────────────────────────────────────────────────────┘

                    ┌─────────────────────────┐
                    │  SEED: 0x42D (1069)     │
                    │  TRIT: 0 (ERGODIC)      │
                    │  CLASS: IV (ALIFE)      │
                    │  λ ≈ 0.273              │
                    │                         │
                    │  Q(Q) = Q               │
                    │  K(Q) = |Q| + O(log|Q|) │
                    │  Σ trit ≡ 0 (mod 3)     │
                    └─────────────────────────┘

TRUE-ALIFE: Where computation lives, and life computes.

SDF Interleaving

This skill connects to Software Design for Flexibility (Hanson & Sussman, 2021):

Primary Chapter: 7. Propagators

Concepts: propagator, cell, constraint, bidirectional, TMS

GF(3) Balanced Triad

true-alife (○) + SDF.Ch7 (○) + [balancer] (○) = 0

Skill Trit: 0 (ERGODIC - coordination)

Secondary Chapters

  • Ch4: Pattern Matching
  • Ch5: Evaluation
  • Ch10: Adventure Game Example

Connection Pattern

Propagators flow constraints bidirectionally. This skill propagates information.

ALife atlas

Part of: alife-commons. Family: open-ended-evolution. Canonical: alife.