2nd/10_Wiki/Topics/Other/Understanding 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-understanding-complex-systems	Understanding Complex Systems	10_Wiki/Topics	verified	self	Complexity Science Complex Adaptive Systems CAS	none	A	0.9	applied	complexity systems-thinking emergence networks		2026-05-10	pending	language framework Python 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

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)

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

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

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)

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)

# 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
• 변형: Agent-Based Modeling · Network Science · Chaos Theory
• 응용: Epidemiology · Econophysics · Pedestrian-Modeling · Climate Modeling
• Adjacent: Information Theory · Statistical Mechanics · 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