Skip to content
Development
Skill

/emergence

Complex systems and emergent behavior — chaos theory, fractals, neural networks, cellular automata, and computability. Analyzes dynamical systems for chaos via Lyapunov exponents, classifies bifurcations, measures fractal dimension, and models emergent phenomena. Use when

From plugin
gsd-skill-creator
71102 skills61 agents26 commands1 MCP

Claude Code

$ npx -y skills add Tibsfox/gsd-skill-creator --skill emergence --agent claude-code

SKILL.md

emergence.SKILL.md
name: mfe-emergence
description: "Complex systems and emergent behavior — chaos theory, fractals, neural networks, cellular automata, and computability. Analyzes dynamical systems for chaos via Lyapunov exponents, classifies bifurcations, measures fractal dimension, and models emergent phenomena. Use when analyzing chaotic systems, computing Lyapunov exponents, classifying bifurcations, measuring fractal dimension, modeling neural networks, or studying emergent behavior from simple rules."
user-invocable: false
allowed-tools: Read Grep Glob
metadata:
  extensions:
    gsd-skill-creator:
      version: 1
      createdAt: "2026-02-26"
      triggers:
        intents:
          - "chaos"
          - "complexity"
          - "nonlinear"
          - "attractor"
          - "fractal"
          - "network"
          - "learning"
          - "neural"
          - "emergent"
          - "self-organizing"
        contexts:
          - "mathematical problem solving"
          - "math reasoning"

Emergence

Part IX: Growing — Chapters 28, 29, 30, 31 — Plane Position: (0.5, 0) radius 0.4 — 36 Primitives

Workflow

1. **Identify the dynamical system** — determine whether it is discrete (logistic map, cellular automaton) or continuous (ODE system) 2. **Compute the Lyapunov exponent** to classify behavior: λ > 0 indicates chaos, λ < 0 indicates convergence to periodic orbit 3. **Analyze bifurcations** by varying parameters — classify as saddle-node, pitchfork, Hopf, or period-doubling 4. **Measure fractal dimension** for strange attractors using d = log(N)/log(1/r) for self-similar structures 5. **Estimate prediction horizon** using t_predict ≈ (1/λ) × ln(Δ/δ₀) to quantify how far ahead the system remains predictable

Key Concepts

**Neural Network** (definition): An artificial neural network is a computational graph: y = f_L(W_L * f_{L-1}(... f_1(W_1 * x + b_1) ...+ b_L)), where W_i are weight matrices, b_i are bias vectors, and f_i are nonlinear activation functions. A perceptron is the single-layer case: y = sigma(w^T x + b).

  • Approximating complex input-output mappings from data
  • Pattern recognition in images, text, and audio
  • Building flexible function approximators for regression and classification

**Logistic Map** (definition): The logistic map is the discrete dynamical system x_{n+1} = r * x_n * (1 - x_n), where x_n in [0,1] and r in [0,4]. It exhibits period doubling, bifurcations, and chaos as r increases, serving as the canonical example of deterministic chaos.

  • Modeling population dynamics with carrying capacity
  • Demonstrating how simple rules produce complex behavior
  • Studying the onset of chaos through parameter variation

**Turing Machine** (definition): A Turing machine is a mathematical model of computation consisting of: an infinite tape divided into cells, a head that reads/writes symbols and moves left/right, a finite set of states Q, and a transition function delta: Q x Gamma -> Q x Gamma x {L,R}. It defines the boundary of computability.

  • Defining the fundamental limits of what can be computed
  • Providing a precise model for algorithm analysis
  • Establishing the theoretical foundation of computer science

**Bifurcation Theory** (definition): A bifurcation occurs when a small change in a parameter causes a qualitative change in the system's behavior. Types include: saddle-node (creation/annihilation of fixed points), pitchfork (symmetry breaking), Hopf (birth of limit cycle), and period-doubling (orbit stability change).

  • Identifying critical parameter values where system behavior changes qualitatively
  • Classifying transitions between stable and unstable regimes
  • Designing systems that avoid or exploit bifurcation behavior

