---
id: wiki-2026-0508-emergence-in-complex-systems
title: Emergence in Complex Systems
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [emergence, complex systems, self-organization, weak emergence, strong emergence]
duplicate_of: none
source_trust_level: A
confidence_score: 0.94
verification_status: applied
tags: [systems-thinking, emergence, complexity, self-organization, swarm, abm, nonlinearity]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Python / NetLogo
  applicable_to: [Systems, ABM, Swarm, ML]
---

# Emergence in Complex Systems

## 매 한 줄
> **"매 part 의 sum 의 X — 매 interaction 의 의 의 macro property"**. 매 ant colony 의 path, 매 flock 의 V-formation, 매 traffic jam, 매 LLM 의 in-context learning. 매 weak (predictable) vs strong (irreducible). 매 modern AI: 매 emergent abilities (Wei 2022).

## 매 핵심

### 매 type
- **Weak**: 매 simulate 의 predictable.
- **Strong**: 매 reduce 의 X (consciousness?).
- **Nominal**: 매 just labeling.

### 매 example
- **Boids**: 매 3 rule → 매 flocking.
- **Game of Life**: 매 4 rule → 매 glider.
- **Ant colony**: 매 pheromone → 매 shortest path.
- **Sandpile**: 매 SOC (self-organized criticality).
- **LLM emergent**: 매 scale → 매 capability jump.
- **Traffic**: 매 individual driver → 매 jam.

### 매 hallmark
- **Nonlinearity**.
- **Many interacting agents**.
- **Local rule → global pattern**.
- **Phase transition**.
- **Sensitivity to initial condition**.

### 매 modern AI emergence
- **Few-shot learning**: 매 GPT-3 emergence.
- **CoT reasoning**: 매 scale 의 emerge.
- **Tool use**: 매 instruction-tuning.
- **Theory of mind**: 매 large model.
- **Caveat**: Schaeffer 2023 의 매 metric artifact 의 argue.

### 매 응용
1. **ABM**: 매 emergent traffic / market.
2. **Swarm robotics**: 매 collective task.
3. **Neural network**: 매 feature emergence.
4. **Economy**: 매 market price.
5. **Biology**: 매 morphogenesis.

## 💻 패턴

### Boids (3 rules)
```python
import numpy as np

def boids_step(positions, velocities, R=10, max_v=2):
    N = len(positions)
    new_v = velocities.copy()
    for i in range(N):
        neighbors = [j for j in range(N) if j != i and np.linalg.norm(positions[j] - positions[i]) < R]
        if not neighbors: continue
        
        # 매 separation
        sep = sum(positions[i] - positions[j] for j in neighbors) / len(neighbors)
        # 매 alignment
        align = sum(velocities[j] for j in neighbors) / len(neighbors) - velocities[i]
        # 매 cohesion
        cent = sum(positions[j] for j in neighbors) / len(neighbors)
        cohe = cent - positions[i]
        
        new_v[i] += 0.5 * sep + 0.3 * align + 0.2 * cohe
        if np.linalg.norm(new_v[i]) > max_v:
            new_v[i] = new_v[i] / np.linalg.norm(new_v[i]) * max_v
    
    return positions + new_v, new_v
```

### Conway Game of Life
```python
def life_step(grid):
    n = grid.shape[0]
    new = grid.copy()
    for i in range(1, n - 1):
        for j in range(1, n - 1):
            neighbors = grid[i-1:i+2, j-1:j+2].sum() - grid[i, j]
            if grid[i, j] == 1:
                new[i, j] = 1 if neighbors in (2, 3) else 0
            else:
                new[i, j] = 1 if neighbors == 3 else 0
    return new
```

### Ant colony optimization
```python
class ACO:
    def __init__(self, n, n_ants=20, alpha=1, beta=2, rho=0.5):
        self.pheromone = np.ones((n, n))
        self.alpha, self.beta, self.rho = alpha, beta, rho
        self.n_ants = n_ants
    
    def step(self, distances):
        all_paths = []
        for _ in range(self.n_ants):
            path = self.ant_walk(distances)
            length = self.path_length(path, distances)
            all_paths.append((path, length))
        
        # 매 evaporate
        self.pheromone *= (1 - self.rho)
        # 매 deposit
        for path, length in all_paths:
            for i in range(len(path) - 1):
                self.pheromone[path[i], path[i+1]] += 1 / length
```

