2nd/10_Wiki/Topic_General/From_Other/Principles-of-Structuralism.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-principles-of-structuralism	Principles of Structuralism	10_Wiki/Topics	verified	self	Structuralism Structural Analysis	none	A	0.9	applied	philosophy linguistics methodology semiotics		2026-05-10	pending	language framework theory 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)

# 매 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)

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)

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

# 매 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

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

# 매 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 패턴