2nd/10_Wiki/Topic_General/From_Other/Understanding Complex Systems.md

---
id: wiki-2026-0508-understanding-complex-systems
title: Understanding Complex Systems
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Complexity Science, Complex Adaptive Systems, CAS]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [complexity, systems-thinking, emergence, networks]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Python
  framework: NetworkX / Mesa / SciPy
---

# Understanding Complex Systems

## 매 한 줄
> **"매 부분의 합 그 이상 — 매 emergence"**. Santa Fe Institute 1984 founding 이후 complexity science 는 economics, biology, AI safety 까지 확장됐고, 2026 현재 ABM + GNN + dynamical systems 의 hybrid analysis 가 standard toolkit이다.

## 매 핵심

### 매 정의 axes
- **Many components**: 매 대량의 interacting agent.
- **Nonlinearity**: small cause → large effect (butterfly).
- **Emergence**: macro pattern not reducible to micro rules.
- **Adaptation**: agent rule 의 evolution (CAS).
- **Self-organization**: external designer 없이 ordered structure.

### 매 phenomena
- **Phase transitions** (percolation, Ising).
- **Power laws / scale-free networks** (Barabási 1999).
- **Chaos & strange attractors** (Lorenz 1963).
- **Synchronization** (Kuramoto oscillators).
- **Critical brain hypothesis** (Beggs & Plenz 2003).

### 매 응용
1. Epidemic modeling (COVID-19, agent-based + network).
2. Financial market (heavy tails, flash crashes).
3. AI safety: emergent behaviors in LLM scaling, multi-agent.
4. Climate tipping points.
5. Urban / supply chain resilience.

## 💻 패턴

### Game of Life — emergence demo
```python
import numpy as np

def step(grid):
    n = sum(np.roll(np.roll(grid, i, 0), j, 1)
            for i in (-1, 0, 1) for j in (-1, 0, 1)
            if (i, j) != (0, 0))
    return ((n == 3) | ((grid == 1) & (n == 2))).astype(int)

g = np.random.binomial(1, 0.3, (200, 200))
for _ in range(500):
    g = step(g)
```

### Scale-free network (Barabási–Albert)
```python
import networkx as nx
G = nx.barabasi_albert_graph(n=10_000, m=3, seed=42)

degrees = [d for _, d in G.degree()]
# verify power-law
import powerlaw
fit = powerlaw.Fit(degrees, discrete=True)
print(fit.alpha, fit.xmin, fit.distribution_compare("power_law", "lognormal"))
```

### Kuramoto synchronization
```python
import numpy as np
from scipy.integrate import odeint

def kuramoto(theta, t, omega, K, N):
    dtheta = omega.copy()
    for i in range(N):
        dtheta[i] += (K/N) * np.sum(np.sin(theta - theta[i]))
    return dtheta

N, K = 100, 1.5
omega = np.random.normal(0, 1, N)
theta0 = np.random.uniform(0, 2*np.pi, N)
t = np.linspace(0, 50, 1000)
sol = odeint(kuramoto, theta0, t, args=(omega, K, N))

# order parameter r(t)
r = np.abs(np.exp(1j * sol).mean(axis=1))
```

### SIR epidemic on network
```python
import networkx as nx, random

def sir(G, beta=0.05, gamma=0.01, init=5, T=200):
    state = {n: "S" for n in G}
    for n in random.sample(list(G), init): state[n] = "I"
    history = []
    for _ in range(T):
        new = state.copy()
        for n, s in state.items():
            if s == "I":
                if random.random() < gamma: new[n] = "R"
                for nb in G.neighbors(n):
                    if state[nb] == "S" and random.random() < beta:
                        new[nb] = "I"
        state = new
        history.append((sum(v=="S" for v in state.values()),
                        sum(v=="I" for v in state.values()),
                        sum(v=="R" for v in state.values())))
    return history
```

### Lyapunov exponent (logistic map)
```python
import numpy as np
def lyapunov(r, x0=0.5, n=10_000, burn=1000):
    x = x0
    for _ in range(burn): x = r*x*(1-x)
    s = 0.0
    for _ in range(n):
        x = r*x*(1-x)
        s += np.log(abs(r - 2*r*x) + 1e-12)
    return s / n

for r in np.linspace(2.5, 4.0, 16):
    print(f"r={r:.2f}  λ={lyapunov(r):+.4f}")
```

### Causal emergence via effective info (PyPhi-lite idea)
```python
# coarse-grain & measure mutual info gain — 매 Hoel 2017
def effective_info(P_micro, grouping):
    # P_micro: (S, S) transition matrix
    # grouping: list of macro-state index per micro-state
    import numpy as np
    macro = max(grouping) + 1
    P_macro = np.zeros((macro, macro))
    for i, gi in enumerate(grouping):
        for j, gj in enumerate(grouping):
            P_macro[gi, gj] += P_micro[i, j]
    P_macro /= P_macro.sum(axis=1, keepdims=True) + 1e-12
    return P_macro
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Local rules, emergent macro | Agent-based (Mesa, NetLogo) |
| Network structure matters | NetworkX / igraph + null models |
| Continuous coupled oscillators | Kuramoto / ODE |
| Discrete-time chaos | Iterated maps + Lyapunov |
| Real data, latent dynamics | SINDy / Koopman / NeuralODE |

**기본값**: NetworkX + Mesa for structure+dynamics, SciPy for ODE, powerlaw for tail fit.

## 🔗 Graph
- 부모: [[Systems Theory]] · [[Nonlinear Dynamics]]
- 응용: [[Pedestrian-Modeling]]
- Adjacent: [[Entropy in Information Theory|Information Theory]] · [[AI_Safety_and_Alignment|AI Safety]]

## 🤖 LLM 활용
**언제**: model scaffolding, parameter sweep, hypothesis enumeration, literature 정리.
**언제 X**: long-horizon stability claim — 매 numerical proof / theorem 직접 검증.

## ❌ 안티패턴
- **Power-law claim 의 over-fit**: 매 lognormal vs power-law 비교 검증 필수 (Clauset 2009).
- **Emergence as magic**: 매 정의 명확화 — weak (epistemic) vs strong (ontological).
- **Single ABM run**: Monte Carlo ensemble 필수 (≥100 runs).
- **Network metric without null**: 매 configuration model baseline 비교.

## 🧪 검증 / 중복
- Verified (Mitchell "Complexity: A Guided Tour", SFI lectures, Strogatz "Nonlinear Dynamics and Chaos", Newman "Networks" 2nd ed).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — emergence + networks + chaos pattern set |