---
id: wiki-2026-0508-social-systems-theory
title: Social Systems Theory
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Luhmann Systems Theory, Sociocybernetics]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [systems, sociology, complexity, autopoiesis]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: python
  framework: networkx/mesa
---

# Social Systems Theory

## 매 한 줄
> **"매 사회는 communication 의 self-referential network — agent 가 아니라 communication 이 element."**. Parsons 1951 structural functionalism → Luhmann 1984 autopoietic systems → 2020s computational social science (ABM, network 분석). 2026 LLM-driven 시뮬에서 communication system 모델링이 부활.

## 매 핵심

### 매 Luhmann 의 핵심
- 사회 = 매 communication 으로 구성된 자기지시 system.
- Functional differentiation: 경제, 법, 과학, 정치 등 subsystem이 서로 환경.
- 각 subsystem 고유 binary code: 경제 (pay/not pay), 법 (legal/illegal), 과학 (true/false).
- Autopoiesis: 시스템이 자신의 element 를 자체 생산.

### 매 관련 frameworks
- **Parsons AGIL**: Adaptation, Goal-attainment, Integration, Latency.
- **Giddens structuration**: structure ↔ agency duality.
- **Bourdieu habitus + field**: 매 internalized disposition × structured arena.
- **Network sociology**: Granovetter weak ties, Burt structural holes.

### 매 응용
1. Organization design (subsystem boundaries, decision codes).
2. Policy analysis (cross-system irritation/coupling).
3. Epidemic + diffusion modeling.
4. Online platform dynamics, virality.

## 💻 패턴

### Agent-based: opinion dynamics (Mesa)
```python
import mesa, random

class Citizen(mesa.Agent):
    def __init__(self, uid, model):
        super().__init__(uid, model)
        self.opinion = random.random()
    def step(self):
        nbrs = self.model.grid.get_neighbors(self.pos, moore=True)
        if nbrs:
            avg = sum(n.opinion for n in nbrs) / len(nbrs)
            self.opinion += 0.1 * (avg - self.opinion)

class Society(mesa.Model):
    def __init__(self, N, w, h):
        self.grid = mesa.space.MultiGrid(w, h, torus=True)
        self.schedule = mesa.time.RandomActivation(self)
        for i in range(N):
            a = Citizen(i, self)
            self.grid.place_agent(a, (random.randrange(w), random.randrange(h)))
            self.schedule.add(a)
    def step(self): self.schedule.step()
```

### Network: weak-tie diffusion (Granovetter)
```python
import networkx as nx, random

G = nx.watts_strogatz_graph(1000, k=10, p=0.05)
infected = {0}
for t in range(20):
    new = set()
    for n in infected:
        for nbr in G.neighbors(n):
            if nbr not in infected and random.random() < 0.05:
                new.add(nbr)
    infected |= new
print(len(infected), "infected after 20 steps")
```

### Structural holes (Burt)
```python
def constraint(G, ego):
    nbrs = list(G.neighbors(ego))
    n = len(nbrs)
    if n < 2: return 0
    c = 0
    for j in nbrs:
        p_ij = 1/n
        sum_term = p_ij
        for q in nbrs:
            if q != j and G.has_edge(q, j):
                sum_term += (1/n) * (1/n)
        c += sum_term ** 2
    return c
```

### Schelling segregation
```python
def schelling_step(grid, threshold=0.3):
    h, w = grid.shape
    moves = []
    for r in range(h):
        for c in range(w):
            if grid[r,c] == 0: continue
            nbrs = grid[max(r-1,0):r+2, max(c-1,0):c+2].flatten()
            same = (nbrs == grid[r,c]).sum() - 1
            total = (nbrs != 0).sum() - 1
            if total > 0 and same/total < threshold:
                moves.append((r,c))
    return moves
```

### Cross-system coupling (Luhmann-inspired ABM sketch)
```python
class Subsystem:
    def __init__(self, code): self.code = code  # ('pay','no pay')
    def operate(self, event):
        return self.code[0] if event['value'] > 0 else self.code[1]

economy = Subsystem(('pay','no_pay'))
law = Subsystem(('legal','illegal'))
# Structural coupling: legal subsystem 'irritates' economic decision
def coupled_decision(event):
    legal = law.operate(event)
    if legal == 'illegal': return 'no_pay'
    return economy.operate(event)
```

## 매 결정 기준
| 상황 | Framework |
|---|---|
| Macro structural change | Parsons AGIL, Luhmann differentiation |
| Micro-macro link | Giddens structuration, Coleman boat |
| Inequality reproduction | Bourdieu habitus + capital |
| Empirical network data | Granovetter / Burt / Watts |
| Simulation / forecasting | ABM (Mesa, NetLogo, Repast) |

**기본값**: ABM + network analysis 조합 — Mesa for agents, NetworkX for structure, Luhmann for theoretical lens.

## 🔗 Graph
- 부모: [[Systemic_Simulation_Principles]] · [[Emergence-in-Systems]]
- 변형: [[Sociocybernetics]]
- 응용: [[Diffusion-Models]]
- Adjacent: [[Social-Network-Analysis]] · [[Chaos-Theory in Systems]]

## 🤖 LLM 활용
**언제**: theory comparison (Parsons vs Luhmann), ABM hypothesis 설계, qualitative coding.
**언제 X**: 매 large-N empirical analysis (use Stata/R/Python).

## ❌ 안티패턴
- **Reification**: "society did X" — 매 actor / process specify 必.
- **Single-frame**: 매 Luhmann만 으로 모든 현상 설명 — combine w/ network/empirical.
- **ABM toy validation**: 매 simulation 이 reality 매칭 안 해도 publish — calibrate against data.
- **Scale confusion**: 매 micro mechanism → macro pattern jump 검증 없이.

## 🧪 검증 / 중복
- Verified (Luhmann *Social Systems* 1984/1995; Hedström & Ylikoski 2010 analytical sociology).
- 신뢰도 A−.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Luhmann 코드, Parsons/Bourdieu/Giddens, ABM/network 패턴 |
