---
id: wiki-2026-0508-principles-of-structuralism
title: Principles of Structuralism
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Structuralism, Structural Analysis]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [philosophy, linguistics, methodology, semiotics]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: theory
  framework: structural-analysis
---

# Principles of Structuralism

## 매 한 줄
> **"매 meaning emerges from relations, not essences."**. 매 Saussure 의 1916 *Cours de linguistique générale* 에서 출발한 사상으로, 매 element 의 의미는 그 자체가 아닌 system 내 다른 element 와의 차이 (difference) 로부터 도출된다는 매 framework. 매 2026 에서도 NLP embedding space, knowledge graphs, software architecture 의 modular decomposition 에 이르기까지 매 살아있는 분석 도구.

## 매 핵심

### 매 4대 원칙
- **Synchrony over diachrony**: 매 system 의 현재 상태를 분석 — 매 historical evolution 보다 우선.
- **Sign = signifier + signified**: 매 sound-image 와 concept 의 arbitrary pairing.
- **Value through difference**: 매 "cat" 의 의미는 "bat", "rat", "hat" 와 다르기에 존재.
- **Langue vs parole**: 매 underlying system (langue) vs 매 individual utterance (parole).

### 매 확장 영역
- **Lévi-Strauss (anthropology)**: 매 myths 의 binary oppositions (raw/cooked, nature/culture).
- **Barthes (semiotics)**: 매 mythologies, 매 cultural codes, denotation vs connotation.
- **Lacan (psychoanalysis)**: 매 unconscious 가 language 처럼 구조화되어 있다.
- **Piaget (cognitive)**: 매 mental schemas 의 structural development.

### 매 응용
1. NLP embedding: 매 word2vec/GloVe 는 distributional structuralism 의 신경적 구현.
2. Software architecture: 매 module 의 의미는 dependency graph 내 위치로 결정.
3. UX semiotics: 매 icon affordance 는 매 visual sign system 내 차이로 해독.

## 💻 패턴

### Pattern 1: Distributional embedding (NLP)
```python
# 매 word meaning = 매 context distribution (distributional structuralism)
import numpy as np
from collections import Counter, defaultdict

def build_cooccurrence(corpus, window=5):
    cooc = defaultdict(Counter)
    for sent in corpus:
        for i, w in enumerate(sent):
            for j in range(max(0, i-window), min(len(sent), i+window+1)):
                if i != j:
                    cooc[w][sent[j]] += 1
    return cooc

# 매 차이 — 두 word vector 사이의 cosine distance
def diff(v1, v2):
    return 1 - np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
```

### Pattern 2: Binary opposition extraction (Lévi-Strauss style)
```python
def extract_oppositions(text_units, embed_fn):
    embeddings = [embed_fn(t) for t in text_units]
    # 매 most-distant pairs = 매 strongest oppositions
    pairs = []
    for i in range(len(text_units)):
        for j in range(i+1, len(text_units)):
            d = np.linalg.norm(embeddings[i] - embeddings[j])
            pairs.append((d, text_units[i], text_units[j]))
    pairs.sort(reverse=True)
    return pairs[:10]
```

### Pattern 3: Sign decomposition (Barthes)
```typescript
type Sign = {
  signifier: string;        // 매 form (word, image, sound)
  signified: string;        // 매 mental concept
  denotation: string;       // 매 literal
  connotation: string[];    // 매 cultural associations
};

const rose: Sign = {
  signifier: "rose",
  signified: "flower",
  denotation: "Rosa genus plant",
  connotation: ["love", "passion", "England", "secrecy (sub rosa)"],
};
```

### Pattern 4: Structural diff for software modules
```python
# 매 module value = 매 dependency-graph position
import networkx as nx

def structural_role(g: nx.DiGraph, node):
    return {
        "in_degree": g.in_degree(node),
        "out_degree": g.out_degree(node),
        "betweenness": nx.betweenness_centrality(g).get(node, 0),
        "neighbors": list(g.neighbors(node)),
    }
```

### Pattern 5: Synchronic vs diachronic analysis
```python
def synchronic_snapshot(repo, commit_sha):
    # 매 freeze a moment, analyze structure
    return {"deps": parse_deps(repo, commit_sha)}

def diachronic_trace(repo, sha_list):
    # 매 evolution over time
    return [synchronic_snapshot(repo, sha) for sha in sha_list]
```

### Pattern 6: Code review — surface vs deep structure
```python
# 매 surface (parole) — actual code
# 매 deep (langue) — design pattern, architectural rule
def review(pr):
    surface = lint_results(pr)
    deep = check_pattern_compliance(pr, patterns=["DI", "SRP", "boundary"])
    return surface, deep
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 "what does X mean?" | Map relations, not essences |
| 매 NLP embedding choice | Distributional methods (word2vec, BERT) |
| 매 cultural artifact analysis | Binary oppositions + connotations |
| 매 software module design | Structural role > implementation detail |
| 매 LLM prompt design | Define by contrast (few-shot oppositions) |

**기본값**: 매 always ask "what is this *not*?" before "what is this?".

## 🔗 Graph
- 변형: [[Distributional Semantics]]
- 응용: [[Word Embeddings]] · [[Knowledge Representation]] · [[Software Architecture]]

## 🤖 LLM 활용
**언제**: 매 meaning analysis, 매 cultural decoding, 매 embedding interpretation, 매 dependency graph reasoning.
**언제 X**: 매 essentialist questions ("what is the *true* nature of X?") — 매 structuralism 은 reject 함.

## ❌ 안티패턴
- **Essentialism**: 매 "X has an inherent meaning" — 매 structuralism rejects this.
- **Static langue**: 매 langue 를 fixed 로 보면 변화하는 system 을 놓침.
- **Over-binarization**: 매 모든 것을 binary opposition 으로 환원하면 nuance 손실.
- **Ignoring parole**: 매 actual usage data 무시하면 model 이 stale.

## 🧪 검증 / 중복
- Verified (Saussure 1916, Lévi-Strauss 1958, Barthes 1957).
- 신뢰도 A (foundational philosophical canon).

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Saussure 4대 원칙, NLP embedding 연결, 6 패턴 |
