2nd/10_Wiki/Topic_Programming/AI_and_ML/System-Theory.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-system-theory	System Theory	10_Wiki/Topics	verified	self	Systems Theory General Systems Theory GST 시스템 이론 Systems Thinking	none	A	0.9	applied	systems-theory cybernetics complexity emergence feedback		2026-05-10	pending	language framework python 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)

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

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)

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)

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

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)

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

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 · 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)