2nd/10_Wiki/Topics/AI_and_ML/Emergence-in-Complex-Systems.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-emergence-in-complex-systems	Emergence in Complex Systems	10_Wiki/Topics	verified	self	emergence complex systems self-organization weak emergence strong emergence	none	A	0.94	applied	systems-thinking emergence complexity self-organization swarm abm nonlinearity		2026-05-10	pending	language applicable_to Python / NetLogo 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)

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

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

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)

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

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

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)

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)

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
• 변형: Self-Organization
• 응용: Swarm_Intelligence · Cellular Automata
• Adjacent: Cybernetics Foundations · 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