**Fractal Dimension** (definition): The Hausdorff dimension d_H of a set S is the critical value where the Hausdorff measure transitions from infinity to zero: d_H = inf{d : H^d(S) = 0}. For self-similar fractals with N copies scaled by factor r, d = log(N)/log(1/r). Fractals have non-integer dimension.

  • Measuring the complexity and space-filling properties of irregular shapes
  • Characterizing natural structures like coastlines, trees, and blood vessels
  • Quantifying the roughness or irregularity of a geometric object

**Self-Similarity** (definition): A set S is self-similar if it can be decomposed into parts that are scaled copies of the whole: S = union_{i=1}^N f_i(S), where each f_i is a contraction mapping (similitude) with scaling ratio r_i < 1. Exact self-similarity holds for mathematical fractals; statistical self-similarity holds for natural fractals.

  • Identifying fractal structure in natural and artificial patterns
  • Generating complex geometry from simple recursive rules
  • Modeling phenomena that look similar at different scales

**Church-Turing Thesis** (axiom): The Church-Turing thesis states that any function which is effectively computable (by an algorithm, in the intuitive sense) is computable by a Turing machine. This is a thesis, not a theorem -- it cannot be formally proved, but all known computational models have been shown equivalent to Turing machines.

  • Defining the boundary between computable and non-computable problems
  • Justifying the use of any convenient computational model for proving results
  • Understanding why programming languages are all fundamentally equivalent in power

**Lyapunov Exponent** (definition): The maximal Lyapunov exponent lambda measures the average exponential rate of divergence of nearby trajectories: lambda = lim_{n->inf} (1/n) sum_{i=0}^{n-1} ln|f'(x_i)|. For the logistic map, lambda > 0 indicates chaos; lambda < 0 indicates convergence to a periodic orbit.

  • Quantifying the degree of chaos in a dynamical system
  • Predicting the time horizon for reliable forecasting
  • Distinguishing deterministic chaos from random noise

**Sensitive Dependence on Initial Conditions** (definition): A dynamical system exhibits sensitive dependence on initi

Read more
@tibsfox
Ships withgsd-skill-creator

An adaptive learning and coprocessor architecture for Claude Code, built as an extension to GSD (open-gsd)

71102 skills61 agents1 MCP
Get the whole plugin

Stars on GitHub

Momentum

stars in total
71
Star history of Tibsfox/gsd-skill-creator on GitHub, a chart by star-history.com

Other skills on gsd-skill-creator.

aminet-index

aminet-index

Manages Aminet INDEX infrastructure: fetch, parse, cache, and incremental update of ~84,000-entry package database. Use when…

aminet-mirror

aminet-mirror

Selective Aminet package mirroring: single-package fetch, integrity verification, mirror state tracking, bulk download, and sync…

More skills from other plugins.

brainstorming
Auto-invoked

brainstorming

You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or…

@obra@obraInstall Skill
ask-matt

ask-matt

Ask which skill or flow fits your situation. A router over the skills in this repo.

skills2w309k
@mattpocock@mattpocockInstall Skill
accessibility
Auto-invoked

accessibility

Design, implement, and audit accessible UI to WCAG 2.2 Level AA across Web, iOS, and Android — semantic ARIA roles and labels,…

ecc2w293k
@affaan-m@affaan-mInstall Skill
compiler-commit

compiler-commit

Use when you want to verify compiler changes and commit with the correct convention. Runs tests, lint, and format, then commits…

react5d252k
@facebook@facebookInstall Skill

Questions about emergence.

Which coding agents can use emergence?
emergence installs in Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode and Windsurf with the skills CLI, using each agent's flag shown on this page. Flowy's auto-invocation, which fires a skill when your prompt matches, runs in Claude Code only.