docs(10_Wiki): 위키 전체 재구성 — Topic_* 폴더를 4개 카테고리로 통합 + 대규모 중복 제거

Topic_Agent/Topic_Blog/Topics/Topics_Biz/Topics_Meeting/Topics_Rag의 마크다운 지식 문서를
Topic_General/Topic_Programming/Topic_Graphic/Topic_Business 4개 카테고리로 재분류.

- 중복 제거: frontmatter의 status:duplicate/merged + duplicate_of/redirect_to 필드로
  자기 자신을 중복으로 선언한 리다이렉트 stub 1032개 제거, 완전 동일 내용 파일 472개 제거,
  동일 파일명·다른 내용 충돌 시 더 큰(완전한) 버전만 유지(162개 제거) — 총 1639개 중복 제거.
- 분류: 폴더 단위로 명확한 항목(AI_and_ML/Coding/Architecture 등 → Programming,
  Comfyui/Visual_Effects → Graphic, Topics_Biz/Topics_Meeting/사업 등 → Business,
  Poetic_Blog_Writing/창의성/Game_Design 등 → General)은 폴더 우선순위로,
  나머지 혼재 폴더(Topic_Agent/Topic_Blog/Topics 루트/Thinking & Reasoning/Other/UI_UX_Assets)는
  title/tags 키워드 스코어링으로 파일 단위 분류(불명확한 경우 General로 폴백).
  원본 폴더명은 "From_*" 서브폴더로 보존해 추적 가능성 유지.
- 최종 배치: Programming 2784 / General 1608 / Graphic 285 / Business 249 = 4926개 문서.
- 에이전트 운영 상태(.astra/.agent/.obsidian/sessions/memory/_company/docs/lessons/_shared/src)는
  지식 콘텐츠가 아니므로 재분류 대상에서 제외하고 원위치 유지.
- Topics/Topic_email(상위 보호 폴더 Topic_email과 파일명 100% 중복) 삭제 — 보호 폴더 자체는 미변경.
- 완전히 비게 된 Topic_Agent/Topic_Blog/Topics_Biz/Topics_Rag 폴더 제거.
This commit is contained in:
Antigravity Agent
2026-07-05 00:33:48 +09:00
parent 1cfd3bbb56
commit 9148c358d0
6455 changed files with 1 additions and 86875 deletions
@@ -0,0 +1,210 @@
---
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) |