---
id: wiki-2026-0508-system-theory
title: System Theory
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Systems Theory, General Systems Theory, GST, 시스템 이론, Systems Thinking]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [systems-theory, cybernetics, complexity, emergence, feedback]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: python
  framework: networkx
---

# System Theory

## 매 한 줄
> **"매 system theory 는 components 의 isolation 의 X — 매 interaction·feedback·emergence 의 study"**. 매 von Bertalanffy "General System Theory" (1968) 의 origin, Wiener cybernetics 의 partner. 매 2026 의 modern descendants: complex systems, network science, dynamical systems, software architecture (microservice, observability).

## 매 핵심

### 매 foundational figures
- **Ludwig von Bertalanffy (1968)**: General System Theory — 매 biology·sociology·engineering 의 unify.
- **Norbert Wiener (1948)**: Cybernetics — feedback 의 first-class.
- **Ashby**: Law of Requisite Variety — 매 controller variety ≥ system variety.
- **Forrester**: System Dynamics — stock·flow·delay model.
- **Senge (1990)**: "Fifth Discipline" — organizational systems thinking.
- **Meadows (2008)**: "Thinking in Systems" — leverage points.

### 매 core concepts
- **System = elements + interconnections + purpose** (Meadows).
- **Open vs closed**: open = energy/info exchange with env; biology, business 매 open.
- **Feedback loop**: balancing (B, negative) → stabilize. reinforcing (R, positive) → exponential.
- **Stock & flow**: state (stock) 의 flow rate 의 integral.
- **Delay**: 매 oscillation·overshoot 의 source.
- **Emergence**: macro property 의 micro 의 absent.
- **Equifinality**: 매 다른 path 의 same end state.

### 매 leverage points (Meadows, low → high)
1. Numbers (parameters).
2. Buffers.
3. Stock-flow structure.
4. Delays.
5. Balancing loops.
6. Reinforcing loops.
7. Information flows.
8. Rules.
9. Self-organization.
10. Goals.
11. Paradigms.
12. Power to transcend paradigms.

### 매 modern descendants
- **Complex Systems**: Santa Fe Institute — Holland, Kauffman.
- **Network Science**: Barabási — scale-free, small-world.
- **Dynamical Systems**: Strogatz — nonlinear, chaos, attractor.
- **Software**: SRE (feedback via SLO), DDD (bounded context = subsystem), observability.

### 매 응용
1. **Software architecture**: microservice = subsystem + bounded context.
2. **SRE**: error budget = balancing loop on reliability.
3. **Climate / business**: System Dynamics simulation (Vensim, Stella).
4. **AI safety**: feedback loop analysis for reward hacking, recursive improvement.

## 💻 패턴

### 1. Stock & flow simulation (System Dynamics)
```python
import numpy as np
import matplotlib.pyplot as plt

def simulate(birth_rate=0.05, death_rate=0.02, init_pop=1000, T=100, dt=0.1):
    pop = np.zeros(int(T/dt))
    pop[0] = init_pop
    for t in range(1, len(pop)):
        births = birth_rate * pop[t-1] * dt   # reinforcing
        deaths = death_rate * pop[t-1] * dt   # balancing
        pop[t] = pop[t-1] + births - deaths
    return pop

pop = simulate()
plt.plot(pop); plt.title("Population stock")
```

### 2. Feedback loop classification
```python
def classify_loop(edges):
    """edges: list of (src, dst, sign in {+1, -1})"""
    product = 1
    for _, _, sign in edges:
        product *= sign
    return "reinforcing (R)" if product > 0 else "balancing (B)"
```

### 3. Lotka-Volterra (predator-prey, dynamical system)
```python
from scipy.integrate import odeint

def lv(state, t, alpha, beta, delta, gamma):
    x, y = state  # prey, predator
    dxdt = alpha*x - beta*x*y
    dydt = delta*x*y - gamma*y
    return [dxdt, dydt]

t = np.linspace(0, 50, 1000)
sol = odeint(lv, [40, 9], t, args=(0.1, 0.02, 0.01, 0.1))
```

