2nd/10_Wiki/Topics/Domain_Programming/From_Other/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-complex-systems	Complex Systems	10_Wiki/Topics	verified	self	Complexity Theory Complex Adaptive Systems CAS	none	A	0.9	applied	systems-thinking complexity emergence distributed-systems		2026-05-10	pending	language framework n/a n/a

Complex Systems

매 한 줄

"매 Complex System 매 part 의 sum 초과 의 emergent 결과 발생 system". 매 simple-rule 매 unpredictable global 의 야기. Santa Fe Institute (Holland, Kauffman, Mitchell) 의 lineage. 2026 매 LLM swarm, distributed micro-services, social platform 매 canonical 예.

매 핵심

매 정의 specifics

• Many components (10² ~ 10⁹).
• Local interaction (no central control).
• Non-linearity: 매 input → output 의 disproportionate.
• Emergence: 매 macro behavior 매 micro rule 의 not directly inferrable.
• Adaptation: 매 component 의 state-update 의 environment 응답.

매 simple ↔ complicated ↔ complex (Cynefin)

• Simple: 매 cause↔effect obvious. Best practice 의 사용.
• Complicated: 매 expert analysis required. Good practice.
• Complex: 매 retrospect 만 cause 추론 가능. 매 probe-sense-respond.
• Chaotic: 매 cause↔effect link absent. Act-sense-respond.

매 응용

1. Distributed system design 매 emergent failure mode 의 anticipate.
2. Org change 매 directly-controllable lever 부재 — 매 nudge.
3. Market / social media 의 non-linear viral propagation.

💻 패턴

Power-law detection (Pareto)

import numpy as np, scipy.stats as st

def is_powerlaw(data: np.ndarray) -> bool:
    """Heavy-tailed → likely complex, not Gaussian."""
    fit = st.powerlaw.fit(data)
    ks_p = st.kstest(data, "powerlaw", fit).pvalue
    return ks_p > 0.05

Agent-based model (Mesa)

from mesa import Agent, Model
from mesa.space import MultiGrid
from mesa.time import RandomActivation

class Cell(Agent):
    def step(self):
        n = self.neighbors_alive()
        self.alive = (n == 3) or (self.alive and n == 2)

class Life(Model):
    def __init__(self, w=80, h=80):
        self.grid = MultiGrid(w, h, torus=True)
        self.schedule = RandomActivation(self)
        for x in range(w):
            for y in range(h):
                a = Cell(self)
                self.grid.place_agent(a, (x, y))
                self.schedule.add(a)

Feedback-loop diagram (Mermaid)

graph LR
  Demand --> Price
  Price -->|+| Supply
  Supply -->|-| Price
  Price -->|-| Demand

Tipping-point detection

def early_warning_signal(timeseries):
    """Increased variance + autocorrelation → near phase transition."""
    rolling_var = pd.Series(timeseries).rolling(50).var()
    rolling_ac = pd.Series(timeseries).rolling(50).apply(lambda x: x.autocorr(1))
    return rolling_var.iloc[-1] > rolling_var.mean() * 1.5 \
       and rolling_ac.iloc[-1] > 0.7

Causal-loop policy lever map

# policy_levers.yml
goal: reduce-incident-rate
levers:
  - lever: deploy-frequency
    feedback: positive  # more deploys → more incidents short-term
    horizon: weeks
  - lever: test-coverage
    feedback: negative  # higher coverage → fewer incidents
    horizon: months
  - lever: oncall-rotation-size
    feedback: negative  # larger rotation → less burnout → fewer incidents
    horizon: quarters

Network resilience metric

import networkx as nx
def fragility(G: nx.Graph) -> float:
    """Higher = more fragile to targeted node removal."""
    bc = nx.betweenness_centrality(G)
    return max(bc.values()) - np.median(list(bc.values()))

매 결정 기준

상황	Approach
Linear, well-understood	Optimization, KPI
Complicated (expert solvable)	Plan + execute
Complex (emergent)	Probe + small experiments + observe
Chaotic (crisis)	Act first, stabilize, then sense
Pre-tipping point	Early-warning + circuit-breaker

기본값: probe-sense-respond + diversity + redundancy.

🔗 Graph

• 부모: Systems_Thinking
• 변형: Complex Adaptive Systems
• 응용: Distributed Systems
• Adjacent: Emergence

🤖 LLM 활용

언제: 매 system map 의 first-draft, 매 feedback-loop 의 surface, 매 policy lever brainstorm. 언제 X: 매 prediction 의 complex system — 매 LLM 매 false confidence 매 위험. 매 historical analogy 의 limit.

❌ 안티패턴

• Linear thinking: 매 cause→effect 의 direct mapping 매 complex 에서 wrong.
• Optimization fallacy: 매 single metric 의 optimization 매 emergent failure 야기 (Goodhart).
• Central control assumption: 매 top-down command 매 local-rule system 매 ineffective.
• Reductionism over-reach: 매 component 의 분석 매 emergent property 의 missing.
• Plan-the-future fallacy: 매 5-year-plan 매 complex domain 매 fiction.

🧪 검증 / 중복

• Verified (Mitchell Complexity: A Guided Tour, Holland Hidden Order, Snowden Cynefin Framework, Santa Fe Institute lectures, Donella Meadows Thinking in Systems).
• 신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — Cynefin, agent-based model, power law, anti-patterns