### Self-organized criticality (sandpile)
```python
def sandpile_topple(grid, threshold=4):
    """매 BTW model. 매 power-law avalanche."""
    while (grid >= threshold).any():
        i, j = np.unravel_index(grid.argmax(), grid.shape)
        grid[i, j] -= threshold
        for di, dj in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
            ni, nj = i + di, j + dj
            if 0 <= ni < grid.shape[0] and 0 <= nj < grid.shape[1]:
                grid[ni, nj] += 1
    return grid
```

### Schelling segregation
```python
def schelling_step(grid, threshold=0.3):
    """매 mild preference → 매 stark segregation."""
    H, W = grid.shape
    moved = True
    while moved:
        moved = False
        for i in range(H):
            for j in range(W):
                if grid[i, j] == 0: continue
                neighbors = grid[max(0,i-1):i+2, max(0,j-1):j+2].flatten()
                same = (neighbors == grid[i, j]).sum() - 1
                total = (neighbors > 0).sum() - 1
                if total > 0 and same / total < threshold:
                    # 매 move to empty
                    empties = list(zip(*np.where(grid == 0)))
                    if empties:
                        ni, nj = empties[np.random.randint(len(empties))]
                        grid[ni, nj] = grid[i, j]
                        grid[i, j] = 0
                        moved = True
    return grid
```

### Detect phase transition
```python
def detect_phase_transition(order_param, control_param):
    """매 derivative 의 spike."""
    derivs = np.gradient(order_param, control_param)
    threshold = np.std(derivs) * 3
    transitions = np.where(np.abs(derivs) > threshold)[0]
    return [control_param[i] for i in transitions]
```

### Emergence metric (transfer entropy)
```python
def transfer_entropy(X, Y, k=1):
    """매 X → Y information flow."""
    from sklearn.feature_selection import mutual_info_regression
    Y_future = Y[k:]
    Y_past = Y[:-k]
    X_past = X[:-k]
    
    H_y_given_ypast = mutual_info_regression(Y_past.reshape(-1, 1), Y_future)[0]
    XY_past = np.column_stack([X_past, Y_past])
    H_y_given_xy = mutual_info_regression(XY_past, Y_future)[0]
    return H_y_given_xy - H_y_given_ypast
```

### LLM scaling law (emergence test)
```python
def is_emergent(model_sizes, accuracies, metric='step'):
    """매 Wei 2022-style emergence detection."""
    if metric == 'step':
        # 매 sudden jump
        diffs = np.diff(accuracies)
        return np.max(diffs) > 3 * np.std(diffs)
    elif metric == 'continuous':
        # 매 Schaeffer 2023 의 critique 의 sensitivity
        return False  # 매 use continuous metric instead
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Animal behavior | Boids / Schelling |
| Optimization | ACO |
| Critical phenomena | Sandpile / Ising |
| Market | ABM economic |
| Neural net | Mechanistic interpretability |
| LLM scale | Emergence + critique |

**기본값**: 매 ABM + 매 phase transition 의 detect + 매 emergent 의 careful (metric artifact). 매 rules 의 simple 의 prefer.

## 🔗 Graph
- 부모: [[Complex Systems]] · [[Systems_Thinking|Systems-Thinking]]
- 변형: [[Self-Organization]]
- 응용: [[Swarm_Intelligence|Swarm-Intelligence]] · [[Cellular Automata]]
- Adjacent: [[Cybernetics Foundations|Cybernetics]] · [[Computational_Creativity|Computational-Creativity]] · [[Drama Management Systems]]

## 🤖 LLM 활용
**언제**: 매 systems analysis. 매 ABM. 매 emergent capability research.
**언제 X**: 매 reductionist sufficient.

## ❌ 안티패턴
- **Mistake nominal for genuine**: 매 just labeling.
- **Strong emergence claim**: 매 unfalsifiable.
- **No baseline**: 매 emergence vs random.
- **Metric artifact**: 매 step metric only.
- **Reductionism only**: 매 macro property 의 miss.

## 🧪 검증 / 중복
- Verified (Mitchell Complexity, Wei 2022, Schaeffer 2023).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-04-20 | Auto-reinforced |
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — emergence + 매 boids / GoL / ACO / Schelling / TE / scaling code |