### 4. Network analysis (small-world, scale-free)
```python
import networkx as nx

# Watts-Strogatz small-world
G_sw = nx.watts_strogatz_graph(n=1000, k=10, p=0.1)
print("avg path:", nx.average_shortest_path_length(G_sw))
print("clustering:", nx.average_clustering(G_sw))

# Barabási-Albert scale-free
G_ba = nx.barabasi_albert_graph(n=1000, m=3)
degrees = [d for _, d in G_ba.degree()]
# power-law degree distribution
```

### 5. Causal Loop Diagram (CLD) as graph
```python
import networkx as nx

cld = nx.DiGraph()
cld.add_edge("ad spend", "leads", sign=+1)
cld.add_edge("leads", "revenue", sign=+1)
cld.add_edge("revenue", "ad spend", sign=+1)   # R loop
cld.add_edge("ad spend", "cash", sign=-1)
cld.add_edge("cash", "ad spend", sign=+1)      # B loop on cash

for cycle in nx.simple_cycles(cld):
    edges = [(cycle[i], cycle[(i+1) % len(cycle)]) for i in range(len(cycle))]
    signs = [cld[u][v]["sign"] for u, v in edges]
    loop_type = "R" if np.prod(signs) > 0 else "B"
    print(cycle, loop_type)
```

### 6. SLO error budget (SRE balancing loop)
```python
class ErrorBudget:
    def __init__(self, slo=0.999, window_days=30):
        self.budget = (1 - slo) * window_days * 24 * 60  # minutes
        self.consumed = 0

    def consume(self, downtime_min):
        self.consumed += downtime_min
        return self.consumed >= self.budget  # halt deploys when burned

    def remaining(self):
        return max(0, self.budget - self.consumed)
```

### 7. Leverage point identification
```python
LEVERAGE = {
    "params":      1, "buffer":     2, "structure":  3, "delays":     4,
    "balancing":   5, "reinforce":  6, "info":       7, "rules":      8,
    "self_org":    9, "goals":     10, "paradigm":  11, "transcend": 12,
}

def rank_intervention(name, kind):
    return LEVERAGE.get(kind, 0)
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Continuous quantities, feedback | System Dynamics (Vensim/PySD) |
| Discrete agents, interaction | Agent-Based Model (Mesa) |
| Network of relationships | Network Science (NetworkX) |
| Software subsystem boundary | DDD bounded context |
| Reliability | SRE error budget loops |

**기본값**: 매 problem framing 의 first — stock/flow/loop 의 sketch, 그 후 quantitative tool 의 select.

## 🔗 Graph
- 부모: [[Cybernetics Foundations|Cybernetics]] · [[Complexity-Science]]
- 응용: [[SRE]]
- Adjacent: [[Synergy]] · [[Emergence]] · [[Feedback-Loop]] · [[Domain-Driven-Design]]

## 🤖 LLM 활용
**언제**: CLD 의 sketch from natural language description, leverage point 의 explain, scenario walk-through.
**언제 X**: quantitative simulation 의 itself (PySD/Mesa 의 사용 — LLM 의 number drift).

## ❌ 안티패턴
- **Linear thinking on systems**: 매 cause→effect chain 의 only — feedback 의 ignore.
- **Local optimization**: 매 sub-optimum globally — Goodhart's law.
- **Delays 무시**: 매 oscillation·overshoot 의 surprise.
- **Numbers (params) 의 leverage 의 prioritize**: 매 lowest leverage — paradigm·goals 의 더 powerful.
- **Closed-system assumption on open**: 매 boundary 의 false → ignored externalities.

## 🧪 검증 / 중복
- Verified (Bertalanffy "General System Theory" 1968, Meadows "Thinking in Systems" 2008, Wiener "Cybernetics" 1948, Forrester "Industrial Dynamics" 1961).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — system theory (Bertalanffy + cybernetics + modern complexity + software apps) |